diff --git a/.appveyor.yml b/.appveyor.yml deleted file mode 100644 index 4c7080fd..00000000 --- a/.appveyor.yml +++ /dev/null @@ -1,264 +0,0 @@ -version: '{branch}-{build}' -build: off -environment: - global: - TWINE_USERNAME: ionel - matrix: - - TOXENV: check - TOXPYTHON: C:\Python36\python.exe - PYTHON_HOME: C:\Python36 - PYTHON_VERSION: '3.6' - PYTHON_ARCH: '32' - - TOXENV: py27-pure-cover,codecov - TOXPYTHON: C:\Python27\python.exe - PYTHON_HOME: C:\Python27 - PYTHON_VERSION: '2.7' - PYTHON_ARCH: '32' - - TOXENV: py27-pure-cover,codecov - TOXPYTHON: C:\Python27-x64\python.exe - PYTHON_HOME: C:\Python27-x64 - PYTHON_VERSION: '2.7' - PYTHON_ARCH: '64' - WINDOWS_SDK_VERSION: v7.0 - - TOXENV: py27-pure-nocov - TOXPYTHON: C:\Python27\python.exe - PYTHON_HOME: C:\Python27 - PYTHON_VERSION: '2.7' - PYTHON_ARCH: '32' - - TOXENV: py27-pure-nocov - TOXPYTHON: C:\Python27-x64\python.exe - PYTHON_HOME: C:\Python27-x64 - PYTHON_VERSION: '2.7' - PYTHON_ARCH: '64' - WINDOWS_SDK_VERSION: v7.0 - - TOXENV: py27-cython-cover,codecov - TOXPYTHON: C:\Python27\python.exe - PYTHON_HOME: C:\Python27 - PYTHON_VERSION: '2.7' - PYTHON_ARCH: '32' - - TOXENV: py27-cython-cover,codecov - TOXPYTHON: C:\Python27-x64\python.exe - PYTHON_HOME: C:\Python27-x64 - PYTHON_VERSION: '2.7' - PYTHON_ARCH: '64' - WINDOWS_SDK_VERSION: v7.0 - - TOXENV: py27-cython-nocov - TOXPYTHON: C:\Python27\python.exe - PYTHON_HOME: C:\Python27 - PYTHON_VERSION: '2.7' - PYTHON_ARCH: '32' - WHEEL_PATH: .tox/dist - - TOXENV: py27-cython-nocov - TOXPYTHON: C:\Python27-x64\python.exe - PYTHON_HOME: C:\Python27-x64 - PYTHON_VERSION: '2.7' - PYTHON_ARCH: '64' - WHEEL_PATH: .tox/dist - WINDOWS_SDK_VERSION: v7.0 - - TOXENV: py35-pure-cover,codecov - TOXPYTHON: C:\Python35\python.exe - PYTHON_HOME: C:\Python35 - PYTHON_VERSION: '3.5' - PYTHON_ARCH: '32' - - TOXENV: py35-pure-cover,codecov - TOXPYTHON: C:\Python35-x64\python.exe - PYTHON_HOME: C:\Python35-x64 - PYTHON_VERSION: '3.5' - PYTHON_ARCH: '64' - - TOXENV: py35-pure-nocov - TOXPYTHON: C:\Python35\python.exe - PYTHON_HOME: C:\Python35 - PYTHON_VERSION: '3.5' - PYTHON_ARCH: '32' - - TOXENV: py35-pure-nocov - TOXPYTHON: C:\Python35-x64\python.exe - PYTHON_HOME: C:\Python35-x64 - PYTHON_VERSION: '3.5' - PYTHON_ARCH: '64' - - TOXENV: py35-cython-cover,codecov - TOXPYTHON: C:\Python35\python.exe - PYTHON_HOME: C:\Python35 - PYTHON_VERSION: '3.5' - PYTHON_ARCH: '32' - - TOXENV: py35-cython-cover,codecov - TOXPYTHON: C:\Python35-x64\python.exe - PYTHON_HOME: C:\Python35-x64 - PYTHON_VERSION: '3.5' - PYTHON_ARCH: '64' - - TOXENV: py35-cython-nocov - TOXPYTHON: C:\Python35\python.exe - PYTHON_HOME: C:\Python35 - PYTHON_VERSION: '3.5' - PYTHON_ARCH: '32' - WHEEL_PATH: .tox/dist - - TOXENV: py35-cython-nocov - TOXPYTHON: C:\Python35-x64\python.exe - PYTHON_HOME: C:\Python35-x64 - PYTHON_VERSION: '3.5' - PYTHON_ARCH: '64' - WHEEL_PATH: .tox/dist - - TOXENV: py36-pure-cover,codecov - TOXPYTHON: C:\Python36\python.exe - PYTHON_HOME: C:\Python36 - PYTHON_VERSION: '3.6' - PYTHON_ARCH: '32' - - TOXENV: py36-pure-cover,codecov - TOXPYTHON: C:\Python36-x64\python.exe - PYTHON_HOME: C:\Python36-x64 - PYTHON_VERSION: '3.6' - PYTHON_ARCH: '64' - - TOXENV: py36-pure-nocov - TOXPYTHON: C:\Python36\python.exe - PYTHON_HOME: C:\Python36 - PYTHON_VERSION: '3.6' - PYTHON_ARCH: '32' - - TOXENV: py36-pure-nocov - TOXPYTHON: C:\Python36-x64\python.exe - PYTHON_HOME: C:\Python36-x64 - PYTHON_VERSION: '3.6' - PYTHON_ARCH: '64' - - TOXENV: py36-cython-cover,codecov - TOXPYTHON: C:\Python36\python.exe - PYTHON_HOME: C:\Python36 - PYTHON_VERSION: '3.6' - PYTHON_ARCH: '32' - - TOXENV: py36-cython-cover,codecov - TOXPYTHON: C:\Python36-x64\python.exe - PYTHON_HOME: C:\Python36-x64 - PYTHON_VERSION: '3.6' - PYTHON_ARCH: '64' - - TOXENV: py36-cython-nocov - TOXPYTHON: C:\Python36\python.exe - PYTHON_HOME: C:\Python36 - PYTHON_VERSION: '3.6' - PYTHON_ARCH: '32' - WHEEL_PATH: .tox/dist - - TOXENV: py36-cython-nocov - TOXPYTHON: C:\Python36-x64\python.exe - PYTHON_HOME: C:\Python36-x64 - PYTHON_VERSION: '3.6' - PYTHON_ARCH: '64' - WHEEL_PATH: .tox/dist - - TOXENV: py37-pure-cover,codecov - TOXPYTHON: C:\Python37\python.exe - PYTHON_HOME: C:\Python37 - PYTHON_VERSION: '3.7' - PYTHON_ARCH: '32' - - TOXENV: py37-pure-cover,codecov - TOXPYTHON: C:\Python37-x64\python.exe - PYTHON_HOME: C:\Python37-x64 - PYTHON_VERSION: '3.7' - PYTHON_ARCH: '64' - - TOXENV: py37-pure-nocov - TOXPYTHON: C:\Python37\python.exe - PYTHON_HOME: C:\Python37 - PYTHON_VERSION: '3.7' - PYTHON_ARCH: '32' - - TOXENV: py37-pure-nocov - TOXPYTHON: C:\Python37-x64\python.exe - PYTHON_HOME: C:\Python37-x64 - PYTHON_VERSION: '3.7' - PYTHON_ARCH: '64' - - TOXENV: py37-cython-cover,codecov - TOXPYTHON: C:\Python37\python.exe - PYTHON_HOME: C:\Python37 - PYTHON_VERSION: '3.7' - PYTHON_ARCH: '32' - - TOXENV: py37-cython-cover,codecov - TOXPYTHON: C:\Python37-x64\python.exe - PYTHON_HOME: C:\Python37-x64 - PYTHON_VERSION: '3.7' - PYTHON_ARCH: '64' - - TOXENV: py37-cython-nocov - TOXPYTHON: C:\Python37\python.exe - PYTHON_HOME: C:\Python37 - PYTHON_VERSION: '3.7' - PYTHON_ARCH: '32' - WHEEL_PATH: .tox/dist - - TOXENV: py37-cython-nocov - TOXPYTHON: C:\Python37-x64\python.exe - PYTHON_HOME: C:\Python37-x64 - PYTHON_VERSION: '3.7' - PYTHON_ARCH: '64' - WHEEL_PATH: .tox/dist - - TOXENV: py38-pure-cover,codecov - TOXPYTHON: C:\Python38\python.exe - PYTHON_HOME: C:\Python38 - PYTHON_VERSION: '3.8' - PYTHON_ARCH: '32' - - TOXENV: py38-pure-cover,codecov - TOXPYTHON: C:\Python38-x64\python.exe - PYTHON_HOME: C:\Python38-x64 - PYTHON_VERSION: '3.8' - PYTHON_ARCH: '64' - - TOXENV: py38-pure-nocov - TOXPYTHON: C:\Python38\python.exe - PYTHON_HOME: C:\Python38 - PYTHON_VERSION: '3.8' - PYTHON_ARCH: '32' - - TOXENV: py38-pure-nocov - TOXPYTHON: C:\Python38-x64\python.exe - PYTHON_HOME: C:\Python38-x64 - PYTHON_VERSION: '3.8' - PYTHON_ARCH: '64' - - TOXENV: py38-cython-cover,codecov - TOXPYTHON: C:\Python38\python.exe - PYTHON_HOME: C:\Python38 - PYTHON_VERSION: '3.8' - PYTHON_ARCH: '32' - - TOXENV: py38-cython-cover,codecov - TOXPYTHON: C:\Python38-x64\python.exe - PYTHON_HOME: C:\Python38-x64 - PYTHON_VERSION: '3.8' - PYTHON_ARCH: '64' - - TOXENV: py38-cython-nocov - TOXPYTHON: C:\Python38\python.exe - PYTHON_HOME: C:\Python38 - PYTHON_VERSION: '3.8' - PYTHON_ARCH: '32' - WHEEL_PATH: .tox/dist - - TOXENV: py38-cython-nocov - TOXPYTHON: C:\Python38-x64\python.exe - PYTHON_HOME: C:\Python38-x64 - PYTHON_VERSION: '3.8' - PYTHON_ARCH: '64' - WHEEL_PATH: .tox/dist -init: - - ps: echo $env:TOXENV - - ps: ls C:\Python* -install: - - ps: | - Set-PSDebug -Trace 1 - if ($Env:TOXENV.StartsWith("py38")) { - if ($Env:PYTHON_ARCH -eq "64") { - iex "choco install python3 --version=3.8 --no-progress --params /InstallDir:$Env:PYTHON_HOME" - } else { - iex "choco install python3 --version=3.8 --no-progress --params /InstallDir:$Env:PYTHON_HOME --x86" - } - } - - '%PYTHON_HOME%\python -mpip install --progress-bar=off twine tox-wheel -rci/requirements.txt' - - '%PYTHON_HOME%\Scripts\virtualenv --version' - - '%PYTHON_HOME%\Scripts\easy_install --version' - - '%PYTHON_HOME%\Scripts\pip --version' - - '%PYTHON_HOME%\Scripts\tox --version' -test_script: - - ps: | - Set-PSDebug -Trace 1 - if ($Env:WHEEL_PATH) { - cmd /E:ON /V:ON /C .\ci\appveyor-with-compiler.cmd $Env:PYTHON_HOME\Scripts\tox --wheel - if ($LastExitCode -eq 0) { - $ErrorActionPreference = "Stop" - iex "$Env:PYTHON_HOME\Scripts\twine check $Env:WHEEL_PATH/*.whl" - iex "$Env:PYTHON_HOME\Scripts\twine upload --repository-url https://test.pypi.org/legacy/ --skip-existing $Env:WHEEL_PATH/*.whl" - } - } else { - cmd /E:ON /V:ON /C .\ci\appveyor-with-compiler.cmd $Env:PYTHON_HOME\Scripts\tox - } - if ($LastExitCode -ne 0) { - Get-ChildItem Env: - Get-Content .tox\*\log\* - } - -### To enable remote debugging uncomment this (also, see: http://www.appveyor.com/docs/how-to/rdp-to-build-worker): -# on_finish: -# - ps: $blockRdp = $true; iex ((new-object net.webclient).DownloadString('https://raw.githubusercontent.com/appveyor/ci/master/scripts/enable-rdp.ps1')) diff --git a/.bumpversion.cfg b/.bumpversion.cfg index 54a88289..e37a7bff 100644 --- a/.bumpversion.cfg +++ b/.bumpversion.cfg @@ -1,15 +1,19 @@ [bumpversion] -current_version = 3.1.3 +current_version = 3.9.0 commit = True tag = True -[bumpversion:file:setup.py] -search = 'fallback_version': '{current_version}' -replace = 'fallback_version': '{new_version}' +[bumpversion:file:pyproject.toml] +search = fallback_version = "{current_version}" +replace = fallback_version = "{new_version}" -[bumpversion:file:README.rst] -search = v{current_version}. -replace = v{new_version}. +[bumpversion:file (badge):README.rst] +search = /v{current_version}.svg +replace = /v{new_version}.svg + +[bumpversion:file (link):README.rst] +search = /v{current_version}...master +replace = /v{new_version}...master [bumpversion:file:docs/conf.py] search = version = release = '{current_version}' @@ -19,3 +23,6 @@ replace = version = release = '{new_version}' search = __version__ = '{current_version}' replace = __version__ = '{new_version}' +[bumpversion:file:.cookiecutterrc] +search = version: {current_version} +replace = version: {new_version} diff --git a/.cookiecutterrc b/.cookiecutterrc index 5904a3ea..dea7b0cd 100644 --- a/.cookiecutterrc +++ b/.cookiecutterrc @@ -1,55 +1,47 @@ # Generated by cookiepatcher, a small shim around cookiecutter (pip install cookiepatcher) -cookiecutter: - _extensions: - - jinja2_time.TimeExtension - _template: cookiecutter-pylibrary - allow_tests_inside_package: no - appveyor: yes - c_extension_function: '-' - c_extension_module: '-' - c_extension_optional: yes +default_context: + c_extension_optional: 'yes' c_extension_support: cython - c_extension_test_pypi: yes - c_extension_test_pypi_username: ionel - codacy: no + codacy: 'no' codacy_projectid: '-' - codeclimate: no - codecov: yes + codeclimate: 'no' + codecov: 'yes' command_line_interface: argparse command_line_interface_bin_name: hunter-trace - coveralls: no - coveralls_token: '-' + coveralls: 'no' distribution_name: hunter email: contact@ionelmc.ro + formatter_quote_style: single full_name: Ionel Cristian Mărieș - landscape: no + function_name: compute + github_actions: 'yes' + github_actions_osx: 'yes' + github_actions_windows: 'yes' license: BSD 2-Clause License - linter: flake8 + module_name: core package_name: hunter + pre_commit: 'yes' project_name: Hunter - project_short_description: Hunter is a flexible code tracing toolkit, not for measuring coverage, but for debugging, logging, inspection and other nefarious purposes. It has a simple Python API and a convenient terminal API (see `Environment variable activation `_). - pypi_badge: yes - pypi_disable_upload: no - release_date: '2019-10-10' + project_short_description: Hunter is a flexible code tracing toolkit. + pypi_badge: 'yes' + pypi_disable_upload: 'no' + release_date: '2024-05-02' repo_hosting: github.com repo_hosting_domain: github.com + repo_main_branch: master repo_name: python-hunter repo_username: ionelmc - requiresio: yes - scrutinizer: no - setup_py_uses_setuptools_scm: yes - setup_py_uses_test_runner: no - sphinx_docs: yes + scrutinizer: 'no' + setup_py_uses_setuptools_scm: 'yes' + sphinx_docs: 'yes' sphinx_docs_hosting: https://python-hunter.readthedocs.io/ - sphinx_doctest: no - sphinx_theme: sphinx-py3doc-enhanced-theme - test_matrix_configurator: no - test_matrix_separate_coverage: yes - test_runner: pytest - travis: yes - travis_osx: no - version: 3.0.2 + sphinx_doctest: 'no' + sphinx_theme: furo + test_matrix_separate_coverage: 'yes' + tests_inside_package: 'no' + version: 3.9.0 + version_manager: bump2version website: https://blog.ionelmc.ro year_from: '2015' - year_to: '2019' + year_to: '2025' diff --git a/.coveragerc b/.coveragerc index b74227ab..a9a2ce8b 100644 --- a/.coveragerc +++ b/.coveragerc @@ -1,8 +1,13 @@ +[paths] +source = src + [run] branch = true -source = src +source = + src + tests parallel = true -plugins = Cython.Coverage +plugins = ${COVERAGE_PLUGIN} [report] show_missing = true diff --git a/.editorconfig b/.editorconfig index 608de9c1..586c7367 100644 --- a/.editorconfig +++ b/.editorconfig @@ -1,16 +1,20 @@ -# see http://editorconfig.org +# see https://editorconfig.org/ root = true [*] +# Use Unix-style newlines for most files (except Windows files, see below). end_of_line = lf trim_trailing_whitespace = true -insert_final_newline = true indent_style = space +insert_final_newline = true indent_size = 4 charset = utf-8 [*.{bat,cmd,ps1}] end_of_line = crlf -[*.yml] +[*.{yml,yaml}] indent_size = 2 + +[*.tsv] +indent_style = tab diff --git a/.github/workflows/github-actions.yml b/.github/workflows/github-actions.yml new file mode 100644 index 00000000..1fd8bdc6 --- /dev/null +++ b/.github/workflows/github-actions.yml @@ -0,0 +1,1325 @@ +name: build +on: [push, pull_request, workflow_dispatch] +jobs: + test: + name: ${{ matrix.name }} + runs-on: ${{ matrix.os }} + timeout-minutes: 30 + strategy: + fail-fast: false + matrix: + include: + - name: 'check' + python: '3.13' + tox_env: 'check' + os: 'ubuntu-latest' + - name: 'docs' + python: '3.13' + tox_env: 'docs' + os: 'ubuntu-latest' + - name: 'py39-pure-cover (ubuntu/x86_64)' + artifact: 'py39-pure-ubuntu-x86_64' + python: '3.9' + python_arch: 'x64' + tox_env: 'py39-pure-cover' + cover: true + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'py39-pure-cover (windows/AMD64)' + artifact: 'py39-pure-windows-AMD64' + python: '3.9' + python_arch: 'x64' + tox_env: 'py39-pure-cover' + cover: true + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'py39-pure-cover (macos/arm64)' + artifact: 'py39-pure-macos-arm64' + python: '3.9' + python_arch: 'arm64' + tox_env: 'py39-pure-cover' + cover: true + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'py39-pure-nocov (ubuntu/x86_64)' + artifact: 'py39-pure-ubuntu-x86_64' + python: '3.9' + python_arch: 'x64' + tox_env: 'py39-pure-nocov' + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'py39-pure-nocov (windows/AMD64)' + artifact: 'py39-pure-windows-AMD64' + python: '3.9' + python_arch: 'x64' + tox_env: 'py39-pure-nocov' + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'py39-pure-nocov (macos/arm64)' + artifact: 'py39-pure-macos-arm64' + python: '3.9' + python_arch: 'arm64' + tox_env: 'py39-pure-nocov' + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'py39-cython-cover (ubuntu/x86_64)' + artifact: 'py39-cython-ubuntu-x86_64' + python: '3.9' + python_arch: 'x64' + tox_env: 'py39-cython-cover' + cover: true + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'py39-cython-cover (windows/AMD64)' + artifact: 'py39-cython-windows-AMD64' + python: '3.9' + python_arch: 'x64' + tox_env: 'py39-cython-cover' + cover: true + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'py39-cython-cover (macos/arm64)' + artifact: 'py39-cython-macos-arm64' + python: '3.9' + python_arch: 'arm64' + tox_env: 'py39-cython-cover' + cover: true + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'py39-cython-nocov (ubuntu/x86_64/manylinux)' + artifact: 'py39-cython-ubuntu-x86_64-manylinux' + python: '3.9' + python_arch: 'x64' + tox_env: 'py39-cython-nocov' + cibw_arch: 'x86_64' + cibw_build: 'cp39-*manylinux*' + cibw_ft: 'false' + os: 'ubuntu-latest' + - name: 'py39-cython-nocov (ubuntu/x86_64/musllinux)' + artifact: 'py39-cython-ubuntu-x86_64-musllinux' + python: '3.9' + python_arch: 'x64' + tox_env: 'py39-cython-nocov' + cibw_arch: 'x86_64' + cibw_build: 'cp39-*musllinux*' + cibw_ft: 'false' + os: 'ubuntu-latest' + - name: 'py39-cython-nocov (ubuntu/aarch64/manylinux)' + artifact: 'py39-cython-ubuntu-aarch64-manylinux' + python: '3.9' + python_arch: 'x64' + tox_env: 'py39-cython-nocov' + cibw_arch: 'aarch64' + cibw_build: 'cp39-*manylinux*' + cibw_ft: 'false' + os: 'ubuntu-latest' + - name: 'py39-cython-nocov (ubuntu/aarch64/musllinux)' + artifact: 'py39-cython-ubuntu-aarch64-musllinux' + python: '3.9' + python_arch: 'x64' + tox_env: 'py39-cython-nocov' + cibw_arch: 'aarch64' + cibw_build: 'cp39-*musllinux*' + cibw_ft: 'false' + os: 'ubuntu-latest' + - name: 'py39-cython-nocov (windows/AMD64)' + artifact: 'py39-cython-windows-AMD64' + python: '3.9' + python_arch: 'x64' + tox_env: 'py39-cython-nocov' + cibw_arch: 'AMD64' + cibw_build: 'cp39-*' + cibw_ft: 'false' + os: 'windows-latest' + - name: 'py39-cython-nocov (windows/x86)' + artifact: 'py39-cython-windows-x86' + python: '3.9' + python_arch: 'x86' + tox_env: 'py39-cython-nocov' + cibw_arch: 'x86' + cibw_build: 'cp39-*' + cibw_ft: 'false' + os: 'windows-latest' + - name: 'py39-cython-nocov (macos/arm64)' + artifact: 'py39-cython-macos-arm64' + python: '3.9' + python_arch: 'arm64' + tox_env: 'py39-cython-nocov' + cibw_arch: 'arm64' + cibw_build: 'cp39-*' + cibw_ft: 'false' + os: 'macos-latest' + - name: 'py310-pure-cover (ubuntu/x86_64)' + artifact: 'py310-pure-ubuntu-x86_64' + python: '3.10' + python_arch: 'x64' + tox_env: 'py310-pure-cover' + cover: true + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'py310-pure-cover (windows/AMD64)' + artifact: 'py310-pure-windows-AMD64' + python: '3.10' + python_arch: 'x64' + tox_env: 'py310-pure-cover' + cover: true + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'py310-pure-cover (macos/arm64)' + artifact: 'py310-pure-macos-arm64' + python: '3.10' + python_arch: 'arm64' + tox_env: 'py310-pure-cover' + cover: true + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'py310-pure-nocov (ubuntu/x86_64)' + artifact: 'py310-pure-ubuntu-x86_64' + python: '3.10' + python_arch: 'x64' + tox_env: 'py310-pure-nocov' + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'py310-pure-nocov (windows/AMD64)' + artifact: 'py310-pure-windows-AMD64' + python: '3.10' + python_arch: 'x64' + tox_env: 'py310-pure-nocov' + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'py310-pure-nocov (macos/arm64)' + artifact: 'py310-pure-macos-arm64' + python: '3.10' + python_arch: 'arm64' + tox_env: 'py310-pure-nocov' + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'py310-cython-cover (ubuntu/x86_64)' + artifact: 'py310-cython-ubuntu-x86_64' + python: '3.10' + python_arch: 'x64' + tox_env: 'py310-cython-cover' + cover: true + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'py310-cython-cover (windows/AMD64)' + artifact: 'py310-cython-windows-AMD64' + python: '3.10' + python_arch: 'x64' + tox_env: 'py310-cython-cover' + cover: true + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'py310-cython-cover (macos/arm64)' + artifact: 'py310-cython-macos-arm64' + python: '3.10' + python_arch: 'arm64' + tox_env: 'py310-cython-cover' + cover: true + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'py310-cython-nocov (ubuntu/x86_64/manylinux)' + artifact: 'py310-cython-ubuntu-x86_64-manylinux' + python: '3.10' + python_arch: 'x64' + tox_env: 'py310-cython-nocov' + cibw_arch: 'x86_64' + cibw_build: 'cp310-*manylinux*' + cibw_ft: 'false' + os: 'ubuntu-latest' + - name: 'py310-cython-nocov (ubuntu/x86_64/musllinux)' + artifact: 'py310-cython-ubuntu-x86_64-musllinux' + python: '3.10' + python_arch: 'x64' + tox_env: 'py310-cython-nocov' + cibw_arch: 'x86_64' + cibw_build: 'cp310-*musllinux*' + cibw_ft: 'false' + os: 'ubuntu-latest' + - name: 'py310-cython-nocov (ubuntu/aarch64/manylinux)' + artifact: 'py310-cython-ubuntu-aarch64-manylinux' + python: '3.10' + python_arch: 'x64' + tox_env: 'py310-cython-nocov' + cibw_arch: 'aarch64' + cibw_build: 'cp310-*manylinux*' + cibw_ft: 'false' + os: 'ubuntu-latest' + - name: 'py310-cython-nocov (ubuntu/aarch64/musllinux)' + artifact: 'py310-cython-ubuntu-aarch64-musllinux' + python: '3.10' + python_arch: 'x64' + tox_env: 'py310-cython-nocov' + cibw_arch: 'aarch64' + cibw_build: 'cp310-*musllinux*' + cibw_ft: 'false' + os: 'ubuntu-latest' + - name: 'py310-cython-nocov (windows/AMD64)' + artifact: 'py310-cython-windows-AMD64' + python: '3.10' + python_arch: 'x64' + tox_env: 'py310-cython-nocov' + cibw_arch: 'AMD64' + cibw_build: 'cp310-*' + cibw_ft: 'false' + os: 'windows-latest' + - name: 'py310-cython-nocov (windows/x86)' + artifact: 'py310-cython-windows-x86' + python: '3.10' + python_arch: 'x86' + tox_env: 'py310-cython-nocov' + cibw_arch: 'x86' + cibw_build: 'cp310-*' + cibw_ft: 'false' + os: 'windows-latest' + - name: 'py310-cython-nocov (macos/arm64)' + artifact: 'py310-cython-macos-arm64' + python: '3.10' + python_arch: 'arm64' + tox_env: 'py310-cython-nocov' + cibw_arch: 'arm64' + cibw_build: 'cp310-*' + cibw_ft: 'false' + os: 'macos-latest' + - name: 'py311-pure-cover (ubuntu/x86_64)' + artifact: 'py311-pure-ubuntu-x86_64' + python: '3.11' + python_arch: 'x64' + tox_env: 'py311-pure-cover' + cover: true + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'py311-pure-cover (windows/AMD64)' + artifact: 'py311-pure-windows-AMD64' + python: '3.11' + python_arch: 'x64' + tox_env: 'py311-pure-cover' + cover: true + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'py311-pure-cover (macos/arm64)' + artifact: 'py311-pure-macos-arm64' + python: '3.11' + python_arch: 'arm64' + tox_env: 'py311-pure-cover' + cover: true + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'py311-pure-nocov (ubuntu/x86_64)' + artifact: 'py311-pure-ubuntu-x86_64' + python: '3.11' + python_arch: 'x64' + tox_env: 'py311-pure-nocov' + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'py311-pure-nocov (windows/AMD64)' + artifact: 'py311-pure-windows-AMD64' + python: '3.11' + python_arch: 'x64' + tox_env: 'py311-pure-nocov' + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'py311-pure-nocov (macos/arm64)' + artifact: 'py311-pure-macos-arm64' + python: '3.11' + python_arch: 'arm64' + tox_env: 'py311-pure-nocov' + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'py311-cython-cover (ubuntu/x86_64)' + artifact: 'py311-cython-ubuntu-x86_64' + python: '3.11' + python_arch: 'x64' + tox_env: 'py311-cython-cover' + cover: true + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'py311-cython-cover (windows/AMD64)' + artifact: 'py311-cython-windows-AMD64' + python: '3.11' + python_arch: 'x64' + tox_env: 'py311-cython-cover' + cover: true + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'py311-cython-cover (macos/arm64)' + artifact: 'py311-cython-macos-arm64' + python: '3.11' + python_arch: 'arm64' + tox_env: 'py311-cython-cover' + cover: true + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'py311-cython-nocov (ubuntu/x86_64/manylinux)' + artifact: 'py311-cython-ubuntu-x86_64-manylinux' + python: '3.11' + python_arch: 'x64' + tox_env: 'py311-cython-nocov' + cibw_arch: 'x86_64' + cibw_build: 'cp311-*manylinux*' + cibw_ft: 'false' + os: 'ubuntu-latest' + - name: 'py311-cython-nocov (ubuntu/x86_64/musllinux)' + artifact: 'py311-cython-ubuntu-x86_64-musllinux' + python: '3.11' + python_arch: 'x64' + tox_env: 'py311-cython-nocov' + cibw_arch: 'x86_64' + cibw_build: 'cp311-*musllinux*' + cibw_ft: 'false' + os: 'ubuntu-latest' + - name: 'py311-cython-nocov (ubuntu/aarch64/manylinux)' + artifact: 'py311-cython-ubuntu-aarch64-manylinux' + python: '3.11' + python_arch: 'x64' + tox_env: 'py311-cython-nocov' + cibw_arch: 'aarch64' + cibw_build: 'cp311-*manylinux*' + cibw_ft: 'false' + os: 'ubuntu-latest' + - name: 'py311-cython-nocov (ubuntu/aarch64/musllinux)' + artifact: 'py311-cython-ubuntu-aarch64-musllinux' + python: '3.11' + python_arch: 'x64' + tox_env: 'py311-cython-nocov' + cibw_arch: 'aarch64' + cibw_build: 'cp311-*musllinux*' + cibw_ft: 'false' + os: 'ubuntu-latest' + - name: 'py311-cython-nocov (windows/AMD64)' + artifact: 'py311-cython-windows-AMD64' + python: '3.11' + python_arch: 'x64' + tox_env: 'py311-cython-nocov' + cibw_arch: 'AMD64' + cibw_build: 'cp311-*' + cibw_ft: 'false' + os: 'windows-latest' + - name: 'py311-cython-nocov (windows/x86)' + artifact: 'py311-cython-windows-x86' + python: '3.11' + python_arch: 'x86' + tox_env: 'py311-cython-nocov' + cibw_arch: 'x86' + cibw_build: 'cp311-*' + cibw_ft: 'false' + os: 'windows-latest' + - name: 'py311-cython-nocov (macos/arm64)' + artifact: 'py311-cython-macos-arm64' + python: '3.11' + python_arch: 'arm64' + tox_env: 'py311-cython-nocov' + cibw_arch: 'arm64' + cibw_build: 'cp311-*' + cibw_ft: 'false' + os: 'macos-latest' + - name: 'py312-pure-cover (ubuntu/x86_64)' + artifact: 'py312-pure-ubuntu-x86_64' + python: '3.12' + python_arch: 'x64' + tox_env: 'py312-pure-cover' + cover: true + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'py312-pure-cover (windows/AMD64)' + artifact: 'py312-pure-windows-AMD64' + python: '3.12' + python_arch: 'x64' + tox_env: 'py312-pure-cover' + cover: true + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'py312-pure-cover (macos/arm64)' + artifact: 'py312-pure-macos-arm64' + python: '3.12' + python_arch: 'arm64' + tox_env: 'py312-pure-cover' + cover: true + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'py312-pure-nocov (ubuntu/x86_64)' + artifact: 'py312-pure-ubuntu-x86_64' + python: '3.12' + python_arch: 'x64' + tox_env: 'py312-pure-nocov' + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'py312-pure-nocov (windows/AMD64)' + artifact: 'py312-pure-windows-AMD64' + python: '3.12' + python_arch: 'x64' + tox_env: 'py312-pure-nocov' + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'py312-pure-nocov (macos/arm64)' + artifact: 'py312-pure-macos-arm64' + python: '3.12' + python_arch: 'arm64' + tox_env: 'py312-pure-nocov' + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'py312-cython-cover (ubuntu/x86_64)' + artifact: 'py312-cython-ubuntu-x86_64' + python: '3.12' + python_arch: 'x64' + tox_env: 'py312-cython-cover' + cover: true + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'py312-cython-cover (windows/AMD64)' + artifact: 'py312-cython-windows-AMD64' + python: '3.12' + python_arch: 'x64' + tox_env: 'py312-cython-cover' + cover: true + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'py312-cython-cover (macos/arm64)' + artifact: 'py312-cython-macos-arm64' + python: '3.12' + python_arch: 'arm64' + tox_env: 'py312-cython-cover' + cover: true + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'py312-cython-nocov (ubuntu/x86_64/manylinux)' + artifact: 'py312-cython-ubuntu-x86_64-manylinux' + python: '3.12' + python_arch: 'x64' + tox_env: 'py312-cython-nocov' + cibw_arch: 'x86_64' + cibw_build: 'cp312-*manylinux*' + cibw_ft: 'false' + os: 'ubuntu-latest' + - name: 'py312-cython-nocov (ubuntu/x86_64/musllinux)' + artifact: 'py312-cython-ubuntu-x86_64-musllinux' + python: '3.12' + python_arch: 'x64' + tox_env: 'py312-cython-nocov' + cibw_arch: 'x86_64' + cibw_build: 'cp312-*musllinux*' + cibw_ft: 'false' + os: 'ubuntu-latest' + - name: 'py312-cython-nocov (ubuntu/aarch64/manylinux)' + artifact: 'py312-cython-ubuntu-aarch64-manylinux' + python: '3.12' + python_arch: 'x64' + tox_env: 'py312-cython-nocov' + cibw_arch: 'aarch64' + cibw_build: 'cp312-*manylinux*' + cibw_ft: 'false' + os: 'ubuntu-latest' + - name: 'py312-cython-nocov (ubuntu/aarch64/musllinux)' + artifact: 'py312-cython-ubuntu-aarch64-musllinux' + python: '3.12' + python_arch: 'x64' + tox_env: 'py312-cython-nocov' + cibw_arch: 'aarch64' + cibw_build: 'cp312-*musllinux*' + cibw_ft: 'false' + os: 'ubuntu-latest' + - name: 'py312-cython-nocov (windows/AMD64)' + artifact: 'py312-cython-windows-AMD64' + python: '3.12' + python_arch: 'x64' + tox_env: 'py312-cython-nocov' + cibw_arch: 'AMD64' + cibw_build: 'cp312-*' + cibw_ft: 'false' + os: 'windows-latest' + - name: 'py312-cython-nocov (windows/x86)' + artifact: 'py312-cython-windows-x86' + python: '3.12' + python_arch: 'x86' + tox_env: 'py312-cython-nocov' + cibw_arch: 'x86' + cibw_build: 'cp312-*' + cibw_ft: 'false' + os: 'windows-latest' + - name: 'py312-cython-nocov (macos/arm64)' + artifact: 'py312-cython-macos-arm64' + python: '3.12' + python_arch: 'arm64' + tox_env: 'py312-cython-nocov' + cibw_arch: 'arm64' + cibw_build: 'cp312-*' + cibw_ft: 'false' + os: 'macos-latest' + - name: 'py313-pure-cover (ubuntu/x86_64)' + artifact: 'py313-pure-ubuntu-x86_64' + python: '3.13' + python_arch: 'x64' + tox_env: 'py313-pure-cover' + cover: true + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'py313-pure-cover (windows/AMD64)' + artifact: 'py313-pure-windows-AMD64' + python: '3.13' + python_arch: 'x64' + tox_env: 'py313-pure-cover' + cover: true + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'py313-pure-cover (macos/arm64)' + artifact: 'py313-pure-macos-arm64' + python: '3.13' + python_arch: 'arm64' + tox_env: 'py313-pure-cover' + cover: true + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'py313-pure-nocov (ubuntu/x86_64)' + artifact: 'py313-pure-ubuntu-x86_64' + python: '3.13' + python_arch: 'x64' + tox_env: 'py313-pure-nocov' + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'py313-pure-nocov (windows/AMD64)' + artifact: 'py313-pure-windows-AMD64' + python: '3.13' + python_arch: 'x64' + tox_env: 'py313-pure-nocov' + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'py313-pure-nocov (macos/arm64)' + artifact: 'py313-pure-macos-arm64' + python: '3.13' + python_arch: 'arm64' + tox_env: 'py313-pure-nocov' + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'py313-cython-cover (ubuntu/x86_64)' + artifact: 'py313-cython-ubuntu-x86_64' + python: '3.13' + python_arch: 'x64' + tox_env: 'py313-cython-cover' + cover: true + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'py313-cython-cover (windows/AMD64)' + artifact: 'py313-cython-windows-AMD64' + python: '3.13' + python_arch: 'x64' + tox_env: 'py313-cython-cover' + cover: true + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'py313-cython-cover (macos/arm64)' + artifact: 'py313-cython-macos-arm64' + python: '3.13' + python_arch: 'arm64' + tox_env: 'py313-cython-cover' + cover: true + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'py313-cython-nocov (ubuntu/x86_64/manylinux)' + artifact: 'py313-cython-ubuntu-x86_64-manylinux' + python: '3.13' + python_arch: 'x64' + tox_env: 'py313-cython-nocov' + cibw_arch: 'x86_64' + cibw_build: 'cp313-*manylinux*' + cibw_ft: 'false' + os: 'ubuntu-latest' + - name: 'py313-cython-nocov (ubuntu/x86_64/musllinux)' + artifact: 'py313-cython-ubuntu-x86_64-musllinux' + python: '3.13' + python_arch: 'x64' + tox_env: 'py313-cython-nocov' + cibw_arch: 'x86_64' + cibw_build: 'cp313-*musllinux*' + cibw_ft: 'false' + os: 'ubuntu-latest' + - name: 'py313-cython-nocov (ubuntu/aarch64/manylinux)' + artifact: 'py313-cython-ubuntu-aarch64-manylinux' + python: '3.13' + python_arch: 'x64' + tox_env: 'py313-cython-nocov' + cibw_arch: 'aarch64' + cibw_build: 'cp313-*manylinux*' + cibw_ft: 'false' + os: 'ubuntu-latest' + - name: 'py313-cython-nocov (ubuntu/aarch64/musllinux)' + artifact: 'py313-cython-ubuntu-aarch64-musllinux' + python: '3.13' + python_arch: 'x64' + tox_env: 'py313-cython-nocov' + cibw_arch: 'aarch64' + cibw_build: 'cp313-*musllinux*' + cibw_ft: 'false' + os: 'ubuntu-latest' + - name: 'py313-cython-nocov (windows/AMD64)' + artifact: 'py313-cython-windows-AMD64' + python: '3.13' + python_arch: 'x64' + tox_env: 'py313-cython-nocov' + cibw_arch: 'AMD64' + cibw_build: 'cp313-*' + cibw_ft: 'false' + os: 'windows-latest' + - name: 'py313-cython-nocov (windows/x86)' + artifact: 'py313-cython-windows-x86' + python: '3.13' + python_arch: 'x86' + tox_env: 'py313-cython-nocov' + cibw_arch: 'x86' + cibw_build: 'cp313-*' + cibw_ft: 'false' + os: 'windows-latest' + - name: 'py313-cython-nocov (macos/arm64)' + artifact: 'py313-cython-macos-arm64' + python: '3.13' + python_arch: 'arm64' + tox_env: 'py313-cython-nocov' + cibw_arch: 'arm64' + cibw_build: 'cp313-*' + cibw_ft: 'false' + os: 'macos-latest' + - name: 'py313t-pure-cover (ubuntu/x86_64)' + artifact: 'py313t-pure-ubuntu-x86_64' + python: '3.13' + python_arch: 'x64-freethreaded' + tox_env: 'py313t-pure-cover' + cover: true + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'py313t-pure-cover (windows/AMD64)' + artifact: 'py313t-pure-windows-AMD64' + python: '3.13' + python_arch: 'x64-freethreaded' + tox_env: 'py313t-pure-cover' + cover: true + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'py313t-pure-cover (macos/arm64)' + artifact: 'py313t-pure-macos-arm64' + python: '3.13' + python_arch: 'arm64-freethreaded' + tox_env: 'py313t-pure-cover' + cover: true + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'py313t-pure-nocov (ubuntu/x86_64)' + artifact: 'py313t-pure-ubuntu-x86_64' + python: '3.13' + python_arch: 'x64-freethreaded' + tox_env: 'py313t-pure-nocov' + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'py313t-pure-nocov (windows/AMD64)' + artifact: 'py313t-pure-windows-AMD64' + python: '3.13' + python_arch: 'x64-freethreaded' + tox_env: 'py313t-pure-nocov' + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'py313t-pure-nocov (macos/arm64)' + artifact: 'py313t-pure-macos-arm64' + python: '3.13' + python_arch: 'arm64-freethreaded' + tox_env: 'py313t-pure-nocov' + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'py313t-cython-cover (ubuntu/x86_64)' + artifact: 'py313t-cython-ubuntu-x86_64' + python: '3.13' + python_arch: 'x64-freethreaded' + tox_env: 'py313t-cython-cover' + cover: true + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'py313t-cython-cover (windows/AMD64)' + artifact: 'py313t-cython-windows-AMD64' + python: '3.13' + python_arch: 'x64-freethreaded' + tox_env: 'py313t-cython-cover' + cover: true + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'py313t-cython-cover (macos/arm64)' + artifact: 'py313t-cython-macos-arm64' + python: '3.13' + python_arch: 'arm64-freethreaded' + tox_env: 'py313t-cython-cover' + cover: true + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'py313t-cython-nocov (ubuntu/x86_64/manylinux)' + artifact: 'py313t-cython-ubuntu-x86_64-manylinux' + python: '3.13' + python_arch: 'x64-freethreaded' + tox_env: 'py313t-cython-nocov' + cibw_arch: 'x86_64' + cibw_build: 'cp313t-*manylinux*' + cibw_ft: 'true' + os: 'ubuntu-latest' + - name: 'py313t-cython-nocov (ubuntu/x86_64/musllinux)' + artifact: 'py313t-cython-ubuntu-x86_64-musllinux' + python: '3.13' + python_arch: 'x64-freethreaded' + tox_env: 'py313t-cython-nocov' + cibw_arch: 'x86_64' + cibw_build: 'cp313t-*musllinux*' + cibw_ft: 'true' + os: 'ubuntu-latest' + - name: 'py313t-cython-nocov (ubuntu/aarch64/manylinux)' + artifact: 'py313t-cython-ubuntu-aarch64-manylinux' + python: '3.13' + python_arch: 'x64-freethreaded' + tox_env: 'py313t-cython-nocov' + cibw_arch: 'aarch64' + cibw_build: 'cp313t-*manylinux*' + cibw_ft: 'true' + os: 'ubuntu-latest' + - name: 'py313t-cython-nocov (ubuntu/aarch64/musllinux)' + artifact: 'py313t-cython-ubuntu-aarch64-musllinux' + python: '3.13' + python_arch: 'x64-freethreaded' + tox_env: 'py313t-cython-nocov' + cibw_arch: 'aarch64' + cibw_build: 'cp313t-*musllinux*' + cibw_ft: 'true' + os: 'ubuntu-latest' + - name: 'py313t-cython-nocov (windows/AMD64)' + artifact: 'py313t-cython-windows-AMD64' + python: '3.13' + python_arch: 'x64-freethreaded' + tox_env: 'py313t-cython-nocov' + cibw_arch: 'AMD64' + cibw_build: 'cp313t-*' + cibw_ft: 'true' + os: 'windows-latest' + - name: 'py313t-cython-nocov (windows/x86)' + artifact: 'py313t-cython-windows-x86' + python: '3.13' + python_arch: 'x86-freethreaded' + tox_env: 'py313t-cython-nocov' + cibw_arch: 'x86' + cibw_build: 'cp313t-*' + cibw_ft: 'true' + os: 'windows-latest' + - name: 'py313t-cython-nocov (macos/arm64)' + artifact: 'py313t-cython-macos-arm64' + python: '3.13' + python_arch: 'arm64-freethreaded' + tox_env: 'py313t-cython-nocov' + cibw_arch: 'arm64' + cibw_build: 'cp313t-*' + cibw_ft: 'true' + os: 'macos-latest' + - name: 'py314-pure-cover (ubuntu/x86_64)' + artifact: 'py314-pure-ubuntu-x86_64' + python: '3.14.0-rc.2' + python_arch: 'x64' + tox_env: 'py314-pure-cover' + cover: true + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'py314-pure-cover (windows/AMD64)' + artifact: 'py314-pure-windows-AMD64' + python: '3.14.0-rc.2' + python_arch: 'x64' + tox_env: 'py314-pure-cover' + cover: true + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'py314-pure-cover (macos/arm64)' + artifact: 'py314-pure-macos-arm64' + python: '3.14.0-rc.2' + python_arch: 'arm64' + tox_env: 'py314-pure-cover' + cover: true + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'py314-pure-nocov (ubuntu/x86_64)' + artifact: 'py314-pure-ubuntu-x86_64' + python: '3.14.0-rc.2' + python_arch: 'x64' + tox_env: 'py314-pure-nocov' + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'py314-pure-nocov (windows/AMD64)' + artifact: 'py314-pure-windows-AMD64' + python: '3.14.0-rc.2' + python_arch: 'x64' + tox_env: 'py314-pure-nocov' + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'py314-pure-nocov (macos/arm64)' + artifact: 'py314-pure-macos-arm64' + python: '3.14.0-rc.2' + python_arch: 'arm64' + tox_env: 'py314-pure-nocov' + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'py314-cython-cover (ubuntu/x86_64)' + artifact: 'py314-cython-ubuntu-x86_64' + python: '3.14.0-rc.2' + python_arch: 'x64' + tox_env: 'py314-cython-cover' + cover: true + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'py314-cython-cover (windows/AMD64)' + artifact: 'py314-cython-windows-AMD64' + python: '3.14.0-rc.2' + python_arch: 'x64' + tox_env: 'py314-cython-cover' + cover: true + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'py314-cython-cover (macos/arm64)' + artifact: 'py314-cython-macos-arm64' + python: '3.14.0-rc.2' + python_arch: 'arm64' + tox_env: 'py314-cython-cover' + cover: true + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'py314-cython-nocov (ubuntu/x86_64/manylinux)' + artifact: 'py314-cython-ubuntu-x86_64-manylinux' + python: '3.14.0-rc.2' + python_arch: 'x64' + tox_env: 'py314-cython-nocov' + cibw_arch: 'x86_64' + cibw_build: 'cp314-*manylinux*' + cibw_ft: 'false' + os: 'ubuntu-latest' + - name: 'py314-cython-nocov (ubuntu/x86_64/musllinux)' + artifact: 'py314-cython-ubuntu-x86_64-musllinux' + python: '3.14.0-rc.2' + python_arch: 'x64' + tox_env: 'py314-cython-nocov' + cibw_arch: 'x86_64' + cibw_build: 'cp314-*musllinux*' + cibw_ft: 'false' + os: 'ubuntu-latest' + - name: 'py314-cython-nocov (ubuntu/aarch64/manylinux)' + artifact: 'py314-cython-ubuntu-aarch64-manylinux' + python: '3.14.0-rc.2' + python_arch: 'x64' + tox_env: 'py314-cython-nocov' + cibw_arch: 'aarch64' + cibw_build: 'cp314-*manylinux*' + cibw_ft: 'false' + os: 'ubuntu-latest' + - name: 'py314-cython-nocov (ubuntu/aarch64/musllinux)' + artifact: 'py314-cython-ubuntu-aarch64-musllinux' + python: '3.14.0-rc.2' + python_arch: 'x64' + tox_env: 'py314-cython-nocov' + cibw_arch: 'aarch64' + cibw_build: 'cp314-*musllinux*' + cibw_ft: 'false' + os: 'ubuntu-latest' + - name: 'py314-cython-nocov (windows/AMD64)' + artifact: 'py314-cython-windows-AMD64' + python: '3.14.0-rc.2' + python_arch: 'x64' + tox_env: 'py314-cython-nocov' + cibw_arch: 'AMD64' + cibw_build: 'cp314-*' + cibw_ft: 'false' + os: 'windows-latest' + - name: 'py314-cython-nocov (windows/x86)' + artifact: 'py314-cython-windows-x86' + python: '3.14.0-rc.2' + python_arch: 'x86' + tox_env: 'py314-cython-nocov' + cibw_arch: 'x86' + cibw_build: 'cp314-*' + cibw_ft: 'false' + os: 'windows-latest' + - name: 'py314-cython-nocov (macos/arm64)' + artifact: 'py314-cython-macos-arm64' + python: '3.14.0-rc.2' + python_arch: 'arm64' + tox_env: 'py314-cython-nocov' + cibw_arch: 'arm64' + cibw_build: 'cp314-*' + cibw_ft: 'false' + os: 'macos-latest' + - name: 'py314t-pure-cover (ubuntu/x86_64)' + artifact: 'py314t-pure-ubuntu-x86_64' + python: '3.14.0-rc.2' + python_arch: 'x64-freethreaded' + tox_env: 'py314t-pure-cover' + cover: true + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'py314t-pure-cover (windows/AMD64)' + artifact: 'py314t-pure-windows-AMD64' + python: '3.14.0-rc.2' + python_arch: 'x64-freethreaded' + tox_env: 'py314t-pure-cover' + cover: true + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'py314t-pure-cover (macos/arm64)' + artifact: 'py314t-pure-macos-arm64' + python: '3.14.0-rc.2' + python_arch: 'arm64-freethreaded' + tox_env: 'py314t-pure-cover' + cover: true + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'py314t-pure-nocov (ubuntu/x86_64)' + artifact: 'py314t-pure-ubuntu-x86_64' + python: '3.14.0-rc.2' + python_arch: 'x64-freethreaded' + tox_env: 'py314t-pure-nocov' + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'py314t-pure-nocov (windows/AMD64)' + artifact: 'py314t-pure-windows-AMD64' + python: '3.14.0-rc.2' + python_arch: 'x64-freethreaded' + tox_env: 'py314t-pure-nocov' + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'py314t-pure-nocov (macos/arm64)' + artifact: 'py314t-pure-macos-arm64' + python: '3.14.0-rc.2' + python_arch: 'arm64-freethreaded' + tox_env: 'py314t-pure-nocov' + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'py314t-cython-cover (ubuntu/x86_64)' + artifact: 'py314t-cython-ubuntu-x86_64' + python: '3.14.0-rc.2' + python_arch: 'x64-freethreaded' + tox_env: 'py314t-cython-cover' + cover: true + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'py314t-cython-cover (windows/AMD64)' + artifact: 'py314t-cython-windows-AMD64' + python: '3.14.0-rc.2' + python_arch: 'x64-freethreaded' + tox_env: 'py314t-cython-cover' + cover: true + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'py314t-cython-cover (macos/arm64)' + artifact: 'py314t-cython-macos-arm64' + python: '3.14.0-rc.2' + python_arch: 'arm64-freethreaded' + tox_env: 'py314t-cython-cover' + cover: true + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'py314t-cython-nocov (ubuntu/x86_64/manylinux)' + artifact: 'py314t-cython-ubuntu-x86_64-manylinux' + python: '3.14.0-rc.2' + python_arch: 'x64-freethreaded' + tox_env: 'py314t-cython-nocov' + cibw_arch: 'x86_64' + cibw_build: 'cp314-*manylinux*' + cibw_ft: 'true' + os: 'ubuntu-latest' + - name: 'py314t-cython-nocov (ubuntu/x86_64/musllinux)' + artifact: 'py314t-cython-ubuntu-x86_64-musllinux' + python: '3.14.0-rc.2' + python_arch: 'x64-freethreaded' + tox_env: 'py314t-cython-nocov' + cibw_arch: 'x86_64' + cibw_build: 'cp314-*musllinux*' + cibw_ft: 'true' + os: 'ubuntu-latest' + - name: 'py314t-cython-nocov (ubuntu/aarch64/manylinux)' + artifact: 'py314t-cython-ubuntu-aarch64-manylinux' + python: '3.14.0-rc.2' + python_arch: 'x64-freethreaded' + tox_env: 'py314t-cython-nocov' + cibw_arch: 'aarch64' + cibw_build: 'cp314-*manylinux*' + cibw_ft: 'true' + os: 'ubuntu-latest' + - name: 'py314t-cython-nocov (ubuntu/aarch64/musllinux)' + artifact: 'py314t-cython-ubuntu-aarch64-musllinux' + python: '3.14.0-rc.2' + python_arch: 'x64-freethreaded' + tox_env: 'py314t-cython-nocov' + cibw_arch: 'aarch64' + cibw_build: 'cp314-*musllinux*' + cibw_ft: 'true' + os: 'ubuntu-latest' + - name: 'py314t-cython-nocov (windows/AMD64)' + artifact: 'py314t-cython-windows-AMD64' + python: '3.14.0-rc.2' + python_arch: 'x64-freethreaded' + tox_env: 'py314t-cython-nocov' + cibw_arch: 'AMD64' + cibw_build: 'cp314-*' + cibw_ft: 'true' + os: 'windows-latest' + - name: 'py314t-cython-nocov (windows/x86)' + artifact: 'py314t-cython-windows-x86' + python: '3.14.0-rc.2' + python_arch: 'x86-freethreaded' + tox_env: 'py314t-cython-nocov' + cibw_arch: 'x86' + cibw_build: 'cp314-*' + cibw_ft: 'true' + os: 'windows-latest' + - name: 'py314t-cython-nocov (macos/arm64)' + artifact: 'py314t-cython-macos-arm64' + python: '3.14.0-rc.2' + python_arch: 'arm64-freethreaded' + tox_env: 'py314t-cython-nocov' + cibw_arch: 'arm64' + cibw_build: 'cp314-*' + cibw_ft: 'true' + os: 'macos-latest' + - name: 'pypy39-pure-cover (ubuntu/x86_64)' + artifact: 'pypy39-pure-ubuntu-x86_64' + python: 'pypy-3.9' + python_arch: 'x64' + tox_env: 'pypy39-pure-cover' + cover: true + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'pypy39-pure-cover (windows/AMD64)' + artifact: 'pypy39-pure-windows-AMD64' + python: 'pypy-3.9' + python_arch: 'x64' + tox_env: 'pypy39-pure-cover' + cover: true + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'pypy39-pure-cover (macos/arm64)' + artifact: 'pypy39-pure-macos-arm64' + python: 'pypy-3.9' + python_arch: 'arm64' + tox_env: 'pypy39-pure-cover' + cover: true + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'pypy39-pure-nocov (ubuntu/x86_64)' + artifact: 'pypy39-pure-ubuntu-x86_64' + python: 'pypy-3.9' + python_arch: 'x64' + tox_env: 'pypy39-pure-nocov' + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'pypy39-pure-nocov (windows/AMD64)' + artifact: 'pypy39-pure-windows-AMD64' + python: 'pypy-3.9' + python_arch: 'x64' + tox_env: 'pypy39-pure-nocov' + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'pypy39-pure-nocov (macos/arm64)' + artifact: 'pypy39-pure-macos-arm64' + python: 'pypy-3.9' + python_arch: 'arm64' + tox_env: 'pypy39-pure-nocov' + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'pypy310-pure-cover (ubuntu/x86_64)' + artifact: 'pypy310-pure-ubuntu-x86_64' + python: 'pypy-3.10' + python_arch: 'x64' + tox_env: 'pypy310-pure-cover' + cover: true + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'pypy310-pure-cover (windows/AMD64)' + artifact: 'pypy310-pure-windows-AMD64' + python: 'pypy-3.10' + python_arch: 'x64' + tox_env: 'pypy310-pure-cover' + cover: true + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'pypy310-pure-cover (macos/arm64)' + artifact: 'pypy310-pure-macos-arm64' + python: 'pypy-3.10' + python_arch: 'arm64' + tox_env: 'pypy310-pure-cover' + cover: true + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'pypy310-pure-nocov (ubuntu/x86_64)' + artifact: 'pypy310-pure-ubuntu-x86_64' + python: 'pypy-3.10' + python_arch: 'x64' + tox_env: 'pypy310-pure-nocov' + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'pypy310-pure-nocov (windows/AMD64)' + artifact: 'pypy310-pure-windows-AMD64' + python: 'pypy-3.10' + python_arch: 'x64' + tox_env: 'pypy310-pure-nocov' + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'pypy310-pure-nocov (macos/arm64)' + artifact: 'pypy310-pure-macos-arm64' + python: 'pypy-3.10' + python_arch: 'arm64' + tox_env: 'pypy310-pure-nocov' + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + steps: + - uses: docker/setup-qemu-action@v3 + if: matrix.cibw_arch == 'aarch64' + with: + platforms: arm64 + - uses: actions/checkout@v4 + with: + fetch-depth: 0 + - uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python }} + architecture: ${{ matrix.python_arch }} + - name: install dependencies + run: | + python -mpip install --progress-bar=off cibuildwheel -r ci/requirements.txt + virtualenv --version + pip --version + tox --version + pip list --format=freeze + - name: install dependencies (gdb) + if: > + !matrix.cibw_build && matrix.os == 'ubuntu' + run: | + sudo apt-get install gdb + echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope + - name: cibw build and test + if: matrix.cibw_build + run: cibuildwheel + env: + CIBW_ARCHS: '${{ matrix.cibw_arch }}' + CIBW_BUILD: '${{ matrix.cibw_build }}' + CIBW_CONTAINER_ENGINE: "docker; create_args: --cap-add=SYS_PTRACE" + CIBW_ENABLE: cpython-freethreading + CIBW_BUILD_VERBOSITY: '3' + CIBW_TEST_REQUIRES: > + tox + tox-direct + CIBW_TEST_COMMAND: > + cd {project} && + tox --skip-pkg-install --direct-yolo -e ${{ matrix.tox_env }} -vv + CIBW_TEST_COMMAND_WINDOWS: > + cd /d {project} && + tox --skip-pkg-install --direct-yolo -e ${{ matrix.tox_env }} -vv + - name: regular build and test + if: > + !matrix.cibw_build + run: > + tox -e ${{ matrix.tox_env }} -vv + - uses: codecov/codecov-action@v5 + if: matrix.cover + with: + verbose: true + flags: ${{ matrix.tox_env }} + - name: check wheel + if: > + !matrix.cibw_ft && matrix.cibw_build + run: | + python -mpip install --progress-bar=off twine + twine check wheelhouse/*.whl + - name: upload wheel + uses: actions/upload-artifact@v4 + if: matrix.cibw_build + with: + name: wheel-${{ matrix.artifact }} + path: wheelhouse/*.whl + finish: + needs: test + if: ${{ always() }} + runs-on: ubuntu-latest + steps: + - uses: actions/upload-artifact/merge@v4 + with: + name: all-wheels + - uses: codecov/codecov-action@v5 + with: + CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} diff --git a/.gitignore b/.gitignore index f20791ee..48334525 100644 --- a/.gitignore +++ b/.gitignore @@ -1,51 +1,67 @@ *.py[cod] __pycache__ +# Temp files +.*.sw[po] +*~ +*.bak +.DS_Store + # C extensions *.so -# Packages +# Build and package files *.egg *.egg-info -dist -build -eggs +.bootstrap +.build +.cache .eggs -parts +.env +.installed.cfg +.ve bin -var -sdist -wheelhouse +build develop-eggs -.installed.cfg +dist +eggs lib lib64 -venv*/ -pyvenv*/ +parts pip-wheel-metadata/ +pyvenv*/ +sdist +var +venv*/ +wheelhouse # Installer logs pip-log.txt # Unit test / coverage reports +.benchmarks .coverage -.tox .coverage.* +.pytest .pytest_cache/ -nosetests.xml +.tox coverage.xml htmlcov +nosetests.xml # Translations *.mo -# Mr Developer +# Buildout .mr.developer.cfg -.project -.pydevproject -.idea + +# IDE project files *.iml *.komodoproject +.idea +.project +.pydevproject +.vscode # Complexity output/*.html @@ -54,20 +70,6 @@ output/*/index.html # Sphinx docs/_build -.DS_Store -*~ -.*.sw[po] -.build -.ve -.env -.cache -.pytest -.benchmarks -.pytest_cache -.bootstrap -.appveyor.token -*.bak - # Mypy Cache .mypy_cache/ diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 00000000..2d81bbce --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,35 @@ +# To install the git pre-commit hooks run: +# pre-commit install --install-hooks +# To update the versions: +# pre-commit autoupdate +exclude: '^(.tox/|ci/templates/|src/hunter.(pth|embed)$|src/hunter/vendor/|.bumpversion.cfg$|.*\.c$)' +# Note the order is intentional to avoid multiple passes of the hooks +repos: + - repo: https://github.com/astral-sh/ruff-pre-commit + rev: v0.12.10 + hooks: + - id: ruff + args: [--fix, --exit-non-zero-on-fix, --show-fixes] + - id: ruff-format + - repo: https://github.com/ComPWA/taplo-pre-commit + rev: v0.9.3 + hooks: + - id: taplo-format + - id: taplo-lint + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v6.0.0 + hooks: + - id: trailing-whitespace + exclude_types: + - c + - id: end-of-file-fixer + exclude_types: + - c + - id: mixed-line-ending + args: [--fix=lf] + - id: debug-statements + exclude: '^tests/sample*|src/hunter/actions.py' + - repo: https://github.com/MarcoGorelli/cython-lint + rev: v0.16.7 + hooks: + - id: cython-lint diff --git a/.python-version b/.python-version new file mode 100644 index 00000000..9fb2c23d --- /dev/null +++ b/.python-version @@ -0,0 +1 @@ +hunter diff --git a/.readthedocs.yml b/.readthedocs.yml new file mode 100644 index 00000000..009a913c --- /dev/null +++ b/.readthedocs.yml @@ -0,0 +1,14 @@ +# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details +version: 2 +sphinx: + configuration: docs/conf.py +formats: all +build: + os: ubuntu-22.04 + tools: + python: "3" +python: + install: + - requirements: docs/requirements.txt + - method: pip + path: . diff --git a/.taplo.toml b/.taplo.toml new file mode 100644 index 00000000..8f8054d3 --- /dev/null +++ b/.taplo.toml @@ -0,0 +1,3 @@ +[formatting] +array_auto_collapse = false +indent_string = " " diff --git a/.travis.yml b/.travis.yml deleted file mode 100644 index 647e5d5f..00000000 --- a/.travis.yml +++ /dev/null @@ -1,229 +0,0 @@ -language: python -dist: xenial -cache: false -git: - depth: false -addons: - apt: - packages: - - gdb -env: - global: - - LD_PRELOAD=/lib/x86_64-linux-gnu/libSegFault.so - - SEGFAULT_SIGNALS=all - - PYTEST_ADDOPTS=--benchmark-disable - - TWINE_USERNAME=ionel -matrix: - include: - - python: '3.8' - env: - - TOXENV=cythonize - script: - - | - ( - set -eux - tox -v - git update-index --ignore-submodules --refresh - if ! git diff-files --exit-code --ignore-submodules; then - echo "C files are stale!" - exit 1 - fi - ) - - python: '3.8' - env: - - TOXENV=check - - python: '3.8' - env: - - TOXENV=docs - - os: osx - language: generic - env: - - TOXENV=py27-pure-cover - - SETUPPY_CFLAGS= - - env: - - TOXENV=py27-pure-cover,codecov - python: '2.7' - - os: osx - language: generic - env: - - TOXENV=py27-pure-nocov - - SETUPPY_CFLAGS= - - env: - - TOXENV=py27-pure-nocov - - WHEEL_MANYLINUX1=cp27 - - WHEEL_PATH=wheelhouse - python: '2.7' - - os: osx - language: generic - env: - - TOXENV=py27-cython-cover - - SETUPPY_CFLAGS= - - env: - - TOXENV=py27-cython-cover,codecov - python: '2.7' - - os: osx - language: generic - env: - - TOXENV=py27-cython-nocov - - SETUPPY_CFLAGS= - - WHEEL_PATH=.tox/dist - - env: - - TOXENV=py27-cython-nocov - - WHEEL_MANYLINUX1=cp27 - - WHEEL_PATH=wheelhouse - python: '2.7' - - env: - - TOXENV=py35-pure-cover,codecov - python: '3.5' - - env: - - TOXENV=py35-pure-nocov - - WHEEL_MANYLINUX1=cp35 - - WHEEL_PATH=wheelhouse - python: '3.5' - - env: - - TOXENV=py35-cython-cover,codecov - python: '3.5' - - env: - - TOXENV=py35-cython-nocov - - WHEEL_MANYLINUX1=cp35 - - WHEEL_PATH=wheelhouse - python: '3.5' - - env: - - TOXENV=py36-pure-cover,codecov - python: '3.6' - - env: - - TOXENV=py36-pure-nocov - - WHEEL_MANYLINUX1=cp36 - - WHEEL_PATH=wheelhouse - python: '3.6' - - env: - - TOXENV=py36-cython-cover,codecov - python: '3.6' - - env: - - TOXENV=py36-cython-nocov - - WHEEL_MANYLINUX1=cp36 - - WHEEL_PATH=wheelhouse - python: '3.6' - - os: osx - language: generic - env: - - TOXENV=py3-pure-cover - - SETUPPY_CFLAGS= - - env: - - TOXENV=py37-pure-cover,codecov - python: '3.7' - - os: osx - language: generic - env: - - TOXENV=py3-pure-nocov - - SETUPPY_CFLAGS= - - env: - - TOXENV=py37-pure-nocov - - WHEEL_MANYLINUX1=cp37 - - WHEEL_PATH=wheelhouse - python: '3.7' - - os: osx - language: generic - env: - - TOXENV=py3-cython-cover - - SETUPPY_CFLAGS= - - env: - - TOXENV=py37-cython-cover,codecov - python: '3.7' - - os: osx - language: generic - env: - - TOXENV=py3-cython-nocov - - SETUPPY_CFLAGS= - - WHEEL_PATH=.tox/dist - - env: - - TOXENV=py37-cython-nocov - - WHEEL_MANYLINUX1=cp37 - - WHEEL_PATH=wheelhouse - python: '3.7' - - env: - - TOXENV=py38-pure-cover,codecov - python: '3.8' - - env: - - TOXENV=py38-pure-nocov - - WHEEL_MANYLINUX1=cp38 - - WHEEL_PATH=wheelhouse - python: '3.8' - - env: - - TOXENV=py38-cython-cover,codecov - python: '3.8' - - env: - - TOXENV=py38-cython-nocov - - WHEEL_MANYLINUX1=cp38 - - WHEEL_PATH=wheelhouse - python: '3.8' - - env: - - TOXENV=pypy-pure-cover,codecov - python: 'pypy' - - env: - - TOXENV=pypy-pure-nocov - python: 'pypy' - - env: - - TOXENV=pypy-cython-cover,codecov - python: 'pypy' - - env: - - TOXENV=pypy-cython-nocov - python: 'pypy' - - env: - - TOXENV=pypy3-pure-cover,codecov - - TOXPYTHON=pypy3 - python: 'pypy3' - - env: - - TOXENV=pypy3-pure-nocov - - TOXPYTHON=pypy3 - python: 'pypy3' - - env: - - TOXENV=pypy3-cython-cover,codecov - - TOXPYTHON=pypy3 - python: 'pypy3' - - env: - - TOXENV=pypy3-cython-nocov - - TOXPYTHON=pypy3 - python: 'pypy3' -before_install: - - python --version - - uname -a - - lsb_release -a || true - - sudo sysctl -w kernel.yama.ptrace_scope=0 || true - - | - if [[ $TRAVIS_OS_NAME == 'osx' ]]; then - brew update-reset - [[ $TOXENV =~ py3 ]] && brew upgrade python - [[ $TOXENV =~ py2 ]] && brew install python@2 - export PATH="/usr/local/opt/python/libexec/bin:${PATH}" - fi -install: - - python -mpip install --progress-bar=off twine tox-wheel -rci/requirements.txt - - virtualenv --version - - easy_install --version - - pip --version - - tox --version -script: - - | - ( - set -eux - if [[ -n ${WHEEL_MANYLINUX1:-} ]]; then - docker run --rm --user $UID -itv $(pwd):/code ionelmc/manylinux $WHEEL_MANYLINUX1 - tox --installpkg $WHEEL_PATH/*.whl -v - elif [[ -n ${WHEEL_PATH:-} ]]; then - tox -v --wheel - else - tox -v - fi - if [[ -n ${WHEEL_PATH:-} ]]; then - twine check $WHEEL_PATH/*.whl - twine upload --repository-url https://test.pypi.org/legacy/ --skip-existing $WHEEL_PATH/*.whl - fi - ) -after_failure: - - more .tox/log/* | cat - - more .tox/*/log/* | cat -notifications: - email: - on_success: never - on_failure: always diff --git a/AUTHORS.rst b/AUTHORS.rst index dcc2ac83..42f04ff5 100644 --- a/AUTHORS.rst +++ b/AUTHORS.rst @@ -5,3 +5,6 @@ Authors * Ionel Cristian Mărieș - https://blog.ionelmc.ro * Claudiu Popa - https://github.com/PCManticore * Mikhail Borisov - https://github.com/borman +* Dan Ailenei - https://github.com/Dan-Ailenei +* Tom Schraitle - https://github.com/tomschr +* Steve Kowalik - https://github.com/s-t-e-v-e-n-k diff --git a/CHANGELOG.rst b/CHANGELOG.rst index 48ce96e1..561731b9 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -2,6 +2,180 @@ Changelog ========= +3.9.0 (2025-08-22) +------------------ + +* Added support and wheels for Python 3.14. +* Modernized packaging to have metadata in ``pyproject.toml``. + +3.8.0 (2025-07-11) +------------------ + +* Drop support for Python 3.8. +* Added support for Python 3.13, including freethreading variant (but not really tested, as most of the test suite is singlethreaded). +* Fixed issues with latest Cython release (3.1.2). +* Simplified the `Event.__init__` so doesn't require or accept a Tracer instance anymore to fill in some options. +* Fixed hardcoded python executable in tests. + Contributed by Steve Kowalik in `#126 `. + +3.7.0 (2024-05-02) +------------------ + +* Drop support for Python 3.7. +* Upgrade linters and refactor various string formatting and other cleanups. +* Upgrade Cython to latest release (3.0.10). +* Linux wheels should be back now. +* Switched docs theme to furo. + +3.6.1 (2023-04-26) +------------------ + +* Added safe repr support for Decimal objects. + +3.6.0 (2023-04-25) +------------------ + +* Added C extension support for Python 3.11. This may come with up to 10% performance hit (depending on use-case) for all Pythons. + Unfortunately some `compat shims `_ are + now used for getting frame details. This is necessary to be able to work with Python 3.11 and be more future-proof. +* Added safe repr support for ZoneInfo objects. +* C extension files are now prebuilt with Cython 3.0b2. +* Replaced the flake8/isort pre-commit hooks with ruff. +* Disabled editable wheels (`PEP-0662 `_) as they don't include the `hunter.pth` file. + There may be a way to do it but I haven't figured out a way to customize the `editable_wheel` command without a + very brittle solution glued to setuptools' internals. + +3.5.1 (2022-09-27) +------------------ + +* Fixed breakage in ``hunter-trace`` when Ctrl-C. + +3.5.0 (2022-09-11) +------------------ + +* Add support for generators and coroutines in the :obj:`hunter.wrap` decorator. +* Dropped support for Python 3.6. + +3.4.3 (2021-12-15) +------------------ + +* Removed most of the Python 2 support code. +* Fix some refactoring regression in ``setup.py`` and make the 3.4.x series installable only on Python 3.6 and later. +* Yank 3.4.0, 3.4.1, 3.4.2 releases to avoid install problems on Python 2.7. + +3.4.2 (2021-12-15) +------------------ + +* Fixed CI to properly make win32 wheels. + +3.4.1 (2021-12-14) +------------------ + +* Add support for building a ``pp37.pp38`` tagged wheel + (basically an universal wheel installable just for those two PyPy versions). + +3.4.0 (2021-12-14) +------------------ + +* Switched CI to GitHub Actions, this has a couple consequences: + + * Support for Python 2.7 is dropped. You can still install it there but it's not tested anymore and + Python 2 specific handling will be removed at some point. + * Linux wheels are now provided in `musllinux` and `manylinux2014` variants. +* Extension building is now completely skipped on PyPy. +* A pure but tagged as platform specific wheel is now provided for PyPy (to have fast installs there as well). + +3.3.8 (2021-06-23) +------------------ + +* Fixed CI problem that publishes same type of wheels two times. + +3.3.7 (2021-06-23) +------------------ + +* Fixed a bug with how ``stdlib`` is detected on Windows (at least). + +3.3.6 (2021-06-23) +------------------ + +* Fixed regression from *3.3.4*: ``stdlib`` filter was broken. +* Improved the pth file (``PYTHONHUNTER`` environment variable activation) to use a clean eval environment. + No bogus variables like ``line`` (from the ``site.py`` machinery) will be available anymore. +* Fixed a bug in ``VarsSnooper`` that would make it fail in rare situation where a double `return` event is emitted. + +3.3.5 (2021-06-11) +------------------ + +* Added support for Python 3.10. +* Added support for ``time`` objects and the ``fold`` option in ``safe_repr``. +* *3.3.4 was skipped cause I messed up the CI.* + +3.3.3 (2021-05-04) +------------------ + +* Fixed tracer still being active for other threads after it was stopped. + + Python unfortunately only allows removing the trace function for the current thread - + now :obj:`~hunter.tracer.Tracer` will uninstall itself if it's marked as stopped. + + This fixes bogus errors that appear when using ``ipdb`` with + the :class:`hunter.actions.Debugger` action while thread support is enabled (the default). + +3.3.2 (2021-03-25) +------------------ + +* Changed CI to build Python 3.9 wheels. Python 3.5 no longer tested and wheels no longer built to keep things simple. +* Documentation improvements. + +3.3.1 (2020-10-24) +------------------ + +* Fixed CI/test issues that prevented all of 21 wheels being published. + +3.3.0 (2020-10-23) +------------------ + +* Fixed handling so that :any:`hunter.event.Event.module` is always the ``"?"`` string instead of ``None``. + Previously it was ``None`` when tracing particularly broken code and broke various predicates. +* Similarly :any:`hunter.event.Event.filename` is now ``"?"`` if there's no filename available. +* Building on the previous changes the actions have simpler code for displaying missing module/filenames. +* Changed :class:`hunter.actions.CallPrinter` so that trace events for builtin functions are displayed differently. + These events appear when using profile mode (eg: ``trace(profile=True)``). +* Fixed failure that could occur if :any:`hunter.event.Event.module` is an unicode string. Now it's always a regular string. + *Only applies to Python 2.* +* Fixed argument display when tracing functions with tuple arguments. + Closes `#88 `_. *Only applies to Python 2.* +* Improved error reporting when internal failures occur. Now some details about the triggering event are logged. + +3.2.2 (2020-09-04) +------------------ + +* Fixed oversight over what value is in :any:`hunter.event.Event.builtin`. Now it's always a boolean, and can be used consistently + in filters (eg: ``builtin=True,function='getattr'``). + +3.2.1 (2020-08-18) +------------------ + +* Added support for regex, date and datetime in ``safe_repr``. +* Fixed call argument display when positional and keyword arguments are used in :class:`hunter.actions.CallPrinter`. + +3.2.0 (2020-08-16) +------------------ + +* Implemented the :class:`~hunter.actions.StackPrinter` action. +* Implemented the :class:`~hunter.predicates.Backlog` predicate. + Contributed by Dan Ailenei in `#81 `_. +* Improved contributing section in docs a bit. + Contributed by Tom Schraitle in `#85 `_. +* Improved filtering performance by avoiding a lot of unnecessary + ``PyObject_GetAttr`` calls in the Cython implementation of :class:`~hunter.predicates.Backlog`. +* Implemented the :class:`~hunter.actions.ErrorSnooper` action. +* Added support for profiling mode (eg: ``trace(profile=True)``). + This mode will use ``setprofile`` instead of ``settrace``. +* Added ARM64 wheels and CI. +* Added :any:`hunter.event.Event.instruction` and :any:`hunter.event.Event.builtin` (usable in profile mode). +* Added more cookbook entries. + 3.1.3 (2020-02-02) ------------------ @@ -145,12 +319,12 @@ Changelog 2.0.0 (2017-09-02) ------------------ -* Added the :attr:`hunter.event.Event.count` and :attr:`hunter.event.Event.calls`` attributes. +* Added the :attr:`hunter.event.Event.count` and :attr:`hunter.event.Event.calls` attributes. * Added the ``lt``/``lte``/``gt``/``gte`` lookups. * Added convenience aliases for ``startswith`` (``sw``), ``endswith`` (``ew``), ``contains`` (``has``) and ``regex`` (``rx``). * Added a convenience :func:`hunter.wrap` decorator to start tracing around a function. -* Added support for remote tracing (with two backends: `manhole `__ and GDB) via +* Added support for remote tracing (with two backends: `manhole `__ and GDB) via the ``hunter-trace`` bin. Note: **Windows is NOT SUPPORTED**. * Changed the default action to :class:`hunter.actions.CallPrinter`. You'll need to use ``action=CodePrinter`` if you want the old output. @@ -174,8 +348,8 @@ Changelog (available for filtering with :func:`hunter.Q`). * Added :attr:`hunter.event.Event.threading_support` argument to :func:`hunter.trace`. It makes new threads be traced and changes action output to include thread name. -* Added support for using `pdb++ `_ in the :class:`hunter.actions.Debugger` action. -* Added support for using `manhole `_ via a new :class:`hunter.actions.Manhole` +* Added support for using `pdb++ `_ in the :class:`hunter.actions.Debugger` action. +* Added support for using `manhole `_ via a new :class:`hunter.actions.Manhole` action. * Made the :attr:`hunter.event.Event.handler` a public but readonly property. @@ -183,7 +357,7 @@ Changelog 1.2.2 (2016-01-28) ------------------ -* Fix broken import. Require `fields>=4.0`. +* Fix broken import. Require ``fields>=4.0``. * Simplify a string check in Cython code. 1.2.1 (2016-01-27) @@ -237,7 +411,7 @@ Changelog * Removed the ``merge`` option. Now when you call ``hunter.trace(...)`` multiple times only the last one is active. **BACKWARDS INCOMPATIBLE** -* Remove the `previous_tracer handling`. Now when you call ``hunter.trace(...)`` the previous tracer (whatever was in +* Remove the ``previous_tracer`` handling. Now when you call ``hunter.trace(...)`` the previous tracer (whatever was in ``sys.gettrace()``) is disabled and restored when ``hunter.stop()`` is called. **BACKWARDS INCOMPATIBLE** * Fixed ``CodePrinter`` to show module name if it fails to get any sources. @@ -249,7 +423,7 @@ Changelog * Allowed setting the `stream` to a file name (option on :class:`hunter.actions.VarsPrinter` and :class:`hunter.actions.CodePrinter`). * Bumped up the filename alignment to 40 cols. -* If not merging then `self` is not kept as a previous tracer anymore. +* If not merging then ``self`` is not kept as a previous tracer anymore. Closes `#16 `_. * Fixed handling in VarsPrinter: properly print eval errors and don't try to show anything if there's an AttributeError. Closes `#18 `_. diff --git a/CONTRIBUTING.rst b/CONTRIBUTING.rst index 02c29cf9..1ec15597 100644 --- a/CONTRIBUTING.rst +++ b/CONTRIBUTING.rst @@ -41,7 +41,7 @@ To set up `python-hunter` for local development: (look for the "Fork" button). 2. Clone your fork locally:: - git clone git@github.com:ionelmc/python-hunter.git + git clone git@github.com:YOURGITHUBNAME/python-hunter.git 3. Create a branch for local development:: @@ -49,7 +49,7 @@ To set up `python-hunter` for local development: Now you can make your changes locally. -4. When you're done making changes, run all the checks, doc builder and spell checker with `tox `_ one command:: +4. When you're done making changes run all the checks and docs builder with one command:: tox @@ -68,16 +68,11 @@ If you need some code review or feedback while you're developing the code just m For merging, you should: -1. Include passing tests (run ``tox``) [1]_. +1. Include passing tests (run ``tox``). 2. Update documentation when there's new API, functionality etc. 3. Add a note to ``CHANGELOG.rst`` about the changes. 4. Add yourself to ``AUTHORS.rst``. -.. [1] If you don't have all the necessary python versions available locally you can rely on Travis - it will - `run the tests `_ for each change you add in the pull request. - - It will be slower though ... - Tips ---- @@ -85,6 +80,6 @@ To run a subset of tests:: tox -e envname -- pytest -k test_myfeature -To run all the test environments in *parallel* (you need to ``pip install detox``):: +To run all the test environments in *parallel*:: - detox + tox -p auto diff --git a/LICENSE b/LICENSE index af0c96fc..c774d659 100644 --- a/LICENSE +++ b/LICENSE @@ -1,7 +1,6 @@ BSD 2-Clause License -Copyright (c) 2015-2019, Ionel Cristian Mărieș -All rights reserved. +Copyright (c) 2015-2025, Ionel Cristian Mărieș. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: diff --git a/README.rst b/README.rst index 603bb048..2def86d6 100644 --- a/README.rst +++ b/README.rst @@ -10,28 +10,20 @@ Overview * - docs - |docs| * - tests - - | |travis| |appveyor| |requires| |codecov| + - |github-actions| |codecov| * - package - - | |version| |wheel| |supported-versions| |supported-implementations| |commits-since| + - |version| |wheel| |supported-versions| |supported-implementations| |commits-since| .. |docs| image:: https://readthedocs.org/projects/python-hunter/badge/?style=flat - :target: https://readthedocs.org/projects/python-hunter + :target: https://readthedocs.org/projects/python-hunter/ :alt: Documentation Status -.. |travis| image:: https://api.travis-ci.org/ionelmc/python-hunter.svg?branch=master - :alt: Travis-CI Build Status - :target: https://travis-ci.org/ionelmc/python-hunter +.. |github-actions| image:: https://github.com/ionelmc/python-hunter/actions/workflows/github-actions.yml/badge.svg + :alt: GitHub Actions Build Status + :target: https://github.com/ionelmc/python-hunter/actions -.. |appveyor| image:: https://ci.appveyor.com/api/projects/status/github/ionelmc/python-hunter?branch=master&svg=true - :alt: AppVeyor Build Status - :target: https://ci.appveyor.com/project/ionelmc/python-hunter - -.. |requires| image:: https://requires.io/github/ionelmc/python-hunter/requirements.svg?branch=master - :alt: Requirements Status - :target: https://requires.io/github/ionelmc/python-hunter/requirements/?branch=master - -.. |codecov| image:: https://codecov.io/github/ionelmc/python-hunter/coverage.svg?branch=master +.. |codecov| image:: https://codecov.io/gh/ionelmc/python-hunter/branch/master/graphs/badge.svg?branch=master :alt: Coverage Status - :target: https://codecov.io/github/ionelmc/python-hunter + :target: https://app.codecov.io/github/ionelmc/python-hunter .. |version| image:: https://img.shields.io/pypi/v/hunter.svg :alt: PyPI Package latest release @@ -49,9 +41,9 @@ Overview :alt: Supported implementations :target: https://pypi.org/project/hunter -.. |commits-since| image:: https://img.shields.io/github/commits-since/ionelmc/python-hunter/v3.1.3.svg +.. |commits-since| image:: https://img.shields.io/github/commits-since/ionelmc/python-hunter/v3.9.0.svg :alt: Commits since latest release - :target: https://github.com/ionelmc/python-hunter/compare/v3.1.3...master + :target: https://github.com/ionelmc/python-hunter/compare/v3.9.0...master @@ -59,8 +51,8 @@ Overview Hunter is a flexible code tracing toolkit, not for measuring coverage, but for debugging, logging, inspection and other nefarious purposes. It has a `simple Python API `_, -a `convenient terminal API `_ and -a `CLI tool to attach to processes `_. +a `convenient terminal API `_ and +a `CLI tool to attach to processes `_. * Free software: BSD 2-Clause License @@ -77,8 +69,8 @@ Documentation https://python-hunter.readthedocs.io/ -Overview -======== +Getting started +=============== Basic use involves passing various filters to the ``trace`` option. An example: @@ -119,6 +111,14 @@ In a terminal it would look like: .. image:: https://raw.githubusercontent.com/ionelmc/python-hunter/master/docs/code-trace.png +Another useful scenario is to ignore all standard modules and force colors to make them stay even if the output is +redirected to a file. + +.. sourcecode:: python + + import hunter + hunter.trace(stdlib=False, action=hunter.CallPrinter(force_colors=True)) + Actions ------- @@ -385,7 +385,7 @@ confusion and inconsistency). This has few consequences: * Layering is minimal. There's are some `helpers `_ that do some argument processing and conversions to save you some typing but that's about it. * The library doesn't try to hide the mechanics of tracing in Python - it's 1:1 regarding what Python sends to a trace function if you'd be - using `sys.settrace `_. + using `sys.settrace `_. * Doesn't have any storage. You are expected to redirect output to a file. You should look at it like it's a tool to help you understand and debug big applications, or a framework ridding you of the boring parts of @@ -397,7 +397,7 @@ FAQ Why not Smiley? --------------- -There's some obvious overlap with `smiley `_ but there are few fundamental differences: +There's some obvious overlap with `smiley `_ but there are few fundamental differences: * Complexity. Smiley is simply over-engineered: @@ -432,7 +432,7 @@ In contrast, Hunter is very simple: Why not pytrace? ---------------- -`Pytrace `_ is another tracer tool. It seems quite similar to Smiley - it uses a sqlite +`Pytrace `_ is another tracer tool. It seems quite similar to Smiley - it uses a sqlite database for the events, threads and IPC, thus it's reasonable to expect the same kind of problems. Why not PySnooper or snoop? @@ -445,7 +445,7 @@ where Hunter provides more flexible setup, filtering capabilities, speed and bre Why not coverage? ----------------- -For purposes of debugging `coverage `_ is a great tool but only as far as "debugging +For purposes of debugging `coverage `_ is a great tool but only as far as "debugging by looking at what code is (not) run". Checking branch coverage is good but it will only get you as far. From the other perspective, you'd be wondering if you could use Hunter to measure coverage-like things. You could do it but @@ -455,3 +455,14 @@ recording. In other words, filtering events is the main selling point of Hunter - it's fast (cython implementation) and the query API is flexible enough. + +Projects using Hunter +===================== + +Noteworthy usages or Hunter (submit a PR with your project if you built a tool that relies on hunter): + +* `Crunch-io/diagnose `_ - a runtime instrumentation library. +* `talwrii/huntrace `_ - an alternative cli (similar to ltrace). +* `anki-code/xunter `_ - a profiling tool made specifically for `the xonsh shell `_. + +More projects using it at https://github.com/ionelmc/python-hunter/network/dependents diff --git a/build_backend/backend.py b/build_backend/backend.py new file mode 100644 index 00000000..da6a44f2 --- /dev/null +++ b/build_backend/backend.py @@ -0,0 +1,5 @@ +from setuptools import build_meta +from setuptools.build_meta import * # noqa + +if hasattr(build_meta, 'build_editable'): + del build_editable # noqa: F821 diff --git a/ci/appveyor-with-compiler.cmd b/ci/appveyor-with-compiler.cmd deleted file mode 100644 index 289585fc..00000000 --- a/ci/appveyor-with-compiler.cmd +++ /dev/null @@ -1,23 +0,0 @@ -:: Very simple setup: -:: - if WINDOWS_SDK_VERSION is set then activate the SDK. -:: - disable the WDK if it's around. - -SET COMMAND_TO_RUN=%* -SET WIN_SDK_ROOT=C:\Program Files\Microsoft SDKs\Windows -SET WIN_WDK="c:\Program Files (x86)\Windows Kits\10\Include\wdf" -ECHO SDK: %WINDOWS_SDK_VERSION% ARCH: %PYTHON_ARCH% - -IF EXIST %WIN_WDK% ( - REM See: https://connect.microsoft.com/VisualStudio/feedback/details/1610302/ - REN %WIN_WDK% 0wdf -) -IF "%WINDOWS_SDK_VERSION%"=="" GOTO main - -SET DISTUTILS_USE_SDK=1 -SET MSSdk=1 -"%WIN_SDK_ROOT%\%WINDOWS_SDK_VERSION%\Setup\WindowsSdkVer.exe" -q -version:%WINDOWS_SDK_VERSION% -CALL "%WIN_SDK_ROOT%\%WINDOWS_SDK_VERSION%\Bin\SetEnv.cmd" /x64 /release - -:main -ECHO Executing: %COMMAND_TO_RUN% -CALL %COMMAND_TO_RUN% || EXIT 1 diff --git a/ci/bootstrap.py b/ci/bootstrap.py index 86b8640d..ee69e2c5 100755 --- a/ci/bootstrap.py +++ b/ci/bootstrap.py @@ -1,64 +1,55 @@ #!/usr/bin/env python -# -*- coding: utf-8 -*- -from __future__ import absolute_import -from __future__ import print_function -from __future__ import unicode_literals - import os +import pathlib import subprocess import sys -from os.path import abspath -from os.path import dirname -from os.path import exists -from os.path import join -base_path = dirname(dirname(abspath(__file__))) +base_path: pathlib.Path = pathlib.Path(__file__).resolve().parent.parent +templates_path = base_path / 'ci' / 'templates' def check_call(args): - print("+", *args) + print('+', *args) subprocess.check_call(args) def exec_in_env(): - env_path = join(base_path, ".tox", "bootstrap") - if sys.platform == "win32": - bin_path = join(env_path, "Scripts") + env_path = base_path / '.tox' / 'bootstrap' + if sys.platform == 'win32': + bin_path = env_path / 'Scripts' else: - bin_path = join(env_path, "bin") - if not exists(env_path): - import subprocess - - print("Making bootstrap env in: {0} ...".format(env_path)) + bin_path = env_path / 'bin' + if not env_path.exists(): + print(f'Making bootstrap env in: {env_path} ...') try: - check_call([sys.executable, "-m", "venv", env_path]) + check_call([sys.executable, '-m', 'venv', env_path]) except subprocess.CalledProcessError: try: - check_call([sys.executable, "-m", "virtualenv", env_path]) + check_call([sys.executable, '-m', 'virtualenv', env_path]) except subprocess.CalledProcessError: - check_call(["virtualenv", env_path]) - print("Installing `jinja2` into bootstrap environment...") - check_call([join(bin_path, "pip"), "install", "jinja2", "tox"]) - python_executable = join(bin_path, "python") - if not os.path.exists(python_executable): - python_executable += '.exe' + check_call(['virtualenv', env_path]) + print('Installing `jinja2` into bootstrap environment...') + check_call([bin_path / 'pip', 'install', 'jinja2', 'tox']) + python_executable = bin_path / 'python' + if not python_executable.exists(): + python_executable = python_executable.with_suffix('.exe') + + print(f'Re-executing with: {python_executable}') + print('+ exec', python_executable, __file__, '--no-env') + os.execv(python_executable, [python_executable, __file__, '--no-env']) - print("Re-executing with: {0}".format(python_executable)) - print("+ exec", python_executable, __file__, "--no-env") - os.execv(python_executable, [python_executable, __file__, "--no-env"]) def main(): import jinja2 - print("Project path: {0}".format(base_path)) + print(f'Project path: {base_path}') jinja = jinja2.Environment( - loader=jinja2.FileSystemLoader(join(base_path, "ci", "templates")), + loader=jinja2.FileSystemLoader(str(templates_path)), trim_blocks=True, lstrip_blocks=True, - keep_trailing_newline=True + keep_trailing_newline=True, ) - tox_environments = [ line.strip() # 'tox' need not be installed globally, but must be importable @@ -69,20 +60,22 @@ def main(): for line in subprocess.check_output([sys.executable, '-m', 'tox', '--listenvs'], universal_newlines=True).splitlines() ] tox_environments = [line for line in tox_environments if line.startswith('py')] - - for name in os.listdir(join("ci", "templates")): - with open(join(base_path, name), "w") as fh: - fh.write(jinja.get_template(name).render(tox_environments=tox_environments)) - print("Wrote {}".format(name)) - print("DONE.") + for template in templates_path.rglob('*'): + if template.is_file(): + template_path = template.relative_to(templates_path).as_posix() + destination = base_path / template_path + destination.parent.mkdir(parents=True, exist_ok=True) + destination.write_text(jinja.get_template(template_path).render(tox_environments=tox_environments)) + print(f'Wrote {template_path}') + print('DONE.') -if __name__ == "__main__": +if __name__ == '__main__': args = sys.argv[1:] - if args == ["--no-env"]: + if args == ['--no-env']: main() elif not args: exec_in_env() else: - print("Unexpected arguments {0}".format(args), file=sys.stderr) + print(f'Unexpected arguments: {args}', file=sys.stderr) sys.exit(1) diff --git a/ci/requirements.txt b/ci/requirements.txt index 1c8d385b..c1a28073 100644 --- a/ci/requirements.txt +++ b/ci/requirements.txt @@ -1,3 +1,5 @@ -virtualenv>=16.6.0 -pip>=19.1.1 -setuptools>=18.0.1 +pip>=25 +setuptools>=80 +setuptools_scm>=8 +tox>=4 +virtualenv>=20.34 diff --git a/ci/templates/.appveyor.yml b/ci/templates/.appveyor.yml deleted file mode 100644 index 24caef4a..00000000 --- a/ci/templates/.appveyor.yml +++ /dev/null @@ -1,72 +0,0 @@ -version: '{branch}-{build}' -build: off -environment: - global: - TWINE_USERNAME: ionel - matrix: - - TOXENV: check - TOXPYTHON: C:\Python36\python.exe - PYTHON_HOME: C:\Python36 - PYTHON_VERSION: '3.6' - PYTHON_ARCH: '32' -{% for env in tox_environments %} -{% if env.startswith(('py2', 'py3')) %} - - TOXENV: {{ env }}{% if env.endswith('-cover') %},codecov{% endif %}{{ "" }} - TOXPYTHON: C:\Python{{ env[2:4] }}\python.exe - PYTHON_HOME: C:\Python{{ env[2:4] }} - PYTHON_VERSION: '{{ env[2] }}.{{ env[3] }}' - PYTHON_ARCH: '32' -{% if "cython-nocov" in env %} - WHEEL_PATH: .tox/dist -{% endif %} - - TOXENV: {{ env }}{% if env.endswith('-cover') %},codecov{% endif %}{{ '' }} - TOXPYTHON: C:\Python{{ env[2:4] }}-x64\python.exe - PYTHON_HOME: C:\Python{{ env[2:4] }}-x64 - PYTHON_VERSION: '{{ env[2] }}.{{ env[3] }}' - PYTHON_ARCH: '64' -{% if "cython-nocov" in env %} - WHEEL_PATH: .tox/dist -{% endif %} -{% if env.startswith('py2') %} - WINDOWS_SDK_VERSION: v7.0 -{% endif %} -{% endif %}{% endfor %} -init: - - ps: echo $env:TOXENV - - ps: ls C:\Python* -install: - - ps: | - Set-PSDebug -Trace 1 - if ($Env:TOXENV.StartsWith("py38")) { - if ($Env:PYTHON_ARCH -eq "64") { - iex "choco install python3 --version=3.8 --no-progress --params /InstallDir:$Env:PYTHON_HOME" - } else { - iex "choco install python3 --version=3.8 --no-progress --params /InstallDir:$Env:PYTHON_HOME --x86" - } - } - - '%PYTHON_HOME%\python -mpip install --progress-bar=off twine tox-wheel -rci/requirements.txt' - - '%PYTHON_HOME%\Scripts\virtualenv --version' - - '%PYTHON_HOME%\Scripts\easy_install --version' - - '%PYTHON_HOME%\Scripts\pip --version' - - '%PYTHON_HOME%\Scripts\tox --version' -test_script: - - ps: | - Set-PSDebug -Trace 1 - if ($Env:WHEEL_PATH) { - cmd /E:ON /V:ON /C .\ci\appveyor-with-compiler.cmd $Env:PYTHON_HOME\Scripts\tox --wheel - if ($LastExitCode -eq 0) { - $ErrorActionPreference = "Stop" - iex "$Env:PYTHON_HOME\Scripts\twine check $Env:WHEEL_PATH/*.whl" - iex "$Env:PYTHON_HOME\Scripts\twine upload --repository-url https://test.pypi.org/legacy/ --skip-existing $Env:WHEEL_PATH/*.whl" - } - } else { - cmd /E:ON /V:ON /C .\ci\appveyor-with-compiler.cmd $Env:PYTHON_HOME\Scripts\tox - } - if ($LastExitCode -ne 0) { - Get-ChildItem Env: - Get-Content .tox\*\log\* - } - -### To enable remote debugging uncomment this (also, see: http://www.appveyor.com/docs/how-to/rdp-to-build-worker): -# on_finish: -# - ps: $blockRdp = $true; iex ((new-object net.webclient).DownloadString('https://raw.githubusercontent.com/appveyor/ci/master/scripts/enable-rdp.ps1')) diff --git a/ci/templates/.github/workflows/github-actions.yml b/ci/templates/.github/workflows/github-actions.yml new file mode 100644 index 00000000..2c70b412 --- /dev/null +++ b/ci/templates/.github/workflows/github-actions.yml @@ -0,0 +1,141 @@ +name: build +on: [push, pull_request, workflow_dispatch] +jobs: + test: + name: {{ '${{ matrix.name }}' }} + runs-on: {{ '${{ matrix.os }}' }} + timeout-minutes: 30 + strategy: + fail-fast: false + matrix: + include: + - name: 'check' + python: '3.13' + tox_env: 'check' + os: 'ubuntu-latest' + - name: 'docs' + python: '3.13' + tox_env: 'docs' + os: 'ubuntu-latest' +{% for env in tox_environments %} +{% set prefix = env.split('-')[0] -%} +{% set freethreaded = prefix.endswith('t') %} +{% if prefix.startswith('pypy') %} +{% set python %}pypy-{{ prefix[4] }}.{{ prefix[5:] }}{% endset %} +{% set cpython %}pp{{ prefix[4:5] }}{% endset %} +{% elif prefix.startswith('py314') %} +{% set python %}3.14.0-rc.2{% endset %} +{% set cpython %}cp314{% endset %} +{% else %} +{% set python %}{{ prefix[2] }}.{{ prefix[3:].rstrip('t') }}{% endset %} +{% set cpython %}cp{{ prefix[2:] }}{% endset %} +{% endif %} +{% for os, python_arch, cibw_arch, wheel_arch, include_cover in [ + ['ubuntu', 'x64', 'x86_64', '*manylinux*', True], + ['ubuntu', 'x64', 'x86_64', '*musllinux*', False], + ['ubuntu', 'x64', 'aarch64', '*manylinux*', False], + ['ubuntu', 'x64', 'aarch64', '*musllinux*', False], + ['windows', 'x64', 'AMD64', '*', True], + ['windows', 'x86', 'x86', '*', False], + ['macos', 'arm64', 'arm64', '*', True], +] %} +{% if include_cover or (env.endswith('cython-nocov') and not prefix.startswith('pypy')) %} +{% set wheel_suffix = env.endswith('cython-nocov') and wheel_arch.strip('*') %} +{% set name_suffix = '/' + wheel_suffix if wheel_suffix else '' %} + - name: '{{ env }} ({{ os }}/{{ cibw_arch }}{{ name_suffix }})' + artifact: '{{ env.rsplit('-', 1)[0] }}-{{ os }}-{{ cibw_arch }}{{ name_suffix.replace('/', '-') }}' + python: '{{ python }}' + python_arch: '{{ python_arch }}{% if freethreaded %}-freethreaded{% endif %}' + tox_env: '{{ env }}' +{% if 'cover' in env %} + cover: true +{% endif %} + cibw_arch: '{{ cibw_arch }}' +{% if env.endswith('cython-nocov') and not prefix.startswith('pypy') %} + cibw_build: '{{ cpython }}-{{ wheel_arch }}' + cibw_ft: '{% if freethreaded %}true{% else %}false{% endif %}' +{% else %} + cibw_build: false +{% endif %} + os: '{{ os }}-latest' +{% endif %} +{% endfor %} +{% endfor %} + steps: + - uses: docker/setup-qemu-action@v3 + if: matrix.cibw_arch == 'aarch64' + with: + platforms: arm64 + - uses: actions/checkout@v4 + with: + fetch-depth: 0 + - uses: actions/setup-python@v5 + with: + python-version: {{ '${{ matrix.python }}' }} + architecture: {{ '${{ matrix.python_arch }}' }} + - name: install dependencies + run: | + python -mpip install --progress-bar=off cibuildwheel -r ci/requirements.txt + virtualenv --version + pip --version + tox --version + pip list --format=freeze + - name: install dependencies (gdb) + if: > + !matrix.cibw_build && matrix.os == 'ubuntu' + run: | + sudo apt-get install gdb + echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope + - name: cibw build and test + if: matrix.cibw_build + run: cibuildwheel + env: + CIBW_ARCHS: '{{ '${{ matrix.cibw_arch }}' }}' + CIBW_BUILD: '{{ '${{ matrix.cibw_build }}' }}' + CIBW_CONTAINER_ENGINE: "docker; create_args: --cap-add=SYS_PTRACE" + CIBW_ENABLE: cpython-freethreading + CIBW_BUILD_VERBOSITY: '3' + CIBW_TEST_REQUIRES: > + tox + tox-direct + CIBW_TEST_COMMAND: > + cd {project} && + tox --skip-pkg-install --direct-yolo -e {{ '${{ matrix.tox_env }}' }} -vv + CIBW_TEST_COMMAND_WINDOWS: > + cd /d {project} && + tox --skip-pkg-install --direct-yolo -e {{ '${{ matrix.tox_env }}' }} -vv + - name: regular build and test + if: > + !matrix.cibw_build + run: > + tox -e {{ '${{ matrix.tox_env }}' }} -vv + - uses: codecov/codecov-action@v5 + if: matrix.cover + with: + verbose: true + flags: {{ '${{ matrix.tox_env }}' }} + - name: check wheel + if: > + !matrix.cibw_ft && matrix.cibw_build + run: | + python -mpip install --progress-bar=off twine + twine check wheelhouse/*.whl + - name: upload wheel + uses: actions/upload-artifact@v4 + if: matrix.cibw_build + with: + name: {{ 'wheel-${{ matrix.artifact }}' }} + path: wheelhouse/*.whl + finish: + needs: test + if: {{ '${{ always() }}' }} + runs-on: ubuntu-latest + steps: + - uses: actions/upload-artifact/merge@v4 + with: + name: all-wheels + - uses: codecov/codecov-action@v5 + with: + verbose: true + token: {% raw %}${{ secrets.CODECOV_TOKEN }}{% endraw %} +{{ '' }} diff --git a/ci/templates/.travis.yml b/ci/templates/.travis.yml deleted file mode 100644 index 8e75b7a7..00000000 --- a/ci/templates/.travis.yml +++ /dev/null @@ -1,105 +0,0 @@ -language: python -dist: xenial -cache: false -git: - depth: false -addons: - apt: - packages: - - gdb -env: - global: - - LD_PRELOAD=/lib/x86_64-linux-gnu/libSegFault.so - - SEGFAULT_SIGNALS=all - - PYTEST_ADDOPTS=--benchmark-disable - - TWINE_USERNAME=ionel -matrix: - include: - - python: '3.8' - env: - - TOXENV=cythonize - script: - - | - ( - set -eux - tox -v - git update-index --ignore-submodules --refresh - if ! git diff-files --exit-code --ignore-submodules; then - echo "C files are stale!" - exit 1 - fi - ) - - python: '3.8' - env: - - TOXENV=check - - python: '3.8' - env: - - TOXENV=docs -{%- for env in tox_environments %}{{ '' }} -{%- if 'py37' in env or 'py27' in env %}{{ '' }} - - os: osx - language: generic - env: - - TOXENV={{ env|replace('py37', 'py3') }} - - SETUPPY_CFLAGS= -{%- if "cython-nocov" in env %}{{ '' }} - - WHEEL_PATH=.tox/dist -{%- endif %} -{%- endif %}{{ '' }} - - env: - - TOXENV={{ env }}{% if 'cover' in env %},codecov{% endif %} -{%- if 'pypy' not in env and 'nocov' in env %}{{ '' }} - - WHEEL_MANYLINUX1=cp{{ env.split('-')[0][2:] }} - - WHEEL_PATH=wheelhouse -{%- endif %} -{%- if env.startswith('pypy3') %}{{ '' }} - - TOXPYTHON=pypy3 - python: 'pypy3' -{%- elif env.startswith('pypy') %}{{ '' }} - python: 'pypy' -{%- else %}{{ '' }} - python: '{{ '{0[2]}.{0[3]}'.format(env) }}' -{%- endif %} -{%- endfor %}{{ '' }} -before_install: - - python --version - - uname -a - - lsb_release -a || true - - sudo sysctl -w kernel.yama.ptrace_scope=0 || true - - | - if [[ $TRAVIS_OS_NAME == 'osx' ]]; then - brew update-reset - [[ $TOXENV =~ py3 ]] && brew upgrade python - [[ $TOXENV =~ py2 ]] && brew install python@2 - export PATH="/usr/local/opt/python/libexec/bin:${PATH}" - fi -install: - - python -mpip install --progress-bar=off twine tox-wheel -rci/requirements.txt - - virtualenv --version - - easy_install --version - - pip --version - - tox --version -script: - - | - ( - set -eux - if [[ -n ${WHEEL_MANYLINUX1:-} ]]; then - docker run --rm --user $UID -itv $(pwd):/code ionelmc/manylinux $WHEEL_MANYLINUX1 - tox --installpkg $WHEEL_PATH/*.whl -v - elif [[ -n ${WHEEL_PATH:-} ]]; then - tox -v --wheel - else - tox -v - fi - if [[ -n ${WHEEL_PATH:-} ]]; then - twine check $WHEEL_PATH/*.whl - twine upload --repository-url https://test.pypi.org/legacy/ --skip-existing $WHEEL_PATH/*.whl - fi - ) -after_failure: - - more .tox/log/* | cat - - more .tox/*/log/* | cat -notifications: - email: - on_success: never - on_failure: always diff --git a/docs/conf.py b/docs/conf.py index 69ecfcd2..20ebe577 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -1,8 +1,4 @@ -# -*- coding: utf-8 -*- -from __future__ import unicode_literals - import os -import traceback os.environ['PUREPYTHONHUNTER'] = 'yes' @@ -18,49 +14,48 @@ 'sphinx.ext.todo', 'sphinx.ext.viewcode', ] -if os.getenv('SPELLCHECK'): - extensions += 'sphinxcontrib.spelling', - spelling_show_suggestions = True - spelling_lang = 'en_US' - source_suffix = '.rst' master_doc = 'index' project = 'Hunter' -year = '2015-2019' +year = '2015-2025' author = 'Ionel Cristian Mărieș' -copyright = '{0}, {1}'.format(year, author) +copyright = f'{year}, {author}' try: - from pkg_resources import get_distribution - version = release = get_distribution('hunter').version + from importlib import metadata + + version = release = metadata.version('hunter') except Exception: + import traceback + traceback.print_exc() - version = release = '3.1.3' + version = release = '3.9.0' pygments_style = 'trac' templates_path = ['.'] extlinks = { - 'issue': ('https://github.com/ionelmc/python-hunter/issues/%s', '#'), - 'pr': ('https://github.com/ionelmc/python-hunter/pull/%s', 'PR #'), + 'issue': ('https://github.com/ionelmc/python-hunter/issues/%s', '#%s'), + 'pr': ('https://github.com/ionelmc/python-hunter/pull/%s', 'PR #%s'), } -import sphinx_py3doc_enhanced_theme -html_theme = "sphinx_py3doc_enhanced_theme" -html_theme_path = [sphinx_py3doc_enhanced_theme.get_html_theme_path()] + +html_theme = 'furo' html_theme_options = { - 'githuburl': 'https://github.com/ionelmc/python-hunter/' + 'source_repository': 'https://github.com/ionelmc/python-hunter/', + 'source_branch': 'master', + 'source_directory': 'docs/', + 'footer_icons': [ + { + 'url': 'https://github.com/ionelmc/python-hunter/', + 'html': 'github.com/ionelmc/python-hunter', + }, + ], } + html_use_smartypants = True html_last_updated_fmt = '%b %d, %Y' html_split_index = False -html_sidebars = { - '**': ['searchbox.html', 'globaltoc.html', 'sourcelink.html'], -} -html_short_title = '%s-%s' % (project, version) +html_short_title = f'{project}-{version}' napoleon_use_ivar = True napoleon_use_rtype = False napoleon_use_param = False - -autosummary_generate = True - -autosectionlabel_prefix_document = True diff --git a/docs/configuration.rst b/docs/configuration.rst index 990c3091..de4f3dfe 100644 --- a/docs/configuration.rst +++ b/docs/configuration.rst @@ -4,7 +4,7 @@ Configuration Default predicates and action kwargs defaults can be configured via a ``PYTHONHUNTERCONFIG`` environment variable. -All the action kwargs: +All the :ref:`actions` kwargs: * ``klass`` * ``stream`` @@ -38,4 +38,3 @@ Notes: which is the equivalent of:: PYTHONHUNTER="Q(module_startswith='django')&Q(module_startswith='celery')" - diff --git a/docs/cookbook.rst b/docs/cookbook.rst index 040d9bcf..af495134 100644 --- a/docs/cookbook.rst +++ b/docs/cookbook.rst @@ -66,6 +66,25 @@ directory (assuming the filename is going to be a relative path): PYTHONHUNTER='~Q(filename_startswith="/")' python setup.py build +Debugging a test +================ + +In tests it is convenient to ignore everything that is in ``stdlib`` and ``site-packages`` and start hunter right before +the tested function. + +.. sourcecode:: python + + from hunter import trace, Q + trace(Q(stdlib=False), ~Q(filename_contains='site-packages')) + +It also helps to save output into a file to compare different runs. An example below uses ``pytest`` with ``-k`` option +to select and tun a test or tests with string ``some`` in name. The output is then piped to ``testout1`` file. + +.. sourcecode:: python + + pytest test/test_simple.py -k some &> testout1 + + Needle in the haystack ====================== @@ -122,7 +141,7 @@ Say you want to stop tracing after 1000 events, you'd do this: "Probe" - lightweight tracing ============================= -Based on Robert Brewer's `FunctionProbe `_ +Based on Robert Brewer's `FunctionProbe `_ example. The use-case is that you'd like to trace a huge application and running a tracer (even a cython one) would have a too @@ -175,11 +194,18 @@ of tracing just inside the target function (eg: ``probe('module.func', local=Tru filtering to trim irrelevant events from around the function (like return from tracer setup, and the internals of the decorator), in addition to what :func:`hunter.trace` does. Not exactly lightweight... +.. _silenced-exception-runtime-analysis: + Silenced exception runtime analysis =================================== Finding code that discards exceptions is sometimes really hard. +.. note:: + + This was made available in :class:`hunter.actions.ErrorSnooper` for convenience. This cookbook entry will remain for educational + purposes. + While this is easy to find with a ``grep "except:" -R .``: .. code-block:: python @@ -227,9 +253,9 @@ If you can't simply review all the sourcecode then runtime analysis is one way t if event.depth > self.depth: # too many details return elif event.depth < self.depth and event.kind == 'return': # stop if function returned - op = event.code.co_code[event.frame.f_lasti] + op = event.instruction op = op if isinstance(op, int) else ord(op) - if op == RETURN_VALUE: + if op in RETURN_OPCODES: self.output("{BRIGHT}{fore(BLUE)}{} tracing {} on {}{RESET}\n", ">" * 46, event.function, self.exc) for event in self.events: @@ -249,4 +275,144 @@ If you can't simply review all the sourcecode then runtime analysis is one way t Take note about the use of :meth:`~hunter.event.Event.detach` and :meth:`~hunter.actions.ColorStreamAction.output`. +Profiling +========= + +Hunter can be used to implement profiling (measure function timings). + +The most basic implementation that only measures timings looks like this: + +.. code-block:: python + + from hunter.actions import Action + from hunter.actions import RETURN_OPCODES + + class ProfileAction(Action): + def __init__(self): + self.timings = {} + + def __call__(self, event): + if event.kind == 'call': + self.timings[id(event.frame)] = time() + elif event.kind == 'return': + start_time = self.timings.pop(id(event.frame), None) + if start_time is None: + return + delta = time() - start_time + print(f'{event.function} returned: {event.arg}. Duration: {delta:.4f}s\n') + +If you don't care about exceptions at all this will be fine, but then you might just as well use a real profiler. +When exceptions occur Python send this to the tracer: + +* .. code-block:: python + + event.kind="exception", event.arg=(exc_value, exc_type, tb) + +* .. code-block:: python + + event.kind="return", event.arg=None + +Unfortunately Python emits the return event even if the exception wasn't discarded so we need to do some extra checks around the last +bytecode instruction that run at the return event. + +This means that we have to store the exception for a little while, and do the check at return: + +.. code-block:: python + + from hunter.actions import Action + from hunter.actions import RETURN_OPCODES + + class ProfileAction(Action): + def __init__(self): + self.timings = {} + + def __call__(self, event): + current_time = time() + frame_id = id(event.frame) + + if event.kind == 'call': + self.timings[frame_id] = current_time, None + elif frame_id in self.timings: + start_time, depth, exception = self.timings.pop(frame_id) + + if event.kind == 'exception': + # store the exception + # (there will be a followup 'return' event in which we deal with it) + self.timings[frame_id] = start_time, event.arg + elif event.kind == 'return': + delta = current_time - start_time + if event.instruction in RETURN_OPCODES: + # exception was discarded + print(f'{event.function} returned: {event.arg}. Duration: {delta:.4f}s\n') + else: + print(f'{event.function} raised exception: {exception}. Duration: {delta:.4f}s\n') + +If you try that example you may notice that it's not completely equivalent to any of the profilers available out there: data for builtin +functions is missing. + +Python does in fact have a profiling mode (eg: ``hunter.trace(profile=True``) and that will make hunter use ``sys.setprofile`` instead +of ``sys.setrace``. However there are some downsides with that API: + +* exception data will be missing (most likely because profiling is designed for speed and tracebacks are costly to build) +* trace events for builtin functions do not have their own frame objects (so we need to cater for that) + +Behold, a `ProfileAction` that works in any mode: + +.. code-block:: python + + from hunter.actions import ColorStreamAction + from hunter.actions import RETURN_OPCODES + + class ProfileAction(ColorStreamAction): + # using ColorStreamAction brings this more in line with the other actions + # (stream option, coloring and such, see the other examples for colors) + def __init__(self, **kwargs): + self.timings = {} + super(ProfileAction, self).__init__(**kwargs) + + def __call__(self, event): + current_time = time() + # include event.builtin in the id so we don't have problems + # with Python reusing frame objects from the previous call for builtin calls + frame_id = id(event.frame), str(event.builtin) + + if event.kind == 'call': + self.timings[frame_id] = current_time, None + elif frame_id in self.timings: + start_time, exception = self.timings.pop(frame_id) + + # try to find a complete function name for display + function_object = event.function_object + if event.builtin: + function = '.{}'.format(event.arg.__name__) + elif function_object: + if hasattr(function_object, '__qualname__'): + function = '{}.{}'.format( + function_object.__module__, function_object.__qualname__ + ) + else: + function = '{}.{}'.format( + function_object.__module__, + function_object.__name__ + ) + else: + function = event.function + + if event.kind == 'exception': + # store the exception + # (there will be a followup 'return' event in which we deal with it) + self.timings[frame_id] = start_time, event.arg + elif event.kind == 'return': + delta = current_time - start_time + if event.instruction in RETURN_OPCODES: + # exception was discarded + self.output( + '{fore(BLUE)}{} returned: {}. Duration: {:.4f}s{RESET}\n', + function, safe_repr(event.arg), delta + ) + else: + self.output( + '{fore(RED)}{} raised exception: {}. Duration: {:.4f}s{RESET}\n', + function, safe_repr(exception), delta + ) diff --git a/docs/filtering.rst b/docs/filtering.rst new file mode 100644 index 00000000..3e4c1b03 --- /dev/null +++ b/docs/filtering.rst @@ -0,0 +1,61 @@ +========= +Filtering +========= + +A list of all the keyword filters that :obj:`hunter.trace` or :obj:`hunter.Q` accept: + +* ``arg`` - you probably don't care about this - it may have a value for return/exception events +* ``builtin`` (`bool`) - ``True`` if function is a builtin function +* ``calls`` (`int`) - a call counter, you can use it to limit output by using a ``lt`` operator +* ``depth`` (`int`) - call depth, starts from 0, increases for call events and decreases for returns +* ``filename`` (`str`) +* ``fullsource`` (`str`) - sourcecode for the executed lines (may be multiple lines in some situations) +* ``function`` (`str`) - function name +* ``globals`` (`dict`) - global variables +* ``instruction`` (`int` or `str`, depending on Python version) - current executed bytecode, + see :ref:`silenced-exception-runtime-analysis` for example usage +* ``kind`` (`str`) - one of 'call', 'exception', 'line' or 'return' +* ``lineno`` (`int`) +* ``locals`` (`dict`) - local variables +* ``module`` (`str`) - dotted module +* ``source`` (`str`) - sourcecode for the executed line +* ``stdlib`` (`bool`) - ``True`` if module is from stdlib +* ``threadid`` (`int`) +* ``threadname`` (`str`) - whatever `threading.Thread.name `_ + returns + +You can append operators to the above filters. Note that some of of the filters won't work well with the `bool` or `int` types. + +* ``contains`` - works best with `str`, for + example ``module_contains='foobar'`` translates to ``'foobar' in event.module`` +* ``has`` - alias for ``contains`` +* ``endswith`` - works best with `str`, for + example ``module_endswith='foobar'`` translates to ``event.module.endswith('foobar')``. You can also pass in a iterable, + example ``module_endswith=('foo', 'bar')`` is `acceptable `_ +* ``ew`` - alias for ``endswith`` +* ``gt`` - works best with `int`, for example ``lineno_gt=100`` translates to ``event.lineno > 100`` +* ``gte`` - works best with `int`, for example ``lineno_gte=100`` translates to ``event.lineno >= 100`` +* ``in`` - a membership test, for example ``module_in=('foo', 'bar')`` translates to ``event.module in ('foo', 'bar')``. You can use any + iterable, for example ``module_in='foo bar'`` translates to ``event.module in 'foo bar'``, and that would probably have the same result + as the first example +* ``lt`` - works best with `int`, for example ``calls_lt=100`` translates to ``event.calls < 100`` +* ``lte`` - works best with `int`, for example ``depth_lte=100`` translates to ``event.depth <= 100`` +* ``regex`` - works best with `str`, for + example ``module_regex=r'(test|test.*)\b'`` translates to ``re.match(r'(test|test.*)\b', event.module)`` +* ``rx`` - alias for ``regex`` +* ``startswith`` - works best with `str`, for + example ``module_startswith='foobar'`` translates to ``event.module.startswith('foobar')``. You can also pass in a iterable, + example ``module_startswith=('foo', 'bar')`` is `acceptable `_ +* ``sw`` - alias for ``startswith`` + +Notes: + +* you can also use double underscore (if you're too used to Django query lookups), eg: ``module__has='foobar'`` is acceptable +* there's nothing smart going on for the dots in module names so sometimes you might need to account for said dots: + + * ``module_sw='foo'`` will match ``"foo.bar"`` and ``"foobar"`` - if you want to avoid matchin the later you could do either of: + + * ``Q(module='foo')|Q(module_sw='foo.')`` + * ``Q(module_rx=r'foo($|\.)')`` - but this might cost you in speed + * ``Q(filename_sw='/path/to/foo/')`` - probably the fastest + * ``Q(filename_has='/foo/')`` - avoids putting in the full path but might match unwanted paths diff --git a/docs/index.rst b/docs/index.rst index cce1d429..2dfdee8f 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -10,6 +10,7 @@ Contents introduction remote configuration + filtering cookbook reference contributing @@ -22,4 +23,3 @@ Indices and tables * :ref:`genindex` * :ref:`modindex` * :ref:`search` - diff --git a/docs/reference.rst b/docs/reference.rst index 1383f837..f400a138 100644 --- a/docs/reference.rst +++ b/docs/reference.rst @@ -1,9 +1,9 @@ Reference ========= -.. autosummary:: +.. _helpers-summary: -.. highlights:: :ref:`reference:Helpers` +.. highlights:: :ref:`Helpers` .. autosummary:: @@ -11,12 +11,13 @@ Reference hunter.stop hunter.wrap hunter.And + hunter.Backlog hunter.From hunter.Not hunter.Or hunter.Q -.. highlights:: :ref:`reference:Actions` +.. highlights:: :ref:`Actions` .. autosummary:: @@ -26,27 +27,28 @@ Reference hunter.actions.Debugger hunter.actions.ErrorSnooper hunter.actions.Manhole + hunter.actions.StackPrinter hunter.actions.VarsPrinter hunter.actions.VarsSnooper .. warning:: The following (Predicates and Internals) have Cython implementations in modules prefixed with "_". - They should be imported from the ``hunter`` module, not ``hunter.something`` to be sure you get the right implementation. + They should be imported from the ``hunter`` module, not ``hunter.something`` to be sure you get the best available implementation. -.. highlights:: :ref:`reference:Predicates` +.. highlights:: :ref:`Predicates` .. autosummary:: - hunter.predicates.Query - hunter.predicates.From - hunter.predicates.When hunter.predicates.And + hunter.predicates.Backlog + hunter.predicates.From hunter.predicates.Not hunter.predicates.Or hunter.predicates.Query + hunter.predicates.When -.. highlights:: :ref:`reference:Internals` +.. highlights:: :ref:`Internals` .. autosummary:: @@ -70,6 +72,8 @@ Helpers .. autofunction:: hunter.And +.. autofunction:: hunter.Backlog + .. autofunction:: hunter.From .. autofunction:: hunter.Not @@ -78,6 +82,7 @@ Helpers .. autofunction:: hunter.Q + ---- Actions @@ -107,6 +112,10 @@ Actions :members: :special-members: +.. autoclass:: hunter.actions.StackPrinter(depth=15, limit=2, stream=sys.stderr, force_colors=False, force_pid=False, filename_alignment=40, thread_alignment=12, pid_alignment=9, repr_limit=1024, repr_func='safe_repr') + :members: + :special-members: + .. autoclass:: hunter.actions.VarsPrinter(name, [name, [name, [...]]], stream=sys.stderr, force_colors=False, force_pid=False, filename_alignment=40, thread_alignment=12, pid_alignment=9, repr_limit=1024, repr_func='safe_repr') :members: :special-members: @@ -123,13 +132,19 @@ Predicates .. warning:: These have Cython implementations in modules prefixed with "_". - They should be imported from the ``hunter`` module, not ``hunter.something`` to be sure you get the right implementation. -.. autoclass:: hunter.predicates.Query + Note that: + + * Every predicate except :class:`~hunter.predicates.When` has a :ref:`helper ` importable directly from the + ``hunter`` package. + * Ideally you'd use the helpers instead of these to get the best available implementation, extra validation and + better argument handling. + +.. autoclass:: hunter.predicates.And :members: :special-members: -.. autoclass:: hunter.predicates.When +.. autoclass:: hunter.predicates.Backlog :members: :special-members: @@ -137,7 +152,7 @@ Predicates :members: :special-members: -.. autoclass:: hunter.predicates.And +.. autoclass:: hunter.predicates.Not :members: :special-members: @@ -145,7 +160,11 @@ Predicates :members: :special-members: -.. autoclass:: hunter.predicates.Not +.. autoclass:: hunter.predicates.Query + :members: + :special-members: + +.. autoclass:: hunter.predicates.When :members: :special-members: @@ -157,7 +176,7 @@ Internals .. warning:: These have Cython implementations in modules prefixed with "_". - They should be imported from the ``hunter`` module, not ``hunter.something`` to be sure you get the right implementation. + They should be imported from the ``hunter`` module, not ``hunter.something`` to be sure you get the best available implementation. Normally these are not used directly. Perhaps just the :class:`~hunter.tracer.Tracer` may be used directly for performance reasons. diff --git a/docs/remote.rst b/docs/remote.rst index e89f2138..944a9ae5 100644 --- a/docs/remote.rst +++ b/docs/remote.rst @@ -2,7 +2,7 @@ Remote tracing ============== -Hunter supports tracing local processes, with two backends: `manhole `_ and GDB. +Hunter supports tracing local processes, with two backends: `manhole `_ and GDB. For now Windows isn't supported. Using GDB is risky (if anything goes wrong your process will probably be hosed up badly) so the Manhole backend is diff --git a/docs/requirements.txt b/docs/requirements.txt index 6234ed0f..c03e307a 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -1,2 +1,2 @@ sphinx>=1.3 -sphinx-py3doc-enhanced-theme>=2.3.2 +furo diff --git a/pyproject.toml b/pyproject.toml index 23cf6d7e..9c1450c9 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,123 @@ [build-system] requires = [ - "setuptools>=30.3.0", - "wheel", - "setuptools_scm>=3.3.1", + "setuptools>=80", + "setuptools_scm>=8", ] +build-backend = "setuptools.build_meta" + +[project] +dynamic = [ + "readme", + "version", +] +name = "hunter" +license = "BSD-2-Clause" +license-files = ["LICENSE"] +description = "Hunter is a flexible code tracing toolkit." +authors = [ + { name = "Ionel Cristian Mărieș", email = "contact@ionelmc.ro" }, +] +classifiers = [ + # complete classifier list: http://pypi.python.org/pypi?%3Aaction=list_classifiers + "Development Status :: 5 - Production/Stable", + "Intended Audience :: Developers", + "Operating System :: Unix", + "Operating System :: POSIX", + "Operating System :: Microsoft :: Windows", + "Programming Language :: Python", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3 :: Only", + "Programming Language :: Python :: 3.9", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", + "Programming Language :: Python :: Implementation :: CPython", + "Programming Language :: Python :: Implementation :: PyPy", + "Topic :: Utilities", + "Topic :: Software Development :: Debuggers", +] +keywords = [ + "trace", + "tracer", + "settrace", + "debugger", + "debugging", + "code", + "source", +] +requires-python = ">=3.9" +dependencies = [ + "manhole>=1.5; platform_system!='Windows'", +] + +[project.optional-dependencies] +# rst = ["docutils>=0.11"] + +[project.scripts] +hunter-trace = "hunter.remote:main" + +[project.urls] +"Sources" = "https://github.com/ionelmc/python-hunter" +"Documentation" = "https://python-hunter.readthedocs.io/" +"Changelog" = "https://python-hunter.readthedocs.io/en/latest/changelog.html" +"Issue Tracker" = "https://github.com/ionelmc/python-hunter/issues" + +[tool.setuptools_scm] +local_scheme = "dirty-tag" +write_to = "src/hunter/_version.py" +fallback_version = "3.9.0" + +[tool.ruff] +extend-exclude = ["static", "ci/templates"] +line-length = 140 +src = ["src", "tests"] +target-version = "py39" + +[tool.cython-lint] +max-line-length = 140 + +[tool.ruff.lint.per-file-ignores] +"ci/*" = ["S"] +"tests/*" = ["ALL"] + +[tool.ruff.lint] +ignore = [ + "RUF001", # ruff-specific rules ambiguous-unicode-character-string + "S101", # flake8-bandit assert + "S307", + "S308", # flake8-bandit suspicious-mark-safe-usage + "E501", # pycodestyle line-too-long + "PLC0415", # import-outside-top-level +] +select = [ + "B", # flake8-bugbear + "C4", # flake8-comprehensions + "DTZ", # flake8-datetimez + "E", # pycodestyle errors + "EXE", # flake8-executable + "F", # pyflakes + "I", # isort + "INT", # flake8-gettext + "PIE", # flake8-pie + "PLC", # pylint convention + "PLE", # pylint errors + "PT", # flake8-pytest-style + "RSE", # flake8-raise + "RUF", # ruff-specific rules + "S", # flake8-bandit + "UP", # pyupgrade + "W", # pycodestyle warnings +] + +[tool.ruff.lint.flake8-pytest-style] +fixture-parentheses = false +mark-parentheses = false + +[tool.ruff.lint.isort] +extra-standard-library = ["opcode"] +forced-separate = ["conftest"] +force-single-line = true + +[tool.ruff.format] +quote-style = "single" diff --git a/pytest.ini b/pytest.ini new file mode 100644 index 00000000..52bf885a --- /dev/null +++ b/pytest.ini @@ -0,0 +1,36 @@ +[pytest] +# If a pytest section is found in one of the possible config files +# (pytest.ini, tox.ini or setup.cfg), then pytest will not look for any others, +# so if you add a pytest config section elsewhere, +# you will need to delete this section from setup.cfg. +norecursedirs = + .git + .tox + .env + dist + build + migrations + +python_files = + test_*.py + *_test.py + tests.py +addopts = + -ra + --strict-markers + --ignore=docs/conf.py + --ignore=setup.py + --ignore=ci + --ignore=.eggs + --tb=short +testpaths = + tests + +# Idea from: https://til.simonwillison.net/pytest/treat-warnings-as-errors +filterwarnings = + error + ignore:Plugin file tracers .Cython.Coverage.Plugin. aren::: +# You can add exclusions, some examples: +# ignore:'hunter' defines default_app_config:PendingDeprecationWarning:: +# ignore:The {{% if::: +# ignore:Coverage disabled via --no-cov switch! diff --git a/setup.cfg b/setup.cfg deleted file mode 100644 index b71b6007..00000000 --- a/setup.cfg +++ /dev/null @@ -1,21 +0,0 @@ -[flake8] -max-line-length = 140 -exclude = tests - -[tool:pytest] -testpaths = - tests -addopts = - -ra - --strict - --tb=short - -[tool:isort] -force_single_line = True -line_length = 120 -known_first_party = hunter -default_section = THIRDPARTY -forced_separate = test_hunter -not_skip = __init__.py -skip = migrations -known_standard_library = opcode diff --git a/setup.py b/setup.py old mode 100644 new mode 100755 index eedf0048..ec67ced1 --- a/setup.py +++ b/setup.py @@ -1,27 +1,19 @@ #!/usr/bin/env python -# -*- encoding: utf-8 -*- -from __future__ import absolute_import -from __future__ import print_function - -import io import os import re -from distutils.command.build import build -from glob import glob +import sys from itertools import chain -from os.path import basename -from os.path import dirname -from os.path import join -from os.path import relpath -from os.path import splitext +from pathlib import Path from setuptools import Extension -from setuptools import find_packages +from setuptools import find_namespace_packages from setuptools import setup +from setuptools.command.build import build from setuptools.command.build_ext import build_ext from setuptools.command.develop import develop from setuptools.command.easy_install import easy_install from setuptools.command.install_lib import install_lib +from setuptools.dist import Distribution try: # Allow installing package without any Cython available. This @@ -31,43 +23,44 @@ Cython = None -def read(*names, **kwargs): - with io.open( - join(dirname(__file__), *names), - encoding=kwargs.get('encoding', 'utf8') - ) as fh: - return fh.read() +# Enable code coverage for C code: we cannot use CFLAGS=-coverage in tox.ini, since that may mess with compiling +# dependencies (e.g. numpy). Therefore, we set SETUPPY_CFLAGS=-coverage in tox.ini and copy it to CFLAGS here (after +# deps have been safely installed). +if 'TOX_ENV_NAME' in os.environ and os.environ.get('SETUPPY_EXT_COVERAGE') == 'yes': + CFLAGS = os.environ['CFLAGS'] = '-DCYTHON_TRACE=1 -DCYTHON_USE_SYS_MONITORING=0' + LFLAGS = os.environ['LFLAGS'] = '' +else: + CFLAGS = os.environ['CFLAGS'] = '-DCYTHON_USE_SYS_MONITORING=0' + LFLAGS = '' + +allow_extensions = True +if '__pypy__' in sys.builtin_module_names: + print('NOTICE: C extensions disabled on PyPy (would be broken)!') + allow_extensions = False +if os.environ.get('SETUPPY_FORCE_PURE'): + print('NOTICE: C extensions disabled (SETUPPY_FORCE_PURE)!') + allow_extensions = False + +pth_file = str(Path(__file__).parent.joinpath('src', 'hunter.pth')) class BuildWithPTH(build): def run(self): - build.run(self) - src = join(dirname(__file__), 'src', 'hunter.embed') - path = join(dirname(__file__), 'src', 'hunter.pth') - with open(src) as sh: - with open(path, 'w') as fh: - fh.write( - 'import os, sys;' - 'exec(%r)' % sh.read().replace(' ', ' ') - ) - dest = join(self.build_lib, basename(path)) - self.copy_file(path, dest) + super().run() + self.copy_file(pth_file, str(Path(self.build_lib, 'hunter.pth'))) class EasyInstallWithPTH(easy_install): - def run(self): - easy_install.run(self) - path = join(dirname(__file__), 'src', 'hunter.pth') - dest = join(self.install_dir, basename(path)) - self.copy_file(path, dest) + def run(self, *args, **kwargs): + super().run(*args, **kwargs) + self.copy_file(pth_file, str(Path(self.install_dir, 'hunter.pth'))) class InstallLibWithPTH(install_lib): def run(self): - install_lib.run(self) - path = join(dirname(__file__), 'src', 'hunter.pth') - dest = join(self.install_dir, basename(path)) - self.copy_file(path, dest) + super().run() + dest = str(Path(self.install_dir, 'hunter.pth')) + self.copy_file(pth_file, dest) self.outputs = [dest] def get_outputs(self): @@ -76,31 +69,32 @@ def get_outputs(self): class DevelopWithPTH(develop): def run(self): - develop.run(self) - path = join(dirname(__file__), 'src', 'hunter.pth') - dest = join(self.install_dir, basename(path)) - self.copy_file(path, dest) + super().run() + self.copy_file(pth_file, str(Path(self.install_dir, 'hunter.pth'))) class OptionalBuildExt(build_ext): - """Allow the building of C extensions to fail.""" + """ + Allow the building of C extensions to fail. + """ + def run(self): try: - if 'SETUPPY_NOEXT' in os.environ: - raise Exception("C extensions disabled (SETUPPY_NOEXT)!") - build_ext.run(self) + super().run() except Exception as e: self._unavailable(e) self.extensions = [] # avoid copying missing files (it would fail). def _unavailable(self, e): print('*' * 80) - print('''WARNING: + print( + """WARNING: An optional code optimization (C extension) could not be compiled. Optimizations for this package will not be available! - ''') + """ + ) print('CAUSE:') print('') @@ -108,72 +102,31 @@ def _unavailable(self, e): print('*' * 80) +class BinaryDistribution(Distribution): + """ + Distribution which almost always forces a binary package with platform name + """ + + def has_ext_modules(self): + return super().has_ext_modules() or not os.environ.get('SETUPPY_ALLOW_PURE') + + +def read(*names, **kwargs): + with Path(__file__).parent.joinpath(*names).open(encoding=kwargs.get('encoding', 'utf8')) as fh: + return fh.read() + + setup( - name='hunter', - use_scm_version={ - 'local_scheme': 'dirty-tag', - 'write_to': 'src/hunter/_version.py', - 'fallback_version': '3.1.3', - }, - license='BSD-2-Clause', - description='Hunter is a flexible code tracing toolkit.', - long_description='%s\n%s' % ( + long_description='{}\n{}'.format( re.compile('^.. start-badges.*^.. end-badges', re.M | re.S).sub('', read('README.rst')), - re.sub(':[a-z]+:`~?(.*?)`', r'``\1``', read('CHANGELOG.rst')) + re.sub(':[a-z]+:`~?(.*?)`', r'``\1``', read('CHANGELOG.rst')), ), - author='Ionel Cristian Mărieș', - author_email='contact@ionelmc.ro', - url='https://github.com/ionelmc/python-hunter', - packages=find_packages('src'), + long_description_content_type='text/x-rst', + packages=find_namespace_packages('src'), package_dir={'': 'src'}, - py_modules=[splitext(basename(path))[0] for path in glob('src/*.py')], + py_modules=[path.stem for path in Path('src').glob('*.py')], + include_package_data=True, zip_safe=False, - classifiers=[ - # complete classifier list: http://pypi.python.org/pypi?%3Aaction=list_classifiers - 'Development Status :: 5 - Production/Stable', - 'Intended Audience :: Developers', - 'License :: OSI Approved :: BSD License', - 'Operating System :: Unix', - 'Operating System :: POSIX', - 'Operating System :: Microsoft :: Windows', - 'Programming Language :: Python', - 'Programming Language :: Python :: 2.7', - 'Programming Language :: Python :: 3', - 'Programming Language :: Python :: 3.5', - 'Programming Language :: Python :: 3.6', - 'Programming Language :: Python :: 3.7', - 'Programming Language :: Python :: 3.8', - 'Programming Language :: Python :: Implementation :: CPython', - 'Programming Language :: Python :: Implementation :: PyPy', - 'Topic :: Utilities', - 'Topic :: Software Development :: Debuggers', - ], - project_urls={ - 'Documentation': 'https://python-hunter.readthedocs.io/', - 'Changelog': 'https://python-hunter.readthedocs.io/en/latest/changelog.html', - 'Issue Tracker': 'https://github.com/ionelmc/python-hunter/issues', - }, - keywords=[ - 'trace', 'tracer', 'settrace', 'debugger', 'debugging', 'code', 'source' - ], - python_requires='>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*', - install_requires=[ - 'colorama', - ], - extras_require={ - ':platform_system != "Windows"': ['manhole >= 1.5'], - }, - setup_requires=[ - 'setuptools_scm>=3.3.1', - 'cython', - ] if Cython else [ - 'setuptools_scm>=3.3.1', - ], - entry_points={ - 'console_scripts': [ - 'hunter-trace = hunter.remote:main', - ] - }, cmdclass={ 'build': BuildWithPTH, 'easy_install': EasyInstallWithPTH, @@ -183,12 +136,15 @@ def _unavailable(self, e): }, ext_modules=[ Extension( - splitext(relpath(path, 'src').replace(os.sep, '.'))[0], - sources=[path], - extra_compile_args=os.environ.get('SETUPPY_CFLAGS', '').split(), - include_dirs=[dirname(path)] + str(path.relative_to('src').with_suffix('')).replace(os.sep, '.'), + sources=[str(path)], + extra_compile_args=CFLAGS.split(), + extra_link_args=LFLAGS.split(), + include_dirs=[str(path.parent)], ) - for root, _, _ in os.walk('src') - for path in glob(join(root, '*.pyx' if Cython else '*.c')) - ], + for path in Path('src').glob('**/*.pyx' if Cython else '**/*.c') + ] + if allow_extensions + else [], + distclass=BinaryDistribution if allow_extensions else None, ) diff --git a/src/hunter.embed b/src/hunter.embed deleted file mode 100644 index 6ac1065b..00000000 --- a/src/hunter.embed +++ /dev/null @@ -1,7 +0,0 @@ -from __future__ import print_function -if "PYTHONHUNTER" in os.environ: - try: - from hunter import * - eval("trace({[PYTHONHUNTER]})".format(os.environ)) - except Exception as exc: - sys.stderr.write("Failed to load hunter from PYTHONHUNTER environ variable {[PYTHONHUNTER]!r}: {!r}\n".format(os.environ, exc)) diff --git a/src/hunter.pth b/src/hunter.pth index b5a5f008..70cf2af8 100644 --- a/src/hunter.pth +++ b/src/hunter.pth @@ -1 +1 @@ -import os, sys;exec('from __future__ import print_function\nif "PYTHONHUNTER" in os.environ:\n try:\n from hunter import *\n eval("trace({[PYTHONHUNTER]})".format(os.environ))\n except Exception as exc:\n sys.stderr.write("Failed to load hunter from PYTHONHUNTER environ variable {[PYTHONHUNTER]!r}: {!r}\\n".format(os.environ, exc))\n') \ No newline at end of file +import hunter; hunter._embed_via_environment() diff --git a/src/hunter/__init__.py b/src/hunter/__init__.py index 0817b04c..8616a596 100644 --- a/src/hunter/__init__.py +++ b/src/hunter/__init__.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import - import atexit import functools import inspect @@ -14,38 +12,42 @@ from .actions import Debugger from .actions import ErrorSnooper from .actions import Manhole +from .actions import StackPrinter from .actions import VarsPrinter from .actions import VarsSnooper try: - if os.environ.get("PUREPYTHONHUNTER"): - raise ImportError("Cython speedups are disabled.") + if os.environ.get('PUREPYTHONHUNTER'): + raise ImportError('Cython speedups are disabled.') from ._event import Event from ._predicates import And as _And + from ._predicates import Backlog as _Backlog from ._predicates import From as _From from ._predicates import Not as _Not from ._predicates import Or as _Or - from ._predicates import When from ._predicates import Query + from ._predicates import When from ._tracer import Tracer except ImportError: from .event import Event # noqa from .predicates import And as _And + from .predicates import Backlog as _Backlog from .predicates import From as _From from .predicates import Not as _Not from .predicates import Or as _Or - from .predicates import When from .predicates import Query + from .predicates import When from .tracer import Tracer try: from ._version import version as __version__ except ImportError: - __version__ = '3.1.3' + __version__ = '3.9.0' __all__ = ( 'And', + 'Backlog', 'CallPrinter', 'CodePrinter', 'Debugger', @@ -56,24 +58,60 @@ 'Or', 'Q', 'Query', + 'StackPrinter', 'VarsPrinter', 'VarsSnooper', 'When', - 'stop', 'trace', ) THREADING_SUPPORT_ALIASES = ( - "threading_support", "threads_support", "thread_support", - "threadingsupport", "threadssupport", "threadsupport", - "threading", "threads", "thread", + 'threading_support', + 'threads_support', + 'thread_support', + 'threadingsupport', + 'threadssupport', + 'threadsupport', + 'threading', + 'threads', + 'thread', ) +TRACER_OPTION_NAMES = (*THREADING_SUPPORT_ALIASES, 'clear_env_var', 'profile') _last_tracer = None _default_trace_args = None _default_config = {} _default_stream = sys.stderr +def _embed_via_environment(): + if 'PYTHONHUNTER' in os.environ: + try: + eval( + f'trace({os.environ["PYTHONHUNTER"]})', + { + 'And': And, + 'Backlog': Backlog, + 'CallPrinter': CallPrinter, + 'CodePrinter': CodePrinter, + 'Debugger': Debugger, + 'ErrorSnooper': ErrorSnooper, + 'From': From, + 'Manhole': Manhole, + 'Not': Not, + 'Or': Or, + 'Q': Q, + 'Query': Query, + 'StackPrinter': StackPrinter, + 'VarsPrinter': VarsPrinter, + 'VarsSnooper': VarsSnooper, + 'When': When, + 'trace': trace, + }, + ) + except Exception as exc: + sys.stderr.write(f'Failed to load hunter from PYTHONHUNTER environ variable {os.environ["PYTHONHUNTER"]!r}: {exc!r}\n') + + def _prepare_config(*args, **kwargs): _default_config.clear() _default_config.update((key.lower(), val) for key, val in kwargs.items()) @@ -81,20 +119,20 @@ def _prepare_config(*args, **kwargs): predicates = [] for key, value in list(_default_config.items()): - if key in THREADING_SUPPORT_ALIASES or key == "clear_env_var": + if key in TRACER_OPTION_NAMES: options[key] = _default_config.pop(key) continue elif key in ( # builtin actions config - "klass", - "stream", - "force_colors", - "force_pid", - "filename_alignment", - "thread_alignment", - "pid_alignment", - "repr_limit", - "repr_func", + 'klass', + 'stream', + 'force_colors', + 'force_pid', + 'filename_alignment', + 'thread_alignment', + 'pid_alignment', + 'repr_limit', + 'repr_func', ): continue @@ -107,14 +145,12 @@ def _prepare_config(*args, **kwargs): continue _default_config.pop(key) - sys.stderr.write("Discarded config from PYTHONHUNTERCONFIG {}={!r}: Unknown option\n".format( - key, value)) + sys.stderr.write(f'Discarded config from PYTHONHUNTERCONFIG {key}={value!r}: Unknown option\n') for position, predicate in enumerate(args): if callable(predicate): predicates.append(predicate) else: - sys.stderr.write("Discarded config from PYTHONHUNTERCONFIG {} (position {}): Not a callable\n".format( - predicate, position)) + sys.stderr.write(f'Discarded config from PYTHONHUNTERCONFIG {predicate} (position {position}): Not a callable\n') return predicates, options @@ -128,30 +164,27 @@ def Q(*predicates, **query): See Also: :class:`hunter.predicates.Query` """ - optional_actions = query.pop("actions", []) - if "action" in query: - optional_actions.append(query.pop("action")) + optional_actions = query.pop('actions', []) + if 'action' in query: + optional_actions.append(query.pop('action')) for p in predicates: if not callable(p): - raise TypeError("Predicate {0!r} is not callable.".format(p)) + raise TypeError(f'Predicate {p!r} is not callable.') for a in optional_actions: if not callable(a): - raise TypeError("Action {0!r} is not callable.".format(a)) + raise TypeError(f'Action {a!r} is not callable.') if predicates: - predicates = tuple( - p() if inspect.isclass(p) and issubclass(p, Action) else p - for p in predicates - ) + predicates = tuple(p() if inspect.isclass(p) and issubclass(p, Action) else p for p in predicates) if any(isinstance(p, (CallPrinter, CodePrinter)) for p in predicates): # the user provided an action as a filter, remove the action then to prevent double output for action in optional_actions: if action in (CallPrinter, CodePrinter) or isinstance(action, (CallPrinter, CodePrinter)): optional_actions.remove(action) if query: - predicates += Query(**query), + predicates += (Query(**query),) result = And(*predicates) else: @@ -163,6 +196,15 @@ def Q(*predicates, **query): return result +def _merge(*predicates, **query): + if predicates: + if query: + predicates += (Query(**query),) + return And(*predicates) + else: + return Query(**query) + + def _flatten(cls, predicate, *predicates): if not predicates: return predicate @@ -188,7 +230,7 @@ def And(*predicates, **kwargs): Args: *predicates (callables): Callables that returns True/False or :class:`hunter.predicates.Query` objects. - **kwargs: Arguments that may be passed to :class:`hunter.predicates.Query` + **kwargs: Arguments that may be passed to :class:`hunter.predicates.Query`. Returns: A :class:`hunter.predicates.And` instance. @@ -196,7 +238,7 @@ def And(*predicates, **kwargs): :class:`hunter.predicates.And` """ if kwargs: - predicates += Query(**kwargs), + predicates += (Query(**kwargs),) return _flatten(_And, *predicates) @@ -234,7 +276,7 @@ def Not(*predicates, **kwargs): :class:`hunter.predicates.Not` """ if kwargs: - predicates += Query(**kwargs), + predicates += (Query(**kwargs),) if len(predicates) > 1: return _Not(_flatten(_And, *predicates)) else: @@ -262,15 +304,56 @@ def From(condition=None, predicate=None, watermark=0, **kwargs): """ if predicate is None and condition is None: condition_kwargs = {key: value for key, value in kwargs.items() if not key.startswith('depth') and not key.startswith('calls')} - predicate_kwargs = {key: value for key, value in kwargs.items() if key.startswith('depth') or key.startswith('calls')} + predicate_kwargs = {key: value for key, value in kwargs.items() if key.startswith(('depth', 'calls'))} return _From(Q(**condition_kwargs), Q(**predicate_kwargs), watermark) else: if kwargs: - raise TypeError("Unexpected arguments {}. Don't combine positional with keyword arguments.".format( - kwargs.keys())) + raise TypeError(f"Unexpected arguments {kwargs.keys()}. Don't combine positional with keyword arguments.") return _From(condition, predicate, watermark) +def Backlog(*conditions, **kwargs): + """ + Helper that merges kwargs and conditions prior to creating the :class:`~hunter.predicates.Backlog`. + + Args: + *conditions (callable): Optional :class:`~hunter.predicates.Query` object or a callable that returns True/False. + size (int): Number of events that the backlog stores. Effectively this is the ``maxlen`` for the internal deque. + stack (int): Stack size to fill. Setting this to ``0`` disables creating fake call events. + vars (bool): Makes global/local variables available in the stored events. + This is an expensive option - it will use ``action.try_repr`` on all the variables. + strip (bool): If this option is set then the backlog will be cleared every time an event matching the ``condition`` is found. + Disabling this may show more context every time an event matching the ``condition`` is found but said context may also be + duplicated across multiple matches. + action (ColorStreamAction): A ColorStreamAction to display the stored events when an event matching the ``condition`` is found. + filter (callable): Optional :class:`~hunter.predicates.Query` object or a callable that returns True/False to filter the stored + events with. + **kwargs: Arguments that are passed to :func:`hunter.Q`. Any kwarg that starts with "depth" or "calls" will be included `predicate`. + + See Also: + :class:`hunter.predicates.Backlog` + """ + action = kwargs.pop('action', CallPrinter) + filter = kwargs.pop('filter', None) + size = kwargs.pop('size', 100) + stack = kwargs.pop('stack', 10) + strip = kwargs.pop('strip', True) + vars = kwargs.pop('vars', False) + if not conditions and not kwargs: + raise TypeError( + "Backlog needs at least 1 condition (it doesn't have any effect without one besides making everything incredibly slow)." + ) + return _Backlog( + _merge(*conditions, **kwargs), + size=size, + stack=stack, + vars=vars, + strip=strip, + action=action, + filter=filter, + ) + + def stop(): """ Stop tracing. Restores previous tracer (if there was any). @@ -278,7 +361,7 @@ def stop(): global _last_tracer if _last_tracer is None: - warnings.warn('There is no tracer to stop.') + warnings.warn('There is no tracer to stop.', stacklevel=2) else: _last_tracer.stop() _last_tracer = None @@ -290,8 +373,8 @@ def __call__(self, event): def _prepare_predicate(*predicates, **options): - if "action" not in options and "actions" not in options: - options["action"] = CallPrinter + if 'action' not in options and 'actions' not in options: + options['action'] = CallPrinter return Q(*predicates, **options) @@ -335,7 +418,8 @@ def trace(*predicates, **options): predicates, options = _apply_config(predicates, options) - clear_env_var = options.pop("clear_env_var", False) + clear_env_var = options.pop('clear_env_var', False) + profiling_mode = options.pop('profile', False) threading_support = None for alias in THREADING_SUPPORT_ALIASES: if alias in options: @@ -343,12 +427,12 @@ def trace(*predicates, **options): predicate = _prepare_predicate(*predicates, **options) if clear_env_var: - os.environ.pop("PYTHONHUNTER", None) + os.environ.pop('PYTHONHUNTER', None) - _last_tracer = Tracer(threading_support) + _last_tracer = Tracer(threading_support, profiling_mode) @atexit.register - def atexit_cleanup(ref=weakref.ref(_last_tracer)): + def atexit_cleanup(ref=weakref.ref(_last_tracer)): # noqa: B008 maybe_tracer = ref() if maybe_tracer is not None: maybe_tracer.stop() @@ -380,27 +464,63 @@ def my_function(): """ def tracing_decorator(func): - @functools.wraps(func) - def tracing_wrapper(*args, **kwargs): - predicates = [] - local = trace_options.pop('local', False) - if local: - predicates.append(Query(depth_lt=2)) - predicates.append( - From( - Query(kind="call"), - Not(When( + predicates = [] + local = trace_options.pop('local', False) + if local: + predicates.append(Query(depth_lt=2)) + predicates.append( + From( + Query(kind='call', function=func.__name__), + Not( + When( Query(calls_gt=0, depth=0) & Not(Query(kind='return')), - Stop - )), - watermark=-1 - ) + Stop, + ) + ), + watermark=-1, ) - local_tracer = trace(*predicates, **trace_options) - try: - return func(*args, **kwargs) - finally: - local_tracer.stop() + ) + + if inspect.isasyncgenfunction(func): + + @functools.wraps(func) + async def tracing_wrapper(*args, **kwargs): + local_tracer = trace(*predicates, **trace_options) + try: + async for item in func(*args, **kwargs): + yield item + finally: + local_tracer.stop() + + elif inspect.iscoroutinefunction(func): + + @functools.wraps(func) + async def tracing_wrapper(*args, **kwargs): + local_tracer = trace(*predicates, **trace_options) + try: + return await func(*args, **kwargs) + finally: + local_tracer.stop() + + elif inspect.isgeneratorfunction(func): + + @functools.wraps(func) + def tracing_wrapper(*args, **kwargs): + local_tracer = trace(*predicates, **trace_options) + try: + yield from func(*args, **kwargs) + finally: + local_tracer.stop() + + else: + + @functools.wraps(func) + def tracing_wrapper(*args, **kwargs): + local_tracer = trace(*predicates, **trace_options) + try: + return func(*args, **kwargs) + finally: + local_tracer.stop() return tracing_wrapper @@ -412,15 +532,15 @@ def tracing_wrapper(*args, **kwargs): def load_config(*args, **kwargs): global _default_trace_args - try: - if args or kwargs: - _default_trace_args = _prepare_config(*args, **kwargs) - else: - _default_trace_args = eval("_prepare_config({})".format(os.environ.get("PYTHONHUNTERCONFIG", ''))) - except Exception as exc: - sys.stderr.write("Failed to load hunter config from PYTHONHUNTERCONFIG {[PYTHONHUNTERCONFIG]!r}: {!r}\n".format( - os.environ, exc)) - _default_trace_args = (), () + if args or kwargs: + _default_trace_args = _prepare_config(*args, **kwargs) + else: + config = os.environ.get('PYTHONHUNTERCONFIG', '') + try: + _default_trace_args = eval(f'_prepare_config({config})') + except Exception as exc: + sys.stderr.write(f'Failed to load hunter config from PYTHONHUNTERCONFIG {config!r}: {exc!r}\n') + _default_trace_args = (), () load_config() diff --git a/src/hunter/_event.c b/src/hunter/_event.c index 113c9fe4..f5efe0d5 100644 --- a/src/hunter/_event.c +++ b/src/hunter/_event.c @@ -1,20 +1,49 @@ -/* Generated by Cython 0.29.14 */ +/* Generated by Cython 3.1.3 */ +/* BEGIN: Cython Metadata +{ + "distutils": { + "depends": [ + "src/hunter/vendor/_compat.h" + ], + "extra_compile_args": [ + "-DCYTHON_USE_SYS_MONITORING=0" + ], + "include_dirs": [ + "src/hunter" + ], + "name": "hunter._event", + "sources": [ + "src/hunter/_event.pyx" + ] + }, + "module_name": "hunter._event" +} +END: Cython Metadata */ + +#ifndef PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN +#endif /* PY_SSIZE_T_CLEAN */ +/* InitLimitedAPI */ +#if defined(Py_LIMITED_API) && !defined(CYTHON_LIMITED_API) + #define CYTHON_LIMITED_API 1 +#endif + #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+. +#elif PY_VERSION_HEX < 0x03080000 + #error Cython requires Python 3.8+. #else -#define CYTHON_ABI "0_29_14" -#define CYTHON_HEX_VERSION 0x001D0EF0 +#define __PYX_ABI_VERSION "3_1_3" +#define CYTHON_HEX_VERSION 0x030103F0 #define CYTHON_FUTURE_DIVISION 1 +/* CModulePreamble */ #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif -#if !defined(WIN32) && !defined(MS_WINDOWS) +#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif @@ -33,9 +62,7 @@ #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG - #if PY_VERSION_HEX >= 0x02070000 - #define HAVE_LONG_LONG - #endif + #define HAVE_LONG_LONG #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG @@ -43,20 +70,21 @@ #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 __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX +#if defined(GRAALVM_PYTHON) + /* For very preliminary testing purposes. Most variables are set the same as PyPy. + The existence of this section does not imply that anything works or is even tested */ + #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 1 + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 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 @@ -67,95 +95,219 @@ #define CYTHON_USE_PYLONG_INTERNALS 0 #undef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1 #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 0 #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 -#elif defined(PYSTON_VERSION) - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 1 + #define CYTHON_USE_EXC_INFO_STACK 1 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(PYPY_VERSION) + #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_CPYTHON 0 - #ifndef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 1 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 #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_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_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #ifndef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 1 + #endif + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #if PY_VERSION_HEX < 0x03090000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PYPY_VERSION_NUM >= 0x07030C00) + #endif + #undef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_NUM >= 0x07031100) + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(CYTHON_LIMITED_API) + #ifdef Py_LIMITED_API + #undef __PYX_LIMITED_VERSION_HEX + #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API + #endif + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 1 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + #undef CYTHON_CLINE_IN_TRACEBACK + #define CYTHON_CLINE_IN_TRACEBACK 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 1 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #endif + #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 + #ifndef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0 #endif + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL (__PYX_LIMITED_VERSION_HEX >= 0x030C0000) #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 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif + #undef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #endif + #ifndef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND (__PYX_LIMITED_VERSION_HEX >= 0x030A0000) + #endif #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 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_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #ifdef Py_GIL_DISABLED + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 1 + #else + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + #endif + #if PY_VERSION_HEX < 0x030A0000 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #elif !defined(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 + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 #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 + #ifndef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif - #if PY_VERSION_HEX < 0x02070000 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #ifndef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 1 #endif - #ifndef CYTHON_USE_PYLIST_INTERNALS + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #elif !defined(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 + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING || PY_VERSION_HEX >= 0x030B00A2 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #elif !defined(CYTHON_USE_UNICODE_WRITER) @@ -164,36 +316,82 @@ #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1 + #elif !defined(CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS) + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0 + #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif + #ifndef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 1 + #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #elif !defined(CYTHON_FAST_GIL) + #define CYTHON_FAST_GIL (PY_VERSION_HEX < 0x030C00A6) + #endif + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 1 + #endif #ifndef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 1 #endif + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif + #ifndef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING (PY_VERSION_HEX >= 0x030d00B1) #endif #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) + #define CYTHON_USE_TP_FINALIZE 1 #endif - #ifndef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) + #ifndef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND 1 + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #elif !defined(CYTHON_USE_DICT_VERSIONS) + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5 && !CYTHON_USE_MODULE_STATE) #endif #ifndef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) + #define CYTHON_USE_EXC_INFO_STACK 1 + #endif + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS (!CYTHON_COMPILING_IN_CPYTHON_FREETHREADING) + #endif +#endif +#ifndef CYTHON_FAST_PYCCALL +#define CYTHON_FAST_PYCCALL CYTHON_FAST_PYCALL +#endif +#ifndef CYTHON_VECTORCALL +#if CYTHON_COMPILING_IN_LIMITED_API +#define CYTHON_VECTORCALL (__PYX_LIMITED_VERSION_HEX >= 0x030C0000) +#else +#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) #endif -#if !defined(CYTHON_FAST_PYCCALL) -#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif +#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) #if CYTHON_USE_PYLONG_INTERNALS - #include "longintrepr.h" #undef SHIFT #undef BASE #undef MASK @@ -201,6 +399,9 @@ enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; #endif #endif +#ifndef CYTHON_LOCK_AND_GIL_DEADLOCK_AVOIDANCE_TIME + #define CYTHON_LOCK_AND_GIL_DEADLOCK_AVOIDANCE_TIME 100 +#endif #ifndef __has_attribute #define __has_attribute(x) 0 #endif @@ -218,6 +419,17 @@ #define CYTHON_RESTRICT #endif #endif +#ifndef CYTHON_UNUSED + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(maybe_unused) + #define CYTHON_UNUSED [[maybe_unused]] + #endif + #endif + #endif +#endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) @@ -231,42 +443,76 @@ # define CYTHON_UNUSED # endif #endif -#ifndef CYTHON_MAYBE_UNUSED_VAR +#ifndef CYTHON_UNUSED_VAR # if defined(__cplusplus) - template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } + template void CYTHON_UNUSED_VAR( const T& ) { } # else -# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# define CYTHON_UNUSED_VAR(x) (void)(x) # endif #endif +#ifndef CYTHON_MAYBE_UNUSED_VAR + #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) +#endif #ifndef CYTHON_NCP_UNUSED -# if CYTHON_COMPILING_IN_CPYTHON +# if CYTHON_COMPILING_IN_CPYTHON && !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING # define CYTHON_NCP_UNUSED # else # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif +#ifndef CYTHON_USE_CPP_STD_MOVE + #if defined(__cplusplus) && (\ + __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) + #define CYTHON_USE_CPP_STD_MOVE 1 + #else + #define CYTHON_USE_CPP_STD_MOVE 0 + #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; + typedef unsigned char uint8_t; + typedef unsigned short uint16_t; + typedef unsigned int uint32_t; #else - typedef unsigned __int8 uint8_t; - typedef unsigned __int32 uint32_t; + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; + #endif + #endif + #if _MSC_VER < 1300 + #ifdef _WIN64 + typedef unsigned long long __pyx_uintptr_t; + #else + typedef unsigned int __pyx_uintptr_t; + #endif + #else + #ifdef _WIN64 + typedef unsigned __int64 __pyx_uintptr_t; + #else + typedef unsigned __int32 __pyx_uintptr_t; #endif #endif #else - #include + #include + typedef uintptr_t __pyx_uintptr_t; #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]] + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(fallthrough) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif #endif #endif #ifndef CYTHON_FALLTHROUGH @@ -276,14 +522,31 @@ #define CYTHON_FALLTHROUGH #endif #endif - #if defined(__clang__ ) && defined(__apple_build_version__) + #if defined(__clang__) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif +#ifndef Py_UNREACHABLE + #define Py_UNREACHABLE() assert(0); abort() +#endif +#ifdef __cplusplus + template + struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; + #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) +#else + #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) +#endif +#if CYTHON_COMPILING_IN_PYPY == 1 + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000) +#else + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000) +#endif +#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) +/* CInitCode */ #ifndef CYTHON_INLINE #if defined(__clang__) #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) @@ -298,26 +561,72 @@ #endif #endif -#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) - #define Py_OptimizeFlag 0 -#endif +/* PythonCompatibility */ #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" -#if PY_VERSION_HEX >= 0x030800A4 && PY_VERSION_HEX < 0x030800B2 - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_New(a, 0, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) -#else - #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_BUILTIN_MODULE_NAME "builtins" +#define __Pyx_DefaultClassType PyType_Type +#if CYTHON_COMPILING_IN_LIMITED_API + #ifndef CO_OPTIMIZED + static int CO_OPTIMIZED; + #endif + #ifndef CO_NEWLOCALS + static int CO_NEWLOCALS; + #endif + #ifndef CO_VARARGS + static int CO_VARARGS; + #endif + #ifndef CO_VARKEYWORDS + static int CO_VARKEYWORDS; + #endif + #ifndef CO_ASYNC_GENERATOR + static int CO_ASYNC_GENERATOR; + #endif + #ifndef CO_GENERATOR + static int CO_GENERATOR; + #endif + #ifndef CO_COROUTINE + static int CO_COROUTINE; + #endif +#else + #ifndef CO_COROUTINE + #define CO_COROUTINE 0x80 + #endif + #ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x200 + #endif +#endif +static int __Pyx_init_co_variables(void); +#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE) + #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) +#else + #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) + #define __Pyx_Py_Is(x, y) Py_Is(x, y) +#else + #define __Pyx_Py_Is(x, y) ((x) == (y)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) + #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) +#else + #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) #endif - #define __Pyx_DefaultClassType PyType_Type +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) + #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) +#else + #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) + #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) +#else + #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) +#endif +#define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) +#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) +#else + #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 @@ -331,10 +640,16 @@ #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif +#ifndef Py_TPFLAGS_SEQUENCE + #define Py_TPFLAGS_SEQUENCE 0 +#endif +#ifndef Py_TPFLAGS_MAPPING + #define Py_TPFLAGS_MAPPING 0 +#endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif -#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) +#ifndef METH_FASTCALL #ifndef METH_FASTCALL #define METH_FASTCALL 0x80 #endif @@ -342,114 +657,208 @@ typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else - #define __Pyx_PyCFunctionFast _PyCFunctionFast - #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #if PY_VERSION_HEX >= 0x030d00A4 + # define __Pyx_PyCFunctionFast PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords + #else + # define __Pyx_PyCFunctionFast _PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #endif +#endif +#if CYTHON_METH_FASTCALL + #define __Pyx_METH_FASTCALL METH_FASTCALL + #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast + #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords +#else + #define __Pyx_METH_FASTCALL METH_VARARGS + #define __Pyx_PyCFunction_FastCall PyCFunction + #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords +#endif +#if CYTHON_VECTORCALL + #define __pyx_vectorcallfunc vectorcallfunc + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET + #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) +#elif CYTHON_BACKPORT_VECTORCALL + typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args, + size_t nargsf, PyObject *kwnames); + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)) +#else + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) +#endif +#if PY_VERSION_HEX >= 0x030900B1 +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) +#else +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) +#endif +#define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) +#elif !CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) +#endif +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) +static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { + return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; +} +#endif +static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void (*cfunc)(void)) { +#if CYTHON_COMPILING_IN_LIMITED_API + return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; +#else + return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; #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 | METH_STACKLESS))))) +} +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) +#if __PYX_LIMITED_VERSION_HEX < 0x03090000 + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) + typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); #else -#define __Pyx_PyFastCFunction_Check(func) 0 + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) + #define __Pyx_PyCMethod PyCMethod +#endif +#ifndef METH_METHOD + #define METH_METHOD 0x200 #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_CPYTHON && PY_VERSION_HEX < 0x030400A1 - #define PyMem_RawMalloc(n) PyMem_Malloc(n) - #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) - #define PyMem_RawFree(p) PyMem_Free(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) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) +#elif CYTHON_COMPILING_IN_GRAAL + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #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 +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyThreadState_Current PyThreadState_Get() +#elif !CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() #else - #define __Pyx_PyThreadState_Current _PyThreadState_Current + #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #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; -} -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); +#if CYTHON_USE_MODULE_STATE +static CYTHON_INLINE void *__Pyx__PyModule_GetState(PyObject *op) +{ + void *result; + result = PyModule_GetState(op); + if (!result) + Py_FatalError("Couldn't find the module state"); + return result; } +#define __Pyx_PyModule_GetState(o) (__pyx_mstatetype *)__Pyx__PyModule_GetState(o) +#else +#define __Pyx_PyModule_GetState(op) ((void)op,__pyx_mstate_global) +#endif +#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE((PyObject *) obj), name, func_ctype) +#define __Pyx_PyObject_TryGetSlot(obj, name, func_ctype) __Pyx_PyType_TryGetSlot(Py_TYPE(obj), name, func_ctype) +#define __Pyx_PyObject_GetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_GetSubSlot(Py_TYPE(obj), sub, name, func_ctype) +#define __Pyx_PyObject_TryGetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_TryGetSubSlot(Py_TYPE(obj), sub, name, func_ctype) +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) + #define __Pyx_PyType_TryGetSlot(type, name, func_ctype) __Pyx_PyType_GetSlot(type, name, func_ctype) + #define __Pyx_PyType_GetSubSlot(type, sub, name, func_ctype) (((type)->sub) ? ((type)->sub->name) : NULL) + #define __Pyx_PyType_TryGetSubSlot(type, sub, name, func_ctype) __Pyx_PyType_GetSubSlot(type, sub, name, func_ctype) +#else + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) + #define __Pyx_PyType_TryGetSlot(type, name, func_ctype)\ + ((__PYX_LIMITED_VERSION_HEX >= 0x030A0000 ||\ + (PyType_GetFlags(type) & Py_TPFLAGS_HEAPTYPE) || __Pyx_get_runtime_version() >= 0x030A0000) ?\ + __Pyx_PyType_GetSlot(type, name, func_ctype) : NULL) + #define __Pyx_PyType_GetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_GetSlot(obj, name, func_ctype) + #define __Pyx_PyType_TryGetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_TryGetSlot(obj, name, func_ctype) #endif #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) +#define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) +#define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { + PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); + if (res == NULL) PyErr_Clear(); + return res; +} +#elif !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000 +#define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#else +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { +#if CYTHON_COMPILING_IN_PYPY + return PyDict_GetItem(dict, name); +#else + PyDictEntry *ep; + PyDictObject *mp = (PyDictObject*) dict; + long hash = ((PyStringObject *) name)->ob_shash; + assert(hash != -1); + ep = (mp->ma_lookup)(mp, name, hash); + if (ep == NULL) { + return NULL; + } + return ep->me_value; +#endif +} +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#endif +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) + #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) #else - #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) - #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) + #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) + #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) #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) +#define __Pyx_PyObject_GetIterNextFunc(iterator) __Pyx_PyObject_GetSlot(iterator, tp_iternext, iternextfunc) +#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000 +#define __Pyx_PyHeapTypeObject_GC_Del(obj) {\ + PyTypeObject *type = Py_TYPE((PyObject*)obj);\ + assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\ + PyObject_GC_Del(obj);\ + Py_DECREF(type);\ +} #else -#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) +#define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) #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) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) + #define __Pyx_PyUnicode_DATA(u) ((void*)u) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) +#else + #if PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_READY(op) (0) + #else + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #endif #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_KIND(u) ((int)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)) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, (Py_UCS4) ch) + #if PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #else + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #endif + #endif #endif #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) @@ -459,106 +868,226 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #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) +#if CYTHON_COMPILING_IN_PYPY + #if !defined(PyUnicode_DecodeUnicodeEscape) + #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) + #endif + #if !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) + #endif + #if !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) + #endif + #if !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) + #endif #endif -#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) -#if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#if CYTHON_COMPILING_IN_CPYTHON + #define __Pyx_PySequence_ListKeepNew(obj)\ + (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj)) #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) + #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) #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 +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type) #endif -#if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) - #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#if PY_VERSION_HEX >= 0x030900A4 + #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) +#else + #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) +#endif +#if CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + #define __Pyx_PyList_GetItemRef(o, i) PyList_GetItemRef(o, i) + #elif CYTHON_COMPILING_IN_LIMITED_API || !CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PyList_GetItemRef(o, i) (likely((i) >= 0) ? PySequence_GetItem(o, i) : (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) + #else + #define __Pyx_PyList_GetItemRef(o, i) PySequence_ITEM(o, i) + #endif +#elif CYTHON_COMPILING_IN_LIMITED_API || !CYTHON_ASSUME_SAFE_MACROS + #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + #define __Pyx_PyList_GetItemRef(o, i) PyList_GetItemRef(o, i) + #else + #define __Pyx_PyList_GetItemRef(o, i) __Pyx_XNewRef(PyList_GetItem(o, i)) + #endif #else - #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) - #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) + #define __Pyx_PyList_GetItemRef(o, i) __Pyx_NewRef(PyList_GET_ITEM(o, i)) +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 +#define __Pyx_PyDict_GetItemRef(dict, key, result) PyDict_GetItemRef(dict, key, result) +#elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS +static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key, PyObject **result) { + *result = PyObject_GetItem(dict, key); + if (*result == NULL) { + if (PyErr_ExceptionMatches(PyExc_KeyError)) { + PyErr_Clear(); + return 0; + } + return -1; + } + return 1; +} +#else +static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key, PyObject **result) { + *result = PyDict_GetItemWithError(dict, key); + if (*result == NULL) { + return PyErr_Occurred() ? -1 : 0; + } + Py_INCREF(*result); + return 1; +} #endif -#ifndef PySet_CheckExact - #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#if defined(CYTHON_DEBUG_VISIT_CONST) && CYTHON_DEBUG_VISIT_CONST + #define __Pyx_VISIT_CONST(obj) Py_VISIT(obj) +#else + #define __Pyx_VISIT_CONST(obj) #endif #if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i) #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyTuple_GET_ITEM(o, i) PyTuple_GET_ITEM(o, i) + #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyList_GET_ITEM(o, i) PyList_GET_ITEM(o, i) #else + #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) + #define __Pyx_PyTuple_GET_ITEM(o, i) PyTuple_GetItem(o, i) + #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) + #define __Pyx_PyList_GET_ITEM(o, i) PyList_GetItem(o, i) +#endif +#if CYTHON_ASSUME_SAFE_SIZE + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) + #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GET_LENGTH(o) +#else + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) + #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GetLength(o) +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) +#else + static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { + PyObject *module = PyImport_AddModule(name); + Py_XINCREF(module); + return module; + } #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 +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_InternFromString) + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) +#endif +#define __Pyx_PyLong_FromHash_t PyLong_FromSsize_t +#define __Pyx_PyLong_AsHash_t __Pyx_PyIndex_AsSsize_t +#if __PYX_LIMITED_VERSION_HEX >= 0x030A0000 + #define __Pyx_PySendResult PySendResult +#else + typedef enum { + PYGEN_RETURN = 0, + PYGEN_ERROR = -1, + PYGEN_NEXT = 1, + } __Pyx_PySendResult; +#endif +#if CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX < 0x030A00A3 + typedef __Pyx_PySendResult (*__Pyx_pyiter_sendfunc)(PyObject *iter, PyObject *value, PyObject **result); +#else + #define __Pyx_pyiter_sendfunc sendfunc +#endif +#if !CYTHON_USE_AM_SEND +#define __PYX_HAS_PY_AM_SEND 0 +#elif __PYX_LIMITED_VERSION_HEX >= 0x030A0000 +#define __PYX_HAS_PY_AM_SEND 1 #else - #define __Pyx_PyType_AsAsync(obj) NULL +#define __PYX_HAS_PY_AM_SEND 2 // our own backported implementation #endif -#ifndef __Pyx_PyAsyncMethodsStruct +#if __PYX_HAS_PY_AM_SEND < 2 + #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods +#else typedef struct { unaryfunc am_await; unaryfunc am_aiter; unaryfunc am_anext; + __Pyx_pyiter_sendfunc am_send; } __Pyx_PyAsyncMethodsStruct; + #define __Pyx_SlotTpAsAsync(s) ((PyAsyncMethods*)(s)) +#endif +#if CYTHON_USE_AM_SEND && PY_VERSION_HEX < 0x030A00F0 + #define __Pyx_TPFLAGS_HAVE_AM_SEND (1UL << 21) +#else + #define __Pyx_TPFLAGS_HAVE_AM_SEND (0) +#endif +#if PY_VERSION_HEX >= 0x03090000 +#define __Pyx_PyInterpreterState_Get() PyInterpreterState_Get() +#else +#define __Pyx_PyInterpreterState_Get() PyThreadState_Get()->interp +#endif +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030A0000 +#ifdef __cplusplus +extern "C" +#endif +PyAPI_FUNC(void *) PyMem_Calloc(size_t nelem, size_t elsize); +#endif +#if CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_init_co_variable(PyObject *inspect, const char* name, int *write_to) { + int value; + PyObject *py_value = PyObject_GetAttrString(inspect, name); + if (!py_value) return 0; + value = (int) PyLong_AsLong(py_value); + Py_DECREF(py_value); + *write_to = value; + return value != -1 || !PyErr_Occurred(); +} +static int __Pyx_init_co_variables(void) { + PyObject *inspect; + int result; + inspect = PyImport_ImportModule("inspect"); + result = +#if !defined(CO_OPTIMIZED) + __Pyx_init_co_variable(inspect, "CO_OPTIMIZED", &CO_OPTIMIZED) && +#endif +#if !defined(CO_NEWLOCALS) + __Pyx_init_co_variable(inspect, "CO_NEWLOCALS", &CO_NEWLOCALS) && +#endif +#if !defined(CO_VARARGS) + __Pyx_init_co_variable(inspect, "CO_VARARGS", &CO_VARARGS) && +#endif +#if !defined(CO_VARKEYWORDS) + __Pyx_init_co_variable(inspect, "CO_VARKEYWORDS", &CO_VARKEYWORDS) && +#endif +#if !defined(CO_ASYNC_GENERATOR) + __Pyx_init_co_variable(inspect, "CO_ASYNC_GENERATOR", &CO_ASYNC_GENERATOR) && +#endif +#if !defined(CO_GENERATOR) + __Pyx_init_co_variable(inspect, "CO_GENERATOR", &CO_GENERATOR) && +#endif +#if !defined(CO_COROUTINE) + __Pyx_init_co_variable(inspect, "CO_COROUTINE", &CO_COROUTINE) && +#endif + 1; + Py_DECREF(inspect); + return result ? 0 : -1; +} +#else +static int __Pyx_init_co_variables(void) { + return 0; // It's a limited API-only feature +} #endif -#if defined(WIN32) || defined(MS_WINDOWS) - #define _USE_MATH_DEFINES +/* MathInitCode */ +#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) + #ifndef _USE_MATH_DEFINES + #define _USE_MATH_DEFINES + #endif #endif #include #ifdef NAN @@ -576,13 +1105,30 @@ static CYTHON_INLINE float __PYX_NAN() { #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 +#ifndef CYTHON_CLINE_IN_TRACEBACK_RUNTIME +#define CYTHON_CLINE_IN_TRACEBACK_RUNTIME 0 +#endif +#ifndef CYTHON_CLINE_IN_TRACEBACK +#define CYTHON_CLINE_IN_TRACEBACK CYTHON_CLINE_IN_TRACEBACK_RUNTIME +#endif +#if CYTHON_CLINE_IN_TRACEBACK +#define __PYX_MARK_ERR_POS(f_index, lineno) { __pyx_filename = __pyx_f[f_index]; (void) __pyx_filename; __pyx_lineno = lineno; (void) __pyx_lineno; __pyx_clineno = __LINE__; (void) __pyx_clineno; } +#else +#define __PYX_MARK_ERR_POS(f_index, lineno) { __pyx_filename = __pyx_f[f_index]; (void) __pyx_filename; __pyx_lineno = lineno; (void) __pyx_lineno; (void) __pyx_clineno; } +#endif +#define __PYX_ERR(f_index, lineno, Ln_error) \ + { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } + +#ifdef CYTHON_EXTERN_C + #undef __PYX_EXTERN_C + #define __PYX_EXTERN_C CYTHON_EXTERN_C +#elif defined(__PYX_EXTERN_C) + #ifdef _MSC_VER + #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") + #else + #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. + #endif +#else #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else @@ -593,11 +1139,27 @@ static CYTHON_INLINE float __PYX_NAN() { #define __PYX_HAVE__hunter___event #define __PYX_HAVE_API__hunter___event /* Early includes */ +#include "vendor/_compat.h" + + static inline PyCodeObject* Hunter_PyFrame_GetCode(PyObject* frame) { + return PyFrame_GetCode((PyFrameObject*) frame); + } + static inline int Hunter_PyFrame_GetLasti(PyObject* frame) { + return PyFrame_GetLasti((PyFrameObject*) frame); + } + static inline int Hunter_PyFrame_GetLineNumber(PyObject* frame) { + return PyFrame_GetLineNumber((PyFrameObject*) frame); + } + static inline PyObject* Hunter_PyFrame_GetGlobals(PyObject* frame) { + return PyFrame_GetGlobals((PyFrameObject*) frame); + } + static inline PyObject* Hunter_PyFrame_GetLocals(PyObject* frame) { + return PyFrame_GetLocals((PyFrameObject*) frame); + } + +#include "pythread.h" #include #include -#include "frameobject.h" -#include "pystate.h" -#include "pythread.h" #ifdef _OPENMP #include #endif /* _OPENMP */ @@ -606,13 +1168,8 @@ static CYTHON_INLINE float __PYX_NAN() { #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_ASCII 1 #define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 -#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) -#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) @@ -646,139 +1203,129 @@ static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s); 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)) +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*); #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)) +#if CYTHON_ASSUME_SAFE_MACROS + #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_PyByteArray_AsString(s) PyByteArray_AS_STRING(s) +#else + #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AsString(s)) + #define __Pyx_PyByteArray_AsString(s) PyByteArray_AsString(s) +#endif +#define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __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_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) #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_NewRef(PyObject *obj) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030a0000 || defined(Py_NewRef) + return Py_NewRef(obj); +#else + Py_INCREF(obj); + return obj; +#endif +} +static CYTHON_INLINE PyObject *__Pyx_XNewRef(PyObject *obj) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030a0000 || defined(Py_XNewRef) + return Py_XNewRef(obj); +#else + Py_XINCREF(obj); + return obj; +#endif +} +static CYTHON_INLINE PyObject *__Pyx_Owned_Py_None(int b); static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); -static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Long(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); +static CYTHON_INLINE PyObject * __Pyx_PyLong_FromSize_t(size_t); +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); #if CYTHON_ASSUME_SAFE_MACROS -#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#define __Pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#define __Pyx_PyFloat_AS_DOUBLE(x) PyFloat_AS_DOUBLE(x) #else -#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#define __Pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#define __Pyx_PyFloat_AS_DOUBLE(x) PyFloat_AsDouble(x) #endif -#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) -#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyFloat_AsFloat(x) ((float) __Pyx_PyFloat_AsDouble(x)) #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) + 1); - 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; -} +#if CYTHON_USE_PYLONG_INTERNALS + #if PY_VERSION_HEX >= 0x030C00A7 + #ifndef _PyLong_SIGN_MASK + #define _PyLong_SIGN_MASK 3 + #endif + #ifndef _PyLong_NON_SIZE_BITS + #define _PyLong_NON_SIZE_BITS 3 + #endif + #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK) + #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) + #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) + #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) + #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_SignedDigitCount(x)\ + ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) + #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) + #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) + #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) + #else + #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) + #endif + typedef Py_ssize_t __Pyx_compact_pylong; + typedef size_t __Pyx_compact_upylong; + #else + #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) + #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) + #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) + #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) + #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) + #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) + #define __Pyx_PyLong_CompactValue(x)\ + ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) + typedef sdigit __Pyx_compact_pylong; + typedef digit __Pyx_compact_upylong; + #endif + #if PY_VERSION_HEX >= 0x030C00A5 + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) + #else + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) + #endif #endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#elif __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeASCII(c_str, size, NULL) +#else + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #endif @@ -790,71 +1337,290 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #define likely(x) (x) #define unlikely(x) (x) #endif /* __GNUC__ */ +/* PretendToInitialize */ +#ifdef __cplusplus +#if __cplusplus > 201103L +#include +#endif +template +static void __Pyx_pretend_to_initialize(T* ptr) { +#if __cplusplus > 201103L + if ((std::is_trivially_default_constructible::value)) +#endif + *ptr = T(); + (void)ptr; +} +#else static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } +#endif + +#if !CYTHON_USE_MODULE_STATE 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; +#endif static int __pyx_lineno; static int __pyx_clineno = 0; -static const char * __pyx_cfilenm= __FILE__; +static const char * const __pyx_cfilenm = __FILE__; static const char *__pyx_filename; +/* #### Code section: filename_table ### */ -static const char *__pyx_f[] = { +static const char* const __pyx_f[] = { "src/hunter/_event.pyx", "src/hunter/_event.pxd", - "stringsource", - ".tox/cythonize/lib/python3.8/site-packages/Cython/Includes/cpython/type.pxd", - "src/hunter/_tracer.pxd", + ".tox/cythonize/lib64/python3.13/site-packages/Cython/Includes/cpython/type.pxd", }; +/* #### Code section: utility_code_proto_before_types ### */ +/* Atomics.proto */ +#include +#ifndef CYTHON_ATOMICS + #define CYTHON_ATOMICS 1 +#endif +#define __PYX_CYTHON_ATOMICS_ENABLED() CYTHON_ATOMICS +#define __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING() CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +#define __pyx_atomic_int_type int +#define __pyx_nonatomic_int_type int +#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\ + (__STDC_VERSION__ >= 201112L) &&\ + !defined(__STDC_NO_ATOMICS__)) + #include +#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\ + (__cplusplus >= 201103L) ||\ + (defined(_MSC_VER) && _MSC_VER >= 1700))) + #include +#endif +#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\ + (__STDC_VERSION__ >= 201112L) &&\ + !defined(__STDC_NO_ATOMICS__) &&\ + ATOMIC_INT_LOCK_FREE == 2) + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type atomic_int + #define __pyx_atomic_ptr_type atomic_uintptr_t + #define __pyx_nonatomic_ptr_type uintptr_t + #define __pyx_atomic_incr_relaxed(value) atomic_fetch_add_explicit(value, 1, memory_order_relaxed) + #define __pyx_atomic_incr_acq_rel(value) atomic_fetch_add_explicit(value, 1, memory_order_acq_rel) + #define __pyx_atomic_decr_acq_rel(value) atomic_fetch_sub_explicit(value, 1, memory_order_acq_rel) + #define __pyx_atomic_sub(value, arg) atomic_fetch_sub(value, arg) + #define __pyx_atomic_int_cmp_exchange(value, expected, desired) atomic_compare_exchange_strong(value, expected, desired) + #define __pyx_atomic_load(value) atomic_load(value) + #define __pyx_atomic_store(value, new_value) atomic_store(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) atomic_load_explicit(value, memory_order_relaxed) + #define __pyx_atomic_pointer_load_acquire(value) atomic_load_explicit(value, memory_order_acquire) + #define __pyx_atomic_pointer_exchange(value, new_value) atomic_exchange(value, (__pyx_nonatomic_ptr_type)new_value) + #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) + #pragma message ("Using standard C atomics") + #elif defined(__PYX_DEBUG_ATOMICS) + #warning "Using standard C atomics" + #endif +#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\ + (__cplusplus >= 201103L) ||\ +\ + (defined(_MSC_VER) && _MSC_VER >= 1700)) &&\ + ATOMIC_INT_LOCK_FREE == 2) + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type std::atomic_int + #define __pyx_atomic_ptr_type std::atomic_uintptr_t + #define __pyx_nonatomic_ptr_type uintptr_t + #define __pyx_atomic_incr_relaxed(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_relaxed) + #define __pyx_atomic_incr_acq_rel(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_acq_rel) + #define __pyx_atomic_decr_acq_rel(value) std::atomic_fetch_sub_explicit(value, 1, std::memory_order_acq_rel) + #define __pyx_atomic_sub(value, arg) std::atomic_fetch_sub(value, arg) + #define __pyx_atomic_int_cmp_exchange(value, expected, desired) std::atomic_compare_exchange_strong(value, expected, desired) + #define __pyx_atomic_load(value) std::atomic_load(value) + #define __pyx_atomic_store(value, new_value) std::atomic_store(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) std::atomic_load_explicit(value, std::memory_order_relaxed) + #define __pyx_atomic_pointer_load_acquire(value) std::atomic_load_explicit(value, std::memory_order_acquire) + #define __pyx_atomic_pointer_exchange(value, new_value) std::atomic_exchange(value, (__pyx_nonatomic_ptr_type)new_value) + #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) + #pragma message ("Using standard C++ atomics") + #elif defined(__PYX_DEBUG_ATOMICS) + #warning "Using standard C++ atomics" + #endif +#elif CYTHON_ATOMICS && (__GNUC__ >= 5 || (__GNUC__ == 4 &&\ + (__GNUC_MINOR__ > 1 ||\ + (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ >= 2)))) + #define __pyx_atomic_ptr_type void* + #define __pyx_atomic_incr_relaxed(value) __sync_fetch_and_add(value, 1) + #define __pyx_atomic_incr_acq_rel(value) __sync_fetch_and_add(value, 1) + #define __pyx_atomic_decr_acq_rel(value) __sync_fetch_and_sub(value, 1) + #define __pyx_atomic_sub(value, arg) __sync_fetch_and_sub(value, arg) + static CYTHON_INLINE int __pyx_atomic_int_cmp_exchange(__pyx_atomic_int_type* value, __pyx_nonatomic_int_type* expected, __pyx_nonatomic_int_type desired) { + __pyx_nonatomic_int_type old = __sync_val_compare_and_swap(value, *expected, desired); + int result = old == *expected; + *expected = old; + return result; + } + #define __pyx_atomic_load(value) __sync_fetch_and_add(value, 0) + #define __pyx_atomic_store(value, new_value) __sync_lock_test_and_set(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) __sync_fetch_and_add(value, 0) + #define __pyx_atomic_pointer_load_acquire(value) __sync_fetch_and_add(value, 0) + #define __pyx_atomic_pointer_exchange(value, new_value) __sync_lock_test_and_set(value, (__pyx_atomic_ptr_type)new_value) + #ifdef __PYX_DEBUG_ATOMICS + #warning "Using GNU atomics" + #endif +#elif CYTHON_ATOMICS && defined(_MSC_VER) + #include + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type long + #define __pyx_atomic_ptr_type void* + #undef __pyx_nonatomic_int_type + #define __pyx_nonatomic_int_type long + #pragma intrinsic (_InterlockedExchangeAdd, _InterlockedExchange, _InterlockedCompareExchange, _InterlockedCompareExchangePointer, _InterlockedExchangePointer) + #define __pyx_atomic_incr_relaxed(value) _InterlockedExchangeAdd(value, 1) + #define __pyx_atomic_incr_acq_rel(value) _InterlockedExchangeAdd(value, 1) + #define __pyx_atomic_decr_acq_rel(value) _InterlockedExchangeAdd(value, -1) + #define __pyx_atomic_sub(value, arg) _InterlockedExchangeAdd(value, -arg) + static CYTHON_INLINE int __pyx_atomic_int_cmp_exchange(__pyx_atomic_int_type* value, __pyx_nonatomic_int_type* expected, __pyx_nonatomic_int_type desired) { + __pyx_nonatomic_int_type old = _InterlockedCompareExchange(value, desired, *expected); + int result = old == *expected; + *expected = old; + return result; + } + #define __pyx_atomic_load(value) _InterlockedExchangeAdd(value, 0) + #define __pyx_atomic_store(value, new_value) _InterlockedExchange(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) *(void * volatile *)value + #define __pyx_atomic_pointer_load_acquire(value) _InterlockedCompareExchangePointer(value, 0, 0) + #define __pyx_atomic_pointer_exchange(value, new_value) _InterlockedExchangePointer(value, (__pyx_atomic_ptr_type)new_value) + #ifdef __PYX_DEBUG_ATOMICS + #pragma message ("Using MSVC atomics") + #endif +#else + #undef CYTHON_ATOMICS + #define CYTHON_ATOMICS 0 + #ifdef __PYX_DEBUG_ATOMICS + #warning "Not using atomics" + #endif +#endif +#if CYTHON_ATOMICS + #define __pyx_add_acquisition_count(memview)\ + __pyx_atomic_incr_relaxed(__pyx_get_slice_count_pointer(memview)) + #define __pyx_sub_acquisition_count(memview)\ + __pyx_atomic_decr_acq_rel(__pyx_get_slice_count_pointer(memview)) +#else + #define __pyx_add_acquisition_count(memview)\ + __pyx_add_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) + #define __pyx_sub_acquisition_count(memview)\ + __pyx_sub_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) +#endif + +/* Profile_config.proto */ +#ifndef CYTHON_PROFILE +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + #define CYTHON_PROFILE 0 +#else + #define CYTHON_PROFILE 1 +#endif +#endif +#ifndef CYTHON_TRACE_NOGIL + #define CYTHON_TRACE_NOGIL 0 +#else + #if CYTHON_TRACE_NOGIL && !defined(CYTHON_TRACE) + #define CYTHON_TRACE 1 + #endif +#endif +#ifndef CYTHON_TRACE + #define CYTHON_TRACE 0 +#endif +#if CYTHON_PROFILE || CYTHON_TRACE +#if CYTHON_USE_SYS_MONITORING + typedef enum { + __Pyx_Monitoring_PY_START = 0, + __Pyx_Monitoring_PY_RETURN, + __Pyx_Monitoring_PY_UNWIND, + __Pyx_Monitoring_LINE, + __Pyx_Monitoring_RAISE, + __Pyx_Monitoring_RERAISE, + __Pyx_Monitoring_EXCEPTION_HANDLED, + __Pyx_Monitoring_PY_RESUME, + __Pyx_Monitoring_PY_YIELD, + __Pyx_Monitoring_STOP_ITERATION, + } __Pyx_Monitoring_Event_Index; + static const unsigned char __Pyx_MonitoringEventTypes[] = { + PY_MONITORING_EVENT_PY_START, + PY_MONITORING_EVENT_PY_RETURN, + PY_MONITORING_EVENT_PY_UNWIND, + PY_MONITORING_EVENT_LINE, + PY_MONITORING_EVENT_RAISE, + PY_MONITORING_EVENT_RERAISE, + PY_MONITORING_EVENT_EXCEPTION_HANDLED, + PY_MONITORING_EVENT_PY_RESUME, + PY_MONITORING_EVENT_PY_YIELD, + PY_MONITORING_EVENT_STOP_ITERATION, + }; + #define __Pyx_MonitoringEventTypes_CyFunc_count (sizeof(__Pyx_MonitoringEventTypes) - 3) + #define __Pyx_MonitoringEventTypes_CyGen_count (sizeof(__Pyx_MonitoringEventTypes)) +#endif +#endif + +/* NoFastGil.proto */ +#define __Pyx_PyGILState_Ensure PyGILState_Ensure +#define __Pyx_PyGILState_Release PyGILState_Release +#define __Pyx_FastGIL_Remember() +#define __Pyx_FastGIL_Forget() +#define __Pyx_FastGilFuncInit() + +/* IncludeStructmemberH.proto */ +#include + +/* CriticalSections.proto */ +#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +#define __Pyx_PyCriticalSection void* +#define __Pyx_PyCriticalSection2 void* +#define __Pyx_PyCriticalSection_Begin1(cs, arg) (void)cs +#define __Pyx_PyCriticalSection_Begin2(cs, arg1, arg2) (void)cs +#define __Pyx_PyCriticalSection_End1(cs) +#define __Pyx_PyCriticalSection_End2(cs) +#else +#define __Pyx_PyCriticalSection PyCriticalSection +#define __Pyx_PyCriticalSection2 PyCriticalSection2 +#define __Pyx_PyCriticalSection_Begin1 PyCriticalSection_Begin +#define __Pyx_PyCriticalSection_Begin2 PyCriticalSection2_Begin +#define __Pyx_PyCriticalSection_End1 PyCriticalSection_End +#define __Pyx_PyCriticalSection_End2 PyCriticalSection2_End +#endif +#if PY_VERSION_HEX < 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_BEGIN_CRITICAL_SECTION(o) { +#define __Pyx_END_CRITICAL_SECTION() } +#else +#define __Pyx_BEGIN_CRITICAL_SECTION Py_BEGIN_CRITICAL_SECTION +#define __Pyx_END_CRITICAL_SECTION Py_END_CRITICAL_SECTION +#endif + +/* #### Code section: numeric_typedefs ### */ +/* #### Code section: complex_type_declarations ### */ +/* #### Code section: type_declarations ### */ /*--- Type declarations ---*/ -struct __pyx_obj_6hunter_7_tracer_Tracer; struct __pyx_obj_6hunter_6_event_Event; struct __pyx_obj_6hunter_6_event___pyx_scope_struct__yield_lines; -/* "_tracer.pxd":28 +/* "hunter/_event.pxd":4 * - * @cython.final - * cdef class Tracer: # <<<<<<<<<<<<<< - * cdef: - * readonly object handler - */ -struct __pyx_obj_6hunter_7_tracer_Tracer { - PyObject_HEAD - PyObject *handler; - PyObject *previous; - PyObject *threading_support; - int depth; - int calls; - PyObject *__weakref__; - PyObject *_threading_previous; - Py_tracefunc _previousfunc; -}; - + * + * ctypedef extern FrameType # <<<<<<<<<<<<<< + * + * cdef extern from *: +*/ +typedef PyObject *FrameType; -/* "hunter/_event.pxd":11 +/* "hunter/_event.pxd":39 + * * - * @cython.final - * cdef class Event: # <<<<<<<<<<<<<< + * @cython.final # <<<<<<<<<<<<<< + * cdef class Event: * cdef: - * readonly FrameType frame - */ +*/ struct __pyx_obj_6hunter_6_event_Event { PyObject_HEAD struct __pyx_vtabstruct_6hunter_6_event_Event *__pyx_vtab; - PyFrameObject *frame; + FrameType frame; PyObject *kind; PyObject *arg; int depth; int calls; int threading_support; int detached; + PyObject *builtin; PyObject *_code; PyObject *_filename; PyObject *_fullsource; @@ -869,16 +1635,17 @@ struct __pyx_obj_6hunter_6_event_Event { PyObject *_thread; PyObject *_threadidn; PyObject *_threadname; + PyObject *_instruction; }; -/* "hunter/_event.pyx":297 +/* "hunter/_event.pyx":347 * * * def yield_lines(filename, module_globals, start, list collector, # <<<<<<<<<<<<<< * limit=10): * dedent = None - */ +*/ struct __pyx_obj_6hunter_6_event___pyx_scope_struct__yield_lines { PyObject_HEAD Py_ssize_t __pyx_v_amount; @@ -896,19 +1663,44 @@ struct __pyx_obj_6hunter_6_event___pyx_scope_struct__yield_lines { -/* "hunter/_event.pyx":29 +/* "hunter/_event.pyx":46 * * - * cdef class Event: # <<<<<<<<<<<<<< + * @cython.auto_pickle(False) # <<<<<<<<<<<<<< + * cdef class Event: * """ - * A wrapper object for Frame objects. Instances of this are passed to your custom functions or predicates. - */ +*/ struct __pyx_vtabstruct_6hunter_6_event_Event { - struct __pyx_obj_6hunter_6_event_Event *(*clone)(struct __pyx_obj_6hunter_6_event_Event *); + PyCodeObject *(*code_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*filename_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*fullsource_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*function_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*globals_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*lineno_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*locals_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*module_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*source_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*stdlib_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*threadid_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*threadname_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*instruction_getter)(struct __pyx_obj_6hunter_6_event_Event *); }; static struct __pyx_vtabstruct_6hunter_6_event_Event *__pyx_vtabptr_6hunter_6_event_Event; -static struct __pyx_obj_6hunter_6_event_Event *__pyx_f_6hunter_6_event_5Event_clone(struct __pyx_obj_6hunter_6_event_Event *); +static PyCodeObject *__pyx_f_6hunter_6_event_5Event_code_getter(struct __pyx_obj_6hunter_6_event_Event *); +static PyObject *__pyx_f_6hunter_6_event_5Event_filename_getter(struct __pyx_obj_6hunter_6_event_Event *); +static PyObject *__pyx_f_6hunter_6_event_5Event_fullsource_getter(struct __pyx_obj_6hunter_6_event_Event *); +static PyObject *__pyx_f_6hunter_6_event_5Event_function_getter(struct __pyx_obj_6hunter_6_event_Event *); +static PyObject *__pyx_f_6hunter_6_event_5Event_globals_getter(struct __pyx_obj_6hunter_6_event_Event *); +static PyObject *__pyx_f_6hunter_6_event_5Event_lineno_getter(struct __pyx_obj_6hunter_6_event_Event *); +static PyObject *__pyx_f_6hunter_6_event_5Event_locals_getter(struct __pyx_obj_6hunter_6_event_Event *); +static PyObject *__pyx_f_6hunter_6_event_5Event_module_getter(struct __pyx_obj_6hunter_6_event_Event *); +static PyObject *__pyx_f_6hunter_6_event_5Event_source_getter(struct __pyx_obj_6hunter_6_event_Event *); +static PyObject *__pyx_f_6hunter_6_event_5Event_stdlib_getter(struct __pyx_obj_6hunter_6_event_Event *); +static PyObject *__pyx_f_6hunter_6_event_5Event_threadid_getter(struct __pyx_obj_6hunter_6_event_Event *); +static PyObject *__pyx_f_6hunter_6_event_5Event_threadname_getter(struct __pyx_obj_6hunter_6_event_Event *); +static PyObject *__pyx_f_6hunter_6_event_5Event_instruction_getter(struct __pyx_obj_6hunter_6_event_Event *); +/* #### Code section: utility_code_proto ### */ /* --- Runtime support code (head) --- */ /* Refnanny.proto */ @@ -917,42 +1709,48 @@ static struct __pyx_obj_6hunter_6_event_Event *__pyx_f_6hunter_6_event_5Event_cl #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 (*INCREF)(void*, PyObject*, Py_ssize_t); + void (*DECREF)(void*, PyObject*, Py_ssize_t); + void (*GOTREF)(void*, PyObject*, Py_ssize_t); + void (*GIVEREF)(void*, PyObject*, Py_ssize_t); + void* (*SetupContext)(const char*, Py_ssize_t, 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__);\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ + } + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ + } + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ } -#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) + #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); else {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContextNogil() #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) @@ -963,6 +1761,10 @@ static struct __pyx_obj_6hunter_6_event_Event *__pyx_f_6hunter_6_event_5Event_cl #define __Pyx_XGOTREF(r) #define __Pyx_XGIVEREF(r) #endif +#define __Pyx_Py_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; Py_XDECREF(tmp);\ + } while (0) #define __Pyx_XDECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_XDECREF(tmp);\ @@ -974,43 +1776,30 @@ static struct __pyx_obj_6hunter_6_event_Event *__pyx_f_6hunter_6_event_5Event_cl #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); +/* PyErrExceptionMatches.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); #else -#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) #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); - -/* ArgTypeTest.proto */ -#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ - ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ - __Pyx__ArgTypeTest(obj, type, name, exact)) -static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); - /* 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 +#if PY_VERSION_HEX >= 0x030C00A6 +#define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL) +#else +#define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type) +#endif #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign -#define __Pyx_PyErr_Occurred() PyErr_Occurred() +#define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) +#define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() #endif /* PyErrFetchRestore.proto */ @@ -1022,7 +1811,7 @@ static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *nam #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 +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6 #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) #else #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) @@ -1038,34 +1827,376 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif -/* Profile.proto */ -#ifndef CYTHON_PROFILE -#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_PYSTON - #define CYTHON_PROFILE 0 +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); #else - #define CYTHON_PROFILE 1 +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* PyObjectGetAttrStrNoError.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* TupleAndListFromArray.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); #endif +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); #endif -#ifndef CYTHON_TRACE_NOGIL - #define CYTHON_TRACE_NOGIL 0 + +/* IncludeStringH.proto */ +#include + +/* BytesEquals.proto */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); + +/* UnicodeEquals.proto */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); + +/* fastcall.proto */ +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_PySequence_ITEM(args, i) +#elif CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_NewRef(__Pyx_PyTuple_GET_ITEM(args, i)) #else - #if CYTHON_TRACE_NOGIL && !defined(CYTHON_TRACE) - #define CYTHON_TRACE 1 + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_XNewRef(PyTuple_GetItem(args, i)) +#endif +#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) +#define __Pyx_KwValues_VARARGS(args, nargs) NULL +#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) +#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) +#if CYTHON_METH_FASTCALL + #define __Pyx_ArgRef_FASTCALL(args, i) __Pyx_NewRef(args[i]) + #define __Pyx_NumKwargs_FASTCALL(kwds) __Pyx_PyTuple_GET_SIZE(kwds) + #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) + static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API + CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); + #else + #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) #endif +#else + #define __Pyx_ArgRef_FASTCALL __Pyx_ArgRef_VARARGS + #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS + #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS + #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS + #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS +#endif +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) +#if CYTHON_METH_FASTCALL || (CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(args + start, stop - start) +#else +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) #endif -#ifndef CYTHON_TRACE - #define CYTHON_TRACE 0 + +/* RaiseDoubleKeywords.proto */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +/* ParseKeywords.proto */ +static CYTHON_INLINE int __Pyx_ParseKeywords( + PyObject *kwds, PyObject *const *kwvalues, PyObject ** const argnames[], + PyObject *kwds2, PyObject *values[], + Py_ssize_t num_pos_args, Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs +); + +/* CallCFunction.proto */ +#define __Pyx_CallCFunction(cfunc, self, args)\ + ((PyCFunction)(void(*)(void))(cfunc)->func)(self, args) +#define __Pyx_CallCFunctionWithKeywords(cfunc, self, args, kwargs)\ + ((PyCFunctionWithKeywords)(void(*)(void))(cfunc)->func)(self, args, kwargs) +#define __Pyx_CallCFunctionFast(cfunc, self, args, nargs)\ + ((__Pyx_PyCFunctionFast)(void(*)(void))(PyCFunction)(cfunc)->func)(self, args, nargs) +#define __Pyx_CallCFunctionFastWithKeywords(cfunc, self, args, nargs, kwnames)\ + ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))(PyCFunction)(cfunc)->func)(self, args, nargs, kwnames) + +/* PyFunctionFastCall.proto */ +#if CYTHON_FAST_PYCALL +#if !CYTHON_VECTORCALL +#define __Pyx_PyFunction_FastCall(func, args, nargs)\ + __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject *const *args, Py_ssize_t nargs, PyObject *kwargs); +#endif +#define __Pyx_BUILD_ASSERT_EXPR(cond)\ + (sizeof(char [1 - 2*!(cond)]) - 1) +#ifndef Py_MEMBER_SIZE +#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) +#endif +#if !CYTHON_VECTORCALL +#if PY_VERSION_HEX >= 0x03080000 + #include "frameobject.h" + #define __Pxy_PyFrame_Initialize_Offsets() + #define __Pyx_PyFrame_GetLocalsplus(frame) ((frame)->f_localsplus) +#else + static size_t __pyx_pyframe_localsplus_offset = 0; + #include "frameobject.h" + #define __Pxy_PyFrame_Initialize_Offsets()\ + ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ + (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) + #define __Pyx_PyFrame_GetLocalsplus(frame)\ + (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) +#endif +#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 + +/* PyObjectFastCall.proto */ +#define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject * const*args, size_t nargs, PyObject *kwargs); + +/* UnpackUnboundCMethod.proto */ +typedef struct { + PyObject *type; + PyObject **method_name; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && CYTHON_ATOMICS + __pyx_atomic_int_type initialized; +#endif + PyCFunction func; + PyObject *method; + int flag; +} __Pyx_CachedCFunction; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +static CYTHON_INLINE int __Pyx_CachedCFunction_GetAndSetInitializing(__Pyx_CachedCFunction *cfunc) { +#if !CYTHON_ATOMICS + return 1; +#else + __pyx_nonatomic_int_type expected = 0; + if (__pyx_atomic_int_cmp_exchange(&cfunc->initialized, &expected, 1)) { + return 0; + } + return expected; +#endif +} +static CYTHON_INLINE void __Pyx_CachedCFunction_SetFinishedInitializing(__Pyx_CachedCFunction *cfunc) { +#if CYTHON_ATOMICS + __pyx_atomic_store(&cfunc->initialized, 2); +#endif +} +#else +#define __Pyx_CachedCFunction_GetAndSetInitializing(cfunc) 2 +#define __Pyx_CachedCFunction_SetFinishedInitializing(cfunc) #endif + +/* CallUnboundCMethod2.proto */ +CYTHON_UNUSED +static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2); +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2); +#else +#define __Pyx_CallUnboundCMethod2(cfunc, self, arg1, arg2) __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2) +#endif + +/* 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); + +/* Profile.proto */ #if CYTHON_TRACE #undef CYTHON_PROFILE_REUSE_FRAME #endif +#if CYTHON_USE_MODULE_STATE + #undef CYTHON_PROFILE_REUSE_CODEOBJ + #define CYTHON_PROFILE_REUSE_CODEOBJ 0 + #undef CYTHON_PROFILE_REUSE_FRAME +#endif +#ifndef CYTHON_PROFILE_REUSE_CODEOBJ + #define CYTHON_PROFILE_REUSE_CODEOBJ 1 +#endif #ifndef CYTHON_PROFILE_REUSE_FRAME #define CYTHON_PROFILE_REUSE_FRAME 0 #endif +#if CYTHON_USE_SYS_MONITORING && (CYTHON_PROFILE || CYTHON_TRACE) + #define __PYX_MONITORING_ABI_SUFFIX "_mon" +#else + #define __PYX_MONITORING_ABI_SUFFIX +#endif #if CYTHON_PROFILE || CYTHON_TRACE - #include "compile.h" +#if CYTHON_USE_SYS_MONITORING + typedef uint64_t __pyx_monitoring_version_type; + #define __Pyx_TraceDeclarationsFunc\ + PyObject *__pyx_frame_code = NULL;\ + PyMonitoringState __pyx_pymonitoring_state[__Pyx_MonitoringEventTypes_CyFunc_count];\ + int __pyx_exception_already_reported = 0;\ + const int __pyx_sys_monitoring_disabled_in_parallel = 0; CYTHON_UNUSED_VAR(__pyx_sys_monitoring_disabled_in_parallel); + #define __Pyx_TraceDeclarationsGen\ + PyObject *__pyx_frame_code = Py_NewRef(__pyx_generator->gi_code);\ + PyMonitoringState* __pyx_pymonitoring_state = __pyx_generator->__pyx_pymonitoring_state;\ + __pyx_monitoring_version_type __pyx_pymonitoring_version = __pyx_generator->__pyx_pymonitoring_version;\ + int __pyx_exception_already_reported = 0;\ + const int __pyx_sys_monitoring_disabled_in_parallel = 0; CYTHON_UNUSED_VAR(__pyx_sys_monitoring_disabled_in_parallel); + #define __Pyx_IsTracing(event_id) ((!__pyx_sys_monitoring_disabled_in_parallel) && (__pyx_pymonitoring_state[event_id]).active) + #define __Pyx_TraceFrameInit(codeobj)\ + if (codeobj) __pyx_frame_code = codeobj; + #define __Pyx_TurnOffSysMonitoringInParallel\ + const int __pyx_sys_monitoring_disabled_in_parallel = 1;\ + CYTHON_UNUSED_VAR(__pyx_sys_monitoring_disabled_in_parallel); + CYTHON_UNUSED static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno); + CYTHON_UNUSED static int __Pyx__TraceStartFunc(PyMonitoringState *state_array, PyObject *code_obj, int offset, int skip_event); + CYTHON_UNUSED static int __Pyx__TraceStartGen(PyMonitoringState *state_array, __pyx_monitoring_version_type *version, PyObject *code_obj, int offset); + CYTHON_UNUSED static int __Pyx__TraceResumeGen(PyMonitoringState *state_array, __pyx_monitoring_version_type *version, PyObject *code_obj, int offset); + CYTHON_UNUSED static void __Pyx__TraceException(PyMonitoringState *monitoring_state, PyObject *code_obj, int offset, int reraised); + #define __Pyx_PyMonitoring_ExitScope(nogil)\ + if (nogil) {\ + (void) __pyx_exception_already_reported;\ + if (CYTHON_TRACE_NOGIL) {\ + PyGILState_STATE state = PyGILState_Ensure();\ + PyMonitoring_ExitScope();\ + Py_XDECREF(__pyx_frame_code);\ + PyGILState_Release(state);\ + }\ + } else {\ + PyMonitoring_ExitScope();\ + Py_XDECREF(__pyx_frame_code);\ + } + #define __Pyx_TraceStartFunc(funcname, srcfile, firstlineno, offset, nogil, skip_event, goto_error)\ + if ((0) ); else {\ + int ret = 0;\ + memset(__pyx_pymonitoring_state, 0, sizeof(__pyx_pymonitoring_state));\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + PyGILState_STATE state = PyGILState_Ensure();\ + if (!__Pyx_PyThreadState_Current->tracing) {\ + if (likely(__pyx_frame_code)) Py_INCREF(__pyx_frame_code);\ + else __pyx_frame_code = (PyObject*) __Pyx_createFrameCodeObject(funcname, srcfile, firstlineno);\ + if (unlikely(!__pyx_frame_code)) goto_error;\ + ret = __Pyx__TraceStartFunc(__pyx_pymonitoring_state, __pyx_frame_code, offset, skip_event);\ + }\ + PyGILState_Release(state);\ + }\ + } else {\ + if (!__Pyx_PyThreadState_Current->tracing) {\ + if (likely(__pyx_frame_code)) Py_INCREF(__pyx_frame_code);\ + else __pyx_frame_code = (PyObject*) __Pyx_createFrameCodeObject(funcname, srcfile, firstlineno);\ + if (unlikely(!__pyx_frame_code)) goto_error;\ + ret = __Pyx__TraceStartFunc(__pyx_pymonitoring_state, __pyx_frame_code, offset, skip_event);\ + }\ + }\ + if (unlikely(ret == -1)) goto_error;\ + } + #define __Pyx_TraceStartGen(funcname, srcfile, firstlineno, offset, nogil, skip_event, goto_error)\ + if ((0) ); else {\ + int ret = __Pyx__TraceStartGen(__pyx_pymonitoring_state, &__pyx_pymonitoring_version, __pyx_frame_code, offset);\ + if (unlikely(ret == -1)) goto_error;\ + } + #define __Pyx_TraceResumeGen(funcname, srcfile, firstlineno, offset, goto_error)\ + if ((0) ); else {\ + int ret = __Pyx__TraceResumeGen(__pyx_pymonitoring_state, &__pyx_pymonitoring_version, __pyx_frame_code, offset);\ + if (unlikely(ret == -1)) goto_error;\ + } + #define __Pyx_TraceYield(result, offset, goto_error)\ + if (!__Pyx_IsTracing(__Pyx_Monitoring_PY_YIELD)); else {\ + int ret = PyMonitoring_FirePyYieldEvent(&__pyx_pymonitoring_state[__Pyx_Monitoring_PY_RETURN], __pyx_frame_code, offset, result);\ + PyMonitoring_ExitScope();\ + if (unlikely(ret == -1)) goto_error;\ + } + #define __Pyx_TraceException(offset, reraised, fresh)\ + if (!__Pyx_IsTracing((reraised) ? __Pyx_Monitoring_RERAISE : __Pyx_Monitoring_RAISE)); else {\ + if (fresh || reraised || !__pyx_exception_already_reported) {\ + __Pyx__TraceException(&__pyx_pymonitoring_state[(reraised) ? __Pyx_Monitoring_RERAISE : __Pyx_Monitoring_RAISE], __pyx_frame_code, offset, reraised);\ + }\ + __pyx_exception_already_reported = 1;\ + } + #define __Pyx_TraceExceptionDone() __pyx_exception_already_reported = 0 + #define __Pyx_TraceExceptionHandled(offset)\ + if (!__Pyx_IsTracing(__Pyx_Monitoring_EXCEPTION_HANDLED)); else {\ + (void) PyMonitoring_FireExceptionHandledEvent(&__pyx_pymonitoring_state[__Pyx_Monitoring_EXCEPTION_HANDLED], __pyx_frame_code, offset);\ + __pyx_exception_already_reported = 0;\ + } + #define __Pyx_TraceReturnValue(result, offset, nogil, goto_error)\ + if (!__Pyx_IsTracing(__Pyx_Monitoring_PY_RETURN)); else {\ + int ret = 0;\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + PyGILState_STATE state = PyGILState_Ensure();\ + ret = PyMonitoring_FirePyReturnEvent(&__pyx_pymonitoring_state[__Pyx_Monitoring_PY_RETURN], __pyx_frame_code, offset, result);\ + PyGILState_Release(state);\ + }\ + } else {\ + ret = PyMonitoring_FirePyReturnEvent(&__pyx_pymonitoring_state[__Pyx_Monitoring_PY_RETURN], __pyx_frame_code, offset, result);\ + }\ + if (unlikely(ret == -1)) goto_error;\ + } + #define __Pyx_TraceReturnCValue(cresult, convert_function, offset, nogil, goto_error)\ + if (!__Pyx_IsTracing(__Pyx_Monitoring_PY_RETURN)); else {\ + int ret = 0;\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + PyGILState_STATE state = PyGILState_Ensure();\ + PyObject *pyvalue = convert_function(cresult);\ + if (unlikely(!pyvalue)) {\ + PyErr_Clear();\ + pyvalue = Py_None; Py_INCREF(Py_None);\ + }\ + ret = PyMonitoring_FirePyReturnEvent(&__pyx_pymonitoring_state[__Pyx_Monitoring_PY_RETURN], __pyx_frame_code, offset, pyvalue);\ + Py_DECREF(pyvalue);\ + PyGILState_Release(state);\ + }\ + } else {\ + PyObject *pyvalue = convert_function(cresult);\ + if (unlikely(!pyvalue)) {\ + PyErr_Clear();\ + pyvalue = Py_None; Py_INCREF(Py_None);\ + }\ + ret = PyMonitoring_FirePyReturnEvent(&__pyx_pymonitoring_state[__Pyx_Monitoring_PY_RETURN], __pyx_frame_code, offset, pyvalue);\ + Py_DECREF(pyvalue);\ + }\ + if (unlikely(ret == -1)) goto_error;\ + } + #define __Pyx_TraceExceptionUnwind(offset, nogil)\ + if (!__Pyx_IsTracing(__Pyx_Monitoring_PY_UNWIND)); else {\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + PyGILState_STATE state = PyGILState_Ensure();\ + (void) PyMonitoring_FirePyUnwindEvent(&__pyx_pymonitoring_state[__Pyx_Monitoring_PY_UNWIND], __pyx_frame_code, offset);\ + PyGILState_Release(state);\ + }\ + } else {\ + (void) PyMonitoring_FirePyUnwindEvent(&__pyx_pymonitoring_state[__Pyx_Monitoring_PY_UNWIND], __pyx_frame_code, offset);\ + }\ + } + #if CYTHON_TRACE + CYTHON_UNUSED static int __Pyx__TraceLine(PyMonitoringState *monitoring_state, PyObject *code_obj, int line, int offset); + #define __Pyx_TraceLine(line, offset, nogil, goto_error)\ + if (!__Pyx_IsTracing(__Pyx_Monitoring_LINE)); else {\ + int ret = 0;\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + PyGILState_STATE state = PyGILState_Ensure();\ + ret = __Pyx__TraceLine(&__pyx_pymonitoring_state[__Pyx_Monitoring_LINE], __pyx_frame_code, line, offset);\ + PyGILState_Release(state);\ + }\ + } else {\ + ret = __Pyx__TraceLine(&__pyx_pymonitoring_state[__Pyx_Monitoring_LINE], __pyx_frame_code, line, offset);\ + }\ + if (unlikely(ret == -1)) goto_error;\ + } + #endif +#else + #include "compile.h" #include "frameobject.h" #include "traceback.h" +#if PY_VERSION_HEX >= 0x030b00a6 && !defined(PYPY_VERSION) + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif #if CYTHON_PROFILE_REUSE_FRAME #define CYTHON_FRAME_MODIFIER static #define CYTHON_FRAME_DEL(frame) @@ -1073,224 +2204,315 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #define CYTHON_FRAME_MODIFIER #define CYTHON_FRAME_DEL(frame) Py_CLEAR(frame) #endif - #define __Pyx_TraceDeclarations\ - static PyCodeObject *__pyx_frame_code = NULL;\ - CYTHON_FRAME_MODIFIER PyFrameObject *__pyx_frame = NULL;\ - int __Pyx_use_tracing = 0; + #if CYTHON_PROFILE_REUSE_CODEOBJ + #define CYTHON_CODEOBJ_MODIFIER static + #else + #define CYTHON_CODEOBJ_MODIFIER + #endif + #define __Pyx_TraceDeclarationsFunc\ + CYTHON_CODEOBJ_MODIFIER PyCodeObject *__pyx_frame_code = NULL;\ + CYTHON_FRAME_MODIFIER PyFrameObject *__pyx_frame = NULL;\ + int __Pyx_use_tracing = 0; + #define __Pyx_TraceDeclarationsGen\ + PyObject *__pyx_frame_code = __pyx_generator->gi_code;\ + CYTHON_FRAME_MODIFIER PyFrameObject *__pyx_frame = NULL;\ + int __Pyx_use_tracing = 0; #define __Pyx_TraceFrameInit(codeobj)\ - if (codeobj) __pyx_frame_code = (PyCodeObject*) codeobj; - #ifdef WITH_THREAD - #define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error)\ + if (codeobj) __pyx_frame_code = (PyCodeObject*) codeobj; + #define __Pyx_PyMonitoring_ExitScope(nogil) {} + #define __Pyx_TraceException(offset, reraised, fresh) {} + #define __Pyx_TraceExceptionHandled(offset) {} + #define __Pyx_TraceExceptionDone() {} + #define __Pyx_TurnOffSysMonitoringInParallel {} // Only needed for freethreading +#if PY_VERSION_HEX >= 0x030b00a2 + #if PY_VERSION_HEX >= 0x030C00b1 + #define __Pyx_IsTracing(tstate, check_tracing, check_funcs)\ + ((!(check_tracing) || !(tstate)->tracing) &&\ + (!(check_funcs) || (tstate)->c_profilefunc || (CYTHON_TRACE && (tstate)->c_tracefunc))) + #else + #define __Pyx_IsTracing(tstate, check_tracing, check_funcs)\ + (unlikely((tstate)->cframe->use_tracing) &&\ + (!(check_tracing) || !(tstate)->tracing) &&\ + (!(check_funcs) || (tstate)->c_profilefunc || (CYTHON_TRACE && (tstate)->c_tracefunc))) + #endif + #define __Pyx_EnterTracing(tstate) PyThreadState_EnterTracing(tstate) + #define __Pyx_LeaveTracing(tstate) PyThreadState_LeaveTracing(tstate) +#elif PY_VERSION_HEX >= 0x030a00b1 + #define __Pyx_IsTracing(tstate, check_tracing, check_funcs)\ + (unlikely((tstate)->cframe->use_tracing) &&\ + (!(check_tracing) || !(tstate)->tracing) &&\ + (!(check_funcs) || (tstate)->c_profilefunc || (CYTHON_TRACE && (tstate)->c_tracefunc))) + #define __Pyx_EnterTracing(tstate)\ + do { tstate->tracing++; tstate->cframe->use_tracing = 0; } while (0) + #define __Pyx_LeaveTracing(tstate)\ + do {\ + tstate->tracing--;\ + tstate->cframe->use_tracing = ((CYTHON_TRACE && tstate->c_tracefunc != NULL)\ + || tstate->c_profilefunc != NULL);\ + } while (0) +#else + #define __Pyx_IsTracing(tstate, check_tracing, check_funcs)\ + (unlikely((tstate)->use_tracing) &&\ + (!(check_tracing) || !(tstate)->tracing) &&\ + (!(check_funcs) || (tstate)->c_profilefunc || (CYTHON_TRACE && (tstate)->c_tracefunc))) + #define __Pyx_EnterTracing(tstate)\ + do { tstate->tracing++; tstate->use_tracing = 0; } while (0) + #define __Pyx_LeaveTracing(tstate)\ + do {\ + tstate->tracing--;\ + tstate->use_tracing = ((CYTHON_TRACE && tstate->c_tracefunc != NULL)\ + || tstate->c_profilefunc != NULL);\ + } while (0) +#endif + #define __Pyx_TraceStartFunc(funcname, srcfile, firstlineno, offset, nogil, skip_event, goto_error)\ if (nogil) {\ if (CYTHON_TRACE_NOGIL) {\ PyThreadState *tstate;\ PyGILState_STATE state = PyGILState_Ensure();\ tstate = __Pyx_PyThreadState_Current;\ - if (unlikely(tstate->use_tracing) && !tstate->tracing &&\ - (tstate->c_profilefunc || (CYTHON_TRACE && tstate->c_tracefunc))) {\ - __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ + if (__Pyx_IsTracing(tstate, 1, 1)) {\ + __Pyx_use_tracing = __Pyx_TraceSetupAndCall((PyCodeObject**)&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno, skip_event);\ }\ PyGILState_Release(state);\ if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ }\ } else {\ PyThreadState* tstate = PyThreadState_GET();\ - if (unlikely(tstate->use_tracing) && !tstate->tracing &&\ - (tstate->c_profilefunc || (CYTHON_TRACE && tstate->c_tracefunc))) {\ - __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ - if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ - }\ - } - #else - #define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error)\ - { PyThreadState* tstate = PyThreadState_GET();\ - if (unlikely(tstate->use_tracing) && !tstate->tracing &&\ - (tstate->c_profilefunc || (CYTHON_TRACE && tstate->c_tracefunc))) {\ - __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ + if (__Pyx_IsTracing(tstate, 1, 1)) {\ + __Pyx_use_tracing = __Pyx_TraceSetupAndCall((PyCodeObject**)&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno, skip_event);\ if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ }\ } - #endif - #define __Pyx_TraceException()\ + #define __Pyx_TraceStartGen __Pyx_TraceStartFunc + #define __Pyx_TraceYield(result, offset, goto_error)\ if (likely(!__Pyx_use_tracing)); else {\ PyThreadState* tstate = __Pyx_PyThreadState_Current;\ - if (tstate->use_tracing &&\ - (tstate->c_profilefunc || (CYTHON_TRACE && tstate->c_tracefunc))) {\ - tstate->tracing++;\ - tstate->use_tracing = 0;\ - PyObject *exc_info = __Pyx_GetExceptionTuple(tstate);\ - if (exc_info) {\ - if (CYTHON_TRACE && tstate->c_tracefunc)\ - tstate->c_tracefunc(\ - tstate->c_traceobj, __pyx_frame, PyTrace_EXCEPTION, exc_info);\ - tstate->c_profilefunc(\ - tstate->c_profileobj, __pyx_frame, PyTrace_EXCEPTION, exc_info);\ - Py_DECREF(exc_info);\ - }\ - tstate->use_tracing = 1;\ - tstate->tracing--;\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result, 0);\ }\ + if ((1)); else goto_error;\ } - static void __Pyx_call_return_trace_func(PyThreadState *tstate, PyFrameObject *frame, PyObject *result) { + #define __Pyx_TraceResumeGen(funcname, srcfile, firstlineno, offset, goto_error)\ + __Pyx_TraceStartFunc(funcname, srcfile, firstlineno, offset, 0, 0, goto_error) + CYTHON_UNUSED static void __Pyx_call_return_trace_func(PyThreadState *tstate, PyFrameObject *frame, PyObject *result, int delete_frame) { PyObject *type, *value, *traceback; __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); - tstate->tracing++; - tstate->use_tracing = 0; + __Pyx_EnterTracing(tstate); if (CYTHON_TRACE && tstate->c_tracefunc) tstate->c_tracefunc(tstate->c_traceobj, frame, PyTrace_RETURN, result); if (tstate->c_profilefunc) tstate->c_profilefunc(tstate->c_profileobj, frame, PyTrace_RETURN, result); - CYTHON_FRAME_DEL(frame); - tstate->use_tracing = 1; - tstate->tracing--; + if (delete_frame) { + CYTHON_FRAME_DEL(frame); + } + __Pyx_LeaveTracing(tstate); __Pyx_ErrRestoreInState(tstate, type, value, traceback); } - #ifdef WITH_THREAD - #define __Pyx_TraceReturn(result, nogil)\ + #define __Pyx_TraceReturnValue(result, offset, nogil, goto_error)\ if (likely(!__Pyx_use_tracing)); else {\ if (nogil) {\ if (CYTHON_TRACE_NOGIL) {\ PyThreadState *tstate;\ PyGILState_STATE state = PyGILState_Ensure();\ tstate = __Pyx_PyThreadState_Current;\ - if (tstate->use_tracing) {\ - __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result, 1);\ }\ PyGILState_Release(state);\ }\ } else {\ PyThreadState* tstate = __Pyx_PyThreadState_Current;\ - if (tstate->use_tracing) {\ - __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result, 1);\ }\ }\ + if ((1)); else goto_error;\ } - #else - #define __Pyx_TraceReturn(result, nogil)\ + #define __Pyx_TraceReturnCValue(cresult, convert_function, offset, nogil, goto_error)\ if (likely(!__Pyx_use_tracing)); else {\ - PyThreadState* tstate = __Pyx_PyThreadState_Current;\ - if (tstate->use_tracing) {\ - __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + PyThreadState *tstate;\ + PyGILState_STATE state = PyGILState_Ensure();\ + tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ + PyObject *pyvalue = convert_function(cresult);\ + if (unlikely(!pyvalue)) goto_error;\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, pyvalue, 1);\ + Py_DECREF(pyvalue);\ + }\ + PyGILState_Release(state);\ + }\ + } else {\ + PyThreadState* tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ + PyObject *pyvalue = convert_function(cresult);\ + if (unlikely(!pyvalue)) goto_error;\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, pyvalue, 1);\ + Py_DECREF(pyvalue);\ + }\ }\ } - #endif - static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno); - static int __Pyx_TraceSetupAndCall(PyCodeObject** code, PyFrameObject** frame, PyThreadState* tstate, const char *funcname, const char *srcfile, int firstlineno); -#else - #define __Pyx_TraceDeclarations - #define __Pyx_TraceFrameInit(codeobj) - #define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error) if ((1)); else goto_error; - #define __Pyx_TraceException() - #define __Pyx_TraceReturn(result, nogil) -#endif -#if CYTHON_TRACE - static int __Pyx_call_line_trace_func(PyThreadState *tstate, PyFrameObject *frame, int lineno) { - int ret; - PyObject *type, *value, *traceback; - __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); - __Pyx_PyFrame_SetLineNumber(frame, lineno); - tstate->tracing++; - tstate->use_tracing = 0; - ret = tstate->c_tracefunc(tstate->c_traceobj, frame, PyTrace_LINE, NULL); - tstate->use_tracing = 1; - tstate->tracing--; - if (likely(!ret)) { - __Pyx_ErrRestoreInState(tstate, type, value, traceback); - } else { - Py_XDECREF(type); - Py_XDECREF(value); - Py_XDECREF(traceback); - } - return ret; - } - #ifdef WITH_THREAD - #define __Pyx_TraceLine(lineno, nogil, goto_error)\ + #define __Pyx_TraceExceptionUnwind(offset, nogil)\ if (likely(!__Pyx_use_tracing)); else {\ if (nogil) {\ if (CYTHON_TRACE_NOGIL) {\ - int ret = 0;\ PyThreadState *tstate;\ PyGILState_STATE state = PyGILState_Ensure();\ tstate = __Pyx_PyThreadState_Current;\ - if (unlikely(tstate->use_tracing && tstate->c_tracefunc && __pyx_frame->f_trace)) {\ - ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, Py_None, 1);\ }\ PyGILState_Release(state);\ - if (unlikely(ret)) goto_error;\ }\ } else {\ PyThreadState* tstate = __Pyx_PyThreadState_Current;\ - if (unlikely(tstate->use_tracing && tstate->c_tracefunc && __pyx_frame->f_trace)) {\ - int ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ - if (unlikely(ret)) goto_error;\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, Py_None, 1);\ }\ }\ } - #else - #define __Pyx_TraceLine(lineno, nogil, goto_error)\ + static int __Pyx_TraceSetupAndCall(PyCodeObject** code, PyFrameObject** frame, PyThreadState* tstate, const char *funcname, const char *srcfile, int firstlineno, int skip_event); +#if CYTHON_TRACE + CYTHON_UNUSED static int __Pyx_call_line_trace_func(PyThreadState *tstate, PyFrameObject *frame, int line); + #define __Pyx_TraceLine(line, offset, nogil, goto_error)\ if (likely(!__Pyx_use_tracing)); else {\ - PyThreadState* tstate = __Pyx_PyThreadState_Current;\ - if (unlikely(tstate->use_tracing && tstate->c_tracefunc && __pyx_frame->f_trace)) {\ - int ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ - if (unlikely(ret)) goto_error;\ + int ret = 0;\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + PyThreadState *tstate;\ + PyGILState_STATE state = __Pyx_PyGILState_Ensure();\ + tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && __pyx_frame->f_trace) {\ + ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, line);\ + }\ + __Pyx_PyGILState_Release(state);\ + }\ + } else {\ + PyThreadState* tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && __pyx_frame->f_trace) {\ + ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, line);\ + }\ }\ + if (unlikely(ret)) goto_error;\ } - #endif -#else - #define __Pyx_TraceLine(lineno, nogil, goto_error) if ((1)); else goto_error; #endif +#endif +#else + #define __Pyx_TraceDeclarationsFunc + #define __Pyx_TraceDeclarationsGen + #define __Pyx_TraceExceptionDone() {} + #define __Pyx_TraceFrameInit(codeobj) {} + #define __Pyx_TurnOffSysMonitoringInParallel {} + #define __Pyx_PyMonitoring_ExitScope(nogil) {} + #define __Pyx_TraceException(offset, reraised, fresh) {} + #define __Pyx_TraceExceptionUnwind(offset, nogil) {} + #define __Pyx_TraceExceptionHandled(offset) {} + #define __Pyx_TraceStartFunc(funcname, srcfile, firstlineno, offset, nogil, skip_event, goto_error) if ((1)); else goto_error; + #define __Pyx_TraceStartGen __Pyx_TraceStartFunc + #define __Pyx_TraceResumeGen(funcname, srcfile, firstlineno, offset, goto_error) if ((1)); else goto_error; + #define __Pyx_TraceYield(result, offset, goto_error) if ((1)); else goto_error; + #define __Pyx_TraceReturnValue(result, offset, nogil, goto_error)\ + if ((1)); else goto_error; + #define __Pyx_TraceReturnCValue(cresult, convert_function, offset, nogil, goto_error)\ + if ((1)); else { (void) convert_function; goto_error } +#endif +#if !CYTHON_TRACE + #define __Pyx_TraceLine(line, offset, nogil, goto_error) if ((1)); else goto_error; +#endif + +/* PyObjectFormatAndDecref.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f); +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f); + +/* JoinPyUnicode.proto */ +static PyObject* __Pyx_PyUnicode_Join(PyObject** values, Py_ssize_t value_count, Py_ssize_t result_ulength, + Py_UCS4 max_char); + +/* RejectKeywords.proto */ +static void __Pyx_RejectKeywords(const char* function_name, PyObject *kwds); -/* IterFinish.proto */ -static CYTHON_INLINE int __Pyx_IterFinish(void); +/* GetItemInt.proto */ +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil)\ + (__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, has_gil)\ + (__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, has_gil)\ + (__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); -/* 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, Py_ssize_t nargs, PyObject *kwargs); +/* PyDictVersioning.proto */ +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +#define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) +#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ + (version_var) = __PYX_GET_DICT_VERSION(dict);\ + (cache_var) = (value); +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ + (VAR) = __pyx_dict_cached_value;\ + } else {\ + (VAR) = __pyx_dict_cached_value = (LOOKUP);\ + __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ + }\ +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); #else -#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) -#endif -#define __Pyx_BUILD_ASSERT_EXPR(cond)\ - (sizeof(char [1 - 2*!(cond)]) - 1) -#ifndef Py_MEMBER_SIZE -#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) -#endif - static size_t __pyx_pyframe_localsplus_offset = 0; - #include "frameobject.h" - #define __Pxy_PyFrame_Initialize_Offsets()\ - ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ - (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) - #define __Pyx_PyFrame_GetLocalsplus(frame)\ - (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) +#define __PYX_GET_DICT_VERSION(dict) (0) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); #endif -/* PyObjectCall.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +/* GetModuleGlobalName.proto */ +#if CYTHON_USE_DICT_VERSIONS +#define __Pyx_GetModuleGlobalName(var, name) do {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_mstate_global->__pyx_d))) ?\ + (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ + __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} while(0) +#define __Pyx_GetModuleGlobalNameUncached(var, name) do {\ + PY_UINT64_T __pyx_dict_version;\ + PyObject *__pyx_dict_cached_value;\ + (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} while(0) +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); #else -#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) +#define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); #endif -/* PyObjectCallMethO.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +/* PyObjectFastCallMethod.proto */ +#if CYTHON_VECTORCALL && PY_VERSION_HEX >= 0x03090000 +#define __Pyx_PyObject_FastCallMethod(name, args, nargsf) PyObject_VectorcallMethod(name, args, nargsf, NULL) +#else +static PyObject *__Pyx_PyObject_FastCallMethod(PyObject *name, PyObject *const *args, size_t nargsf); #endif +/* 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 - -/* 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 /* PyObjectCallOneArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); @@ -1317,12 +2539,8 @@ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); 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( + PyObject* tuple, PyObject** value1, PyObject** value2, int is_tuple, int has_known_size, int 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( @@ -1334,138 +2552,41 @@ static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int 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); -/* PyObjectCall2Args.proto */ -static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); +/* SliceObject.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice( + PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop, + PyObject** py_start, PyObject** py_stop, PyObject** py_slice, + int has_cstart, int has_cstop, int wraparound); -/* PyDictVersioning.proto */ -#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS -#define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) -#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) -#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ - (version_var) = __PYX_GET_DICT_VERSION(dict);\ - (cache_var) = (value); -#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ - static PY_UINT64_T __pyx_dict_version = 0;\ - static PyObject *__pyx_dict_cached_value = NULL;\ - if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ - (VAR) = __pyx_dict_cached_value;\ - } else {\ - (VAR) = __pyx_dict_cached_value = (LOOKUP);\ - __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ - }\ +/* ExtTypeTest.proto */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + +/* PySequenceContains.proto */ +static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) { + int result = PySequence_Contains(seq, item); + return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); } -static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); -static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); -static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); + +/* IterNextPlain.proto */ +static CYTHON_INLINE PyObject *__Pyx_PyIter_Next_Plain(PyObject *iterator); +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 +static PyObject *__Pyx_GetBuiltinNext_LimitedAPI(void); +#endif + +/* IterNext.proto */ +#define __Pyx_PyIter_Next(obj) __Pyx_PyIter_Next2(obj, NULL) +static CYTHON_INLINE PyObject *__Pyx_PyIter_Next2(PyObject *, PyObject *); + +/* PyLongBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static CYTHON_INLINE PyObject* __Pyx_PyLong_SubtractObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); #else -#define __PYX_GET_DICT_VERSION(dict) (0) -#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) -#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); -#endif - -/* GetModuleGlobalName.proto */ -#if CYTHON_USE_DICT_VERSIONS -#define __Pyx_GetModuleGlobalName(var, name) {\ - static PY_UINT64_T __pyx_dict_version = 0;\ - static PyObject *__pyx_dict_cached_value = NULL;\ - (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ - (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ - __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ -} -#define __Pyx_GetModuleGlobalNameUncached(var, name) {\ - PY_UINT64_T __pyx_dict_version;\ - PyObject *__pyx_dict_cached_value;\ - (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ -} -static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); -#else -#define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) -#define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) -static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); -#endif - -/* 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); - -/* SliceObject.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice( - PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop, - PyObject** py_start, PyObject** py_stop, PyObject** py_slice, - int has_cstart, int has_cstop, int wraparound); - -/* PySequenceContains.proto */ -static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) { - int result = PySequence_Contains(seq, item); - return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); -} - -/* IncludeStringH.proto */ -#include - -/* BytesEquals.proto */ -static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); - -/* UnicodeEquals.proto */ -static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); - -/* StrEquals.proto */ -#if PY_MAJOR_VERSION >= 3 -#define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals -#else -#define __Pyx_PyString_Equals __Pyx_PyBytes_Equals -#endif - -/* IterNext.proto */ -#define __Pyx_PyIter_Next(obj) __Pyx_PyIter_Next2(obj, NULL) -static CYTHON_INLINE PyObject *__Pyx_PyIter_Next2(PyObject *, PyObject *); - -/* PyIntBinop.proto */ -#if !CYTHON_COMPILING_IN_PYPY -static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); -#else -#define __Pyx_PyInt_SubtractObjC(op1, op2, intval, inplace, zerodivision_check)\ - (inplace ? PyNumber_InPlaceSubtract(op1, op2) : PyNumber_Subtract(op1, op2)) -#endif - -/* StringJoin.proto */ -#if PY_MAJOR_VERSION < 3 -#define __Pyx_PyString_Join __Pyx_PyBytes_Join -#define __Pyx_PyBaseString_Join(s, v) (PyUnicode_CheckExact(s) ? PyUnicode_Join(s, v) : __Pyx_PyBytes_Join(s, v)) -#else -#define __Pyx_PyString_Join PyUnicode_Join -#define __Pyx_PyBaseString_Join PyUnicode_Join -#endif -#if CYTHON_COMPILING_IN_CPYTHON - #if PY_MAJOR_VERSION < 3 - #define __Pyx_PyBytes_Join _PyString_Join - #else - #define __Pyx_PyBytes_Join _PyBytes_Join - #endif -#else -static CYTHON_INLINE PyObject* __Pyx_PyBytes_Join(PyObject* sep, PyObject* values); +#define __Pyx_PyLong_SubtractObjC(op1, op2, intval, inplace, zerodivision_check)\ + (inplace ? PyNumber_InPlaceSubtract(op1, op2) : PyNumber_Subtract(op1, op2)) #endif /* GetTopmostException.proto */ -#if CYTHON_USE_EXC_INFO_STACK +#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); #endif @@ -1483,22 +2604,25 @@ static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, 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_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) #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)) +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2) { + return PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2); +} #endif +#define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) - -/* PyErrExceptionMatches.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) -static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); +#ifdef PyExceptionInstance_Check + #define __Pyx_PyBaseException_Check(obj) PyExceptionInstance_Check(obj) #else -#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) + #define __Pyx_PyBaseException_Check(obj) __Pyx_TypeCheck(obj, PyExc_BaseException) #endif /* GetException.proto */ @@ -1517,11 +2641,31 @@ static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject * static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); #endif +/* PyObjectFormatSimple.proto */ +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + PyObject_Format(s, f)) +#elif CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + likely(PyLong_CheckExact(s)) ? PyLong_Type.tp_repr(s) :\ + likely(PyFloat_CheckExact(s)) ? PyFloat_Type.tp_repr(s) :\ + PyObject_Format(s, f)) +#else + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + PyObject_Format(s, f)) +#endif + /* GetAttr.proto */ static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); -/* GetAttr3.proto */ -static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); +/* ArgTypeTest.proto */ +#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ + ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\ + __Pyx__ArgTypeTest(obj, type, name, exact)) +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); /* ListAppend.proto */ #if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS @@ -1530,8 +2674,12 @@ static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { Py_ssize_t len = Py_SIZE(list); if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { Py_INCREF(x); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 + L->ob_item[len] = x; + #else PyList_SET_ITEM(list, len, x); - Py_SIZE(list) = len+1; + #endif + __Pyx_SET_SIZE(list, len + 1); return 0; } return PyList_Append(list, x); @@ -1540,91 +2688,290 @@ static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { #define __Pyx_PyList_Append(L,x) PyList_Append(L,x) #endif -/* Import.proto */ -static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); +/* pep479.proto */ +static void __Pyx_Generator_Replace_StopIteration(int in_async_gen); -/* ImportFrom.proto */ -static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); +/* CallTypeTraverse.proto */ +#if !CYTHON_USE_TYPE_SPECS || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x03090000) +#define __Pyx_call_type_traverse(o, always_call, visit, arg) 0 +#else +static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg); +#endif -/* RaiseException.proto */ -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); +/* TypeImport.proto */ +#ifndef __PYX_HAVE_RT_ImportType_proto_3_1_3 +#define __PYX_HAVE_RT_ImportType_proto_3_1_3 +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L +#include +#endif +#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L +#define __PYX_GET_STRUCT_ALIGNMENT_3_1_3(s) alignof(s) +#else +#define __PYX_GET_STRUCT_ALIGNMENT_3_1_3(s) sizeof(void*) +#endif +enum __Pyx_ImportType_CheckSize_3_1_3 { + __Pyx_ImportType_CheckSize_Error_3_1_3 = 0, + __Pyx_ImportType_CheckSize_Warn_3_1_3 = 1, + __Pyx_ImportType_CheckSize_Ignore_3_1_3 = 2 +}; +static PyTypeObject *__Pyx_ImportType_3_1_3(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_1_3 check_size); +#endif -/* ExtTypeTest.proto */ -static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); +/* LimitedApiGetTypeDict.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_GetTypeDict(PyTypeObject *tp); +#endif -/* HasAttr.proto */ -static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); +/* SetItemOnTypeDict.proto */ +static int __Pyx__SetItemOnTypeDict(PyTypeObject *tp, PyObject *k, PyObject *v); +#define __Pyx_SetItemOnTypeDict(tp, k, v) __Pyx__SetItemOnTypeDict((PyTypeObject*)tp, k, v) -/* PyObject_GenericGetAttrNoDict.proto */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name); -#else -#define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr +/* FixUpExtensionType.proto */ +static CYTHON_INLINE int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); + +/* ValidateBasesTuple.proto */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases); #endif +/* PyType_Ready.proto */ +CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t); + /* SetVTable.proto */ -static int __Pyx_SetVtable(PyObject *dict, void *vtable); +static int __Pyx_SetVtable(PyTypeObject* typeptr , void* vtable); -/* SetupReduce.proto */ -static int __Pyx_setup_reduce(PyObject* type_obj); +/* GetVTable.proto */ +static void* __Pyx_GetVtable(PyTypeObject *type); -/* TypeImport.proto */ -#ifndef __PYX_HAVE_RT_ImportType_proto -#define __PYX_HAVE_RT_ImportType_proto -enum __Pyx_ImportType_CheckSize { - __Pyx_ImportType_CheckSize_Error = 0, - __Pyx_ImportType_CheckSize_Warn = 1, - __Pyx_ImportType_CheckSize_Ignore = 2 -}; -static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size); +/* MergeVTables.proto */ +static int __Pyx_MergeVtables(PyTypeObject *type); + +/* ListPack.proto */ +static PyObject *__Pyx_PyList_Pack(Py_ssize_t n, ...); + +/* Import.proto */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +/* ImportFrom.proto */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); + +/* FetchSharedCythonModule.proto */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void); + +/* dict_setdefault.proto */ +static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value, int is_safe_type); + +/* FetchCommonType.proto */ +static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases); + +/* CommonTypesMetaclass.proto */ +static int __pyx_CommonTypesMetaclass_init(PyObject *module); +#define __Pyx_CommonTypesMetaclass_USED + +/* PyMethodNew.proto */ +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ); + +/* PyVectorcallFastCallDict.proto */ +#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL) +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw); +#endif + +/* CythonFunctionShared.proto */ +#define __Pyx_CyFunction_USED +#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 +#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 +#define __Pyx_CYFUNCTION_CCLASS 0x04 +#define __Pyx_CYFUNCTION_COROUTINE 0x08 +#define __Pyx_CyFunction_GetClosure(f)\ + (((__pyx_CyFunctionObject *) (f))->func_closure) +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_CyFunction_GetClassObj(f)\ + (((__pyx_CyFunctionObject *) (f))->func_classobj) +#else + #define __Pyx_CyFunction_GetClassObj(f)\ + ((PyObject*) ((PyCMethodObject *) (f))->mm_class) +#endif +#define __Pyx_CyFunction_SetClassObj(f, classobj)\ + __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (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 { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject_HEAD + PyObject *func; +#elif PY_VERSION_HEX < 0x030900B1 + PyCFunctionObject func; +#else + PyCMethodObject func; +#endif +#if CYTHON_BACKPORT_VECTORCALL ||\ + (CYTHON_COMPILING_IN_LIMITED_API && CYTHON_METH_FASTCALL) + __pyx_vectorcallfunc func_vectorcall; +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + 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; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_classobj; +#endif + PyObject *defaults; + int flags; + PyObject *defaults_tuple; + PyObject *defaults_kwdict; + PyObject *(*defaults_getter)(PyObject *); + PyObject *func_annotations; + PyObject *func_is_coroutine; +} __pyx_CyFunctionObject; +#undef __Pyx_CyOrPyCFunction_Check +#define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_mstate_global->__pyx_CyFunctionType) +#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_mstate_global->__pyx_CyFunctionType, &PyCFunction_Type) +#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_mstate_global->__pyx_CyFunctionType) +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)); +#undef __Pyx_IsSameCFunction +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCyOrCFunction(func, cfunc) +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); +static CYTHON_INLINE PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func, + PyTypeObject *defaults_type); +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(PyObject *module); +#if CYTHON_METH_FASTCALL +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +#if CYTHON_BACKPORT_VECTORCALL || CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall) +#else +#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall) #endif +#endif + +/* CythonFunction.proto */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); /* CLineInTraceback.proto */ -#ifdef CYTHON_CLINE_IN_TRACEBACK -#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) -#else +#if CYTHON_CLINE_IN_TRACEBACK && CYTHON_CLINE_IN_TRACEBACK_RUNTIME static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); +#else +#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) #endif /* CodeObjectCache.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject __Pyx_CachedCodeObjectType; +#else +typedef PyCodeObject __Pyx_CachedCodeObjectType; +#endif typedef struct { - PyCodeObject* code_object; + __Pyx_CachedCodeObjectType* code_object; int code_line; } __Pyx_CodeObjectCacheEntry; struct __Pyx_CodeObjectCache { int count; int max_count; __Pyx_CodeObjectCacheEntry* entries; + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_atomic_int_type accessor_count; + #endif }; -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); +static __Pyx_CachedCodeObjectType *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, __Pyx_CachedCodeObjectType* code_object); /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); +/* GCCDiagnostics.proto */ +#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#define __Pyx_HAS_GCC_DIAGNOSTIC +#endif + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *); + +/* PyObjectVectorCallKwBuilder.proto */ +CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n); +#if CYTHON_VECTORCALL +#if PY_VERSION_HEX >= 0x03090000 +#define __Pyx_Object_Vectorcall_CallFromBuilder PyObject_Vectorcall +#else +#define __Pyx_Object_Vectorcall_CallFromBuilder _PyObject_Vectorcall +#endif +#define __Pyx_MakeVectorcallBuilderKwds(n) PyTuple_New(n) +static int __Pyx_VectorcallBuilder_AddArg(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n); +static int __Pyx_VectorcallBuilder_AddArgStr(const char *key, PyObject *value, PyObject *builder, PyObject **args, int n); +#else +#define __Pyx_Object_Vectorcall_CallFromBuilder __Pyx_PyObject_FastCallDict +#define __Pyx_MakeVectorcallBuilderKwds(n) __Pyx_PyDict_NewPresized(n) +#define __Pyx_VectorcallBuilder_AddArg(key, value, builder, args, n) PyDict_SetItem(builder, key, value) +#define __Pyx_VectorcallBuilder_AddArgStr(key, value, builder, args, n) PyDict_SetItemString(builder, key, value) +#endif + /* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_int(int value); /* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value); + +/* FormatTypeName.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%U" +#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 +#define __Pyx_PyType_GetFullyQualifiedName PyType_GetFullyQualifiedName +#else +static __Pyx_TypeName __Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp); +#endif +#else // !LIMITED_API +typedef const char *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%.200s" +#define __Pyx_PyType_GetFullyQualifiedName(tp) ((tp)->tp_name) +#define __Pyx_DECREF_TypeName(obj) +#endif /* CIntFromPy.proto */ -static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); +static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *); -/* CIntFromPy.proto */ -static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); -/* FetchCommonType.proto */ -static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); +/* PyObjectCall2Args.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); /* PyObjectCallMethod1.proto */ static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg); +/* ReturnWithStopIteration.proto */ +static CYTHON_INLINE void __Pyx_ReturnWithStopIteration(PyObject* value, int async, int iternext); + /* CoroutineBase.proto */ -typedef PyObject *(*__pyx_coroutine_body_t)(PyObject *, PyThreadState *, PyObject *); +struct __pyx_CoroutineObject; +typedef PyObject *(*__pyx_coroutine_body_t)(struct __pyx_CoroutineObject *, PyThreadState *, PyObject *); #if CYTHON_USE_EXC_INFO_STACK #define __Pyx_ExcInfoStruct _PyErr_StackItem #else @@ -1634,7 +2981,7 @@ typedef struct { PyObject *exc_traceback; } __Pyx_ExcInfoStruct; #endif -typedef struct { +typedef struct __pyx_CoroutineObject { PyObject_HEAD __pyx_coroutine_body_t body; PyObject *closure; @@ -1642,10 +2989,16 @@ typedef struct { PyObject *gi_weakreflist; PyObject *classobj; PyObject *yieldfrom; + __Pyx_pyiter_sendfunc yieldfrom_am_send; PyObject *gi_name; PyObject *gi_qualname; PyObject *gi_modulename; PyObject *gi_code; + PyObject *gi_frame; +#if CYTHON_USE_SYS_MONITORING && (CYTHON_PROFILE || CYTHON_TRACE) + PyMonitoringState __pyx_pymonitoring_state[__Pyx_MonitoringEventTypes_CyGen_count]; + uint64_t __pyx_pymonitoring_version; +#endif int resume_label; char is_running; } __pyx_CoroutineObject; @@ -1657,8 +3010,9 @@ static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit( PyObject *name, PyObject *qualname, PyObject *module_name); static CYTHON_INLINE void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *self); static int __Pyx_Coroutine_clear(PyObject *self); +static __Pyx_PySendResult __Pyx_Coroutine_AmSend(PyObject *self, PyObject *value, PyObject **retval); static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value); -static PyObject *__Pyx_Coroutine_Close(PyObject *self); +static __Pyx_PySendResult __Pyx_Coroutine_Close(PyObject *self, PyObject **retval); static PyObject *__Pyx_Coroutine_Throw(PyObject *gen, PyObject *args); #if CYTHON_USE_EXC_INFO_STACK #define __Pyx_Coroutine_SwapException(self) @@ -1682,305 +3036,342 @@ static PyObject *__Pyx_Coroutine_Throw(PyObject *gen, PyObject *args); #endif static int __Pyx_PyGen__FetchStopIterationValue(PyThreadState *tstate, PyObject **pvalue); static CYTHON_INLINE void __Pyx_Coroutine_ResetFrameBackpointer(__Pyx_ExcInfoStruct *exc_state); - -/* PatchModuleWithCoroutine.proto */ -static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code); - -/* PatchGeneratorABC.proto */ -static int __Pyx_patch_abc(void); +static char __Pyx_Coroutine_test_and_set_is_running(__pyx_CoroutineObject *gen); +static void __Pyx_Coroutine_unset_is_running(__pyx_CoroutineObject *gen); +static char __Pyx_Coroutine_get_is_running(__pyx_CoroutineObject *gen); +static PyObject *__Pyx_Coroutine_get_is_running_getter(PyObject *gen, void *closure); +#if __PYX_HAS_PY_AM_SEND == 2 +static void __Pyx_SetBackportTypeAmSend(PyTypeObject *type, __Pyx_PyAsyncMethodsStruct *static_amsend_methods, __Pyx_pyiter_sendfunc am_send); +#endif +static PyObject *__Pyx_Coroutine_fail_reduce_ex(PyObject *self, PyObject *arg); /* Generator.proto */ #define __Pyx_Generator_USED -static PyTypeObject *__pyx_GeneratorType = 0; -#define __Pyx_Generator_CheckExact(obj) (Py_TYPE(obj) == __pyx_GeneratorType) +#define __Pyx_Generator_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_mstate_global->__pyx_GeneratorType) #define __Pyx_Generator_New(body, code, closure, name, qualname, module_name)\ - __Pyx__Coroutine_New(__pyx_GeneratorType, body, code, closure, name, qualname, module_name) + __Pyx__Coroutine_New(__pyx_mstate_global->__pyx_GeneratorType, body, code, closure, name, qualname, module_name) static PyObject *__Pyx_Generator_Next(PyObject *self); -static int __pyx_Generator_init(void); - -/* CheckBinaryVersion.proto */ -static int __Pyx_check_binary_version(void); +static int __pyx_Generator_init(PyObject *module); +static CYTHON_INLINE PyObject *__Pyx_Generator_GetInlinedResult(PyObject *self); -/* InitStrings.proto */ -static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); +/* GetRuntimeVersion.proto */ +static unsigned long __Pyx_get_runtime_version(void); -static struct __pyx_obj_6hunter_6_event_Event *__pyx_f_6hunter_6_event_5Event_clone(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self); /* proto*/ +/* CheckBinaryVersion.proto */ +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); + +/* FunctionExport.proto */ +static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig); + +/* MultiPhaseInitModuleState.proto */ +#if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE +static PyObject *__Pyx_State_FindModule(void*); +static int __Pyx_State_AddModule(PyObject* module, void*); +static int __Pyx_State_RemoveModule(void*); +#elif CYTHON_USE_MODULE_STATE +#define __Pyx_State_FindModule PyState_FindModule +#define __Pyx_State_AddModule PyState_AddModule +#define __Pyx_State_RemoveModule PyState_RemoveModule +#endif + +/* #### Code section: module_declarations ### */ +/* CythonABIVersion.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API + #if CYTHON_METH_FASTCALL + #define __PYX_FASTCALL_ABI_SUFFIX "_fastcall" + #else + #define __PYX_FASTCALL_ABI_SUFFIX + #endif + #define __PYX_LIMITED_ABI_SUFFIX "limited" __PYX_FASTCALL_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX +#else + #define __PYX_LIMITED_ABI_SUFFIX +#endif +#if __PYX_HAS_PY_AM_SEND == 1 + #define __PYX_AM_SEND_ABI_SUFFIX +#elif __PYX_HAS_PY_AM_SEND == 2 + #define __PYX_AM_SEND_ABI_SUFFIX "amsendbackport" +#else + #define __PYX_AM_SEND_ABI_SUFFIX "noamsend" +#endif +#ifndef __PYX_MONITORING_ABI_SUFFIX + #define __PYX_MONITORING_ABI_SUFFIX +#endif +#if CYTHON_USE_TP_FINALIZE + #define __PYX_TP_FINALIZE_ABI_SUFFIX +#else + #define __PYX_TP_FINALIZE_ABI_SUFFIX "nofinalize" +#endif +#if CYTHON_USE_FREELISTS || !defined(__Pyx_AsyncGen_USED) + #define __PYX_FREELISTS_ABI_SUFFIX +#else + #define __PYX_FREELISTS_ABI_SUFFIX "nofreelists" +#endif +#define CYTHON_ABI __PYX_ABI_VERSION __PYX_LIMITED_ABI_SUFFIX __PYX_MONITORING_ABI_SUFFIX __PYX_TP_FINALIZE_ABI_SUFFIX __PYX_FREELISTS_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX +#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI +#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." -/* Module declarations from 'cython' */ +static PyObject *__pyx_f_6hunter_6_event_5Event_instruction_getter(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_6hunter_6_event_5Event_threadid_getter(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_6hunter_6_event_5Event_threadname_getter(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_6hunter_6_event_5Event_locals_getter(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_6hunter_6_event_5Event_globals_getter(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_6hunter_6_event_5Event_function_getter(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_6hunter_6_event_5Event_module_getter(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_6hunter_6_event_5Event_filename_getter(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_6hunter_6_event_5Event_lineno_getter(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self); /* proto*/ +static PyCodeObject *__pyx_f_6hunter_6_event_5Event_code_getter(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_6hunter_6_event_5Event_stdlib_getter(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_6hunter_6_event_5Event_fullsource_getter(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_6hunter_6_event_5Event_source_getter(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self); /* proto*/ -/* Module declarations from 'libc.string' */ +/* Module declarations from "cython" */ -/* Module declarations from 'libc.stdio' */ +/* Module declarations from "types" */ -/* Module declarations from '__builtin__' */ +/* Module declarations from "cpython.pythread" */ -/* Module declarations from 'cpython.type' */ -static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; +/* Module declarations from "libc.string" */ -/* Module declarations from 'cpython' */ +/* Module declarations from "libc.stdio" */ -/* Module declarations from 'cpython.object' */ +/* Module declarations from "__builtin__" */ -/* Module declarations from 'cpython.pystate' */ +/* Module declarations from "cpython.type" */ -/* Module declarations from 'types' */ +/* Module declarations from "cpython" */ -/* Module declarations from 'hunter._tracer' */ -static PyTypeObject *__pyx_ptype_6hunter_7_tracer_CodeType = 0; -static PyTypeObject *__pyx_ptype_6hunter_7_tracer_FrameType = 0; -static PyTypeObject *__pyx_ptype_6hunter_7_tracer_Tracer = 0; +/* Module declarations from "cpython.object" */ -/* Module declarations from 'cpython.pythread' */ +/* Module declarations from "cpython.ref" */ -/* Module declarations from 'hunter._event' */ -static PyTypeObject *__pyx_ptype_6hunter_6_event_Event = 0; -static PyTypeObject *__pyx_ptype_6hunter_6_event___pyx_scope_struct__yield_lines = 0; +/* Module declarations from "hunter._event" */ static PyObject *__pyx_v_6hunter_6_event_UNSET = 0; -static PyObject *__pyx_f_6hunter_6_event___pyx_unpickle_Event__set_state(struct __pyx_obj_6hunter_6_event_Event *, PyObject *); /*proto*/ +static PyObject *__pyx_v_6hunter_6_event_CALL = 0; +static PyObject *__pyx_v_6hunter_6_event_EXCEPTION = 0; +static PyObject *__pyx_v_6hunter_6_event_LINE = 0; +static PyObject *__pyx_v_6hunter_6_event_RETURN = 0; +static PyObject const **__pyx_v_6hunter_6_event_KIND_NAMES; +static CYTHON_INLINE struct __pyx_obj_6hunter_6_event_Event *__pyx_f_6hunter_6_event_fast_clone(struct __pyx_obj_6hunter_6_event_Event *); /*proto*/ +static CYTHON_INLINE struct __pyx_obj_6hunter_6_event_Event *__pyx_f_6hunter_6_event_fast_detach(struct __pyx_obj_6hunter_6_event_Event *, PyObject *); /*proto*/ +/* #### Code section: typeinfo ### */ +/* #### Code section: before_global_var ### */ #define __Pyx_MODULE_NAME "hunter._event" extern int __pyx_module_is_main_hunter___event; int __pyx_module_is_main_hunter___event = 0; -/* Implementation of 'hunter._event' */ +/* Implementation of "hunter._event" */ +/* #### Code section: global_var ### */ static PyObject *__pyx_builtin_object; -static const char __pyx_k_[] = ""; -static const char __pyx_k__7[] = "."; +/* #### Code section: string_decls ### */ +static const char __pyx_k_[] = ">"; +static const char __pyx_k_1[] = "\2301"; +static const char __pyx_k_6[] = "\320\004\"\240!\330\010\017\210{\230!\2306\240\021"; +static const char __pyx_k_Q[] = "\220Q"; +static const char __pyx_k_a[] = "\220a"; +static const char __pyx_k_v[] = "v"; +static const char __pyx_k__2[] = ""; +static const char __pyx_k__3[] = "?"; +static const char __pyx_k__4[] = "."; +static const char __pyx_k__5[] = "\230\001"; +static const char __pyx_k__6[] = "\200\001\330\020\021"; +static const char __pyx_k_eq[] = "__eq__"; +static const char __pyx_k_gc[] = "gc"; static const char __pyx_k_py[] = ".py"; static const char __pyx_k_so[] = ".so"; +static const char __pyx_k_A_t[] = "\200A\340\010\017\210t\220>\240\021"; +static const char __pyx_k_A_z[] = "\200A\330\010\017\210z\230\021\230!"; static const char __pyx_k_all[] = "__all__"; static const char __pyx_k_arg[] = "arg"; static const char __pyx_k_def[] = "def"; static const char __pyx_k_get[] = "get"; -static const char __pyx_k_new[] = "__new__"; +static const char __pyx_k_pop[] = "pop"; static const char __pyx_k_pyc[] = ".pyc"; static const char __pyx_k_pyd[] = ".pyd"; static const char __pyx_k_pyo[] = ".pyo"; static const char __pyx_k_pyx[] = ".pyx"; static const char __pyx_k_sub[] = "sub"; -static const char __pyx_k_args[] = "args"; +static const char __pyx_k_CALL[] = "CALL"; +static const char __pyx_k_LINE[] = "LINE"; static const char __pyx_k_call[] = "call"; -static const char __pyx_k_code[] = "code"; -static const char __pyx_k_dict[] = "__dict__"; +static const char __pyx_k_code[] = "_code"; static const char __pyx_k_file[] = "__file__"; -static const char __pyx_k_join[] = "join"; +static const char __pyx_k_func[] = "__func__"; +static const char __pyx_k_init[] = "__init__"; +static const char __pyx_k_item[] = "item"; static const char __pyx_k_kind[] = "kind"; static const char __pyx_k_line[] = "line"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_name[] = "name"; static const char __pyx_k_next[] = "next"; +static const char __pyx_k_repr[] = "__repr__"; +static const char __pyx_k_self[] = "self"; static const char __pyx_k_send[] = "send"; static const char __pyx_k_site[] = "site"; static const char __pyx_k_test[] = "__test__"; static const char __pyx_k_util[] = "util"; +static const char __pyx_k_A_t_1[] = "\200A\340\010\017\210t\320\023#\2401"; +static const char __pyx_k_A_t_2[] = "\200A\340\010\017\210t\220?\240!"; +static const char __pyx_k_A_t_Q[] = "\200A\340\010\017\210t\320\023%\240Q"; +static const char __pyx_k_A_t_a[] = "\200A\340\010\017\210t\320\023&\240a"; +static const char __pyx_k_A_t_q[] = "\200A\340\010\017\210t\220<\230q"; +static const char __pyx_k_A_uCq[] = "\200A\330\010\017\210u\220C\220q"; static const char __pyx_k_Event[] = "Event"; +static const char __pyx_k_UNSET[] = "UNSET"; +static const char __pyx_k_calls[] = "calls"; static const char __pyx_k_class[] = "class"; +static const char __pyx_k_clone[] = "clone"; static const char __pyx_k_close[] = "close"; static const char __pyx_k_const[] = "const"; +static const char __pyx_k_depth[] = "depth"; static const char __pyx_k_frame[] = "frame"; +static const char __pyx_k_get_2[] = "__get__"; static const char __pyx_k_ident[] = "ident"; static const char __pyx_k_items[] = "items"; static const char __pyx_k_limit[] = "limit"; +static const char __pyx_k_other[] = "other"; static const char __pyx_k_split[] = "split"; static const char __pyx_k_start[] = "start"; static const char __pyx_k_throw[] = "throw"; +static const char __pyx_k_value[] = "value"; +static const char __pyx_k_A_wavQ[] = "\200A\330\010\017\210w\220a\220v\230Q"; +static const char __pyx_k_RETURN[] = "RETURN"; static const char __pyx_k_amount[] = "amount"; +static const char __pyx_k_code_2[] = "code"; static const char __pyx_k_dedent[] = "dedent"; +static const char __pyx_k_detach[] = "detach"; +static const char __pyx_k_enable[] = "enable"; static const char __pyx_k_exists[] = "exists"; -static const char __pyx_k_format[] = "format"; -static const char __pyx_k_import[] = "__import__"; +static const char __pyx_k_file_2[] = " file"; +static const char __pyx_k_func_2[] = "func"; static const char __pyx_k_lambda[] = "lambda"; -static const char __pyx_k_lineno[] = "lineno"; +static const char __pyx_k_lineno[] = " lineno="; static const char __pyx_k_locals[] = "locals"; -static const char __pyx_k_module[] = "module"; +static const char __pyx_k_module[] = " module="; static const char __pyx_k_name_2[] = "__name__"; static const char __pyx_k_object[] = "object"; -static const char __pyx_k_pickle[] = "pickle"; -static const char __pyx_k_reduce[] = "__reduce__"; -static const char __pyx_k_source[] = "source"; -static const char __pyx_k_stdlib[] = "stdlib"; +static const char __pyx_k_return[] = "return"; +static const char __pyx_k_source[] = "_source"; +static const char __pyx_k_stdlib[] = "_stdlib"; static const char __pyx_k_string[] = ""; -static const char __pyx_k_tracer[] = "tracer"; -static const char __pyx_k_update[] = "update"; +static const char __pyx_k_thread[] = "_thread"; static const char __pyx_k_values[] = "values"; -static const char __pyx_k_co_name[] = "co_name"; +static const char __pyx_k_builtin[] = "builtin"; +static const char __pyx_k_disable[] = "disable"; static const char __pyx_k_findall[] = "findall"; +static const char __pyx_k_getitem[] = "__getitem__"; static const char __pyx_k_getline[] = "getline"; static const char __pyx_k_globals[] = "globals"; static const char __pyx_k_os_path[] = "os.path"; static const char __pyx_k_partial[] = "partial"; +static const char __pyx_k_add_note[] = "add_note"; static const char __pyx_k_basename[] = "basename"; +static const char __pyx_k_detached[] = "detached"; static const char __pyx_k_endswith[] = "endswith"; -static const char __pyx_k_filename[] = "filename"; -static const char __pyx_k_function[] = "function"; +static const char __pyx_k_filename[] = " filename="; +static const char __pyx_k_function[] = " function="; static const char __pyx_k_getlines[] = "getlines"; -static const char __pyx_k_getstate[] = "__getstate__"; -static const char __pyx_k_module_2[] = ""; -static const char __pyx_k_pyx_type[] = "__pyx_type"; -static const char __pyx_k_setstate[] = "__setstate__"; +static const char __pyx_k_lineno_2[] = "lineno"; +static const char __pyx_k_lineno_3[] = "_lineno"; +static const char __pyx_k_locals_2[] = "_locals"; +static const char __pyx_k_module_2[] = "module"; +static const char __pyx_k_module_3[] = "__module__"; +static const char __pyx_k_module_4[] = ""; +static const char __pyx_k_module_5[] = "_module"; +static const char __pyx_k_qualname[] = "__qualname__"; +static const char __pyx_k_set_name[] = "__set_name__"; static const char __pyx_k_splitext[] = "splitext"; -static const char __pyx_k_threadid[] = "threadid"; static const char __pyx_k_tokenize[] = "tokenize"; +static const char __pyx_k_EXCEPTION[] = "EXCEPTION"; +static const char __pyx_k_NO_SOURCE[] = "\077\077? NO SOURCE: "; +static const char __pyx_k_candidate[] = "candidate"; static const char __pyx_k_collector[] = "collector"; +static const char __pyx_k_exception[] = "exception"; +static const char __pyx_k_f_globals[] = "f_globals"; +static const char __pyx_k_first_arg[] = "first_arg"; static const char __pyx_k_functools[] = "functools"; +static const char __pyx_k_globals_2[] = "_globals"; +static const char __pyx_k_isenabled[] = "isenabled"; static const char __pyx_k_linecache[] = "linecache"; -static const char __pyx_k_pyx_state[] = "__pyx_state"; -static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; +static const char __pyx_k_threadidn[] = "_threadidn"; static const char __pyx_k_threading[] = "threading"; +static const char __pyx_k_A_4wc_a_4q[] = "\200A\330\010\013\2104\210w\220c\230\021\330\014\023\320\023)\250\021\250$\250a\340\014\023\2204\220q"; +static const char __pyx_k_Event_kind[] = " 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) + #define CYTHON_SMALL_CODE __attribute__((cold)) +#else + #define CYTHON_SMALL_CODE +#endif +#endif + +typedef struct { + PyObject *__pyx_d; + PyObject *__pyx_b; + PyObject *__pyx_cython_runtime; + PyObject *__pyx_empty_tuple; + PyObject *__pyx_empty_bytes; + PyObject *__pyx_empty_unicode; + #ifdef __Pyx_CyFunction_USED + PyTypeObject *__pyx_CyFunctionType; + #endif + #ifdef __Pyx_FusedFunction_USED + PyTypeObject *__pyx_FusedFunctionType; + #endif + #ifdef __Pyx_Generator_USED + PyTypeObject *__pyx_GeneratorType; + #endif + #ifdef __Pyx_IterableCoroutine_USED + PyTypeObject *__pyx_IterableCoroutineType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineAwaitType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineType; + #endif + PyTypeObject *__pyx_ptype_7cpython_4type_type; + PyObject *__pyx_type_6hunter_6_event_Event; + PyObject *__pyx_type_6hunter_6_event___pyx_scope_struct__yield_lines; + PyTypeObject *__pyx_ptype_6hunter_6_event_CodeType; + PyTypeObject *__pyx_ptype_6hunter_6_event_Event; + PyTypeObject *__pyx_ptype_6hunter_6_event___pyx_scope_struct__yield_lines; + __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_pop; + PyObject *__pyx_slice[1]; + PyObject *__pyx_tuple[7]; + PyObject *__pyx_codeobj_tab[44]; + PyObject *__pyx_string_tab[169]; + PyObject *__pyx_int_1; + PyObject *__pyx_int_10; + PyObject *__pyx_int_neg_1; +/* #### Code section: module_state_contents ### */ +/* IterNextPlain.module_state_decls */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 +PyObject *__Pyx_GetBuiltinNext_LimitedAPI_cache; +#endif + + +#if CYTHON_USE_FREELISTS +struct __pyx_obj_6hunter_6_event___pyx_scope_struct__yield_lines *__pyx_freelist_6hunter_6_event___pyx_scope_struct__yield_lines[8]; +int __pyx_freecount_6hunter_6_event___pyx_scope_struct__yield_lines; +#endif +/* CommonTypesMetaclass.module_state_decls */ +PyTypeObject *__pyx_CommonTypesMetaclassType; + +/* CachedMethodType.module_state_decls */ +#if CYTHON_COMPILING_IN_LIMITED_API +PyObject *__Pyx_CachedMethodType; +#endif + +/* CodeObjectCache.module_state_decls */ +struct __Pyx_CodeObjectCache __pyx_code_cache; + +/* #### Code section: module_state_end ### */ +} __pyx_mstatetype; + +#if CYTHON_USE_MODULE_STATE +#ifdef __cplusplus +namespace { +extern struct PyModuleDef __pyx_moduledef; +} /* anonymous namespace */ +#else +static struct PyModuleDef __pyx_moduledef; +#endif + +#define __pyx_mstate_global (__Pyx_PyModule_GetState(__Pyx_State_FindModule(&__pyx_moduledef))) + +#define __pyx_m (__Pyx_State_FindModule(&__pyx_moduledef)) +#else +static __pyx_mstatetype __pyx_mstate_global_static = +#ifdef __cplusplus + {}; +#else + {0}; +#endif +static __pyx_mstatetype * const __pyx_mstate_global = &__pyx_mstate_global_static; +#endif +/* #### Code section: constant_name_defines ### */ +#define __pyx_kp_u_ __pyx_string_tab[0] +#define __pyx_n_u_CALL __pyx_string_tab[1] +#define __pyx_n_u_CYTHON_SUFFIX_RE __pyx_string_tab[2] +#define __pyx_n_u_EXCEPTION __pyx_string_tab[3] +#define __pyx_n_u_Event __pyx_string_tab[4] +#define __pyx_n_u_Event_clone __pyx_string_tab[5] +#define __pyx_n_u_Event_detach __pyx_string_tab[6] +#define __pyx_kp_u_Event_kind __pyx_string_tab[7] +#define __pyx_n_u_KIND_NAMES __pyx_string_tab[8] +#define __pyx_n_u_LEADING_WHITESPACE_RE __pyx_string_tab[9] +#define __pyx_n_u_LINE __pyx_string_tab[10] +#define __pyx_kp_u_NO_SOURCE __pyx_string_tab[11] +#define __pyx_kp_u_NO_SOURCE_not_reading_binary __pyx_string_tab[12] +#define __pyx_kp_u_Note_that_Cython_is_deliberately __pyx_string_tab[13] +#define __pyx_n_u_RETURN __pyx_string_tab[14] +#define __pyx_n_u_SITE_PACKAGES_PATHS __pyx_string_tab[15] +#define __pyx_n_u_SYS_PREFIX_PATHS __pyx_string_tab[16] +#define __pyx_n_u_TokenError __pyx_string_tab[17] +#define __pyx_n_u_UNSET __pyx_string_tab[18] +#define __pyx_kp_u__2 __pyx_string_tab[19] +#define __pyx_kp_u__3 __pyx_string_tab[20] +#define __pyx_kp_u__4 __pyx_string_tab[21] +#define __pyx_kp_u_add_note __pyx_string_tab[22] +#define __pyx_n_u_all __pyx_string_tab[23] +#define __pyx_n_u_amount __pyx_string_tab[24] +#define __pyx_n_u_arg __pyx_string_tab[25] +#define __pyx_n_u_asyncio_coroutines __pyx_string_tab[26] +#define __pyx_n_u_basename __pyx_string_tab[27] +#define __pyx_n_u_builtin __pyx_string_tab[28] +#define __pyx_n_u_call __pyx_string_tab[29] +#define __pyx_n_u_calls __pyx_string_tab[30] +#define __pyx_n_u_candidate __pyx_string_tab[31] +#define __pyx_n_u_class __pyx_string_tab[32] +#define __pyx_n_u_cline_in_traceback __pyx_string_tab[33] +#define __pyx_n_u_clone __pyx_string_tab[34] +#define __pyx_n_u_close __pyx_string_tab[35] +#define __pyx_n_u_code __pyx_string_tab[36] +#define __pyx_n_u_code_2 __pyx_string_tab[37] +#define __pyx_n_u_code_getter __pyx_string_tab[38] +#define __pyx_n_u_collector __pyx_string_tab[39] +#define __pyx_n_u_const __pyx_string_tab[40] +#define __pyx_n_u_current_thread __pyx_string_tab[41] +#define __pyx_n_u_dedent __pyx_string_tab[42] +#define __pyx_n_u_def __pyx_string_tab[43] +#define __pyx_n_u_depth __pyx_string_tab[44] +#define __pyx_n_u_detach __pyx_string_tab[45] +#define __pyx_n_u_detached __pyx_string_tab[46] +#define __pyx_kp_u_disable __pyx_string_tab[47] +#define __pyx_kp_u_enable __pyx_string_tab[48] +#define __pyx_n_u_endswith __pyx_string_tab[49] +#define __pyx_n_u_eq __pyx_string_tab[50] +#define __pyx_n_u_exception __pyx_string_tab[51] +#define __pyx_n_u_exists __pyx_string_tab[52] +#define __pyx_n_u_f_globals __pyx_string_tab[53] +#define __pyx_n_u_fast_clone __pyx_string_tab[54] +#define __pyx_n_u_fast_detach __pyx_string_tab[55] +#define __pyx_n_u_file __pyx_string_tab[56] +#define __pyx_kp_u_file_2 __pyx_string_tab[57] +#define __pyx_kp_u_filename __pyx_string_tab[58] +#define __pyx_n_u_filename_2 __pyx_string_tab[59] +#define __pyx_n_u_filename_3 __pyx_string_tab[60] +#define __pyx_n_u_filename_getter __pyx_string_tab[61] +#define __pyx_n_u_findall __pyx_string_tab[62] +#define __pyx_n_u_first_arg __pyx_string_tab[63] +#define __pyx_n_u_frame __pyx_string_tab[64] +#define __pyx_n_u_fullsource __pyx_string_tab[65] +#define __pyx_n_u_fullsource_getter __pyx_string_tab[66] +#define __pyx_n_u_func __pyx_string_tab[67] +#define __pyx_n_u_func_2 __pyx_string_tab[68] +#define __pyx_kp_u_function __pyx_string_tab[69] +#define __pyx_n_u_function_2 __pyx_string_tab[70] +#define __pyx_n_u_function_3 __pyx_string_tab[71] +#define __pyx_n_u_function_getter __pyx_string_tab[72] +#define __pyx_n_u_function_object __pyx_string_tab[73] +#define __pyx_n_u_functools __pyx_string_tab[74] +#define __pyx_kp_u_gc __pyx_string_tab[75] +#define __pyx_n_u_generate_tokens __pyx_string_tab[76] +#define __pyx_n_u_get __pyx_string_tab[77] +#define __pyx_n_u_get_2 __pyx_string_tab[78] +#define __pyx_n_u_get_func_in_mro __pyx_string_tab[79] +#define __pyx_n_u_get_main_thread __pyx_string_tab[80] +#define __pyx_n_u_getitem __pyx_string_tab[81] +#define __pyx_n_u_getline __pyx_string_tab[82] +#define __pyx_n_u_getlines __pyx_string_tab[83] +#define __pyx_n_u_globals __pyx_string_tab[84] +#define __pyx_n_u_globals_2 __pyx_string_tab[85] +#define __pyx_n_u_globals_getter __pyx_string_tab[86] +#define __pyx_n_u_hunter__event __pyx_string_tab[87] +#define __pyx_n_u_ident __pyx_string_tab[88] +#define __pyx_n_u_if_same_code __pyx_string_tab[89] +#define __pyx_n_u_init __pyx_string_tab[90] +#define __pyx_n_u_instruction __pyx_string_tab[91] +#define __pyx_n_u_instruction_getter __pyx_string_tab[92] +#define __pyx_n_u_is_coroutine __pyx_string_tab[93] +#define __pyx_kp_u_isenabled __pyx_string_tab[94] +#define __pyx_n_u_item __pyx_string_tab[95] +#define __pyx_n_u_items __pyx_string_tab[96] +#define __pyx_n_u_kind __pyx_string_tab[97] +#define __pyx_n_u_lambda __pyx_string_tab[98] +#define __pyx_n_u_limit __pyx_string_tab[99] +#define __pyx_n_u_line __pyx_string_tab[100] +#define __pyx_n_u_linecache __pyx_string_tab[101] +#define __pyx_kp_u_lineno __pyx_string_tab[102] +#define __pyx_n_u_lineno_2 __pyx_string_tab[103] +#define __pyx_n_u_lineno_3 __pyx_string_tab[104] +#define __pyx_n_u_lineno_getter __pyx_string_tab[105] +#define __pyx_n_u_locals __pyx_string_tab[106] +#define __pyx_n_u_locals_2 __pyx_string_tab[107] +#define __pyx_n_u_locals_getter __pyx_string_tab[108] +#define __pyx_n_u_main __pyx_string_tab[109] +#define __pyx_kp_u_module __pyx_string_tab[110] +#define __pyx_n_u_module_2 __pyx_string_tab[111] +#define __pyx_n_u_module_3 __pyx_string_tab[112] +#define __pyx_kp_u_module_4 __pyx_string_tab[113] +#define __pyx_n_u_module_5 __pyx_string_tab[114] +#define __pyx_n_u_module_getter __pyx_string_tab[115] +#define __pyx_n_u_module_globals __pyx_string_tab[116] +#define __pyx_n_u_name __pyx_string_tab[117] +#define __pyx_n_u_name_2 __pyx_string_tab[118] +#define __pyx_n_u_namedtuple __pyx_string_tab[119] +#define __pyx_n_u_next __pyx_string_tab[120] +#define __pyx_n_u_object __pyx_string_tab[121] +#define __pyx_n_u_os_path __pyx_string_tab[122] +#define __pyx_n_u_other __pyx_string_tab[123] +#define __pyx_n_u_partial __pyx_string_tab[124] +#define __pyx_n_u_pkg_resources __pyx_string_tab[125] +#define __pyx_n_u_pop __pyx_string_tab[126] +#define __pyx_kp_u_py __pyx_string_tab[127] +#define __pyx_kp_u_pyc __pyx_string_tab[128] +#define __pyx_kp_u_pyd __pyx_string_tab[129] +#define __pyx_kp_u_pyo __pyx_string_tab[130] +#define __pyx_kp_u_pyx __pyx_string_tab[131] +#define __pyx_n_u_pyx_vtable __pyx_string_tab[132] +#define __pyx_n_u_qualname __pyx_string_tab[133] +#define __pyx_n_u_repr __pyx_string_tab[134] +#define __pyx_n_u_return __pyx_string_tab[135] +#define __pyx_n_u_self __pyx_string_tab[136] +#define __pyx_n_u_send __pyx_string_tab[137] +#define __pyx_n_u_set_name __pyx_string_tab[138] +#define __pyx_n_u_site __pyx_string_tab[139] +#define __pyx_kp_u_so __pyx_string_tab[140] +#define __pyx_n_u_source __pyx_string_tab[141] +#define __pyx_n_u_source_getter __pyx_string_tab[142] +#define __pyx_n_u_split __pyx_string_tab[143] +#define __pyx_n_u_splitext __pyx_string_tab[144] +#define __pyx_kp_u_src_hunter__event_pxd __pyx_string_tab[145] +#define __pyx_kp_u_src_hunter__event_pyx __pyx_string_tab[146] +#define __pyx_n_u_start __pyx_string_tab[147] +#define __pyx_n_u_startswith __pyx_string_tab[148] +#define __pyx_n_u_stdlib __pyx_string_tab[149] +#define __pyx_n_u_stdlib_getter __pyx_string_tab[150] +#define __pyx_kp_u_string __pyx_string_tab[151] +#define __pyx_n_u_sub __pyx_string_tab[152] +#define __pyx_n_u_test __pyx_string_tab[153] +#define __pyx_n_u_thread __pyx_string_tab[154] +#define __pyx_n_u_threadid_getter __pyx_string_tab[155] +#define __pyx_n_u_threadidn __pyx_string_tab[156] +#define __pyx_n_u_threading __pyx_string_tab[157] +#define __pyx_n_u_threading_support __pyx_string_tab[158] +#define __pyx_n_u_threadname __pyx_string_tab[159] +#define __pyx_n_u_threadname_getter __pyx_string_tab[160] +#define __pyx_n_u_throw __pyx_string_tab[161] +#define __pyx_n_u_tokenize __pyx_string_tab[162] +#define __pyx_n_u_util __pyx_string_tab[163] +#define __pyx_n_u_v __pyx_string_tab[164] +#define __pyx_n_u_value __pyx_string_tab[165] +#define __pyx_n_u_value_filter __pyx_string_tab[166] +#define __pyx_n_u_values __pyx_string_tab[167] +#define __pyx_n_u_yield_lines __pyx_string_tab[168] +/* #### Code section: module_state_clear ### */ +#if CYTHON_USE_MODULE_STATE +static CYTHON_SMALL_CODE int __pyx_m_clear(PyObject *m) { + __pyx_mstatetype *clear_module_state = __Pyx_PyModule_GetState(m); + if (!clear_module_state) return 0; + Py_CLEAR(clear_module_state->__pyx_d); + Py_CLEAR(clear_module_state->__pyx_b); + Py_CLEAR(clear_module_state->__pyx_cython_runtime); + Py_CLEAR(clear_module_state->__pyx_empty_tuple); + Py_CLEAR(clear_module_state->__pyx_empty_bytes); + Py_CLEAR(clear_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_CLEAR(clear_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_CLEAR(clear_module_state->__pyx_FusedFunctionType); + #endif + #if CYTHON_PEP489_MULTI_PHASE_INIT + __Pyx_State_RemoveModule(NULL); + #endif + Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_4type_type); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_6_event_CodeType); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_6_event_Event); + Py_CLEAR(clear_module_state->__pyx_type_6hunter_6_event_Event); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_6_event___pyx_scope_struct__yield_lines); + Py_CLEAR(clear_module_state->__pyx_type_6hunter_6_event___pyx_scope_struct__yield_lines); + for (int i=0; i<1; ++i) { Py_CLEAR(clear_module_state->__pyx_slice[i]); } + for (int i=0; i<7; ++i) { Py_CLEAR(clear_module_state->__pyx_tuple[i]); } + for (int i=0; i<44; ++i) { Py_CLEAR(clear_module_state->__pyx_codeobj_tab[i]); } + for (int i=0; i<169; ++i) { Py_CLEAR(clear_module_state->__pyx_string_tab[i]); } + Py_CLEAR(clear_module_state->__pyx_int_1); + Py_CLEAR(clear_module_state->__pyx_int_10); + Py_CLEAR(clear_module_state->__pyx_int_neg_1); + return 0; +} +#endif +/* #### Code section: module_state_traverse ### */ +#if CYTHON_USE_MODULE_STATE +static CYTHON_SMALL_CODE int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { + __pyx_mstatetype *traverse_module_state = __Pyx_PyModule_GetState(m); + if (!traverse_module_state) return 0; + Py_VISIT(traverse_module_state->__pyx_d); + Py_VISIT(traverse_module_state->__pyx_b); + Py_VISIT(traverse_module_state->__pyx_cython_runtime); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_tuple); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_bytes); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_VISIT(traverse_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_VISIT(traverse_module_state->__pyx_FusedFunctionType); + #endif + Py_VISIT(traverse_module_state->__pyx_ptype_7cpython_4type_type); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_6_event_CodeType); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_6_event_Event); + Py_VISIT(traverse_module_state->__pyx_type_6hunter_6_event_Event); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_6_event___pyx_scope_struct__yield_lines); + Py_VISIT(traverse_module_state->__pyx_type_6hunter_6_event___pyx_scope_struct__yield_lines); + for (int i=0; i<1; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_slice[i]); } + for (int i=0; i<7; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_tuple[i]); } + for (int i=0; i<44; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_codeobj_tab[i]); } + for (int i=0; i<169; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_string_tab[i]); } + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_1); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_10); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_neg_1); + return 0; +} +#endif +/* #### Code section: module_code ### */ + +/* "hunter/_event.pyx":59 + * may be expected. * """ - * def __init__(self, FrameType frame, str kind, object arg, Tracer tracer): # <<<<<<<<<<<<<< + * def __init__(self, FrameType frame, int kind, object arg, int depth, int calls, bint threading_support): # <<<<<<<<<<<<<< * self.arg = arg * self.frame = frame - */ +*/ /* Python wrapper */ static int __pyx_pw_6hunter_6_event_5Event_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_6hunter_6_event_5Event_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyFrameObject *__pyx_v_frame = 0; - PyObject *__pyx_v_kind = 0; + FrameType __pyx_v_frame = 0; + int __pyx_v_kind; PyObject *__pyx_v_arg = 0; - struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_tracer = 0; + int __pyx_v_depth; + int __pyx_v_calls; + int __pyx_v_threading_support; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[6] = {0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_frame,&__pyx_n_s_kind,&__pyx_n_s_arg,&__pyx_n_s_tracer,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); + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_frame,&__pyx_mstate_global->__pyx_n_u_kind,&__pyx_mstate_global->__pyx_n_u_arg,&__pyx_mstate_global->__pyx_n_u_depth,&__pyx_mstate_global->__pyx_n_u_calls,&__pyx_mstate_global->__pyx_n_u_threading_support,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 59, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 6: + values[5] = __Pyx_ArgRef_VARARGS(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 59, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 5: + values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 59, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 4: + values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 59, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 3: + values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 59, __pyx_L3_error) 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_frame)) != 0)) kw_args--; - else goto __pyx_L5_argtuple_error; + case 2: + values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 59, __pyx_L3_error) CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kind)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, 1); __PYX_ERR(0, 43, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_arg)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, 2); __PYX_ERR(0, 43, __pyx_L3_error) - } + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 59, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_tracer)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, 3); __PYX_ERR(0, 43, __pyx_L3_error) - } + case 0: break; + default: goto __pyx_L5_argtuple_error; } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 43, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__init__", 0) < 0) __PYX_ERR(0, 59, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 6; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__init__", 1, 6, 6, i); __PYX_ERR(0, 59, __pyx_L3_error) } } - } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { + } else if (unlikely(__pyx_nargs != 6)) { 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); + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 59, __pyx_L3_error) + values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 59, __pyx_L3_error) + values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 59, __pyx_L3_error) + values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 59, __pyx_L3_error) + values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 59, __pyx_L3_error) + values[5] = __Pyx_ArgRef_VARARGS(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 59, __pyx_L3_error) } - __pyx_v_frame = ((PyFrameObject *)values[0]); - __pyx_v_kind = ((PyObject*)values[1]); + __pyx_v_frame = ((FrameType)values[0]); + __pyx_v_kind = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_kind == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 59, __pyx_L3_error) __pyx_v_arg = values[2]; - __pyx_v_tracer = ((struct __pyx_obj_6hunter_7_tracer_Tracer *)values[3]); + __pyx_v_depth = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_depth == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 59, __pyx_L3_error) + __pyx_v_calls = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_calls == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 59, __pyx_L3_error) + __pyx_v_threading_support = __Pyx_PyObject_IsTrue(values[5]); if (unlikely((__pyx_v_threading_support == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 59, __pyx_L3_error) } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 43, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__init__", 1, 6, 6, __pyx_nargs); __PYX_ERR(0, 59, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } __Pyx_AddTraceback("hunter._event.Event.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_frame), __pyx_ptype_6hunter_7_tracer_FrameType, 1, "frame", 0))) __PYX_ERR(0, 43, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_kind), (&PyString_Type), 1, "kind", 1))) __PYX_ERR(0, 43, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_tracer), __pyx_ptype_6hunter_7_tracer_Tracer, 1, "tracer", 0))) __PYX_ERR(0, 43, __pyx_L1_error) - __pyx_r = __pyx_pf_6hunter_6_event_5Event___init__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self), __pyx_v_frame, __pyx_v_kind, __pyx_v_arg, __pyx_v_tracer); + __pyx_r = __pyx_pf_6hunter_6_event_5Event___init__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self), __pyx_v_frame, __pyx_v_kind, __pyx_v_arg, __pyx_v_depth, __pyx_v_calls, __pyx_v_threading_support); /* function exit code */ - goto __pyx_L0; - __pyx_L1_error:; - __pyx_r = -1; - __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } __Pyx_RefNannyFinishContext(); return __pyx_r; } -static int __pyx_pf_6hunter_6_event_5Event___init__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self, PyFrameObject *__pyx_v_frame, PyObject *__pyx_v_kind, PyObject *__pyx_v_arg, struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_tracer) { +static int __pyx_pf_6hunter_6_event_5Event___init__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self, FrameType __pyx_v_frame, int __pyx_v_kind, PyObject *__pyx_v_arg, int __pyx_v_depth, int __pyx_v_calls, int __pyx_v_threading_support) { int __pyx_r; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[0])) __Pyx_RefNannySetupContext("__init__", 0); - __Pyx_TraceCall("__init__", __pyx_f[0], 43, 0, __PYX_ERR(0, 43, __pyx_L1_error)); + __Pyx_TraceStartFunc("__init__", __pyx_f[0], 59, 0, 0, 0, __PYX_ERR(0, 59, __pyx_L1_error)); - /* "hunter/_event.pyx":44 + /* "hunter/_event.pyx":60 * """ - * def __init__(self, FrameType frame, str kind, object arg, Tracer tracer): + * def __init__(self, FrameType frame, int kind, object arg, int depth, int calls, bint threading_support): * self.arg = arg # <<<<<<<<<<<<<< * self.frame = frame - * self.kind = kind - */ - __Pyx_TraceLine(44,0,__PYX_ERR(0, 44, __pyx_L1_error)) + * self.kind = KIND_NAMES[kind] +*/ + __Pyx_TraceLine(60,1,0,__PYX_ERR(0, 60, __pyx_L1_error)) __Pyx_INCREF(__pyx_v_arg); __Pyx_GIVEREF(__pyx_v_arg); __Pyx_GOTREF(__pyx_v_self->arg); __Pyx_DECREF(__pyx_v_self->arg); __pyx_v_self->arg = __pyx_v_arg; - /* "hunter/_event.pyx":45 - * def __init__(self, FrameType frame, str kind, object arg, Tracer tracer): + /* "hunter/_event.pyx":61 + * def __init__(self, FrameType frame, int kind, object arg, int depth, int calls, bint threading_support): * self.arg = arg * self.frame = frame # <<<<<<<<<<<<<< - * self.kind = kind - * self.depth = tracer.depth - */ - __Pyx_TraceLine(45,0,__PYX_ERR(0, 45, __pyx_L1_error)) - __Pyx_INCREF(((PyObject *)__pyx_v_frame)); - __Pyx_GIVEREF(((PyObject *)__pyx_v_frame)); + * self.kind = KIND_NAMES[kind] + * self.depth = depth +*/ + __Pyx_TraceLine(61,4,0,__PYX_ERR(0, 61, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_frame); + __Pyx_GIVEREF(__pyx_v_frame); __Pyx_GOTREF(__pyx_v_self->frame); - __Pyx_DECREF(((PyObject *)__pyx_v_self->frame)); + __Pyx_DECREF(__pyx_v_self->frame); __pyx_v_self->frame = __pyx_v_frame; - /* "hunter/_event.pyx":46 + /* "hunter/_event.pyx":62 * self.arg = arg * self.frame = frame - * self.kind = kind # <<<<<<<<<<<<<< - * self.depth = tracer.depth - * self.calls = tracer.calls - */ - __Pyx_TraceLine(46,0,__PYX_ERR(0, 46, __pyx_L1_error)) - __Pyx_INCREF(__pyx_v_kind); - __Pyx_GIVEREF(__pyx_v_kind); + * self.kind = KIND_NAMES[kind] # <<<<<<<<<<<<<< + * self.depth = depth + * self.calls = calls +*/ + __Pyx_TraceLine(62,9,0,__PYX_ERR(0, 62, __pyx_L1_error)) + __pyx_t_1 = ((PyObject *)(__pyx_v_6hunter_6_event_KIND_NAMES[__pyx_v_kind])); + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->kind); __Pyx_DECREF(__pyx_v_self->kind); - __pyx_v_self->kind = __pyx_v_kind; + __pyx_v_self->kind = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; - /* "hunter/_event.pyx":47 + /* "hunter/_event.pyx":63 * self.frame = frame - * self.kind = kind - * self.depth = tracer.depth # <<<<<<<<<<<<<< - * self.calls = tracer.calls - * self.threading_support = tracer.threading_support - */ - __Pyx_TraceLine(47,0,__PYX_ERR(0, 47, __pyx_L1_error)) - __pyx_t_1 = __pyx_v_tracer->depth; - __pyx_v_self->depth = __pyx_t_1; - - /* "hunter/_event.pyx":48 - * self.kind = kind - * self.depth = tracer.depth - * self.calls = tracer.calls # <<<<<<<<<<<<<< - * self.threading_support = tracer.threading_support - * self.detached = False - */ - __Pyx_TraceLine(48,0,__PYX_ERR(0, 48, __pyx_L1_error)) - __pyx_t_1 = __pyx_v_tracer->calls; - __pyx_v_self->calls = __pyx_t_1; - - /* "hunter/_event.pyx":49 - * self.depth = tracer.depth - * self.calls = tracer.calls - * self.threading_support = tracer.threading_support # <<<<<<<<<<<<<< + * self.kind = KIND_NAMES[kind] + * self.depth = depth # <<<<<<<<<<<<<< + * self.calls = calls + * self.threading_support = threading_support +*/ + __Pyx_TraceLine(63,13,0,__PYX_ERR(0, 63, __pyx_L1_error)) + __pyx_v_self->depth = __pyx_v_depth; + + /* "hunter/_event.pyx":64 + * self.kind = KIND_NAMES[kind] + * self.depth = depth + * self.calls = calls # <<<<<<<<<<<<<< + * self.threading_support = threading_support * self.detached = False - * - */ - __Pyx_TraceLine(49,0,__PYX_ERR(0, 49, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_tracer->threading_support); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 49, __pyx_L1_error) - __pyx_v_self->threading_support = __pyx_t_2; +*/ + __Pyx_TraceLine(64,16,0,__PYX_ERR(0, 64, __pyx_L1_error)) + __pyx_v_self->calls = __pyx_v_calls; - /* "hunter/_event.pyx":50 - * self.calls = tracer.calls - * self.threading_support = tracer.threading_support + /* "hunter/_event.pyx":65 + * self.depth = depth + * self.calls = calls + * self.threading_support = threading_support # <<<<<<<<<<<<<< + * self.detached = False + * self.builtin = kind > 3 +*/ + __Pyx_TraceLine(65,19,0,__PYX_ERR(0, 65, __pyx_L1_error)) + __pyx_v_self->threading_support = __pyx_v_threading_support; + + /* "hunter/_event.pyx":66 + * self.calls = calls + * self.threading_support = threading_support * self.detached = False # <<<<<<<<<<<<<< + * self.builtin = kind > 3 * - * self._code = UNSET - */ - __Pyx_TraceLine(50,0,__PYX_ERR(0, 50, __pyx_L1_error)) +*/ + __Pyx_TraceLine(66,22,0,__PYX_ERR(0, 66, __pyx_L1_error)) __pyx_v_self->detached = 0; - /* "hunter/_event.pyx":52 + /* "hunter/_event.pyx":67 + * self.threading_support = threading_support * self.detached = False + * self.builtin = kind > 3 # <<<<<<<<<<<<<< + * + * self._code = UNSET +*/ + __Pyx_TraceLine(67,28,0,__PYX_ERR(0, 67, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyBool_FromLong((__pyx_v_kind > 3)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 67, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->builtin); + __Pyx_DECREF(__pyx_v_self->builtin); + __pyx_v_self->builtin = __pyx_t_1; + __pyx_t_1 = 0; + + /* "hunter/_event.pyx":69 + * self.builtin = kind > 3 * * self._code = UNSET # <<<<<<<<<<<<<< * self._filename = UNSET * self._fullsource = UNSET - */ - __Pyx_TraceLine(52,0,__PYX_ERR(0, 52, __pyx_L1_error)) +*/ + __Pyx_TraceLine(69,30,0,__PYX_ERR(0, 69, __pyx_L1_error)) __Pyx_INCREF(__pyx_v_6hunter_6_event_UNSET); __Pyx_GIVEREF(__pyx_v_6hunter_6_event_UNSET); __Pyx_GOTREF(__pyx_v_self->_code); __Pyx_DECREF(__pyx_v_self->_code); __pyx_v_self->_code = __pyx_v_6hunter_6_event_UNSET; - /* "hunter/_event.pyx":53 + /* "hunter/_event.pyx":70 * * self._code = UNSET * self._filename = UNSET # <<<<<<<<<<<<<< * self._fullsource = UNSET * self._function_object = UNSET - */ - __Pyx_TraceLine(53,0,__PYX_ERR(0, 53, __pyx_L1_error)) +*/ + __Pyx_TraceLine(70,33,0,__PYX_ERR(0, 70, __pyx_L1_error)) __Pyx_INCREF(__pyx_v_6hunter_6_event_UNSET); __Pyx_GIVEREF(__pyx_v_6hunter_6_event_UNSET); __Pyx_GOTREF(__pyx_v_self->_filename); __Pyx_DECREF(__pyx_v_self->_filename); __pyx_v_self->_filename = __pyx_v_6hunter_6_event_UNSET; - /* "hunter/_event.pyx":54 + /* "hunter/_event.pyx":71 * self._code = UNSET * self._filename = UNSET * self._fullsource = UNSET # <<<<<<<<<<<<<< * self._function_object = UNSET * self._function = UNSET - */ - __Pyx_TraceLine(54,0,__PYX_ERR(0, 54, __pyx_L1_error)) +*/ + __Pyx_TraceLine(71,36,0,__PYX_ERR(0, 71, __pyx_L1_error)) __Pyx_INCREF(__pyx_v_6hunter_6_event_UNSET); __Pyx_GIVEREF(__pyx_v_6hunter_6_event_UNSET); __Pyx_GOTREF(__pyx_v_self->_fullsource); __Pyx_DECREF(__pyx_v_self->_fullsource); __pyx_v_self->_fullsource = __pyx_v_6hunter_6_event_UNSET; - /* "hunter/_event.pyx":55 + /* "hunter/_event.pyx":72 * self._filename = UNSET * self._fullsource = UNSET * self._function_object = UNSET # <<<<<<<<<<<<<< * self._function = UNSET * self._globals = UNSET - */ - __Pyx_TraceLine(55,0,__PYX_ERR(0, 55, __pyx_L1_error)) +*/ + __Pyx_TraceLine(72,39,0,__PYX_ERR(0, 72, __pyx_L1_error)) __Pyx_INCREF(__pyx_v_6hunter_6_event_UNSET); __Pyx_GIVEREF(__pyx_v_6hunter_6_event_UNSET); __Pyx_GOTREF(__pyx_v_self->_function_object); __Pyx_DECREF(__pyx_v_self->_function_object); __pyx_v_self->_function_object = __pyx_v_6hunter_6_event_UNSET; - /* "hunter/_event.pyx":56 + /* "hunter/_event.pyx":73 * self._fullsource = UNSET * self._function_object = UNSET * self._function = UNSET # <<<<<<<<<<<<<< * self._globals = UNSET * self._lineno = UNSET - */ - __Pyx_TraceLine(56,0,__PYX_ERR(0, 56, __pyx_L1_error)) +*/ + __Pyx_TraceLine(73,42,0,__PYX_ERR(0, 73, __pyx_L1_error)) __Pyx_INCREF(__pyx_v_6hunter_6_event_UNSET); __Pyx_GIVEREF(__pyx_v_6hunter_6_event_UNSET); __Pyx_GOTREF(__pyx_v_self->_function); __Pyx_DECREF(__pyx_v_self->_function); __pyx_v_self->_function = __pyx_v_6hunter_6_event_UNSET; - /* "hunter/_event.pyx":57 + /* "hunter/_event.pyx":74 * self._function_object = UNSET * self._function = UNSET * self._globals = UNSET # <<<<<<<<<<<<<< * self._lineno = UNSET * self._locals = UNSET - */ - __Pyx_TraceLine(57,0,__PYX_ERR(0, 57, __pyx_L1_error)) +*/ + __Pyx_TraceLine(74,45,0,__PYX_ERR(0, 74, __pyx_L1_error)) __Pyx_INCREF(__pyx_v_6hunter_6_event_UNSET); __Pyx_GIVEREF(__pyx_v_6hunter_6_event_UNSET); __Pyx_GOTREF(__pyx_v_self->_globals); __Pyx_DECREF(__pyx_v_self->_globals); __pyx_v_self->_globals = __pyx_v_6hunter_6_event_UNSET; - /* "hunter/_event.pyx":58 + /* "hunter/_event.pyx":75 * self._function = UNSET * self._globals = UNSET * self._lineno = UNSET # <<<<<<<<<<<<<< * self._locals = UNSET * self._module = UNSET - */ - __Pyx_TraceLine(58,0,__PYX_ERR(0, 58, __pyx_L1_error)) +*/ + __Pyx_TraceLine(75,48,0,__PYX_ERR(0, 75, __pyx_L1_error)) __Pyx_INCREF(__pyx_v_6hunter_6_event_UNSET); __Pyx_GIVEREF(__pyx_v_6hunter_6_event_UNSET); __Pyx_GOTREF(__pyx_v_self->_lineno); __Pyx_DECREF(__pyx_v_self->_lineno); __pyx_v_self->_lineno = __pyx_v_6hunter_6_event_UNSET; - /* "hunter/_event.pyx":59 + /* "hunter/_event.pyx":76 * self._globals = UNSET * self._lineno = UNSET * self._locals = UNSET # <<<<<<<<<<<<<< * self._module = UNSET * self._source = UNSET - */ - __Pyx_TraceLine(59,0,__PYX_ERR(0, 59, __pyx_L1_error)) +*/ + __Pyx_TraceLine(76,51,0,__PYX_ERR(0, 76, __pyx_L1_error)) __Pyx_INCREF(__pyx_v_6hunter_6_event_UNSET); __Pyx_GIVEREF(__pyx_v_6hunter_6_event_UNSET); __Pyx_GOTREF(__pyx_v_self->_locals); __Pyx_DECREF(__pyx_v_self->_locals); __pyx_v_self->_locals = __pyx_v_6hunter_6_event_UNSET; - /* "hunter/_event.pyx":60 + /* "hunter/_event.pyx":77 * self._lineno = UNSET * self._locals = UNSET * self._module = UNSET # <<<<<<<<<<<<<< * self._source = UNSET * self._stdlib = UNSET - */ - __Pyx_TraceLine(60,0,__PYX_ERR(0, 60, __pyx_L1_error)) +*/ + __Pyx_TraceLine(77,54,0,__PYX_ERR(0, 77, __pyx_L1_error)) __Pyx_INCREF(__pyx_v_6hunter_6_event_UNSET); __Pyx_GIVEREF(__pyx_v_6hunter_6_event_UNSET); __Pyx_GOTREF(__pyx_v_self->_module); __Pyx_DECREF(__pyx_v_self->_module); __pyx_v_self->_module = __pyx_v_6hunter_6_event_UNSET; - /* "hunter/_event.pyx":61 + /* "hunter/_event.pyx":78 * self._locals = UNSET * self._module = UNSET * self._source = UNSET # <<<<<<<<<<<<<< * self._stdlib = UNSET * self._threadidn = UNSET - */ - __Pyx_TraceLine(61,0,__PYX_ERR(0, 61, __pyx_L1_error)) +*/ + __Pyx_TraceLine(78,57,0,__PYX_ERR(0, 78, __pyx_L1_error)) __Pyx_INCREF(__pyx_v_6hunter_6_event_UNSET); __Pyx_GIVEREF(__pyx_v_6hunter_6_event_UNSET); __Pyx_GOTREF(__pyx_v_self->_source); __Pyx_DECREF(__pyx_v_self->_source); __pyx_v_self->_source = __pyx_v_6hunter_6_event_UNSET; - /* "hunter/_event.pyx":62 + /* "hunter/_event.pyx":79 * self._module = UNSET * self._source = UNSET * self._stdlib = UNSET # <<<<<<<<<<<<<< * self._threadidn = UNSET * self._threadname = UNSET - */ - __Pyx_TraceLine(62,0,__PYX_ERR(0, 62, __pyx_L1_error)) +*/ + __Pyx_TraceLine(79,60,0,__PYX_ERR(0, 79, __pyx_L1_error)) __Pyx_INCREF(__pyx_v_6hunter_6_event_UNSET); __Pyx_GIVEREF(__pyx_v_6hunter_6_event_UNSET); __Pyx_GOTREF(__pyx_v_self->_stdlib); __Pyx_DECREF(__pyx_v_self->_stdlib); __pyx_v_self->_stdlib = __pyx_v_6hunter_6_event_UNSET; - /* "hunter/_event.pyx":63 + /* "hunter/_event.pyx":80 * self._source = UNSET * self._stdlib = UNSET * self._threadidn = UNSET # <<<<<<<<<<<<<< * self._threadname = UNSET * self._thread = UNSET - */ - __Pyx_TraceLine(63,0,__PYX_ERR(0, 63, __pyx_L1_error)) +*/ + __Pyx_TraceLine(80,63,0,__PYX_ERR(0, 80, __pyx_L1_error)) __Pyx_INCREF(__pyx_v_6hunter_6_event_UNSET); __Pyx_GIVEREF(__pyx_v_6hunter_6_event_UNSET); __Pyx_GOTREF(__pyx_v_self->_threadidn); __Pyx_DECREF(__pyx_v_self->_threadidn); __pyx_v_self->_threadidn = __pyx_v_6hunter_6_event_UNSET; - /* "hunter/_event.pyx":64 + /* "hunter/_event.pyx":81 * self._stdlib = UNSET * self._threadidn = UNSET * self._threadname = UNSET # <<<<<<<<<<<<<< * self._thread = UNSET - * - */ - __Pyx_TraceLine(64,0,__PYX_ERR(0, 64, __pyx_L1_error)) + * self._instruction = UNSET +*/ + __Pyx_TraceLine(81,66,0,__PYX_ERR(0, 81, __pyx_L1_error)) __Pyx_INCREF(__pyx_v_6hunter_6_event_UNSET); __Pyx_GIVEREF(__pyx_v_6hunter_6_event_UNSET); __Pyx_GOTREF(__pyx_v_self->_threadname); __Pyx_DECREF(__pyx_v_self->_threadname); __pyx_v_self->_threadname = __pyx_v_6hunter_6_event_UNSET; - /* "hunter/_event.pyx":65 + /* "hunter/_event.pyx":82 * self._threadidn = UNSET * self._threadname = UNSET * self._thread = UNSET # <<<<<<<<<<<<<< + * self._instruction = UNSET * - * def detach(self, value_filter=None): - */ - __Pyx_TraceLine(65,0,__PYX_ERR(0, 65, __pyx_L1_error)) +*/ + __Pyx_TraceLine(82,69,0,__PYX_ERR(0, 82, __pyx_L1_error)) __Pyx_INCREF(__pyx_v_6hunter_6_event_UNSET); __Pyx_GIVEREF(__pyx_v_6hunter_6_event_UNSET); __Pyx_GOTREF(__pyx_v_self->_thread); __Pyx_DECREF(__pyx_v_self->_thread); __pyx_v_self->_thread = __pyx_v_6hunter_6_event_UNSET; - /* "hunter/_event.pyx":43 - * Needed for the ``calls`` and ``depth`` fields. + /* "hunter/_event.pyx":83 + * self._threadname = UNSET + * self._thread = UNSET + * self._instruction = UNSET # <<<<<<<<<<<<<< + * + * def __repr__(self): +*/ + __Pyx_TraceLine(83,72,0,__PYX_ERR(0, 83, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_6hunter_6_event_UNSET); + __Pyx_GIVEREF(__pyx_v_6hunter_6_event_UNSET); + __Pyx_GOTREF(__pyx_v_self->_instruction); + __Pyx_DECREF(__pyx_v_self->_instruction); + __pyx_v_self->_instruction = __pyx_v_6hunter_6_event_UNSET; + + /* "hunter/_event.pyx":59 + * may be expected. * """ - * def __init__(self, FrameType frame, str kind, object arg, Tracer tracer): # <<<<<<<<<<<<<< + * def __init__(self, FrameType frame, int kind, object arg, int depth, int calls, bint threading_support): # <<<<<<<<<<<<<< * self.arg = arg * self.frame = frame - */ +*/ /* function exit code */ __pyx_r = 0; + __Pyx_TraceReturnCValue(__pyx_r, __Pyx_Owned_Py_None, 0, 0, __PYX_ERR(0, 59, __pyx_L1_error)); goto __pyx_L0; __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 59, __pyx_L1_error)); + #endif __Pyx_AddTraceback("hunter._event.Event.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; - __Pyx_TraceReturn(Py_None, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_event.pyx":67 - * self._thread = UNSET +/* "hunter/_event.pyx":85 + * self._instruction = UNSET + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return '' % ( + * self.kind, self.function, self.module, self.filename, self.lineno +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_6_event_5Event_3__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_6_event_5Event_3__repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_6_event_5Event_2__repr__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_6_event_5Event_2__repr__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7[11]; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[1])) + __Pyx_RefNannySetupContext("__repr__", 0); + __Pyx_TraceStartFunc("__repr__", __pyx_f[0], 85, 0, 0, 0, __PYX_ERR(0, 85, __pyx_L1_error)); + + /* "hunter/_event.pyx":86 + * + * def __repr__(self): + * return '' % ( # <<<<<<<<<<<<<< + * self.kind, self.function, self.module, self.filename, self.lineno + * ) +*/ + __Pyx_TraceLine(86,1,0,__PYX_ERR(0, 86, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + + /* "hunter/_event.pyx":87 + * def __repr__(self): + * return '' % ( + * self.kind, self.function, self.module, self.filename, self.lineno # <<<<<<<<<<<<<< + * ) + * +*/ + __Pyx_TraceLine(87,4,0,__PYX_ERR(0, 87, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_self->kind), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_function_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_2), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_module_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_2), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_filename_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_2), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_lineno_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_t_2), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_7[0] = __pyx_mstate_global->__pyx_kp_u_Event_kind; + __pyx_t_7[1] = __pyx_t_1; + __pyx_t_7[2] = __pyx_mstate_global->__pyx_kp_u_function; + __pyx_t_7[3] = __pyx_t_3; + __pyx_t_7[4] = __pyx_mstate_global->__pyx_kp_u_module; + __pyx_t_7[5] = __pyx_t_4; + __pyx_t_7[6] = __pyx_mstate_global->__pyx_kp_u_filename; + __pyx_t_7[7] = __pyx_t_5; + __pyx_t_7[8] = __pyx_mstate_global->__pyx_kp_u_lineno; + __pyx_t_7[9] = __pyx_t_6; + __pyx_t_7[10] = __pyx_mstate_global->__pyx_kp_u_; + + /* "hunter/_event.pyx":86 + * + * def __repr__(self): + * return '' % ( # <<<<<<<<<<<<<< + * self.kind, self.function, self.module, self.filename, self.lineno + * ) +*/ + __Pyx_TraceLine(86,2,0,__PYX_ERR(0, 86, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_7, 11, 12 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1) + 10 * 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + 8 * 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6)); + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 86, __pyx_L1_error)); + goto __pyx_L0; + + /* "hunter/_event.pyx":85 + * self._instruction = UNSET + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return '' % ( + * self.kind, self.function, self.module, self.filename, self.lineno +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 85, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.Event.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/_event.pyx":90 + * ) + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return self is other + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_6_event_5Event_5__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_6hunter_6_event_5Event_5__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_6_event_5Event_4__eq__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_6_event_5Event_4__eq__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[2])) + __Pyx_RefNannySetupContext("__eq__", 0); + __Pyx_TraceStartFunc("__eq__", __pyx_f[0], 90, 0, 0, 0, __PYX_ERR(0, 90, __pyx_L1_error)); + + /* "hunter/_event.pyx":91 + * + * def __eq__(self, other): + * return self is other # <<<<<<<<<<<<<< + * + * def detach(self, value_filter=None): +*/ + __Pyx_TraceLine(91,1,0,__PYX_ERR(0, 91, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = (((PyObject *)__pyx_v_self) == __pyx_v_other); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 91, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 91, __pyx_L1_error)); + goto __pyx_L0; + + /* "hunter/_event.pyx":90 + * ) + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return self is other + * +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 90, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.Event.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/_event.pyx":93 + * return self is other * * def detach(self, value_filter=None): # <<<<<<<<<<<<<< - * event = Event.__new__(Event) + * return fast_detach(self, value_filter) * - */ +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_6_event_5Event_3detach(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static PyObject *__pyx_pw_6hunter_6_event_5Event_3detach(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_6hunter_6_event_5Event_7detach(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_6_event_5Event_7detach = {"detach", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_6_event_5Event_7detach, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_6_event_5Event_7detach(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { PyObject *__pyx_v_value_filter = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("detach (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_value_filter,0}; - PyObject* values[1] = {0}; - values[0] = ((PyObject *)Py_None); - if (unlikely(__pyx_kwds)) { - Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_value_filter,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 93, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 93, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { - case 0: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_value_filter); - if (value) { values[0] = value; kw_args--; } - } - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "detach") < 0)) __PYX_ERR(0, 67, __pyx_L3_error) - } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "detach", 0) < 0) __PYX_ERR(0, 93, __pyx_L3_error) + if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)Py_None)); } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 93, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } + if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)Py_None)); } __pyx_v_value_filter = values[0]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("detach", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 67, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("detach", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 93, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } __Pyx_AddTraceback("hunter._event.Event.detach", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6hunter_6_event_5Event_2detach(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self), __pyx_v_value_filter); + __pyx_r = __pyx_pf_6hunter_6_event_5Event_6detach(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self), __pyx_v_value_filter); /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_6_event_5Event_2detach(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self, PyObject *__pyx_v_value_filter) { - struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event = NULL; - PyObject *__pyx_7genexpr__pyx_v_key = NULL; - PyObject *__pyx_7genexpr__pyx_v_value = NULL; - PyObject *__pyx_8genexpr1__pyx_v_key = NULL; - PyObject *__pyx_8genexpr1__pyx_v_value = NULL; +static PyObject *__pyx_pf_6hunter_6_event_5Event_6detach(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self, PyObject *__pyx_v_value_filter) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - int __pyx_t_3; - Py_ssize_t __pyx_t_4; - Py_ssize_t __pyx_t_5; - int __pyx_t_6; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - int __pyx_t_9; - PyObject *__pyx_t_10 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[3])) __Pyx_RefNannySetupContext("detach", 0); - __Pyx_TraceCall("detach", __pyx_f[0], 67, 0, __PYX_ERR(0, 67, __pyx_L1_error)); + __Pyx_TraceStartFunc("detach", __pyx_f[0], 93, 0, 0, 0, __PYX_ERR(0, 93, __pyx_L1_error)); - /* "hunter/_event.pyx":68 + /* "hunter/_event.pyx":94 * * def detach(self, value_filter=None): - * event = Event.__new__(Event) # <<<<<<<<<<<<<< + * return fast_detach(self, value_filter) # <<<<<<<<<<<<<< * - * event._code = self.code - */ - __Pyx_TraceLine(68,0,__PYX_ERR(0, 68, __pyx_L1_error)) - __pyx_t_1 = ((PyObject *)__pyx_tp_new_6hunter_6_event_Event(((PyTypeObject *)__pyx_ptype_6hunter_6_event_Event), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 68, __pyx_L1_error) - __Pyx_GOTREF(((PyObject *)__pyx_t_1)); - __pyx_t_2 = ((PyObject *)__pyx_t_1); - __Pyx_INCREF(__pyx_t_2); - __Pyx_DECREF(((PyObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_v_event = ((struct __pyx_obj_6hunter_6_event_Event *)__pyx_t_2); - __pyx_t_2 = 0; + * def clone(self): +*/ + __Pyx_TraceLine(94,2,0,__PYX_ERR(0, 94, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_6hunter_6_event_fast_detach(__pyx_v_self, __pyx_v_value_filter)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 2, 0, __PYX_ERR(0, 94, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_event.pyx":70 - * event = Event.__new__(Event) + /* "hunter/_event.pyx":93 + * return self is other * - * event._code = self.code # <<<<<<<<<<<<<< - * event._filename = self.filename - * event._fullsource = self.fullsource - */ - __Pyx_TraceLine(70,0,__PYX_ERR(0, 70, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_code); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 70, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->_code); - __Pyx_DECREF(__pyx_v_event->_code); - __pyx_v_event->_code = __pyx_t_2; - __pyx_t_2 = 0; - - /* "hunter/_event.pyx":71 + * def detach(self, value_filter=None): # <<<<<<<<<<<<<< + * return fast_detach(self, value_filter) * - * event._code = self.code - * event._filename = self.filename # <<<<<<<<<<<<<< - * event._fullsource = self.fullsource - * event._function_object = self._function_object - */ - __Pyx_TraceLine(71,0,__PYX_ERR(0, 71, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_filename); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 71, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->_filename); - __Pyx_DECREF(__pyx_v_event->_filename); - __pyx_v_event->_filename = __pyx_t_2; - __pyx_t_2 = 0; +*/ - /* "hunter/_event.pyx":72 - * event._code = self.code - * event._filename = self.filename - * event._fullsource = self.fullsource # <<<<<<<<<<<<<< - * event._function_object = self._function_object - * event._function = self.function - */ - __Pyx_TraceLine(72,0,__PYX_ERR(0, 72, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_fullsource); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 72, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->_fullsource); - __Pyx_DECREF(__pyx_v_event->_fullsource); - __pyx_v_event->_fullsource = __pyx_t_2; - __pyx_t_2 = 0; + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 93, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.Event.detach", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_event.pyx":73 - * event._filename = self.filename - * event._fullsource = self.fullsource - * event._function_object = self._function_object # <<<<<<<<<<<<<< - * event._function = self.function - * event._lineno = self.lineno - */ - __Pyx_TraceLine(73,0,__PYX_ERR(0, 73, __pyx_L1_error)) - __pyx_t_2 = __pyx_v_self->_function_object; - __Pyx_INCREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->_function_object); - __Pyx_DECREF(__pyx_v_event->_function_object); - __pyx_v_event->_function_object = __pyx_t_2; - __pyx_t_2 = 0; - - /* "hunter/_event.pyx":74 - * event._fullsource = self.fullsource - * event._function_object = self._function_object - * event._function = self.function # <<<<<<<<<<<<<< - * event._lineno = self.lineno - * event._module = self.module - */ - __Pyx_TraceLine(74,0,__PYX_ERR(0, 74, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_function); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 74, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->_function); - __Pyx_DECREF(__pyx_v_event->_function); - __pyx_v_event->_function = __pyx_t_2; - __pyx_t_2 = 0; +/* "hunter/_event.pyx":96 + * return fast_detach(self, value_filter) + * + * def clone(self): # <<<<<<<<<<<<<< + * return fast_clone(self) + * +*/ - /* "hunter/_event.pyx":75 - * event._function_object = self._function_object - * event._function = self.function - * event._lineno = self.lineno # <<<<<<<<<<<<<< - * event._module = self.module - * event._source = self.source - */ - __Pyx_TraceLine(75,0,__PYX_ERR(0, 75, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_lineno); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 75, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->_lineno); - __Pyx_DECREF(__pyx_v_event->_lineno); - __pyx_v_event->_lineno = __pyx_t_2; - __pyx_t_2 = 0; +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_6_event_5Event_9clone(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_6_event_5Event_9clone = {"clone", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_6_event_5Event_9clone, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_6_event_5Event_9clone(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("clone (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("clone", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("clone", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_6hunter_6_event_5Event_8clone(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); - /* "hunter/_event.pyx":76 - * event._function = self.function - * event._lineno = self.lineno - * event._module = self.module # <<<<<<<<<<<<<< - * event._source = self.source - * event._stdlib = self.stdlib - */ - __Pyx_TraceLine(76,0,__PYX_ERR(0, 76, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_module); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 76, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->_module); - __Pyx_DECREF(__pyx_v_event->_module); - __pyx_v_event->_module = __pyx_t_2; - __pyx_t_2 = 0; + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_event.pyx":77 - * event._lineno = self.lineno - * event._module = self.module - * event._source = self.source # <<<<<<<<<<<<<< - * event._stdlib = self.stdlib - * event._threadidn = self.threadid - */ - __Pyx_TraceLine(77,0,__PYX_ERR(0, 77, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_source); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->_source); - __Pyx_DECREF(__pyx_v_event->_source); - __pyx_v_event->_source = __pyx_t_2; - __pyx_t_2 = 0; +static PyObject *__pyx_pf_6hunter_6_event_5Event_8clone(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[4])) + __Pyx_RefNannySetupContext("clone", 0); + __Pyx_TraceStartFunc("clone", __pyx_f[0], 96, 0, 0, 0, __PYX_ERR(0, 96, __pyx_L1_error)); - /* "hunter/_event.pyx":78 - * event._module = self.module - * event._source = self.source - * event._stdlib = self.stdlib # <<<<<<<<<<<<<< - * event._threadidn = self.threadid - * event._threadname = self.threadname - */ - __Pyx_TraceLine(78,0,__PYX_ERR(0, 78, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_stdlib); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 78, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->_stdlib); - __Pyx_DECREF(__pyx_v_event->_stdlib); - __pyx_v_event->_stdlib = __pyx_t_2; - __pyx_t_2 = 0; + /* "hunter/_event.pyx":97 + * + * def clone(self): + * return fast_clone(self) # <<<<<<<<<<<<<< + * + * cdef inline instruction_getter(self): +*/ + __Pyx_TraceLine(97,1,0,__PYX_ERR(0, 97, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_6hunter_6_event_fast_clone(__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 97, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_event.pyx":79 - * event._source = self.source - * event._stdlib = self.stdlib - * event._threadidn = self.threadid # <<<<<<<<<<<<<< - * event._threadname = self.threadname + /* "hunter/_event.pyx":96 + * return fast_detach(self, value_filter) * - */ - __Pyx_TraceLine(79,0,__PYX_ERR(0, 79, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_threadid); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 79, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->_threadidn); - __Pyx_DECREF(__pyx_v_event->_threadidn); - __pyx_v_event->_threadidn = __pyx_t_2; - __pyx_t_2 = 0; + * def clone(self): # <<<<<<<<<<<<<< + * return fast_clone(self) + * +*/ - /* "hunter/_event.pyx":80 - * event._stdlib = self.stdlib - * event._threadidn = self.threadid - * event._threadname = self.threadname # <<<<<<<<<<<<<< + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 96, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.Event.clone", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/_event.pyx":99 + * return fast_clone(self) * - * if value_filter: - */ - __Pyx_TraceLine(80,0,__PYX_ERR(0, 80, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_threadname); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 80, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->_threadname); - __Pyx_DECREF(__pyx_v_event->_threadname); - __pyx_v_event->_threadname = __pyx_t_2; - __pyx_t_2 = 0; + * cdef inline instruction_getter(self): # <<<<<<<<<<<<<< + * cdef int position + * +*/ - /* "hunter/_event.pyx":82 - * event._threadname = self.threadname +static PyObject *__pyx_f_6hunter_6_event_5Event_instruction_getter(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { + int __pyx_v_position; + PyObject *__pyx_v_co_code = NULL; + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + Py_ssize_t __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[5])) + __Pyx_RefNannySetupContext("instruction_getter", 0); + __Pyx_TraceStartFunc("instruction_getter", __pyx_f[0], 99, 0, 0, 0, __PYX_ERR(0, 99, __pyx_L1_error)); + + /* "hunter/_event.pyx":102 + * cdef int position * - * if value_filter: # <<<<<<<<<<<<<< - * event._globals = {key: value_filter(value) for key, value in self.globals.items()} - * event._locals = {key: value_filter(value) for key, value in self.locals.items()} - */ - __Pyx_TraceLine(82,0,__PYX_ERR(0, 82, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_value_filter); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 82, __pyx_L1_error) - if (__pyx_t_3) { + * if self._instruction is UNSET: # <<<<<<<<<<<<<< + * position = Hunter_PyFrame_GetLasti(self.frame) + * co_code = PyCode_GetCode(self.code_getter()) +*/ + __Pyx_TraceLine(102,5,0,__PYX_ERR(0, 102, __pyx_L1_error)) + __pyx_t_1 = (__pyx_v_self->_instruction == __pyx_v_6hunter_6_event_UNSET); + if (__pyx_t_1) { - /* "hunter/_event.pyx":83 + /* "hunter/_event.pyx":103 * - * if value_filter: - * event._globals = {key: value_filter(value) for key, value in self.globals.items()} # <<<<<<<<<<<<<< - * event._locals = {key: value_filter(value) for key, value in self.locals.items()} - * event.arg = value_filter(self.arg) - */ - __Pyx_TraceLine(83,0,__PYX_ERR(0, 83, __pyx_L1_error)) - { /* enter inner scope */ - __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 83, __pyx_L6_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = 0; - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_globals); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 83, __pyx_L6_error) - __Pyx_GOTREF(__pyx_t_7); - if (unlikely(__pyx_t_7 == Py_None)) { - PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items"); - __PYX_ERR(0, 83, __pyx_L6_error) - } - __pyx_t_8 = __Pyx_dict_iterator(__pyx_t_7, 0, __pyx_n_s_items, (&__pyx_t_5), (&__pyx_t_6)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 83, __pyx_L6_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_XDECREF(__pyx_t_1); - __pyx_t_1 = __pyx_t_8; - __pyx_t_8 = 0; - while (1) { - __pyx_t_9 = __Pyx_dict_iter_next(__pyx_t_1, __pyx_t_5, &__pyx_t_4, &__pyx_t_8, &__pyx_t_7, NULL, __pyx_t_6); - if (unlikely(__pyx_t_9 == 0)) break; - if (unlikely(__pyx_t_9 == -1)) __PYX_ERR(0, 83, __pyx_L6_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_GOTREF(__pyx_t_7); - __Pyx_XDECREF_SET(__pyx_7genexpr__pyx_v_key, __pyx_t_8); - __pyx_t_8 = 0; - __Pyx_XDECREF_SET(__pyx_7genexpr__pyx_v_value, __pyx_t_7); - __pyx_t_7 = 0; - __Pyx_INCREF(__pyx_v_value_filter); - __pyx_t_8 = __pyx_v_value_filter; __pyx_t_10 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { - __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_8); - if (likely(__pyx_t_10)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); - __Pyx_INCREF(__pyx_t_10); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_8, function); - } - } - __pyx_t_7 = (__pyx_t_10) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_10, __pyx_7genexpr__pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_7genexpr__pyx_v_value); - __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 83, __pyx_L6_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(PyDict_SetItem(__pyx_t_2, (PyObject*)__pyx_7genexpr__pyx_v_key, (PyObject*)__pyx_t_7))) __PYX_ERR(0, 83, __pyx_L6_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_XDECREF(__pyx_7genexpr__pyx_v_key); __pyx_7genexpr__pyx_v_key = 0; - __Pyx_XDECREF(__pyx_7genexpr__pyx_v_value); __pyx_7genexpr__pyx_v_value = 0; - goto __pyx_L9_exit_scope; - __pyx_L6_error:; - __Pyx_XDECREF(__pyx_7genexpr__pyx_v_key); __pyx_7genexpr__pyx_v_key = 0; - __Pyx_XDECREF(__pyx_7genexpr__pyx_v_value); __pyx_7genexpr__pyx_v_value = 0; - goto __pyx_L1_error; - __pyx_L9_exit_scope:; - } /* exit inner scope */ - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->_globals); - __Pyx_DECREF(__pyx_v_event->_globals); - __pyx_v_event->_globals = __pyx_t_2; - __pyx_t_2 = 0; + * if self._instruction is UNSET: + * position = Hunter_PyFrame_GetLasti(self.frame) # <<<<<<<<<<<<<< + * co_code = PyCode_GetCode(self.code_getter()) + * if co_code and len(co_code) > position >= 0: +*/ + __Pyx_TraceLine(103,10,0,__PYX_ERR(0, 103, __pyx_L1_error)) + __pyx_t_2 = ((PyObject *)__pyx_v_self->frame); + __Pyx_INCREF(__pyx_t_2); + __pyx_v_position = Hunter_PyFrame_GetLasti(((FrameType)__pyx_t_2)); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "hunter/_event.pyx":84 - * if value_filter: - * event._globals = {key: value_filter(value) for key, value in self.globals.items()} - * event._locals = {key: value_filter(value) for key, value in self.locals.items()} # <<<<<<<<<<<<<< - * event.arg = value_filter(self.arg) - * else: - */ - __Pyx_TraceLine(84,0,__PYX_ERR(0, 84, __pyx_L1_error)) - { /* enter inner scope */ - __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 84, __pyx_L12_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_5 = 0; - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_locals); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 84, __pyx_L12_error) - __Pyx_GOTREF(__pyx_t_7); - if (unlikely(__pyx_t_7 == Py_None)) { - PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items"); - __PYX_ERR(0, 84, __pyx_L12_error) - } - __pyx_t_8 = __Pyx_dict_iterator(__pyx_t_7, 0, __pyx_n_s_items, (&__pyx_t_4), (&__pyx_t_6)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 84, __pyx_L12_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_XDECREF(__pyx_t_1); - __pyx_t_1 = __pyx_t_8; - __pyx_t_8 = 0; - while (1) { - __pyx_t_9 = __Pyx_dict_iter_next(__pyx_t_1, __pyx_t_4, &__pyx_t_5, &__pyx_t_8, &__pyx_t_7, NULL, __pyx_t_6); - if (unlikely(__pyx_t_9 == 0)) break; - if (unlikely(__pyx_t_9 == -1)) __PYX_ERR(0, 84, __pyx_L12_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_GOTREF(__pyx_t_7); - __Pyx_XDECREF_SET(__pyx_8genexpr1__pyx_v_key, __pyx_t_8); - __pyx_t_8 = 0; - __Pyx_XDECREF_SET(__pyx_8genexpr1__pyx_v_value, __pyx_t_7); - __pyx_t_7 = 0; - __Pyx_INCREF(__pyx_v_value_filter); - __pyx_t_8 = __pyx_v_value_filter; __pyx_t_10 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { - __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_8); - if (likely(__pyx_t_10)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); - __Pyx_INCREF(__pyx_t_10); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_8, function); - } - } - __pyx_t_7 = (__pyx_t_10) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_10, __pyx_8genexpr1__pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_8genexpr1__pyx_v_value); - __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 84, __pyx_L12_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(PyDict_SetItem(__pyx_t_2, (PyObject*)__pyx_8genexpr1__pyx_v_key, (PyObject*)__pyx_t_7))) __PYX_ERR(0, 84, __pyx_L12_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_key); __pyx_8genexpr1__pyx_v_key = 0; - __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_value); __pyx_8genexpr1__pyx_v_value = 0; - goto __pyx_L15_exit_scope; - __pyx_L12_error:; - __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_key); __pyx_8genexpr1__pyx_v_key = 0; - __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_value); __pyx_8genexpr1__pyx_v_value = 0; - goto __pyx_L1_error; - __pyx_L15_exit_scope:; - } /* exit inner scope */ - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->_locals); - __Pyx_DECREF(__pyx_v_event->_locals); - __pyx_v_event->_locals = __pyx_t_2; - __pyx_t_2 = 0; + /* "hunter/_event.pyx":104 + * if self._instruction is UNSET: + * position = Hunter_PyFrame_GetLasti(self.frame) + * co_code = PyCode_GetCode(self.code_getter()) # <<<<<<<<<<<<<< + * if co_code and len(co_code) > position >= 0: + * self._instruction = co_code[position] +*/ + __Pyx_TraceLine(104,16,0,__PYX_ERR(0, 104, __pyx_L1_error)) + __pyx_t_2 = ((PyObject *)__pyx_f_6hunter_6_event_5Event_code_getter(__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyCode_GetCode(((PyCodeObject *)__pyx_t_2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_co_code = __pyx_t_3; + __pyx_t_3 = 0; - /* "hunter/_event.pyx":85 - * event._globals = {key: value_filter(value) for key, value in self.globals.items()} - * event._locals = {key: value_filter(value) for key, value in self.locals.items()} - * event.arg = value_filter(self.arg) # <<<<<<<<<<<<<< - * else: - * event._globals = {} - */ - __Pyx_TraceLine(85,0,__PYX_ERR(0, 85, __pyx_L1_error)) - __Pyx_INCREF(__pyx_v_value_filter); - __pyx_t_1 = __pyx_v_value_filter; __pyx_t_7 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_7)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_7); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); - } + /* "hunter/_event.pyx":105 + * position = Hunter_PyFrame_GetLasti(self.frame) + * co_code = PyCode_GetCode(self.code_getter()) + * if co_code and len(co_code) > position >= 0: # <<<<<<<<<<<<<< + * self._instruction = co_code[position] + * else: +*/ + __Pyx_TraceLine(105,18,0,__PYX_ERR(0, 105, __pyx_L1_error)) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_co_code); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 105, __pyx_L1_error) + if (__pyx_t_4) { + } else { + __pyx_t_1 = __pyx_t_4; + goto __pyx_L5_bool_binop_done; } - __pyx_t_2 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_7, __pyx_v_self->arg) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_self->arg); - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 85, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->arg); - __Pyx_DECREF(__pyx_v_event->arg); - __pyx_v_event->arg = __pyx_t_2; - __pyx_t_2 = 0; + __pyx_t_5 = PyObject_Length(__pyx_v_co_code); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 105, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_5 > __pyx_v_position); + if (__pyx_t_4) { + __pyx_t_4 = (__pyx_v_position >= 0); + } + __pyx_t_1 = __pyx_t_4; + __pyx_L5_bool_binop_done:; + if (__pyx_t_1) { - /* "hunter/_event.pyx":82 - * event._threadname = self.threadname - * - * if value_filter: # <<<<<<<<<<<<<< - * event._globals = {key: value_filter(value) for key, value in self.globals.items()} - * event._locals = {key: value_filter(value) for key, value in self.locals.items()} - */ - goto __pyx_L3; - } + /* "hunter/_event.pyx":106 + * co_code = PyCode_GetCode(self.code_getter()) + * if co_code and len(co_code) > position >= 0: + * self._instruction = co_code[position] # <<<<<<<<<<<<<< + * else: + * self._instruction = None +*/ + __Pyx_TraceLine(106,29,0,__PYX_ERR(0, 106, __pyx_L1_error)) + __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_co_code, __pyx_v_position, int, 1, __Pyx_PyLong_From_int, 0, 1, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 106, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_self->_instruction); + __Pyx_DECREF(__pyx_v_self->_instruction); + __pyx_v_self->_instruction = __pyx_t_3; + __pyx_t_3 = 0; - /* "hunter/_event.pyx":87 - * event.arg = value_filter(self.arg) - * else: - * event._globals = {} # <<<<<<<<<<<<<< - * event._locals = {} - * event.arg = None - */ - __Pyx_TraceLine(87,0,__PYX_ERR(0, 87, __pyx_L1_error)) - /*else*/ { - __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->_globals); - __Pyx_DECREF(__pyx_v_event->_globals); - __pyx_v_event->_globals = __pyx_t_2; - __pyx_t_2 = 0; + /* "hunter/_event.pyx":105 + * position = Hunter_PyFrame_GetLasti(self.frame) + * co_code = PyCode_GetCode(self.code_getter()) + * if co_code and len(co_code) > position >= 0: # <<<<<<<<<<<<<< + * self._instruction = co_code[position] + * else: +*/ + goto __pyx_L4; + } - /* "hunter/_event.pyx":88 - * else: - * event._globals = {} - * event._locals = {} # <<<<<<<<<<<<<< - * event.arg = None + /* "hunter/_event.pyx":108 + * self._instruction = co_code[position] + * else: + * self._instruction = None # <<<<<<<<<<<<<< + * return self._instruction * - */ - __Pyx_TraceLine(88,0,__PYX_ERR(0, 88, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 88, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->_locals); - __Pyx_DECREF(__pyx_v_event->_locals); - __pyx_v_event->_locals = __pyx_t_2; - __pyx_t_2 = 0; +*/ + __Pyx_TraceLine(108,33,0,__PYX_ERR(0, 108, __pyx_L1_error)) + /*else*/ { + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_instruction); + __Pyx_DECREF(__pyx_v_self->_instruction); + __pyx_v_self->_instruction = Py_None; + } + __pyx_L4:; - /* "hunter/_event.pyx":89 - * event._globals = {} - * event._locals = {} - * event.arg = None # <<<<<<<<<<<<<< + /* "hunter/_event.pyx":102 + * cdef int position * - * event.threading_support = self.threading_support - */ - __Pyx_TraceLine(89,0,__PYX_ERR(0, 89, __pyx_L1_error)) - __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(Py_None); - __Pyx_GOTREF(__pyx_v_event->arg); - __Pyx_DECREF(__pyx_v_event->arg); - __pyx_v_event->arg = Py_None; + * if self._instruction is UNSET: # <<<<<<<<<<<<<< + * position = Hunter_PyFrame_GetLasti(self.frame) + * co_code = PyCode_GetCode(self.code_getter()) +*/ } - __pyx_L3:; - /* "hunter/_event.pyx":91 - * event.arg = None + /* "hunter/_event.pyx":109 + * else: + * self._instruction = None + * return self._instruction # <<<<<<<<<<<<<< * - * event.threading_support = self.threading_support # <<<<<<<<<<<<<< - * event.calls = self.calls - * event.depth = self.depth - */ - __Pyx_TraceLine(91,0,__PYX_ERR(0, 91, __pyx_L1_error)) - __pyx_t_3 = __pyx_v_self->threading_support; - __pyx_v_event->threading_support = __pyx_t_3; + * @property +*/ + __Pyx_TraceLine(109,34,0,__PYX_ERR(0, 109, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_instruction); + __pyx_r = __pyx_v_self->_instruction; + __Pyx_TraceReturnValue(__pyx_r, 34, 0, __PYX_ERR(0, 109, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_event.pyx":92 + /* "hunter/_event.pyx":99 + * return fast_clone(self) * - * event.threading_support = self.threading_support - * event.calls = self.calls # <<<<<<<<<<<<<< - * event.depth = self.depth - * event.kind = self.kind - */ - __Pyx_TraceLine(92,0,__PYX_ERR(0, 92, __pyx_L1_error)) - __pyx_t_6 = __pyx_v_self->calls; - __pyx_v_event->calls = __pyx_t_6; - - /* "hunter/_event.pyx":93 - * event.threading_support = self.threading_support - * event.calls = self.calls - * event.depth = self.depth # <<<<<<<<<<<<<< - * event.kind = self.kind + * cdef inline instruction_getter(self): # <<<<<<<<<<<<<< + * cdef int position * - */ - __Pyx_TraceLine(93,0,__PYX_ERR(0, 93, __pyx_L1_error)) - __pyx_t_6 = __pyx_v_self->depth; - __pyx_v_event->depth = __pyx_t_6; +*/ - /* "hunter/_event.pyx":94 - * event.calls = self.calls - * event.depth = self.depth - * event.kind = self.kind # <<<<<<<<<<<<<< - * - * event.detached = True - */ - __Pyx_TraceLine(94,0,__PYX_ERR(0, 94, __pyx_L1_error)) - __pyx_t_2 = __pyx_v_self->kind; - __Pyx_INCREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->kind); - __Pyx_DECREF(__pyx_v_event->kind); - __pyx_v_event->kind = ((PyObject*)__pyx_t_2); - __pyx_t_2 = 0; + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 99, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.Event.instruction_getter", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_co_code); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_event.pyx":96 - * event.kind = self.kind +/* "hunter/_event.pyx":111 + * return self._instruction * - * event.detached = True # <<<<<<<<<<<<<< - * - * return event - */ - __Pyx_TraceLine(96,0,__PYX_ERR(0, 96, __pyx_L1_error)) - __pyx_v_event->detached = 1; + * @property # <<<<<<<<<<<<<< + * def instruction(self): + * return self.instruction_getter() +*/ - /* "hunter/_event.pyx":98 - * event.detached = True - * - * return event # <<<<<<<<<<<<<< +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_6_event_5Event_11instruction_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_6_event_5Event_11instruction_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_6_event_5Event_11instruction___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_6_event_5Event_11instruction___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[6])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[0], 111, 0, 0, 0, __PYX_ERR(0, 111, __pyx_L1_error)); + + /* "hunter/_event.pyx":113 + * @property + * def instruction(self): + * return self.instruction_getter() # <<<<<<<<<<<<<< * - * cdef inline Event clone(self): - */ - __Pyx_TraceLine(98,0,__PYX_ERR(0, 98, __pyx_L1_error)) + * cdef inline threadid_getter(self): +*/ + __Pyx_TraceLine(113,1,0,__PYX_ERR(0, 113, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_event)); - __pyx_r = ((PyObject *)__pyx_v_event); + __pyx_t_1 = __pyx_f_6hunter_6_event_5Event_instruction_getter(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 113, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_event.pyx":67 - * self._thread = UNSET - * - * def detach(self, value_filter=None): # <<<<<<<<<<<<<< - * event = Event.__new__(Event) + /* "hunter/_event.pyx":111 + * return self._instruction * - */ + * @property # <<<<<<<<<<<<<< + * def instruction(self): + * return self.instruction_getter() +*/ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_XDECREF(__pyx_t_10); - __Pyx_AddTraceback("hunter._event.Event.detach", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 111, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.Event.instruction.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_event); - __Pyx_XDECREF(__pyx_7genexpr__pyx_v_key); - __Pyx_XDECREF(__pyx_7genexpr__pyx_v_value); - __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_key); - __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_value); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_event.pyx":100 - * return event +/* "hunter/_event.pyx":115 + * return self.instruction_getter() * - * cdef inline Event clone(self): # <<<<<<<<<<<<<< - * event = Event.__new__(Event) - * event.arg = self.arg - */ + * cdef inline threadid_getter(self): # <<<<<<<<<<<<<< + * cdef long current + * +*/ -static struct __pyx_obj_6hunter_6_event_Event *__pyx_f_6hunter_6_event_5Event_clone(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { - struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event = NULL; - struct __pyx_obj_6hunter_6_event_Event *__pyx_r = NULL; - __Pyx_TraceDeclarations +static PyObject *__pyx_f_6hunter_6_event_5Event_threadid_getter(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { + long __pyx_v_current; + PyObject *__pyx_v_main = NULL; + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; + int __pyx_t_1; PyObject *__pyx_t_2 = NULL; - int __pyx_t_3; - int __pyx_t_4; - __Pyx_RefNannySetupContext("clone", 0); - __Pyx_TraceCall("clone", __pyx_f[0], 100, 0, __PYX_ERR(0, 100, __pyx_L1_error)); + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + size_t __pyx_t_5; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[7])) + __Pyx_RefNannySetupContext("threadid_getter", 0); + __Pyx_TraceStartFunc("threadid_getter", __pyx_f[0], 115, 0, 0, 0, __PYX_ERR(0, 115, __pyx_L1_error)); - /* "hunter/_event.pyx":101 + /* "hunter/_event.pyx":118 + * cdef long current * - * cdef inline Event clone(self): - * event = Event.__new__(Event) # <<<<<<<<<<<<<< - * event.arg = self.arg - * event.frame = self.frame - */ - __Pyx_TraceLine(101,0,__PYX_ERR(0, 101, __pyx_L1_error)) - __pyx_t_1 = ((PyObject *)__pyx_tp_new_6hunter_6_event_Event(((PyTypeObject *)__pyx_ptype_6hunter_6_event_Event), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 101, __pyx_L1_error) - __Pyx_GOTREF(((PyObject *)__pyx_t_1)); - __pyx_t_2 = ((PyObject *)__pyx_t_1); - __Pyx_INCREF(__pyx_t_2); - __Pyx_DECREF(((PyObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_v_event = ((struct __pyx_obj_6hunter_6_event_Event *)__pyx_t_2); - __pyx_t_2 = 0; - - /* "hunter/_event.pyx":102 - * cdef inline Event clone(self): - * event = Event.__new__(Event) - * event.arg = self.arg # <<<<<<<<<<<<<< - * event.frame = self.frame - * event.kind = self.kind - */ - __Pyx_TraceLine(102,0,__PYX_ERR(0, 102, __pyx_L1_error)) - __pyx_t_2 = __pyx_v_self->arg; - __Pyx_INCREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->arg); - __Pyx_DECREF(__pyx_v_event->arg); - __pyx_v_event->arg = __pyx_t_2; - __pyx_t_2 = 0; + * if self._threadidn is UNSET: # <<<<<<<<<<<<<< + * current = PyThread_get_thread_ident() + * main = get_main_thread() +*/ + __Pyx_TraceLine(118,5,0,__PYX_ERR(0, 118, __pyx_L1_error)) + __pyx_t_1 = (__pyx_v_self->_threadidn == __pyx_v_6hunter_6_event_UNSET); + if (__pyx_t_1) { - /* "hunter/_event.pyx":103 - * event = Event.__new__(Event) - * event.arg = self.arg - * event.frame = self.frame # <<<<<<<<<<<<<< - * event.kind = self.kind - * event.depth = self.depth - */ - __Pyx_TraceLine(103,0,__PYX_ERR(0, 103, __pyx_L1_error)) - __pyx_t_2 = ((PyObject *)__pyx_v_self->frame); - __Pyx_INCREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->frame); - __Pyx_DECREF(((PyObject *)__pyx_v_event->frame)); - __pyx_v_event->frame = ((PyFrameObject *)__pyx_t_2); - __pyx_t_2 = 0; + /* "hunter/_event.pyx":119 + * + * if self._threadidn is UNSET: + * current = PyThread_get_thread_ident() # <<<<<<<<<<<<<< + * main = get_main_thread() + * if main is not None and current == main.ident: +*/ + __Pyx_TraceLine(119,8,0,__PYX_ERR(0, 119, __pyx_L1_error)) + __pyx_v_current = PyThread_get_thread_ident(); - /* "hunter/_event.pyx":104 - * event.arg = self.arg - * event.frame = self.frame - * event.kind = self.kind # <<<<<<<<<<<<<< - * event.depth = self.depth - * event.calls = self.calls - */ - __Pyx_TraceLine(104,0,__PYX_ERR(0, 104, __pyx_L1_error)) - __pyx_t_2 = __pyx_v_self->kind; - __Pyx_INCREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->kind); - __Pyx_DECREF(__pyx_v_event->kind); - __pyx_v_event->kind = ((PyObject*)__pyx_t_2); - __pyx_t_2 = 0; + /* "hunter/_event.pyx":120 + * if self._threadidn is UNSET: + * current = PyThread_get_thread_ident() + * main = get_main_thread() # <<<<<<<<<<<<<< + * if main is not None and current == main.ident: + * self._threadidn = None +*/ + __Pyx_TraceLine(120,11,0,__PYX_ERR(0, 120, __pyx_L1_error)) + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_main_thread); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 120, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 120, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_v_main = __pyx_t_2; + __pyx_t_2 = 0; - /* "hunter/_event.pyx":105 - * event.frame = self.frame - * event.kind = self.kind - * event.depth = self.depth # <<<<<<<<<<<<<< - * event.calls = self.calls - * event.threading_support = self.threading_support - */ - __Pyx_TraceLine(105,0,__PYX_ERR(0, 105, __pyx_L1_error)) - __pyx_t_3 = __pyx_v_self->depth; - __pyx_v_event->depth = __pyx_t_3; + /* "hunter/_event.pyx":121 + * current = PyThread_get_thread_ident() + * main = get_main_thread() + * if main is not None and current == main.ident: # <<<<<<<<<<<<<< + * self._threadidn = None + * else: +*/ + __Pyx_TraceLine(121,15,0,__PYX_ERR(0, 121, __pyx_L1_error)) + __pyx_t_6 = (__pyx_v_main != Py_None); + if (__pyx_t_6) { + } else { + __pyx_t_1 = __pyx_t_6; + goto __pyx_L5_bool_binop_done; + } + __pyx_t_2 = __Pyx_PyLong_From_long(__pyx_v_current); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 121, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_main, __pyx_mstate_global->__pyx_n_u_ident); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 121, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_t_2, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 121, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 121, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __pyx_t_6; + __pyx_L5_bool_binop_done:; + if (__pyx_t_1) { - /* "hunter/_event.pyx":106 - * event.kind = self.kind - * event.depth = self.depth - * event.calls = self.calls # <<<<<<<<<<<<<< - * event.threading_support = self.threading_support - * event._code = self._code - */ - __Pyx_TraceLine(106,0,__PYX_ERR(0, 106, __pyx_L1_error)) - __pyx_t_3 = __pyx_v_self->calls; - __pyx_v_event->calls = __pyx_t_3; + /* "hunter/_event.pyx":122 + * main = get_main_thread() + * if main is not None and current == main.ident: + * self._threadidn = None # <<<<<<<<<<<<<< + * else: + * self._threadidn = current +*/ + __Pyx_TraceLine(122,21,0,__PYX_ERR(0, 122, __pyx_L1_error)) + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_threadidn); + __Pyx_DECREF(__pyx_v_self->_threadidn); + __pyx_v_self->_threadidn = Py_None; - /* "hunter/_event.pyx":107 - * event.depth = self.depth - * event.calls = self.calls - * event.threading_support = self.threading_support # <<<<<<<<<<<<<< - * event._code = self._code - * event._filename = self._filename - */ - __Pyx_TraceLine(107,0,__PYX_ERR(0, 107, __pyx_L1_error)) - __pyx_t_4 = __pyx_v_self->threading_support; - __pyx_v_event->threading_support = __pyx_t_4; + /* "hunter/_event.pyx":121 + * current = PyThread_get_thread_ident() + * main = get_main_thread() + * if main is not None and current == main.ident: # <<<<<<<<<<<<<< + * self._threadidn = None + * else: +*/ + goto __pyx_L4; + } - /* "hunter/_event.pyx":108 - * event.calls = self.calls - * event.threading_support = self.threading_support - * event._code = self._code # <<<<<<<<<<<<<< - * event._filename = self._filename - * event._fullsource = self._fullsource - */ - __Pyx_TraceLine(108,0,__PYX_ERR(0, 108, __pyx_L1_error)) - __pyx_t_2 = __pyx_v_self->_code; - __Pyx_INCREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->_code); - __Pyx_DECREF(__pyx_v_event->_code); - __pyx_v_event->_code = __pyx_t_2; - __pyx_t_2 = 0; + /* "hunter/_event.pyx":124 + * self._threadidn = None + * else: + * self._threadidn = current # <<<<<<<<<<<<<< + * return self._threadidn + * +*/ + __Pyx_TraceLine(124,26,0,__PYX_ERR(0, 124, __pyx_L1_error)) + /*else*/ { + __pyx_t_3 = __Pyx_PyLong_From_long(__pyx_v_current); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 124, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_self->_threadidn); + __Pyx_DECREF(__pyx_v_self->_threadidn); + __pyx_v_self->_threadidn = __pyx_t_3; + __pyx_t_3 = 0; + } + __pyx_L4:; - /* "hunter/_event.pyx":109 - * event.threading_support = self.threading_support - * event._code = self._code - * event._filename = self._filename # <<<<<<<<<<<<<< - * event._fullsource = self._fullsource - * event._function_object = self._function_object - */ - __Pyx_TraceLine(109,0,__PYX_ERR(0, 109, __pyx_L1_error)) - __pyx_t_2 = __pyx_v_self->_filename; - __Pyx_INCREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->_filename); - __Pyx_DECREF(__pyx_v_event->_filename); - __pyx_v_event->_filename = __pyx_t_2; - __pyx_t_2 = 0; + /* "hunter/_event.pyx":118 + * cdef long current + * + * if self._threadidn is UNSET: # <<<<<<<<<<<<<< + * current = PyThread_get_thread_ident() + * main = get_main_thread() +*/ + } - /* "hunter/_event.pyx":110 - * event._code = self._code - * event._filename = self._filename - * event._fullsource = self._fullsource # <<<<<<<<<<<<<< - * event._function_object = self._function_object - * event._function = self._function - */ - __Pyx_TraceLine(110,0,__PYX_ERR(0, 110, __pyx_L1_error)) - __pyx_t_2 = __pyx_v_self->_fullsource; - __Pyx_INCREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->_fullsource); - __Pyx_DECREF(__pyx_v_event->_fullsource); - __pyx_v_event->_fullsource = __pyx_t_2; - __pyx_t_2 = 0; - - /* "hunter/_event.pyx":111 - * event._filename = self._filename - * event._fullsource = self._fullsource - * event._function_object = self._function_object # <<<<<<<<<<<<<< - * event._function = self._function - * event._globals = self._globals - */ - __Pyx_TraceLine(111,0,__PYX_ERR(0, 111, __pyx_L1_error)) - __pyx_t_2 = __pyx_v_self->_function_object; - __Pyx_INCREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->_function_object); - __Pyx_DECREF(__pyx_v_event->_function_object); - __pyx_v_event->_function_object = __pyx_t_2; - __pyx_t_2 = 0; - - /* "hunter/_event.pyx":112 - * event._fullsource = self._fullsource - * event._function_object = self._function_object - * event._function = self._function # <<<<<<<<<<<<<< - * event._globals = self._globals - * event._lineno = self._lineno - */ - __Pyx_TraceLine(112,0,__PYX_ERR(0, 112, __pyx_L1_error)) - __pyx_t_2 = __pyx_v_self->_function; - __Pyx_INCREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->_function); - __Pyx_DECREF(__pyx_v_event->_function); - __pyx_v_event->_function = __pyx_t_2; - __pyx_t_2 = 0; - - /* "hunter/_event.pyx":113 - * event._function_object = self._function_object - * event._function = self._function - * event._globals = self._globals # <<<<<<<<<<<<<< - * event._lineno = self._lineno - * event._locals = self._locals - */ - __Pyx_TraceLine(113,0,__PYX_ERR(0, 113, __pyx_L1_error)) - __pyx_t_2 = __pyx_v_self->_globals; - __Pyx_INCREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->_globals); - __Pyx_DECREF(__pyx_v_event->_globals); - __pyx_v_event->_globals = __pyx_t_2; - __pyx_t_2 = 0; - - /* "hunter/_event.pyx":114 - * event._function = self._function - * event._globals = self._globals - * event._lineno = self._lineno # <<<<<<<<<<<<<< - * event._locals = self._locals - * event._module = self._module - */ - __Pyx_TraceLine(114,0,__PYX_ERR(0, 114, __pyx_L1_error)) - __pyx_t_2 = __pyx_v_self->_lineno; - __Pyx_INCREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->_lineno); - __Pyx_DECREF(__pyx_v_event->_lineno); - __pyx_v_event->_lineno = __pyx_t_2; - __pyx_t_2 = 0; - - /* "hunter/_event.pyx":115 - * event._globals = self._globals - * event._lineno = self._lineno - * event._locals = self._locals # <<<<<<<<<<<<<< - * event._module = self._module - * event._source = self._source - */ - __Pyx_TraceLine(115,0,__PYX_ERR(0, 115, __pyx_L1_error)) - __pyx_t_2 = __pyx_v_self->_locals; - __Pyx_INCREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->_locals); - __Pyx_DECREF(__pyx_v_event->_locals); - __pyx_v_event->_locals = __pyx_t_2; - __pyx_t_2 = 0; - - /* "hunter/_event.pyx":116 - * event._lineno = self._lineno - * event._locals = self._locals - * event._module = self._module # <<<<<<<<<<<<<< - * event._source = self._source - * event._stdlib = self._stdlib - */ - __Pyx_TraceLine(116,0,__PYX_ERR(0, 116, __pyx_L1_error)) - __pyx_t_2 = __pyx_v_self->_module; - __Pyx_INCREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->_module); - __Pyx_DECREF(__pyx_v_event->_module); - __pyx_v_event->_module = __pyx_t_2; - __pyx_t_2 = 0; - - /* "hunter/_event.pyx":117 - * event._locals = self._locals - * event._module = self._module - * event._source = self._source # <<<<<<<<<<<<<< - * event._stdlib = self._stdlib - * event._threadidn = self._threadidn - */ - __Pyx_TraceLine(117,0,__PYX_ERR(0, 117, __pyx_L1_error)) - __pyx_t_2 = __pyx_v_self->_source; - __Pyx_INCREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->_source); - __Pyx_DECREF(__pyx_v_event->_source); - __pyx_v_event->_source = __pyx_t_2; - __pyx_t_2 = 0; - - /* "hunter/_event.pyx":118 - * event._module = self._module - * event._source = self._source - * event._stdlib = self._stdlib # <<<<<<<<<<<<<< - * event._threadidn = self._threadidn - * event._threadname = self._threadname - */ - __Pyx_TraceLine(118,0,__PYX_ERR(0, 118, __pyx_L1_error)) - __pyx_t_2 = __pyx_v_self->_stdlib; - __Pyx_INCREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->_stdlib); - __Pyx_DECREF(__pyx_v_event->_stdlib); - __pyx_v_event->_stdlib = __pyx_t_2; - __pyx_t_2 = 0; - - /* "hunter/_event.pyx":119 - * event._source = self._source - * event._stdlib = self._stdlib - * event._threadidn = self._threadidn # <<<<<<<<<<<<<< - * event._threadname = self._threadname - * event._thread = self._thread - */ - __Pyx_TraceLine(119,0,__PYX_ERR(0, 119, __pyx_L1_error)) - __pyx_t_2 = __pyx_v_self->_threadidn; - __Pyx_INCREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->_threadidn); - __Pyx_DECREF(__pyx_v_event->_threadidn); - __pyx_v_event->_threadidn = __pyx_t_2; - __pyx_t_2 = 0; - - /* "hunter/_event.pyx":120 - * event._stdlib = self._stdlib - * event._threadidn = self._threadidn - * event._threadname = self._threadname # <<<<<<<<<<<<<< - * event._thread = self._thread - * return event - */ - __Pyx_TraceLine(120,0,__PYX_ERR(0, 120, __pyx_L1_error)) - __pyx_t_2 = __pyx_v_self->_threadname; - __Pyx_INCREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->_threadname); - __Pyx_DECREF(__pyx_v_event->_threadname); - __pyx_v_event->_threadname = __pyx_t_2; - __pyx_t_2 = 0; - - /* "hunter/_event.pyx":121 - * event._threadidn = self._threadidn - * event._threadname = self._threadname - * event._thread = self._thread # <<<<<<<<<<<<<< - * return event - * - */ - __Pyx_TraceLine(121,0,__PYX_ERR(0, 121, __pyx_L1_error)) - __pyx_t_2 = __pyx_v_self->_thread; - __Pyx_INCREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->_thread); - __Pyx_DECREF(__pyx_v_event->_thread); - __pyx_v_event->_thread = __pyx_t_2; - __pyx_t_2 = 0; - - /* "hunter/_event.pyx":122 - * event._threadname = self._threadname - * event._thread = self._thread - * return event # <<<<<<<<<<<<<< + /* "hunter/_event.pyx":125 + * else: + * self._threadidn = current + * return self._threadidn # <<<<<<<<<<<<<< * * @property - */ - __Pyx_TraceLine(122,0,__PYX_ERR(0, 122, __pyx_L1_error)) - __Pyx_XDECREF(((PyObject *)__pyx_r)); - __Pyx_INCREF(((PyObject *)__pyx_v_event)); - __pyx_r = __pyx_v_event; +*/ + __Pyx_TraceLine(125,27,0,__PYX_ERR(0, 125, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_threadidn); + __pyx_r = __pyx_v_self->_threadidn; + __Pyx_TraceReturnValue(__pyx_r, 27, 0, __PYX_ERR(0, 125, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_event.pyx":100 - * return event + /* "hunter/_event.pyx":115 + * return self.instruction_getter() * - * cdef inline Event clone(self): # <<<<<<<<<<<<<< - * event = Event.__new__(Event) - * event.arg = self.arg - */ + * cdef inline threadid_getter(self): # <<<<<<<<<<<<<< + * cdef long current + * +*/ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("hunter._event.Event.clone", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 115, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.Event.threadid_getter", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_event); - __Pyx_XGIVEREF((PyObject *)__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_XDECREF(__pyx_v_main); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_event.pyx":125 - * - * @property - * def threadid(self): # <<<<<<<<<<<<<< - * cdef long current +/* "hunter/_event.pyx":127 + * return self._threadidn * - */ + * @property # <<<<<<<<<<<<<< + * def threadid(self): + * return self.threadid_getter() +*/ /* Python wrapper */ static PyObject *__pyx_pw_6hunter_6_event_5Event_8threadid_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_6hunter_6_event_5Event_8threadid_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_6hunter_6_event_5Event_8threadid___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); /* function exit code */ @@ -3447,673 +5168,968 @@ static PyObject *__pyx_pw_6hunter_6_event_5Event_8threadid_1__get__(PyObject *__ } static PyObject *__pyx_pf_6hunter_6_event_5Event_8threadid___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { - long __pyx_v_current; - PyObject *__pyx_v_main = NULL; PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - int __pyx_t_6; + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[8])) __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[0], 125, 0, __PYX_ERR(0, 125, __pyx_L1_error)); - - /* "hunter/_event.pyx":128 - * cdef long current - * - * if self._threadidn is UNSET: # <<<<<<<<<<<<<< - * current = PyThread_get_thread_ident() - * main = get_main_thread() - */ - __Pyx_TraceLine(128,0,__PYX_ERR(0, 128, __pyx_L1_error)) - __pyx_t_1 = (__pyx_v_self->_threadidn == __pyx_v_6hunter_6_event_UNSET); - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { - - /* "hunter/_event.pyx":129 - * - * if self._threadidn is UNSET: - * current = PyThread_get_thread_ident() # <<<<<<<<<<<<<< - * main = get_main_thread() - * if main is not None and current == main.ident: - */ - __Pyx_TraceLine(129,0,__PYX_ERR(0, 129, __pyx_L1_error)) - __pyx_v_current = PyThread_get_thread_ident(); - - /* "hunter/_event.pyx":130 - * if self._threadidn is UNSET: - * current = PyThread_get_thread_ident() - * main = get_main_thread() # <<<<<<<<<<<<<< - * if main is not None and current == main.ident: - * self._threadidn = None - */ - __Pyx_TraceLine(130,0,__PYX_ERR(0, 130, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_get_main_thread); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 130, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - } - } - __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 130, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_v_main = __pyx_t_3; - __pyx_t_3 = 0; - - /* "hunter/_event.pyx":131 - * current = PyThread_get_thread_ident() - * main = get_main_thread() - * if main is not None and current == main.ident: # <<<<<<<<<<<<<< - * self._threadidn = None - * else: - */ - __Pyx_TraceLine(131,0,__PYX_ERR(0, 131, __pyx_L1_error)) - __pyx_t_1 = (__pyx_v_main != Py_None); - __pyx_t_6 = (__pyx_t_1 != 0); - if (__pyx_t_6) { - } else { - __pyx_t_2 = __pyx_t_6; - goto __pyx_L5_bool_binop_done; - } - __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v_current); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 131, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_main, __pyx_n_s_ident); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 131, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyObject_RichCompare(__pyx_t_3, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 131, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 131, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_2 = __pyx_t_6; - __pyx_L5_bool_binop_done:; - if (__pyx_t_2) { + __Pyx_TraceStartFunc("__get__", __pyx_f[0], 127, 0, 0, 0, __PYX_ERR(0, 127, __pyx_L1_error)); - /* "hunter/_event.pyx":132 - * main = get_main_thread() - * if main is not None and current == main.ident: - * self._threadidn = None # <<<<<<<<<<<<<< - * else: - * self._threadidn = current - */ - __Pyx_TraceLine(132,0,__PYX_ERR(0, 132, __pyx_L1_error)) - __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(Py_None); - __Pyx_GOTREF(__pyx_v_self->_threadidn); - __Pyx_DECREF(__pyx_v_self->_threadidn); - __pyx_v_self->_threadidn = Py_None; - - /* "hunter/_event.pyx":131 - * current = PyThread_get_thread_ident() - * main = get_main_thread() - * if main is not None and current == main.ident: # <<<<<<<<<<<<<< - * self._threadidn = None - * else: - */ - goto __pyx_L4; - } - - /* "hunter/_event.pyx":134 - * self._threadidn = None - * else: - * self._threadidn = current # <<<<<<<<<<<<<< - * return self._threadidn - * - */ - __Pyx_TraceLine(134,0,__PYX_ERR(0, 134, __pyx_L1_error)) - /*else*/ { - __pyx_t_5 = __Pyx_PyInt_From_long(__pyx_v_current); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 134, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GIVEREF(__pyx_t_5); - __Pyx_GOTREF(__pyx_v_self->_threadidn); - __Pyx_DECREF(__pyx_v_self->_threadidn); - __pyx_v_self->_threadidn = __pyx_t_5; - __pyx_t_5 = 0; - } - __pyx_L4:; - - /* "hunter/_event.pyx":128 - * cdef long current - * - * if self._threadidn is UNSET: # <<<<<<<<<<<<<< - * current = PyThread_get_thread_ident() - * main = get_main_thread() - */ - } - - /* "hunter/_event.pyx":135 - * else: - * self._threadidn = current - * return self._threadidn # <<<<<<<<<<<<<< - * + /* "hunter/_event.pyx":129 * @property - */ - __Pyx_TraceLine(135,0,__PYX_ERR(0, 135, __pyx_L1_error)) + * def threadid(self): + * return self.threadid_getter() # <<<<<<<<<<<<<< + * + * cdef inline threadname_getter(self): +*/ + __Pyx_TraceLine(129,1,0,__PYX_ERR(0, 129, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->_threadidn); - __pyx_r = __pyx_v_self->_threadidn; + __pyx_t_1 = __pyx_f_6hunter_6_event_5Event_threadid_getter(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 129, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_event.pyx":125 - * - * @property - * def threadid(self): # <<<<<<<<<<<<<< - * cdef long current + /* "hunter/_event.pyx":127 + * return self._threadidn * - */ + * @property # <<<<<<<<<<<<<< + * def threadid(self): + * return self.threadid_getter() +*/ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("hunter._event.Event.threadid.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 127, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.Event.threadid.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF(__pyx_v_main); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_event.pyx":138 +/* "hunter/_event.pyx":131 + * return self.threadid_getter() * - * @property - * def threadname(self): # <<<<<<<<<<<<<< + * cdef inline threadname_getter(self): # <<<<<<<<<<<<<< * if self._threadname is UNSET: * if self._thread is UNSET: - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_6_event_5Event_10threadname_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_6_event_5Event_10threadname_1__get__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_6_event_5Event_10threadname___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); +*/ - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6hunter_6_event_5Event_10threadname___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { +static PyObject *__pyx_f_6hunter_6_event_5Event_threadname_getter(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations int __pyx_t_1; - int __pyx_t_2; + PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[0], 138, 0, __PYX_ERR(0, 138, __pyx_L1_error)); - - /* "hunter/_event.pyx":139 - * @property - * def threadname(self): + size_t __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[9])) + __Pyx_RefNannySetupContext("threadname_getter", 0); + __Pyx_TraceStartFunc("threadname_getter", __pyx_f[0], 131, 0, 0, 0, __PYX_ERR(0, 131, __pyx_L1_error)); + + /* "hunter/_event.pyx":132 + * + * cdef inline threadname_getter(self): * if self._threadname is UNSET: # <<<<<<<<<<<<<< * if self._thread is UNSET: * self._thread = current_thread() - */ - __Pyx_TraceLine(139,0,__PYX_ERR(0, 139, __pyx_L1_error)) +*/ + __Pyx_TraceLine(132,5,0,__PYX_ERR(0, 132, __pyx_L1_error)) __pyx_t_1 = (__pyx_v_self->_threadname == __pyx_v_6hunter_6_event_UNSET); - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { + if (__pyx_t_1) { - /* "hunter/_event.pyx":140 - * def threadname(self): + /* "hunter/_event.pyx":133 + * cdef inline threadname_getter(self): * if self._threadname is UNSET: * if self._thread is UNSET: # <<<<<<<<<<<<<< * self._thread = current_thread() * self._threadname = self._thread.name - */ - __Pyx_TraceLine(140,0,__PYX_ERR(0, 140, __pyx_L1_error)) - __pyx_t_2 = (__pyx_v_self->_thread == __pyx_v_6hunter_6_event_UNSET); - __pyx_t_1 = (__pyx_t_2 != 0); +*/ + __Pyx_TraceLine(133,10,0,__PYX_ERR(0, 133, __pyx_L1_error)) + __pyx_t_1 = (__pyx_v_self->_thread == __pyx_v_6hunter_6_event_UNSET); if (__pyx_t_1) { - /* "hunter/_event.pyx":141 + /* "hunter/_event.pyx":134 * if self._threadname is UNSET: * if self._thread is UNSET: * self._thread = current_thread() # <<<<<<<<<<<<<< * self._threadname = self._thread.name * return self._threadname - */ - __Pyx_TraceLine(141,0,__PYX_ERR(0, 141, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_current_thread); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 141, __pyx_L1_error) +*/ + __Pyx_TraceLine(134,14,0,__PYX_ERR(0, 134, __pyx_L1_error)) + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_current_thread); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 134, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - } + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_5 = 0; } - __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 141, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_GIVEREF(__pyx_t_3); + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_GIVEREF(__pyx_t_2); __Pyx_GOTREF(__pyx_v_self->_thread); __Pyx_DECREF(__pyx_v_self->_thread); - __pyx_v_self->_thread = __pyx_t_3; - __pyx_t_3 = 0; + __pyx_v_self->_thread = __pyx_t_2; + __pyx_t_2 = 0; - /* "hunter/_event.pyx":140 - * def threadname(self): + /* "hunter/_event.pyx":133 + * cdef inline threadname_getter(self): * if self._threadname is UNSET: * if self._thread is UNSET: # <<<<<<<<<<<<<< * self._thread = current_thread() * self._threadname = self._thread.name - */ +*/ } - /* "hunter/_event.pyx":142 + /* "hunter/_event.pyx":135 * if self._thread is UNSET: * self._thread = current_thread() * self._threadname = self._thread.name # <<<<<<<<<<<<<< * return self._threadname * - */ - __Pyx_TraceLine(142,0,__PYX_ERR(0, 142, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_thread, __pyx_n_s_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 142, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); +*/ + __Pyx_TraceLine(135,19,0,__PYX_ERR(0, 135, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_thread, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); __Pyx_GOTREF(__pyx_v_self->_threadname); __Pyx_DECREF(__pyx_v_self->_threadname); - __pyx_v_self->_threadname = __pyx_t_3; - __pyx_t_3 = 0; + __pyx_v_self->_threadname = __pyx_t_2; + __pyx_t_2 = 0; - /* "hunter/_event.pyx":139 - * @property - * def threadname(self): + /* "hunter/_event.pyx":132 + * + * cdef inline threadname_getter(self): * if self._threadname is UNSET: # <<<<<<<<<<<<<< * if self._thread is UNSET: * self._thread = current_thread() - */ +*/ } - /* "hunter/_event.pyx":143 + /* "hunter/_event.pyx":136 * self._thread = current_thread() * self._threadname = self._thread.name * return self._threadname # <<<<<<<<<<<<<< * * @property - */ - __Pyx_TraceLine(143,0,__PYX_ERR(0, 143, __pyx_L1_error)) +*/ + __Pyx_TraceLine(136,20,0,__PYX_ERR(0, 136, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->_threadname); __pyx_r = __pyx_v_self->_threadname; + __Pyx_TraceReturnValue(__pyx_r, 20, 0, __PYX_ERR(0, 136, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_event.pyx":138 + /* "hunter/_event.pyx":131 + * return self.threadid_getter() * - * @property - * def threadname(self): # <<<<<<<<<<<<<< + * cdef inline threadname_getter(self): # <<<<<<<<<<<<<< * if self._threadname is UNSET: * if self._thread is UNSET: - */ +*/ /* function exit code */ __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("hunter._event.Event.threadname.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 131, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.Event.threadname_getter", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_event.pyx":146 +/* "hunter/_event.pyx":138 + * return self._threadname * - * @property - * def locals(self): # <<<<<<<<<<<<<< - * if self._locals is UNSET: - * PyFrame_FastToLocals(self.frame) - */ + * @property # <<<<<<<<<<<<<< + * def threadname(self): + * return self.threadname_getter() +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_6_event_5Event_6locals_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_6_event_5Event_6locals_1__get__(PyObject *__pyx_v_self) { +static PyObject *__pyx_pw_6hunter_6_event_5Event_10threadname_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_6_event_5Event_10threadname_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_6_event_5Event_6locals___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_6_event_5Event_10threadname___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_6_event_5Event_6locals___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { +static PyObject *__pyx_pf_6hunter_6_event_5Event_10threadname___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[10])) __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[0], 146, 0, __PYX_ERR(0, 146, __pyx_L1_error)); + __Pyx_TraceStartFunc("__get__", __pyx_f[0], 138, 0, 0, 0, __PYX_ERR(0, 138, __pyx_L1_error)); - /* "hunter/_event.pyx":147 + /* "hunter/_event.pyx":140 * @property - * def locals(self): + * def threadname(self): + * return self.threadname_getter() # <<<<<<<<<<<<<< + * + * cdef inline locals_getter(self): +*/ + __Pyx_TraceLine(140,1,0,__PYX_ERR(0, 140, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6hunter_6_event_5Event_threadname_getter(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 140, __pyx_L1_error)); + goto __pyx_L0; + + /* "hunter/_event.pyx":138 + * return self._threadname + * + * @property # <<<<<<<<<<<<<< + * def threadname(self): + * return self.threadname_getter() +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 138, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.Event.threadname.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/_event.pyx":142 + * return self.threadname_getter() + * + * cdef inline locals_getter(self): # <<<<<<<<<<<<<< + * if self._locals is UNSET: + * if self.builtin: +*/ + +static PyObject *__pyx_f_6hunter_6_event_5Event_locals_getter(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[11])) + __Pyx_RefNannySetupContext("locals_getter", 0); + __Pyx_TraceStartFunc("locals_getter", __pyx_f[0], 142, 0, 0, 0, __PYX_ERR(0, 142, __pyx_L1_error)); + + /* "hunter/_event.pyx":143 + * + * cdef inline locals_getter(self): * if self._locals is UNSET: # <<<<<<<<<<<<<< - * PyFrame_FastToLocals(self.frame) - * self._locals = self.frame.f_locals - */ - __Pyx_TraceLine(147,0,__PYX_ERR(0, 147, __pyx_L1_error)) + * if self.builtin: + * self._locals = {} +*/ + __Pyx_TraceLine(143,5,0,__PYX_ERR(0, 143, __pyx_L1_error)) __pyx_t_1 = (__pyx_v_self->_locals == __pyx_v_6hunter_6_event_UNSET); - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { + if (__pyx_t_1) { - /* "hunter/_event.pyx":148 - * def locals(self): + /* "hunter/_event.pyx":144 + * cdef inline locals_getter(self): * if self._locals is UNSET: - * PyFrame_FastToLocals(self.frame) # <<<<<<<<<<<<<< - * self._locals = self.frame.f_locals - * return self._locals - */ - __Pyx_TraceLine(148,0,__PYX_ERR(0, 148, __pyx_L1_error)) - __pyx_t_3 = ((PyObject *)__pyx_v_self->frame); - __Pyx_INCREF(__pyx_t_3); - PyFrame_FastToLocals(((PyFrameObject *)__pyx_t_3)); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + * if self.builtin: # <<<<<<<<<<<<<< + * self._locals = {} + * else: +*/ + __Pyx_TraceLine(144,8,0,__PYX_ERR(0, 144, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->builtin); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 144, __pyx_L1_error) + if (__pyx_t_1) { - /* "hunter/_event.pyx":149 + /* "hunter/_event.pyx":145 + * if self._locals is UNSET: + * if self.builtin: + * self._locals = {} # <<<<<<<<<<<<<< + * else: + * self._locals = Hunter_PyFrame_GetLocals(self.frame) +*/ + __Pyx_TraceLine(145,11,0,__PYX_ERR(0, 145, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 145, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->_locals); + __Pyx_DECREF(__pyx_v_self->_locals); + __pyx_v_self->_locals = __pyx_t_2; + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":144 + * cdef inline locals_getter(self): * if self._locals is UNSET: - * PyFrame_FastToLocals(self.frame) - * self._locals = self.frame.f_locals # <<<<<<<<<<<<<< + * if self.builtin: # <<<<<<<<<<<<<< + * self._locals = {} + * else: +*/ + goto __pyx_L4; + } + + /* "hunter/_event.pyx":147 + * self._locals = {} + * else: + * self._locals = Hunter_PyFrame_GetLocals(self.frame) # <<<<<<<<<<<<<< * return self._locals * - */ - __Pyx_TraceLine(149,0,__PYX_ERR(0, 149, __pyx_L1_error)) - __pyx_t_3 = __pyx_v_self->frame->f_locals; - __Pyx_INCREF(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); - __Pyx_GOTREF(__pyx_v_self->_locals); - __Pyx_DECREF(__pyx_v_self->_locals); - __pyx_v_self->_locals = __pyx_t_3; - __pyx_t_3 = 0; +*/ + __Pyx_TraceLine(147,15,0,__PYX_ERR(0, 147, __pyx_L1_error)) + /*else*/ { + __pyx_t_2 = ((PyObject *)__pyx_v_self->frame); + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = Hunter_PyFrame_GetLocals(((FrameType)__pyx_t_2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_self->_locals); + __Pyx_DECREF(__pyx_v_self->_locals); + __pyx_v_self->_locals = __pyx_t_3; + __pyx_t_3 = 0; + } + __pyx_L4:; - /* "hunter/_event.pyx":147 - * @property - * def locals(self): + /* "hunter/_event.pyx":143 + * + * cdef inline locals_getter(self): * if self._locals is UNSET: # <<<<<<<<<<<<<< - * PyFrame_FastToLocals(self.frame) - * self._locals = self.frame.f_locals - */ + * if self.builtin: + * self._locals = {} +*/ } - /* "hunter/_event.pyx":150 - * PyFrame_FastToLocals(self.frame) - * self._locals = self.frame.f_locals + /* "hunter/_event.pyx":148 + * else: + * self._locals = Hunter_PyFrame_GetLocals(self.frame) * return self._locals # <<<<<<<<<<<<<< * * @property - */ - __Pyx_TraceLine(150,0,__PYX_ERR(0, 150, __pyx_L1_error)) +*/ + __Pyx_TraceLine(148,18,0,__PYX_ERR(0, 148, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->_locals); __pyx_r = __pyx_v_self->_locals; + __Pyx_TraceReturnValue(__pyx_r, 18, 0, __PYX_ERR(0, 148, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_event.pyx":146 + /* "hunter/_event.pyx":142 + * return self.threadname_getter() * - * @property - * def locals(self): # <<<<<<<<<<<<<< + * cdef inline locals_getter(self): # <<<<<<<<<<<<<< * if self._locals is UNSET: - * PyFrame_FastToLocals(self.frame) - */ + * if self.builtin: +*/ /* function exit code */ __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("hunter._event.Event.locals.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 142, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.Event.locals_getter", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_event.pyx":153 +/* "hunter/_event.pyx":150 + * return self._locals * - * @property - * def globals(self): # <<<<<<<<<<<<<< - * if self._globals is UNSET: - * self._globals = self.frame.f_globals - */ + * @property # <<<<<<<<<<<<<< + * def locals(self): + * return self.locals_getter() +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_6_event_5Event_7globals_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_6_event_5Event_7globals_1__get__(PyObject *__pyx_v_self) { +static PyObject *__pyx_pw_6hunter_6_event_5Event_6locals_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_6_event_5Event_6locals_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_6_event_5Event_7globals___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_6_event_5Event_6locals___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_6_event_5Event_7globals___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { +static PyObject *__pyx_pf_6hunter_6_event_5Event_6locals___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[12])) __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[0], 153, 0, __PYX_ERR(0, 153, __pyx_L1_error)); - - /* "hunter/_event.pyx":154 - * @property - * def globals(self): - * if self._globals is UNSET: # <<<<<<<<<<<<<< - * self._globals = self.frame.f_globals - * return self._globals - */ - __Pyx_TraceLine(154,0,__PYX_ERR(0, 154, __pyx_L1_error)) - __pyx_t_1 = (__pyx_v_self->_globals == __pyx_v_6hunter_6_event_UNSET); - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { - - /* "hunter/_event.pyx":155 - * def globals(self): - * if self._globals is UNSET: - * self._globals = self.frame.f_globals # <<<<<<<<<<<<<< - * return self._globals - * - */ - __Pyx_TraceLine(155,0,__PYX_ERR(0, 155, __pyx_L1_error)) - __pyx_t_3 = __pyx_v_self->frame->f_globals; - __Pyx_INCREF(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); - __Pyx_GOTREF(__pyx_v_self->_globals); - __Pyx_DECREF(__pyx_v_self->_globals); - __pyx_v_self->_globals = __pyx_t_3; - __pyx_t_3 = 0; + __Pyx_TraceStartFunc("__get__", __pyx_f[0], 150, 0, 0, 0, __PYX_ERR(0, 150, __pyx_L1_error)); - /* "hunter/_event.pyx":154 + /* "hunter/_event.pyx":152 * @property - * def globals(self): - * if self._globals is UNSET: # <<<<<<<<<<<<<< - * self._globals = self.frame.f_globals - * return self._globals - */ - } - - /* "hunter/_event.pyx":156 - * if self._globals is UNSET: - * self._globals = self.frame.f_globals - * return self._globals # <<<<<<<<<<<<<< + * def locals(self): + * return self.locals_getter() # <<<<<<<<<<<<<< * - * @property - */ - __Pyx_TraceLine(156,0,__PYX_ERR(0, 156, __pyx_L1_error)) + * cdef inline globals_getter(self): +*/ + __Pyx_TraceLine(152,1,0,__PYX_ERR(0, 152, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->_globals); - __pyx_r = __pyx_v_self->_globals; + __pyx_t_1 = __pyx_f_6hunter_6_event_5Event_locals_getter(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 152, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_event.pyx":153 + /* "hunter/_event.pyx":150 + * return self._locals * - * @property - * def globals(self): # <<<<<<<<<<<<<< - * if self._globals is UNSET: - * self._globals = self.frame.f_globals - */ + * @property # <<<<<<<<<<<<<< + * def locals(self): + * return self.locals_getter() +*/ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("hunter._event.Event.globals.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 150, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.Event.locals.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_event.pyx":159 +/* "hunter/_event.pyx":154 + * return self.locals_getter() * - * @property - * def function(self): # <<<<<<<<<<<<<< - * if self._function is UNSET: - * self._function = self.frame.f_code.co_name - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_6_event_5Event_8function_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_6_event_5Event_8function_1__get__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_6_event_5Event_8function___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + * cdef inline globals_getter(self): # <<<<<<<<<<<<<< + * if self._globals is UNSET: + * if self.builtin: +*/ -static PyObject *__pyx_pf_6hunter_6_event_5Event_8function___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { +static PyObject *__pyx_f_6hunter_6_event_5Event_globals_getter(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations int __pyx_t_1; - int __pyx_t_2; + PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[0], 159, 0, __PYX_ERR(0, 159, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[13])) + __Pyx_RefNannySetupContext("globals_getter", 0); + __Pyx_TraceStartFunc("globals_getter", __pyx_f[0], 154, 0, 0, 0, __PYX_ERR(0, 154, __pyx_L1_error)); + + /* "hunter/_event.pyx":155 + * + * cdef inline globals_getter(self): + * if self._globals is UNSET: # <<<<<<<<<<<<<< + * if self.builtin: + * self._locals = {} +*/ + __Pyx_TraceLine(155,5,0,__PYX_ERR(0, 155, __pyx_L1_error)) + __pyx_t_1 = (__pyx_v_self->_globals == __pyx_v_6hunter_6_event_UNSET); + if (__pyx_t_1) { + + /* "hunter/_event.pyx":156 + * cdef inline globals_getter(self): + * if self._globals is UNSET: + * if self.builtin: # <<<<<<<<<<<<<< + * self._locals = {} + * else: +*/ + __Pyx_TraceLine(156,8,0,__PYX_ERR(0, 156, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->builtin); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 156, __pyx_L1_error) + if (__pyx_t_1) { + + /* "hunter/_event.pyx":157 + * if self._globals is UNSET: + * if self.builtin: + * self._locals = {} # <<<<<<<<<<<<<< + * else: + * self._globals = Hunter_PyFrame_GetGlobals(self.frame) +*/ + __Pyx_TraceLine(157,11,0,__PYX_ERR(0, 157, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->_locals); + __Pyx_DECREF(__pyx_v_self->_locals); + __pyx_v_self->_locals = __pyx_t_2; + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":156 + * cdef inline globals_getter(self): + * if self._globals is UNSET: + * if self.builtin: # <<<<<<<<<<<<<< + * self._locals = {} + * else: +*/ + goto __pyx_L4; + } + + /* "hunter/_event.pyx":159 + * self._locals = {} + * else: + * self._globals = Hunter_PyFrame_GetGlobals(self.frame) # <<<<<<<<<<<<<< + * return self._globals + * +*/ + __Pyx_TraceLine(159,15,0,__PYX_ERR(0, 159, __pyx_L1_error)) + /*else*/ { + __pyx_t_2 = ((PyObject *)__pyx_v_self->frame); + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = Hunter_PyFrame_GetGlobals(((FrameType)__pyx_t_2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_self->_globals); + __Pyx_DECREF(__pyx_v_self->_globals); + __pyx_v_self->_globals = __pyx_t_3; + __pyx_t_3 = 0; + } + __pyx_L4:; + + /* "hunter/_event.pyx":155 + * + * cdef inline globals_getter(self): + * if self._globals is UNSET: # <<<<<<<<<<<<<< + * if self.builtin: + * self._locals = {} +*/ + } /* "hunter/_event.pyx":160 + * else: + * self._globals = Hunter_PyFrame_GetGlobals(self.frame) + * return self._globals # <<<<<<<<<<<<<< + * * @property - * def function(self): +*/ + __Pyx_TraceLine(160,18,0,__PYX_ERR(0, 160, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_globals); + __pyx_r = __pyx_v_self->_globals; + __Pyx_TraceReturnValue(__pyx_r, 18, 0, __PYX_ERR(0, 160, __pyx_L1_error)); + goto __pyx_L0; + + /* "hunter/_event.pyx":154 + * return self.locals_getter() + * + * cdef inline globals_getter(self): # <<<<<<<<<<<<<< + * if self._globals is UNSET: + * if self.builtin: +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 154, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.Event.globals_getter", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/_event.pyx":162 + * return self._globals + * + * @property # <<<<<<<<<<<<<< + * def globals(self): + * return self.globals_getter() +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_6_event_5Event_7globals_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_6_event_5Event_7globals_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_6_event_5Event_7globals___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_6_event_5Event_7globals___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[14])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[0], 162, 0, 0, 0, __PYX_ERR(0, 162, __pyx_L1_error)); + + /* "hunter/_event.pyx":164 + * @property + * def globals(self): + * return self.globals_getter() # <<<<<<<<<<<<<< + * + * cdef inline function_getter(self): +*/ + __Pyx_TraceLine(164,1,0,__PYX_ERR(0, 164, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6hunter_6_event_5Event_globals_getter(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 164, __pyx_L1_error)); + goto __pyx_L0; + + /* "hunter/_event.pyx":162 + * return self._globals + * + * @property # <<<<<<<<<<<<<< + * def globals(self): + * return self.globals_getter() +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 162, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.Event.globals.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/_event.pyx":166 + * return self.globals_getter() + * + * cdef inline function_getter(self): # <<<<<<<<<<<<<< + * if self._function is UNSET: + * if self.builtin: +*/ + +static PyObject *__pyx_f_6hunter_6_event_5Event_function_getter(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[15])) + __Pyx_RefNannySetupContext("function_getter", 0); + __Pyx_TraceStartFunc("function_getter", __pyx_f[0], 166, 0, 0, 0, __PYX_ERR(0, 166, __pyx_L1_error)); + + /* "hunter/_event.pyx":167 + * + * cdef inline function_getter(self): * if self._function is UNSET: # <<<<<<<<<<<<<< - * self._function = self.frame.f_code.co_name - * return self._function - */ - __Pyx_TraceLine(160,0,__PYX_ERR(0, 160, __pyx_L1_error)) + * if self.builtin: + * self._function = self.arg.__name__ +*/ + __Pyx_TraceLine(167,5,0,__PYX_ERR(0, 167, __pyx_L1_error)) __pyx_t_1 = (__pyx_v_self->_function == __pyx_v_6hunter_6_event_UNSET); - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { + if (__pyx_t_1) { - /* "hunter/_event.pyx":161 - * def function(self): + /* "hunter/_event.pyx":168 + * cdef inline function_getter(self): + * if self._function is UNSET: + * if self.builtin: # <<<<<<<<<<<<<< + * self._function = self.arg.__name__ + * else: +*/ + __Pyx_TraceLine(168,8,0,__PYX_ERR(0, 168, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->builtin); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 168, __pyx_L1_error) + if (__pyx_t_1) { + + /* "hunter/_event.pyx":169 + * if self._function is UNSET: + * if self.builtin: + * self._function = self.arg.__name__ # <<<<<<<<<<<<<< + * else: + * self._function = self.code_getter().co_name +*/ + __Pyx_TraceLine(169,13,0,__PYX_ERR(0, 169, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->arg, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 169, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->_function); + __Pyx_DECREF(__pyx_v_self->_function); + __pyx_v_self->_function = __pyx_t_2; + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":168 + * cdef inline function_getter(self): * if self._function is UNSET: - * self._function = self.frame.f_code.co_name # <<<<<<<<<<<<<< + * if self.builtin: # <<<<<<<<<<<<<< + * self._function = self.arg.__name__ + * else: +*/ + goto __pyx_L4; + } + + /* "hunter/_event.pyx":171 + * self._function = self.arg.__name__ + * else: + * self._function = self.code_getter().co_name # <<<<<<<<<<<<<< * return self._function * - */ - __Pyx_TraceLine(161,0,__PYX_ERR(0, 161, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->frame->f_code), __pyx_n_s_co_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 161, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); - __Pyx_GOTREF(__pyx_v_self->_function); - __Pyx_DECREF(__pyx_v_self->_function); - __pyx_v_self->_function = __pyx_t_3; - __pyx_t_3 = 0; +*/ + __Pyx_TraceLine(171,19,0,__PYX_ERR(0, 171, __pyx_L1_error)) + /*else*/ { + __pyx_t_2 = ((PyObject *)__pyx_f_6hunter_6_event_5Event_code_getter(__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 171, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = ((PyCodeObject *)__pyx_t_2)->co_name; + __Pyx_INCREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_self->_function); + __Pyx_DECREF(__pyx_v_self->_function); + __pyx_v_self->_function = __pyx_t_3; + __pyx_t_3 = 0; + } + __pyx_L4:; - /* "hunter/_event.pyx":160 - * @property - * def function(self): + /* "hunter/_event.pyx":167 + * + * cdef inline function_getter(self): * if self._function is UNSET: # <<<<<<<<<<<<<< - * self._function = self.frame.f_code.co_name - * return self._function - */ + * if self.builtin: + * self._function = self.arg.__name__ +*/ } - /* "hunter/_event.pyx":162 - * if self._function is UNSET: - * self._function = self.frame.f_code.co_name + /* "hunter/_event.pyx":172 + * else: + * self._function = self.code_getter().co_name * return self._function # <<<<<<<<<<<<<< * * @property - */ - __Pyx_TraceLine(162,0,__PYX_ERR(0, 162, __pyx_L1_error)) +*/ + __Pyx_TraceLine(172,20,0,__PYX_ERR(0, 172, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->_function); __pyx_r = __pyx_v_self->_function; + __Pyx_TraceReturnValue(__pyx_r, 20, 0, __PYX_ERR(0, 172, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_event.pyx":159 + /* "hunter/_event.pyx":166 + * return self.globals_getter() * - * @property - * def function(self): # <<<<<<<<<<<<<< + * cdef inline function_getter(self): # <<<<<<<<<<<<<< * if self._function is UNSET: - * self._function = self.frame.f_code.co_name - */ + * if self.builtin: +*/ /* function exit code */ __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 166, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.Event.function_getter", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/_event.pyx":174 + * return self._function + * + * @property # <<<<<<<<<<<<<< + * def function(self): + * return self.function_getter() +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_6_event_5Event_8function_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_6_event_5Event_8function_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_6_event_5Event_8function___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_6_event_5Event_8function___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[16])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[0], 174, 0, 0, 0, __PYX_ERR(0, 174, __pyx_L1_error)); + + /* "hunter/_event.pyx":176 + * @property + * def function(self): + * return self.function_getter() # <<<<<<<<<<<<<< + * + * @property +*/ + __Pyx_TraceLine(176,1,0,__PYX_ERR(0, 176, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6hunter_6_event_5Event_function_getter(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 176, __pyx_L1_error)); + goto __pyx_L0; + + /* "hunter/_event.pyx":174 + * return self._function + * + * @property # <<<<<<<<<<<<<< + * def function(self): + * return self.function_getter() +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 174, __pyx_L1_error)); + #endif __Pyx_AddTraceback("hunter._event.Event.function.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_event.pyx":165 +/* "hunter/_event.pyx":178 + * return self.function_getter() * - * @property - * def function_object(self): # <<<<<<<<<<<<<< - * if self._function_object is UNSET: - * code = self.code - */ + * @property # <<<<<<<<<<<<<< + * def function_object(self): + * cdef CodeType code +*/ /* Python wrapper */ static PyObject *__pyx_pw_6hunter_6_event_5Event_15function_object_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_6hunter_6_event_5Event_15function_object_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_6hunter_6_event_5Event_15function_object___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); /* function exit code */ @@ -4122,1713 +6138,1922 @@ static PyObject *__pyx_pw_6hunter_6_event_5Event_15function_object_1__get__(PyOb } static PyObject *__pyx_pf_6hunter_6_event_5Event_15function_object___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { - PyObject *__pyx_v_code = NULL; + PyCodeObject *__pyx_v_code = 0; PyObject *__pyx_v_candidate = NULL; PyObject *__pyx_v_func = NULL; PyObject *__pyx_v_first_arg = NULL; PyObject *__pyx_v_v = NULL; PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations int __pyx_t_1; - int __pyx_t_2; + PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - int __pyx_t_7; + size_t __pyx_t_5; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; - int __pyx_t_9; + Py_ssize_t __pyx_t_9; Py_ssize_t __pyx_t_10; - Py_ssize_t __pyx_t_11; + int __pyx_t_11; int __pyx_t_12; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[17])) __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[0], 165, 0, __PYX_ERR(0, 165, __pyx_L1_error)); + __Pyx_TraceStartFunc("__get__", __pyx_f[0], 178, 0, 0, 0, __PYX_ERR(0, 178, __pyx_L1_error)); - /* "hunter/_event.pyx":166 - * @property + /* "hunter/_event.pyx":181 + * def function_object(self): + * cdef CodeType code + * if self.builtin: # <<<<<<<<<<<<<< + * return self.builtin + * elif self._function_object is UNSET: +*/ + __Pyx_TraceLine(181,3,0,__PYX_ERR(0, 181, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->builtin); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 181, __pyx_L1_error) + if (__pyx_t_1) { + + /* "hunter/_event.pyx":182 + * cdef CodeType code + * if self.builtin: + * return self.builtin # <<<<<<<<<<<<<< + * elif self._function_object is UNSET: + * code = self.code_getter() +*/ + __Pyx_TraceLine(182,4,0,__PYX_ERR(0, 182, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->builtin); + __pyx_r = __pyx_v_self->builtin; + __Pyx_TraceReturnValue(__pyx_r, 4, 0, __PYX_ERR(0, 182, __pyx_L1_error)); + goto __pyx_L0; + + /* "hunter/_event.pyx":181 * def function_object(self): - * if self._function_object is UNSET: # <<<<<<<<<<<<<< - * code = self.code + * cdef CodeType code + * if self.builtin: # <<<<<<<<<<<<<< + * return self.builtin + * elif self._function_object is UNSET: +*/ + } + + /* "hunter/_event.pyx":183 + * if self.builtin: + * return self.builtin + * elif self._function_object is UNSET: # <<<<<<<<<<<<<< + * code = self.code_getter() * if code.co_name is None: - */ - __Pyx_TraceLine(166,0,__PYX_ERR(0, 166, __pyx_L1_error)) +*/ + __Pyx_TraceLine(183,10,0,__PYX_ERR(0, 183, __pyx_L1_error)) __pyx_t_1 = (__pyx_v_self->_function_object == __pyx_v_6hunter_6_event_UNSET); - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { + if (__pyx_t_1) { - /* "hunter/_event.pyx":167 - * def function_object(self): - * if self._function_object is UNSET: - * code = self.code # <<<<<<<<<<<<<< + /* "hunter/_event.pyx":184 + * return self.builtin + * elif self._function_object is UNSET: + * code = self.code_getter() # <<<<<<<<<<<<<< * if code.co_name is None: * return None - */ - __Pyx_TraceLine(167,0,__PYX_ERR(0, 167, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_code); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 167, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_v_code = __pyx_t_3; - __pyx_t_3 = 0; +*/ + __Pyx_TraceLine(184,14,0,__PYX_ERR(0, 184, __pyx_L1_error)) + __pyx_t_2 = ((PyObject *)__pyx_f_6hunter_6_event_5Event_code_getter(__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_code = ((PyCodeObject *)__pyx_t_2); + __pyx_t_2 = 0; - /* "hunter/_event.pyx":168 - * if self._function_object is UNSET: - * code = self.code + /* "hunter/_event.pyx":185 + * elif self._function_object is UNSET: + * code = self.code_getter() * if code.co_name is None: # <<<<<<<<<<<<<< * return None * # First, try to find the function in globals - */ - __Pyx_TraceLine(168,0,__PYX_ERR(0, 168, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_code, __pyx_n_s_co_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 168, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = (__pyx_t_3 == Py_None); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_1 = (__pyx_t_2 != 0); +*/ + __Pyx_TraceLine(185,19,0,__PYX_ERR(0, 185, __pyx_L1_error)) + __pyx_t_1 = (__pyx_v_code->co_name == Py_None); if (__pyx_t_1) { - /* "hunter/_event.pyx":169 - * code = self.code + /* "hunter/_event.pyx":186 + * code = self.code_getter() * if code.co_name is None: * return None # <<<<<<<<<<<<<< * # First, try to find the function in globals * candidate = self.globals.get(code.co_name, None) - */ - __Pyx_TraceLine(169,0,__PYX_ERR(0, 169, __pyx_L1_error)) +*/ + __Pyx_TraceLine(186,20,0,__PYX_ERR(0, 186, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "hunter/_event.pyx":168 - * if self._function_object is UNSET: - * code = self.code + /* "hunter/_event.pyx":185 + * elif self._function_object is UNSET: + * code = self.code_getter() * if code.co_name is None: # <<<<<<<<<<<<<< * return None * # First, try to find the function in globals - */ +*/ } - /* "hunter/_event.pyx":171 + /* "hunter/_event.pyx":188 * return None * # First, try to find the function in globals * candidate = self.globals.get(code.co_name, None) # <<<<<<<<<<<<<< * func = if_same_code(candidate, code) * # If that failed, as will be the case with class and instance methods, try - */ - __Pyx_TraceLine(171,0,__PYX_ERR(0, 171, __pyx_L1_error)) - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_globals); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 171, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_get); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 171, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_code, __pyx_n_s_co_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 171, __pyx_L1_error) +*/ + __Pyx_TraceLine(188,24,0,__PYX_ERR(0, 188, __pyx_L1_error)) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_globals); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 188, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_6 = NULL; - __pyx_t_7 = 0; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_6)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_6); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - __pyx_t_7 = 1; - } - } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_5)) { - PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_4, Py_None}; - __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 171, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { - PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_4, Py_None}; - __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 171, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - } else - #endif + __pyx_t_3 = __pyx_t_4; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_5 = 0; { - __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 171, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - if (__pyx_t_6) { - __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; - } - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_4); - __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(Py_None); - PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, Py_None); - __pyx_t_4 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 171, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_v_code->co_name, Py_None}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); } - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_candidate = __pyx_t_3; - __pyx_t_3 = 0; + __pyx_v_candidate = __pyx_t_2; + __pyx_t_2 = 0; - /* "hunter/_event.pyx":172 + /* "hunter/_event.pyx":189 * # First, try to find the function in globals * candidate = self.globals.get(code.co_name, None) * func = if_same_code(candidate, code) # <<<<<<<<<<<<<< * # If that failed, as will be the case with class and instance methods, try * # to look up the function from the first argument. In the case of class/instance - */ - __Pyx_TraceLine(172,0,__PYX_ERR(0, 172, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_if_same_code); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 172, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_8 = NULL; - __pyx_t_7 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_8); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - __pyx_t_7 = 1; - } +*/ + __Pyx_TraceLine(189,32,0,__PYX_ERR(0, 189, __pyx_L1_error)) + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_if_same_code); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_5 = 0; } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_5)) { - PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_v_candidate, __pyx_v_code}; - __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 172, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_GOTREF(__pyx_t_3); - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { - PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_v_candidate, __pyx_v_code}; - __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 172, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_GOTREF(__pyx_t_3); - } else #endif { - __pyx_t_4 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 172, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (__pyx_t_8) { - __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_8); __pyx_t_8 = NULL; - } - __Pyx_INCREF(__pyx_v_candidate); - __Pyx_GIVEREF(__pyx_v_candidate); - PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_7, __pyx_v_candidate); - __Pyx_INCREF(__pyx_v_code); - __Pyx_GIVEREF(__pyx_v_code); - PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_7, __pyx_v_code); - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 172, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_v_candidate, ((PyObject *)__pyx_v_code)}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); } - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_func = __pyx_t_3; - __pyx_t_3 = 0; + __pyx_v_func = __pyx_t_2; + __pyx_t_2 = 0; - /* "hunter/_event.pyx":177 + /* "hunter/_event.pyx":194 * # methods, this should be the class (or an instance of the class) on which our * # method is defined. * if func is None and code.co_argcount >= 1: # <<<<<<<<<<<<<< - * first_arg = self.locals.get(code.co_varnames[0]) + * first_arg = self.locals.get(PyCode_GetVarnames(code)[0]) * func = get_func_in_mro(first_arg, code) - */ - __Pyx_TraceLine(177,0,__PYX_ERR(0, 177, __pyx_L1_error)) - __pyx_t_2 = (__pyx_v_func == Py_None); - __pyx_t_9 = (__pyx_t_2 != 0); - if (__pyx_t_9) { +*/ + __Pyx_TraceLine(194,38,0,__PYX_ERR(0, 194, __pyx_L1_error)) + __pyx_t_6 = (__pyx_v_func == Py_None); + if (__pyx_t_6) { } else { - __pyx_t_1 = __pyx_t_9; + __pyx_t_1 = __pyx_t_6; goto __pyx_L6_bool_binop_done; } - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_code, __pyx_n_s_co_argcount); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 177, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = PyObject_RichCompare(__pyx_t_3, __pyx_int_1, Py_GE); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 177, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 177, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_1 = __pyx_t_9; + __pyx_t_6 = (__pyx_v_code->co_argcount >= 1); + __pyx_t_1 = __pyx_t_6; __pyx_L6_bool_binop_done:; if (__pyx_t_1) { - /* "hunter/_event.pyx":178 + /* "hunter/_event.pyx":195 * # method is defined. * if func is None and code.co_argcount >= 1: - * first_arg = self.locals.get(code.co_varnames[0]) # <<<<<<<<<<<<<< + * first_arg = self.locals.get(PyCode_GetVarnames(code)[0]) # <<<<<<<<<<<<<< * func = get_func_in_mro(first_arg, code) * # If we still can't find the function, as will be the case with static methods, - */ - __Pyx_TraceLine(178,0,__PYX_ERR(0, 178, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_locals); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 178, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_get); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 178, __pyx_L1_error) +*/ + __Pyx_TraceLine(195,46,0,__PYX_ERR(0, 195, __pyx_L1_error)) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_locals); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 195, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_code, __pyx_n_s_co_varnames); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 178, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 178, __pyx_L1_error) + __pyx_t_3 = __pyx_t_4; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_7 = PyCode_GetVarnames(__pyx_v_code); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 195, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_7, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 195, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - } - } - __pyx_t_5 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_3, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_8); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 178, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_v_first_arg = __pyx_t_5; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_8}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 195, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_v_first_arg = __pyx_t_2; + __pyx_t_2 = 0; - /* "hunter/_event.pyx":179 + /* "hunter/_event.pyx":196 * if func is None and code.co_argcount >= 1: - * first_arg = self.locals.get(code.co_varnames[0]) + * first_arg = self.locals.get(PyCode_GetVarnames(code)[0]) * func = get_func_in_mro(first_arg, code) # <<<<<<<<<<<<<< * # If we still can't find the function, as will be the case with static methods, * # try looking at classes in global scope. - */ - __Pyx_TraceLine(179,0,__PYX_ERR(0, 179, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_get_func_in_mro); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 179, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_8 = NULL; - __pyx_t_7 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_8); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - __pyx_t_7 = 1; - } +*/ + __Pyx_TraceLine(196,56,0,__PYX_ERR(0, 196, __pyx_L1_error)) + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_get_func_in_mro); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_8); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_8, __pyx__function); + __pyx_t_5 = 0; } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_4)) { - PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_v_first_arg, __pyx_v_code}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 179, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_GOTREF(__pyx_t_5); - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { - PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_v_first_arg, __pyx_v_code}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 179, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_GOTREF(__pyx_t_5); - } else #endif { - __pyx_t_3 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 179, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (__pyx_t_8) { - __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_8); __pyx_t_8 = NULL; - } - __Pyx_INCREF(__pyx_v_first_arg); - __Pyx_GIVEREF(__pyx_v_first_arg); - PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_7, __pyx_v_first_arg); - __Pyx_INCREF(__pyx_v_code); - __Pyx_GIVEREF(__pyx_v_code); - PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_7, __pyx_v_code); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 179, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_v_first_arg, ((PyObject *)__pyx_v_code)}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); } - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF_SET(__pyx_v_func, __pyx_t_5); - __pyx_t_5 = 0; + __Pyx_DECREF_SET(__pyx_v_func, __pyx_t_2); + __pyx_t_2 = 0; - /* "hunter/_event.pyx":177 + /* "hunter/_event.pyx":194 * # methods, this should be the class (or an instance of the class) on which our * # method is defined. * if func is None and code.co_argcount >= 1: # <<<<<<<<<<<<<< - * first_arg = self.locals.get(code.co_varnames[0]) + * first_arg = self.locals.get(PyCode_GetVarnames(code)[0]) * func = get_func_in_mro(first_arg, code) - */ +*/ } - /* "hunter/_event.pyx":182 + /* "hunter/_event.pyx":199 * # If we still can't find the function, as will be the case with static methods, * # try looking at classes in global scope. * if func is None: # <<<<<<<<<<<<<< * for v in self.globals.values(): * if not isinstance(v, type): - */ - __Pyx_TraceLine(182,0,__PYX_ERR(0, 182, __pyx_L1_error)) +*/ + __Pyx_TraceLine(199,62,0,__PYX_ERR(0, 199, __pyx_L1_error)) __pyx_t_1 = (__pyx_v_func == Py_None); - __pyx_t_9 = (__pyx_t_1 != 0); - if (__pyx_t_9) { + if (__pyx_t_1) { - /* "hunter/_event.pyx":183 + /* "hunter/_event.pyx":200 * # try looking at classes in global scope. * if func is None: * for v in self.globals.values(): # <<<<<<<<<<<<<< * if not isinstance(v, type): * continue - */ - __Pyx_TraceLine(183,0,__PYX_ERR(0, 183, __pyx_L1_error)) - __pyx_t_10 = 0; - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_globals); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 183, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (unlikely(__pyx_t_4 == Py_None)) { +*/ + __Pyx_TraceLine(200,63,0,__PYX_ERR(0, 200, __pyx_L1_error)) + __pyx_t_9 = 0; + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_globals); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (unlikely(__pyx_t_8 == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "values"); - __PYX_ERR(0, 183, __pyx_L1_error) + __PYX_ERR(0, 200, __pyx_L1_error) } - __pyx_t_3 = __Pyx_dict_iterator(__pyx_t_4, 0, __pyx_n_s_values, (&__pyx_t_11), (&__pyx_t_7)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 183, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_XDECREF(__pyx_t_5); - __pyx_t_5 = __pyx_t_3; - __pyx_t_3 = 0; + __pyx_t_4 = __Pyx_dict_iterator(__pyx_t_8, 0, __pyx_mstate_global->__pyx_n_u_values, (&__pyx_t_10), (&__pyx_t_11)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_2); + __pyx_t_2 = __pyx_t_4; + __pyx_t_4 = 0; while (1) { - __pyx_t_12 = __Pyx_dict_iter_next(__pyx_t_5, __pyx_t_11, &__pyx_t_10, NULL, &__pyx_t_3, NULL, __pyx_t_7); + __pyx_t_12 = __Pyx_dict_iter_next(__pyx_t_2, __pyx_t_10, &__pyx_t_9, NULL, &__pyx_t_4, NULL, __pyx_t_11); if (unlikely(__pyx_t_12 == 0)) break; - if (unlikely(__pyx_t_12 == -1)) __PYX_ERR(0, 183, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_3); - __pyx_t_3 = 0; + if (unlikely(__pyx_t_12 == -1)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_4); + __pyx_t_4 = 0; - /* "hunter/_event.pyx":184 + /* "hunter/_event.pyx":201 * if func is None: * for v in self.globals.values(): * if not isinstance(v, type): # <<<<<<<<<<<<<< * continue * func = get_func_in_mro(v, code) - */ - __Pyx_TraceLine(184,0,__PYX_ERR(0, 184, __pyx_L1_error)) - __pyx_t_9 = PyType_Check(__pyx_v_v); - __pyx_t_1 = ((!(__pyx_t_9 != 0)) != 0); - if (__pyx_t_1) { +*/ + __Pyx_TraceLine(201,74,0,__PYX_ERR(0, 201, __pyx_L1_error)) + __pyx_t_1 = PyType_Check(__pyx_v_v); + __pyx_t_6 = (!__pyx_t_1); + if (__pyx_t_6) { - /* "hunter/_event.pyx":185 + /* "hunter/_event.pyx":202 * for v in self.globals.values(): * if not isinstance(v, type): * continue # <<<<<<<<<<<<<< * func = get_func_in_mro(v, code) * if func is not None: - */ - __Pyx_TraceLine(185,0,__PYX_ERR(0, 185, __pyx_L1_error)) +*/ + __Pyx_TraceLine(202,75,0,__PYX_ERR(0, 202, __pyx_L1_error)) goto __pyx_L9_continue; - /* "hunter/_event.pyx":184 + /* "hunter/_event.pyx":201 * if func is None: * for v in self.globals.values(): * if not isinstance(v, type): # <<<<<<<<<<<<<< * continue * func = get_func_in_mro(v, code) - */ +*/ } - /* "hunter/_event.pyx":186 + /* "hunter/_event.pyx":203 * if not isinstance(v, type): * continue * func = get_func_in_mro(v, code) # <<<<<<<<<<<<<< * if func is not None: * break - */ - __Pyx_TraceLine(186,0,__PYX_ERR(0, 186, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_get_func_in_mro); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 186, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); +*/ + __Pyx_TraceLine(203,78,0,__PYX_ERR(0, 203, __pyx_L1_error)) __pyx_t_8 = NULL; - __pyx_t_12 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_8); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - __pyx_t_12 = 1; - } + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_get_func_in_mro); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 203, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_8); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_5 = 0; } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_4)) { - PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_v_v, __pyx_v_code}; - __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 186, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_GOTREF(__pyx_t_3); - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { - PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_v_v, __pyx_v_code}; - __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 186, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_GOTREF(__pyx_t_3); - } else #endif { - __pyx_t_6 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 186, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (__pyx_t_8) { - __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_8); __pyx_t_8 = NULL; - } - __Pyx_INCREF(__pyx_v_v); - __Pyx_GIVEREF(__pyx_v_v); - PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_12, __pyx_v_v); - __Pyx_INCREF(__pyx_v_code); - __Pyx_GIVEREF(__pyx_v_code); - PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_12, __pyx_v_code); - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 186, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_v_v, ((PyObject *)__pyx_v_code)}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 203, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); } - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF_SET(__pyx_v_func, __pyx_t_3); - __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_func, __pyx_t_4); + __pyx_t_4 = 0; - /* "hunter/_event.pyx":187 + /* "hunter/_event.pyx":204 * continue * func = get_func_in_mro(v, code) * if func is not None: # <<<<<<<<<<<<<< * break * self._function_object = func - */ - __Pyx_TraceLine(187,0,__PYX_ERR(0, 187, __pyx_L1_error)) - __pyx_t_1 = (__pyx_v_func != Py_None); - __pyx_t_9 = (__pyx_t_1 != 0); - if (__pyx_t_9) { +*/ + __Pyx_TraceLine(204,84,0,__PYX_ERR(0, 204, __pyx_L1_error)) + __pyx_t_6 = (__pyx_v_func != Py_None); + if (__pyx_t_6) { - /* "hunter/_event.pyx":188 + /* "hunter/_event.pyx":205 * func = get_func_in_mro(v, code) * if func is not None: * break # <<<<<<<<<<<<<< * self._function_object = func * return self._function_object - */ - __Pyx_TraceLine(188,0,__PYX_ERR(0, 188, __pyx_L1_error)) +*/ + __Pyx_TraceLine(205,85,0,__PYX_ERR(0, 205, __pyx_L1_error)) goto __pyx_L10_break; - /* "hunter/_event.pyx":187 + /* "hunter/_event.pyx":204 * continue * func = get_func_in_mro(v, code) * if func is not None: # <<<<<<<<<<<<<< * break * self._function_object = func - */ +*/ } __pyx_L9_continue:; } __pyx_L10_break:; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "hunter/_event.pyx":182 + /* "hunter/_event.pyx":199 * # If we still can't find the function, as will be the case with static methods, * # try looking at classes in global scope. * if func is None: # <<<<<<<<<<<<<< * for v in self.globals.values(): * if not isinstance(v, type): - */ +*/ } - /* "hunter/_event.pyx":189 + /* "hunter/_event.pyx":206 * if func is not None: * break * self._function_object = func # <<<<<<<<<<<<<< * return self._function_object * - */ - __Pyx_TraceLine(189,0,__PYX_ERR(0, 189, __pyx_L1_error)) +*/ + __Pyx_TraceLine(206,86,0,__PYX_ERR(0, 206, __pyx_L1_error)) __Pyx_INCREF(__pyx_v_func); __Pyx_GIVEREF(__pyx_v_func); __Pyx_GOTREF(__pyx_v_self->_function_object); __Pyx_DECREF(__pyx_v_self->_function_object); __pyx_v_self->_function_object = __pyx_v_func; - /* "hunter/_event.pyx":166 - * @property - * def function_object(self): - * if self._function_object is UNSET: # <<<<<<<<<<<<<< - * code = self.code + /* "hunter/_event.pyx":183 + * if self.builtin: + * return self.builtin + * elif self._function_object is UNSET: # <<<<<<<<<<<<<< + * code = self.code_getter() * if code.co_name is None: - */ +*/ } - /* "hunter/_event.pyx":190 + /* "hunter/_event.pyx":207 * break * self._function_object = func * return self._function_object # <<<<<<<<<<<<<< * - * @property - */ - __Pyx_TraceLine(190,0,__PYX_ERR(0, 190, __pyx_L1_error)) + * cdef inline module_getter(self): +*/ + __Pyx_TraceLine(207,89,0,__PYX_ERR(0, 207, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->_function_object); __pyx_r = __pyx_v_self->_function_object; + __Pyx_TraceReturnValue(__pyx_r, 89, 0, __PYX_ERR(0, 207, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_event.pyx":165 + /* "hunter/_event.pyx":178 + * return self.function_getter() * - * @property - * def function_object(self): # <<<<<<<<<<<<<< - * if self._function_object is UNSET: - * code = self.code - */ + * @property # <<<<<<<<<<<<<< + * def function_object(self): + * cdef CodeType code +*/ /* function exit code */ __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 178, __pyx_L1_error)); + #endif __Pyx_AddTraceback("hunter._event.Event.function_object.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF(__pyx_v_code); + __Pyx_XDECREF((PyObject *)__pyx_v_code); __Pyx_XDECREF(__pyx_v_candidate); __Pyx_XDECREF(__pyx_v_func); __Pyx_XDECREF(__pyx_v_first_arg); __Pyx_XDECREF(__pyx_v_v); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_event.pyx":193 +/* "hunter/_event.pyx":209 + * return self._function_object * - * @property - * def module(self): # <<<<<<<<<<<<<< + * cdef inline module_getter(self): # <<<<<<<<<<<<<< * if self._module is UNSET: - * module = self.frame.f_globals.get('__name__', '') - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_6_event_5Event_6module_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_6_event_5Event_6module_1__get__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_6_event_5Event_6module___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + * if self.builtin: +*/ -static PyObject *__pyx_pf_6hunter_6_event_5Event_6module___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { +static PyObject *__pyx_f_6hunter_6_event_5Event_module_getter(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { PyObject *__pyx_v_module = NULL; PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations int __pyx_t_1; - int __pyx_t_2; + PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[0], 193, 0, __PYX_ERR(0, 193, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[18])) + __Pyx_RefNannySetupContext("module_getter", 0); + __Pyx_TraceStartFunc("module_getter", __pyx_f[0], 209, 0, 0, 0, __PYX_ERR(0, 209, __pyx_L1_error)); - /* "hunter/_event.pyx":194 - * @property - * def module(self): + /* "hunter/_event.pyx":210 + * + * cdef inline module_getter(self): * if self._module is UNSET: # <<<<<<<<<<<<<< - * module = self.frame.f_globals.get('__name__', '') - * if module is None: - */ - __Pyx_TraceLine(194,0,__PYX_ERR(0, 194, __pyx_L1_error)) + * if self.builtin: + * module = self.arg.__module__ +*/ + __Pyx_TraceLine(210,5,0,__PYX_ERR(0, 210, __pyx_L1_error)) __pyx_t_1 = (__pyx_v_self->_module == __pyx_v_6hunter_6_event_UNSET); - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { + if (__pyx_t_1) { - /* "hunter/_event.pyx":195 - * def module(self): + /* "hunter/_event.pyx":211 + * cdef inline module_getter(self): * if self._module is UNSET: - * module = self.frame.f_globals.get('__name__', '') # <<<<<<<<<<<<<< - * if module is None: - * module = '' - */ - __Pyx_TraceLine(195,0,__PYX_ERR(0, 195, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->frame->f_globals, __pyx_n_s_get); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 195, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 195, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_v_module = __pyx_t_4; - __pyx_t_4 = 0; + * if self.builtin: # <<<<<<<<<<<<<< + * module = self.arg.__module__ + * else: +*/ + __Pyx_TraceLine(211,8,0,__PYX_ERR(0, 211, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->builtin); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 211, __pyx_L1_error) + if (__pyx_t_1) { + + /* "hunter/_event.pyx":212 + * if self._module is UNSET: + * if self.builtin: + * module = self.arg.__module__ # <<<<<<<<<<<<<< + * else: + * module = self.globals.get('__name__', '') +*/ + __Pyx_TraceLine(212,12,0,__PYX_ERR(0, 212, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->arg, __pyx_mstate_global->__pyx_n_u_module_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_module = __pyx_t_2; + __pyx_t_2 = 0; - /* "hunter/_event.pyx":196 + /* "hunter/_event.pyx":211 + * cdef inline module_getter(self): * if self._module is UNSET: - * module = self.frame.f_globals.get('__name__', '') + * if self.builtin: # <<<<<<<<<<<<<< + * module = self.arg.__module__ + * else: +*/ + goto __pyx_L4; + } + + /* "hunter/_event.pyx":214 + * module = self.arg.__module__ + * else: + * module = self.globals.get('__name__', '') # <<<<<<<<<<<<<< + * if module is None: + * module = '?' +*/ + __Pyx_TraceLine(214,17,0,__PYX_ERR(0, 214, __pyx_L1_error)) + /*else*/ { + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_globals); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 214, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_get); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 214, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_mstate_global->__pyx_tuple[0], NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 214, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_module = __pyx_t_2; + __pyx_t_2 = 0; + } + __pyx_L4:; + + /* "hunter/_event.pyx":215 + * else: + * module = self.globals.get('__name__', '') * if module is None: # <<<<<<<<<<<<<< - * module = '' - * - */ - __Pyx_TraceLine(196,0,__PYX_ERR(0, 196, __pyx_L1_error)) - __pyx_t_2 = (__pyx_v_module == Py_None); - __pyx_t_1 = (__pyx_t_2 != 0); + * module = '?' + * self._module = module +*/ + __Pyx_TraceLine(215,23,0,__PYX_ERR(0, 215, __pyx_L1_error)) + __pyx_t_1 = (__pyx_v_module == Py_None); if (__pyx_t_1) { - /* "hunter/_event.pyx":197 - * module = self.frame.f_globals.get('__name__', '') + /* "hunter/_event.pyx":216 + * module = self.globals.get('__name__', '') * if module is None: - * module = '' # <<<<<<<<<<<<<< - * + * module = '?' # <<<<<<<<<<<<<< * self._module = module - */ - __Pyx_TraceLine(197,0,__PYX_ERR(0, 197, __pyx_L1_error)) - __Pyx_INCREF(__pyx_kp_s_); - __Pyx_DECREF_SET(__pyx_v_module, __pyx_kp_s_); + * return self._module +*/ + __Pyx_TraceLine(216,25,0,__PYX_ERR(0, 216, __pyx_L1_error)) + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u__3); + __Pyx_DECREF_SET(__pyx_v_module, __pyx_mstate_global->__pyx_kp_u__3); - /* "hunter/_event.pyx":196 - * if self._module is UNSET: - * module = self.frame.f_globals.get('__name__', '') + /* "hunter/_event.pyx":215 + * else: + * module = self.globals.get('__name__', '') * if module is None: # <<<<<<<<<<<<<< - * module = '' - * - */ + * module = '?' + * self._module = module +*/ } - /* "hunter/_event.pyx":199 - * module = '' - * + /* "hunter/_event.pyx":217 + * if module is None: + * module = '?' * self._module = module # <<<<<<<<<<<<<< * return self._module * - */ - __Pyx_TraceLine(199,0,__PYX_ERR(0, 199, __pyx_L1_error)) +*/ + __Pyx_TraceLine(217,26,0,__PYX_ERR(0, 217, __pyx_L1_error)) __Pyx_INCREF(__pyx_v_module); __Pyx_GIVEREF(__pyx_v_module); __Pyx_GOTREF(__pyx_v_self->_module); __Pyx_DECREF(__pyx_v_self->_module); __pyx_v_self->_module = __pyx_v_module; - /* "hunter/_event.pyx":194 - * @property - * def module(self): + /* "hunter/_event.pyx":210 + * + * cdef inline module_getter(self): * if self._module is UNSET: # <<<<<<<<<<<<<< - * module = self.frame.f_globals.get('__name__', '') - * if module is None: - */ + * if self.builtin: + * module = self.arg.__module__ +*/ } - /* "hunter/_event.pyx":200 - * + /* "hunter/_event.pyx":218 + * module = '?' * self._module = module * return self._module # <<<<<<<<<<<<<< * * @property - */ - __Pyx_TraceLine(200,0,__PYX_ERR(0, 200, __pyx_L1_error)) +*/ + __Pyx_TraceLine(218,29,0,__PYX_ERR(0, 218, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->_module); __pyx_r = __pyx_v_self->_module; + __Pyx_TraceReturnValue(__pyx_r, 29, 0, __PYX_ERR(0, 218, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_event.pyx":193 + /* "hunter/_event.pyx":209 + * return self._function_object * - * @property - * def module(self): # <<<<<<<<<<<<<< + * cdef inline module_getter(self): # <<<<<<<<<<<<<< * if self._module is UNSET: - * module = self.frame.f_globals.get('__name__', '') - */ + * if self.builtin: +*/ /* function exit code */ __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("hunter._event.Event.module.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 209, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.Event.module_getter", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_module); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_event.pyx":203 +/* "hunter/_event.pyx":220 + * return self._module * - * @property - * def filename(self): # <<<<<<<<<<<<<< - * if self._filename is UNSET: - * filename = self.frame.f_code.co_filename - */ + * @property # <<<<<<<<<<<<<< + * def module(self): + * return self.module_getter() +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_6_event_5Event_8filename_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_6_event_5Event_8filename_1__get__(PyObject *__pyx_v_self) { +static PyObject *__pyx_pw_6hunter_6_event_5Event_6module_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_6_event_5Event_6module_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_6_event_5Event_8filename___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_6_event_5Event_6module___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_6_event_5Event_8filename___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { +static PyObject *__pyx_pf_6hunter_6_event_5Event_6module___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[19])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[0], 220, 0, 0, 0, __PYX_ERR(0, 220, __pyx_L1_error)); + + /* "hunter/_event.pyx":222 + * @property + * def module(self): + * return self.module_getter() # <<<<<<<<<<<<<< + * + * cdef inline filename_getter(self): +*/ + __Pyx_TraceLine(222,1,0,__PYX_ERR(0, 222, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6hunter_6_event_5Event_module_getter(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 222, __pyx_L1_error)); + goto __pyx_L0; + + /* "hunter/_event.pyx":220 + * return self._module + * + * @property # <<<<<<<<<<<<<< + * def module(self): + * return self.module_getter() +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 220, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.Event.module.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/_event.pyx":224 + * return self.module_getter() + * + * cdef inline filename_getter(self): # <<<<<<<<<<<<<< + * cdef CodeType code + * if self._filename is UNSET: +*/ + +static PyObject *__pyx_f_6hunter_6_event_5Event_filename_getter(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { + PyCodeObject *__pyx_v_code = 0; PyObject *__pyx_v_filename = NULL; - PyObject *__pyx_v_basename = NULL; + PyObject *__pyx_v_cybasename = NULL; PyObject *__pyx_v_ext = NULL; PyObject *__pyx_v_cyfilename = NULL; PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations int __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; - int __pyx_t_6; + size_t __pyx_t_6; PyObject *__pyx_t_7 = NULL; Py_ssize_t __pyx_t_8; - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[0], 203, 0, __PYX_ERR(0, 203, __pyx_L1_error)); - - /* "hunter/_event.pyx":204 - * @property - * def filename(self): + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[20])) + __Pyx_RefNannySetupContext("filename_getter", 0); + __Pyx_TraceStartFunc("filename_getter", __pyx_f[0], 224, 0, 0, 0, __PYX_ERR(0, 224, __pyx_L1_error)); + + /* "hunter/_event.pyx":226 + * cdef inline filename_getter(self): + * cdef CodeType code * if self._filename is UNSET: # <<<<<<<<<<<<<< - * filename = self.frame.f_code.co_filename - * if not filename: - */ - __Pyx_TraceLine(204,0,__PYX_ERR(0, 204, __pyx_L1_error)) + * code = self.code_getter() + * filename = code.co_filename +*/ + __Pyx_TraceLine(226,5,0,__PYX_ERR(0, 226, __pyx_L1_error)) __pyx_t_1 = (__pyx_v_self->_filename == __pyx_v_6hunter_6_event_UNSET); - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { + if (__pyx_t_1) { - /* "hunter/_event.pyx":205 - * def filename(self): + /* "hunter/_event.pyx":227 + * cdef CodeType code * if self._filename is UNSET: - * filename = self.frame.f_code.co_filename # <<<<<<<<<<<<<< + * code = self.code_getter() # <<<<<<<<<<<<<< + * filename = code.co_filename * if not filename: - * filename = self.frame.f_globals.get('__file__') - */ - __Pyx_TraceLine(205,0,__PYX_ERR(0, 205, __pyx_L1_error)) - __pyx_t_3 = __pyx_v_self->frame->f_code->co_filename; - __Pyx_INCREF(__pyx_t_3); - __pyx_v_filename = __pyx_t_3; - __pyx_t_3 = 0; +*/ + __Pyx_TraceLine(227,9,0,__PYX_ERR(0, 227, __pyx_L1_error)) + __pyx_t_2 = ((PyObject *)__pyx_f_6hunter_6_event_5Event_code_getter(__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 227, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_code = ((PyCodeObject *)__pyx_t_2); + __pyx_t_2 = 0; - /* "hunter/_event.pyx":206 + /* "hunter/_event.pyx":228 * if self._filename is UNSET: - * filename = self.frame.f_code.co_filename + * code = self.code_getter() + * filename = code.co_filename # <<<<<<<<<<<<<< + * if not filename: + * filename = self.globals.get('__file__') +*/ + __Pyx_TraceLine(228,12,0,__PYX_ERR(0, 228, __pyx_L1_error)) + __pyx_t_2 = __pyx_v_code->co_filename; + __Pyx_INCREF(__pyx_t_2); + __pyx_v_filename = __pyx_t_2; + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":229 + * code = self.code_getter() + * filename = code.co_filename * if not filename: # <<<<<<<<<<<<<< - * filename = self.frame.f_globals.get('__file__') + * filename = self.globals.get('__file__') * if not filename: - */ - __Pyx_TraceLine(206,0,__PYX_ERR(0, 206, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_filename); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 206, __pyx_L1_error) - __pyx_t_1 = ((!__pyx_t_2) != 0); - if (__pyx_t_1) { +*/ + __Pyx_TraceLine(229,15,0,__PYX_ERR(0, 229, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_filename); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 229, __pyx_L1_error) + __pyx_t_3 = (!__pyx_t_1); + if (__pyx_t_3) { - /* "hunter/_event.pyx":207 - * filename = self.frame.f_code.co_filename + /* "hunter/_event.pyx":230 + * filename = code.co_filename * if not filename: - * filename = self.frame.f_globals.get('__file__') # <<<<<<<<<<<<<< + * filename = self.globals.get('__file__') # <<<<<<<<<<<<<< * if not filename: - * filename = '' - */ - __Pyx_TraceLine(207,0,__PYX_ERR(0, 207, __pyx_L1_error)) - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->frame->f_globals, __pyx_n_s_get); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 207, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - } + * filename = '?' +*/ + __Pyx_TraceLine(230,18,0,__PYX_ERR(0, 230, __pyx_L1_error)) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_globals); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __pyx_t_5; + __Pyx_INCREF(__pyx_t_4); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_n_u_file}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); } - __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_n_s_file) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_n_s_file); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 207, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF_SET(__pyx_v_filename, __pyx_t_3); - __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_filename, __pyx_t_2); + __pyx_t_2 = 0; - /* "hunter/_event.pyx":206 - * if self._filename is UNSET: - * filename = self.frame.f_code.co_filename + /* "hunter/_event.pyx":229 + * code = self.code_getter() + * filename = code.co_filename * if not filename: # <<<<<<<<<<<<<< - * filename = self.frame.f_globals.get('__file__') + * filename = self.globals.get('__file__') * if not filename: - */ +*/ } - /* "hunter/_event.pyx":208 + /* "hunter/_event.pyx":231 * if not filename: - * filename = self.frame.f_globals.get('__file__') + * filename = self.globals.get('__file__') * if not filename: # <<<<<<<<<<<<<< - * filename = '' + * filename = '?' * elif filename.endswith(('.pyc', '.pyo')): - */ - __Pyx_TraceLine(208,0,__PYX_ERR(0, 208, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_filename); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 208, __pyx_L1_error) - __pyx_t_2 = ((!__pyx_t_1) != 0); - if (__pyx_t_2) { +*/ + __Pyx_TraceLine(231,24,0,__PYX_ERR(0, 231, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_filename); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 231, __pyx_L1_error) + __pyx_t_1 = (!__pyx_t_3); + if (__pyx_t_1) { - /* "hunter/_event.pyx":209 - * filename = self.frame.f_globals.get('__file__') + /* "hunter/_event.pyx":232 + * filename = self.globals.get('__file__') * if not filename: - * filename = '' # <<<<<<<<<<<<<< + * filename = '?' # <<<<<<<<<<<<<< * elif filename.endswith(('.pyc', '.pyo')): * filename = filename[:-1] - */ - __Pyx_TraceLine(209,0,__PYX_ERR(0, 209, __pyx_L1_error)) - __Pyx_INCREF(__pyx_kp_s_); - __Pyx_DECREF_SET(__pyx_v_filename, __pyx_kp_s_); +*/ + __Pyx_TraceLine(232,26,0,__PYX_ERR(0, 232, __pyx_L1_error)) + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u__3); + __Pyx_DECREF_SET(__pyx_v_filename, __pyx_mstate_global->__pyx_kp_u__3); - /* "hunter/_event.pyx":208 + /* "hunter/_event.pyx":231 * if not filename: - * filename = self.frame.f_globals.get('__file__') + * filename = self.globals.get('__file__') * if not filename: # <<<<<<<<<<<<<< - * filename = '' + * filename = '?' * elif filename.endswith(('.pyc', '.pyo')): - */ +*/ goto __pyx_L5; } - /* "hunter/_event.pyx":210 + /* "hunter/_event.pyx":233 * if not filename: - * filename = '' + * filename = '?' * elif filename.endswith(('.pyc', '.pyo')): # <<<<<<<<<<<<<< * filename = filename[:-1] * elif filename.endswith(('.so', '.pyd')): - */ - __Pyx_TraceLine(210,0,__PYX_ERR(0, 210, __pyx_L1_error)) - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_filename, __pyx_n_s_endswith); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 210, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - } +*/ + __Pyx_TraceLine(233,27,0,__PYX_ERR(0, 233, __pyx_L1_error)) + __pyx_t_5 = __pyx_v_filename; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_tuple[1]}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_endswith, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); } - __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_tuple__3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_tuple__3); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 210, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 210, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_2) { + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 233, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_1) { - /* "hunter/_event.pyx":211 - * filename = '' + /* "hunter/_event.pyx":234 + * filename = '?' * elif filename.endswith(('.pyc', '.pyo')): * filename = filename[:-1] # <<<<<<<<<<<<<< * elif filename.endswith(('.so', '.pyd')): - * basename = CYTHON_SUFFIX_RE.sub('', filename) - */ - __Pyx_TraceLine(211,0,__PYX_ERR(0, 211, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_GetSlice(__pyx_v_filename, 0, -1L, NULL, NULL, &__pyx_slice__4, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 211, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF_SET(__pyx_v_filename, __pyx_t_3); - __pyx_t_3 = 0; + * cybasename = CYTHON_SUFFIX_RE.sub('', filename) +*/ + __Pyx_TraceLine(234,34,0,__PYX_ERR(0, 234, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyObject_GetSlice(__pyx_v_filename, 0, -1L, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_filename, __pyx_t_2); + __pyx_t_2 = 0; - /* "hunter/_event.pyx":210 + /* "hunter/_event.pyx":233 * if not filename: - * filename = '' + * filename = '?' * elif filename.endswith(('.pyc', '.pyo')): # <<<<<<<<<<<<<< * filename = filename[:-1] * elif filename.endswith(('.so', '.pyd')): - */ +*/ goto __pyx_L5; } - /* "hunter/_event.pyx":212 + /* "hunter/_event.pyx":235 * elif filename.endswith(('.pyc', '.pyo')): * filename = filename[:-1] * elif filename.endswith(('.so', '.pyd')): # <<<<<<<<<<<<<< - * basename = CYTHON_SUFFIX_RE.sub('', filename) + * cybasename = CYTHON_SUFFIX_RE.sub('', filename) * for ext in ('.pyx', '.py'): - */ - __Pyx_TraceLine(212,0,__PYX_ERR(0, 212, __pyx_L1_error)) - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_filename, __pyx_n_s_endswith); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 212, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - } +*/ + __Pyx_TraceLine(235,36,0,__PYX_ERR(0, 235, __pyx_L1_error)) + __pyx_t_5 = __pyx_v_filename; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_tuple[2]}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_endswith, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); } - __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_tuple__5) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_tuple__5); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 212, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 212, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_2) { + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_1) { - /* "hunter/_event.pyx":213 + /* "hunter/_event.pyx":236 * filename = filename[:-1] * elif filename.endswith(('.so', '.pyd')): - * basename = CYTHON_SUFFIX_RE.sub('', filename) # <<<<<<<<<<<<<< + * cybasename = CYTHON_SUFFIX_RE.sub('', filename) # <<<<<<<<<<<<<< * for ext in ('.pyx', '.py'): - * cyfilename = basename + ext - */ - __Pyx_TraceLine(213,0,__PYX_ERR(0, 213, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_CYTHON_SUFFIX_RE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 213, __pyx_L1_error) + * cyfilename = cybasename + ext +*/ + __Pyx_TraceLine(236,44,0,__PYX_ERR(0, 236, __pyx_L1_error)) + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_CYTHON_SUFFIX_RE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 236, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_sub); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 213, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_sub); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = NULL; - __pyx_t_6 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - __pyx_t_6 = 1; - } + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_7); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_7, __pyx__function); + __pyx_t_6 = 0; } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_5)) { - PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_kp_s_, __pyx_v_filename}; - __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 213, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_GOTREF(__pyx_t_3); - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { - PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_kp_s_, __pyx_v_filename}; - __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 213, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_GOTREF(__pyx_t_3); - } else #endif { - __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 213, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (__pyx_t_4) { - __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL; - } - __Pyx_INCREF(__pyx_kp_s_); - __Pyx_GIVEREF(__pyx_kp_s_); - PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_kp_s_); - __Pyx_INCREF(__pyx_v_filename); - __Pyx_GIVEREF(__pyx_v_filename); - PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_v_filename); - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 213, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u__2, __pyx_v_filename}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); } - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_basename = __pyx_t_3; - __pyx_t_3 = 0; + __pyx_v_cybasename = __pyx_t_2; + __pyx_t_2 = 0; - /* "hunter/_event.pyx":214 + /* "hunter/_event.pyx":237 * elif filename.endswith(('.so', '.pyd')): - * basename = CYTHON_SUFFIX_RE.sub('', filename) + * cybasename = CYTHON_SUFFIX_RE.sub('', filename) * for ext in ('.pyx', '.py'): # <<<<<<<<<<<<<< - * cyfilename = basename + ext + * cyfilename = cybasename + ext * if exists(cyfilename): - */ - __Pyx_TraceLine(214,0,__PYX_ERR(0, 214, __pyx_L1_error)) - __pyx_t_3 = __pyx_tuple__6; __Pyx_INCREF(__pyx_t_3); __pyx_t_8 = 0; +*/ + __Pyx_TraceLine(237,49,0,__PYX_ERR(0, 237, __pyx_L1_error)) + __pyx_t_2 = __pyx_mstate_global->__pyx_tuple[3]; __Pyx_INCREF(__pyx_t_2); + __pyx_t_8 = 0; for (;;) { if (__pyx_t_8 >= 2) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_8); __Pyx_INCREF(__pyx_t_5); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(0, 214, __pyx_L1_error) + __pyx_t_7 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_8)); #else - __pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 214, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_8); #endif - __Pyx_XDECREF_SET(__pyx_v_ext, __pyx_t_5); - __pyx_t_5 = 0; + ++__pyx_t_8; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 237, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_XDECREF_SET(__pyx_v_ext, ((PyObject*)__pyx_t_7)); + __pyx_t_7 = 0; + __Pyx_TraceLine(237,47,0,__PYX_ERR(0, 237, __pyx_L1_error)) - /* "hunter/_event.pyx":215 - * basename = CYTHON_SUFFIX_RE.sub('', filename) + /* "hunter/_event.pyx":238 + * cybasename = CYTHON_SUFFIX_RE.sub('', filename) * for ext in ('.pyx', '.py'): - * cyfilename = basename + ext # <<<<<<<<<<<<<< + * cyfilename = cybasename + ext # <<<<<<<<<<<<<< * if exists(cyfilename): * filename = cyfilename - */ - __Pyx_TraceLine(215,0,__PYX_ERR(0, 215, __pyx_L1_error)) - __pyx_t_5 = PyNumber_Add(__pyx_v_basename, __pyx_v_ext); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 215, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_XDECREF_SET(__pyx_v_cyfilename, __pyx_t_5); - __pyx_t_5 = 0; +*/ + __Pyx_TraceLine(238,54,0,__PYX_ERR(0, 238, __pyx_L1_error)) + __pyx_t_7 = PyNumber_Add(__pyx_v_cybasename, __pyx_v_ext); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_XDECREF_SET(__pyx_v_cyfilename, __pyx_t_7); + __pyx_t_7 = 0; - /* "hunter/_event.pyx":216 + /* "hunter/_event.pyx":239 * for ext in ('.pyx', '.py'): - * cyfilename = basename + ext + * cyfilename = cybasename + ext * if exists(cyfilename): # <<<<<<<<<<<<<< * filename = cyfilename * break - */ - __Pyx_TraceLine(216,0,__PYX_ERR(0, 216, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_exists); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 216, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_4 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_7); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_7, function); - } +*/ + __Pyx_TraceLine(239,58,0,__PYX_ERR(0, 239, __pyx_L1_error)) + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_exists); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_6 = 0; } - __pyx_t_5 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_4, __pyx_v_cyfilename) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_cyfilename); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 216, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_cyfilename}; + __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + } + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 239, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 216, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (__pyx_t_2) { + if (__pyx_t_1) { - /* "hunter/_event.pyx":217 - * cyfilename = basename + ext + /* "hunter/_event.pyx":240 + * cyfilename = cybasename + ext * if exists(cyfilename): * filename = cyfilename # <<<<<<<<<<<<<< * break * - */ - __Pyx_TraceLine(217,0,__PYX_ERR(0, 217, __pyx_L1_error)) +*/ + __Pyx_TraceLine(240,61,0,__PYX_ERR(0, 240, __pyx_L1_error)) __Pyx_INCREF(__pyx_v_cyfilename); __Pyx_DECREF_SET(__pyx_v_filename, __pyx_v_cyfilename); - /* "hunter/_event.pyx":218 + /* "hunter/_event.pyx":241 * if exists(cyfilename): * filename = cyfilename * break # <<<<<<<<<<<<<< * * self._filename = filename - */ - __Pyx_TraceLine(218,0,__PYX_ERR(0, 218, __pyx_L1_error)) +*/ + __Pyx_TraceLine(241,62,0,__PYX_ERR(0, 241, __pyx_L1_error)) goto __pyx_L7_break; - /* "hunter/_event.pyx":216 + /* "hunter/_event.pyx":239 * for ext in ('.pyx', '.py'): - * cyfilename = basename + ext + * cyfilename = cybasename + ext * if exists(cyfilename): # <<<<<<<<<<<<<< * filename = cyfilename * break - */ +*/ } - /* "hunter/_event.pyx":214 + /* "hunter/_event.pyx":237 * elif filename.endswith(('.so', '.pyd')): - * basename = CYTHON_SUFFIX_RE.sub('', filename) + * cybasename = CYTHON_SUFFIX_RE.sub('', filename) * for ext in ('.pyx', '.py'): # <<<<<<<<<<<<<< - * cyfilename = basename + ext + * cyfilename = cybasename + ext * if exists(cyfilename): - */ - __Pyx_TraceLine(214,0,__PYX_ERR(0, 214, __pyx_L1_error)) +*/ + __Pyx_TraceLine(237,47,0,__PYX_ERR(0, 237, __pyx_L1_error)) } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + goto __pyx_L9_for_end; __pyx_L7_break:; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + goto __pyx_L9_for_end; + __pyx_L9_for_end:; - /* "hunter/_event.pyx":212 + /* "hunter/_event.pyx":235 * elif filename.endswith(('.pyc', '.pyo')): * filename = filename[:-1] * elif filename.endswith(('.so', '.pyd')): # <<<<<<<<<<<<<< - * basename = CYTHON_SUFFIX_RE.sub('', filename) + * cybasename = CYTHON_SUFFIX_RE.sub('', filename) * for ext in ('.pyx', '.py'): - */ +*/ } __pyx_L5:; - /* "hunter/_event.pyx":220 + /* "hunter/_event.pyx":243 * break * * self._filename = filename # <<<<<<<<<<<<<< * return self._filename * - */ - __Pyx_TraceLine(220,0,__PYX_ERR(0, 220, __pyx_L1_error)) +*/ + __Pyx_TraceLine(243,63,0,__PYX_ERR(0, 243, __pyx_L1_error)) __Pyx_INCREF(__pyx_v_filename); __Pyx_GIVEREF(__pyx_v_filename); __Pyx_GOTREF(__pyx_v_self->_filename); __Pyx_DECREF(__pyx_v_self->_filename); __pyx_v_self->_filename = __pyx_v_filename; - /* "hunter/_event.pyx":204 - * @property - * def filename(self): + /* "hunter/_event.pyx":226 + * cdef inline filename_getter(self): + * cdef CodeType code * if self._filename is UNSET: # <<<<<<<<<<<<<< - * filename = self.frame.f_code.co_filename - * if not filename: - */ + * code = self.code_getter() + * filename = code.co_filename +*/ } - /* "hunter/_event.pyx":221 + /* "hunter/_event.pyx":244 * * self._filename = filename * return self._filename # <<<<<<<<<<<<<< * * @property - */ - __Pyx_TraceLine(221,0,__PYX_ERR(0, 221, __pyx_L1_error)) +*/ + __Pyx_TraceLine(244,66,0,__PYX_ERR(0, 244, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->_filename); __pyx_r = __pyx_v_self->_filename; + __Pyx_TraceReturnValue(__pyx_r, 66, 0, __PYX_ERR(0, 244, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_event.pyx":203 + /* "hunter/_event.pyx":224 + * return self.module_getter() * - * @property - * def filename(self): # <<<<<<<<<<<<<< + * cdef inline filename_getter(self): # <<<<<<<<<<<<<< + * cdef CodeType code * if self._filename is UNSET: - * filename = self.frame.f_code.co_filename - */ +*/ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_7); - __Pyx_AddTraceback("hunter._event.Event.filename.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 224, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.Event.filename_getter", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_code); __Pyx_XDECREF(__pyx_v_filename); - __Pyx_XDECREF(__pyx_v_basename); + __Pyx_XDECREF(__pyx_v_cybasename); __Pyx_XDECREF(__pyx_v_ext); __Pyx_XDECREF(__pyx_v_cyfilename); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_event.pyx":224 +/* "hunter/_event.pyx":246 + * return self._filename * - * @property - * def lineno(self): # <<<<<<<<<<<<<< - * if self._lineno is UNSET: - * self._lineno = self.frame.f_lineno - */ + * @property # <<<<<<<<<<<<<< + * def filename(self): + * return self.filename_getter() +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_6_event_5Event_6lineno_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_6_event_5Event_6lineno_1__get__(PyObject *__pyx_v_self) { +static PyObject *__pyx_pw_6hunter_6_event_5Event_8filename_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_6_event_5Event_8filename_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_6_event_5Event_6lineno___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_6_event_5Event_8filename___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_6_event_5Event_6lineno___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { +static PyObject *__pyx_pf_6hunter_6_event_5Event_8filename___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[21])) __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[0], 224, 0, __PYX_ERR(0, 224, __pyx_L1_error)); + __Pyx_TraceStartFunc("__get__", __pyx_f[0], 246, 0, 0, 0, __PYX_ERR(0, 246, __pyx_L1_error)); - /* "hunter/_event.pyx":225 + /* "hunter/_event.pyx":248 * @property - * def lineno(self): + * def filename(self): + * return self.filename_getter() # <<<<<<<<<<<<<< + * + * cdef inline lineno_getter(self): +*/ + __Pyx_TraceLine(248,1,0,__PYX_ERR(0, 248, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6hunter_6_event_5Event_filename_getter(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 248, __pyx_L1_error)); + goto __pyx_L0; + + /* "hunter/_event.pyx":246 + * return self._filename + * + * @property # <<<<<<<<<<<<<< + * def filename(self): + * return self.filename_getter() +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 246, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.Event.filename.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/_event.pyx":250 + * return self.filename_getter() + * + * cdef inline lineno_getter(self): # <<<<<<<<<<<<<< + * if self._lineno is UNSET: + * self._lineno = Hunter_PyFrame_GetLineNumber(self.frame) +*/ + +static PyObject *__pyx_f_6hunter_6_event_5Event_lineno_getter(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[22])) + __Pyx_RefNannySetupContext("lineno_getter", 0); + __Pyx_TraceStartFunc("lineno_getter", __pyx_f[0], 250, 0, 0, 0, __PYX_ERR(0, 250, __pyx_L1_error)); + + /* "hunter/_event.pyx":251 + * + * cdef inline lineno_getter(self): * if self._lineno is UNSET: # <<<<<<<<<<<<<< - * self._lineno = self.frame.f_lineno + * self._lineno = Hunter_PyFrame_GetLineNumber(self.frame) * return self._lineno - */ - __Pyx_TraceLine(225,0,__PYX_ERR(0, 225, __pyx_L1_error)) +*/ + __Pyx_TraceLine(251,5,0,__PYX_ERR(0, 251, __pyx_L1_error)) __pyx_t_1 = (__pyx_v_self->_lineno == __pyx_v_6hunter_6_event_UNSET); - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { + if (__pyx_t_1) { - /* "hunter/_event.pyx":226 - * def lineno(self): + /* "hunter/_event.pyx":252 + * cdef inline lineno_getter(self): * if self._lineno is UNSET: - * self._lineno = self.frame.f_lineno # <<<<<<<<<<<<<< + * self._lineno = Hunter_PyFrame_GetLineNumber(self.frame) # <<<<<<<<<<<<<< * return self._lineno * - */ - __Pyx_TraceLine(226,0,__PYX_ERR(0, 226, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->frame->f_lineno); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 226, __pyx_L1_error) +*/ + __Pyx_TraceLine(252,11,0,__PYX_ERR(0, 252, __pyx_L1_error)) + __pyx_t_2 = ((PyObject *)__pyx_v_self->frame); + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyLong_From_int(Hunter_PyFrame_GetLineNumber(((FrameType)__pyx_t_2))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GIVEREF(__pyx_t_3); __Pyx_GOTREF(__pyx_v_self->_lineno); __Pyx_DECREF(__pyx_v_self->_lineno); __pyx_v_self->_lineno = __pyx_t_3; __pyx_t_3 = 0; - /* "hunter/_event.pyx":225 - * @property - * def lineno(self): + /* "hunter/_event.pyx":251 + * + * cdef inline lineno_getter(self): * if self._lineno is UNSET: # <<<<<<<<<<<<<< - * self._lineno = self.frame.f_lineno + * self._lineno = Hunter_PyFrame_GetLineNumber(self.frame) * return self._lineno - */ +*/ } - /* "hunter/_event.pyx":227 + /* "hunter/_event.pyx":253 * if self._lineno is UNSET: - * self._lineno = self.frame.f_lineno + * self._lineno = Hunter_PyFrame_GetLineNumber(self.frame) * return self._lineno # <<<<<<<<<<<<<< * * @property - */ - __Pyx_TraceLine(227,0,__PYX_ERR(0, 227, __pyx_L1_error)) +*/ + __Pyx_TraceLine(253,12,0,__PYX_ERR(0, 253, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->_lineno); __pyx_r = __pyx_v_self->_lineno; + __Pyx_TraceReturnValue(__pyx_r, 12, 0, __PYX_ERR(0, 253, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_event.pyx":224 + /* "hunter/_event.pyx":250 + * return self.filename_getter() * - * @property - * def lineno(self): # <<<<<<<<<<<<<< + * cdef inline lineno_getter(self): # <<<<<<<<<<<<<< * if self._lineno is UNSET: - * self._lineno = self.frame.f_lineno - */ + * self._lineno = Hunter_PyFrame_GetLineNumber(self.frame) +*/ /* function exit code */ __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("hunter._event.Event.lineno.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 250, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.Event.lineno_getter", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_event.pyx":230 +/* "hunter/_event.pyx":255 + * return self._lineno * - * @property - * def code(self): # <<<<<<<<<<<<<< - * if self._code is UNSET: - * return self.frame.f_code - */ + * @property # <<<<<<<<<<<<<< + * def lineno(self): + * return self.lineno_getter() +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_6_event_5Event_4code_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_6_event_5Event_4code_1__get__(PyObject *__pyx_v_self) { +static PyObject *__pyx_pw_6hunter_6_event_5Event_6lineno_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_6_event_5Event_6lineno_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_6_event_5Event_4code___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_6_event_5Event_6lineno___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_6_event_5Event_4code___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { +static PyObject *__pyx_pf_6hunter_6_event_5Event_6lineno___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[23])) __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[0], 230, 0, __PYX_ERR(0, 230, __pyx_L1_error)); + __Pyx_TraceStartFunc("__get__", __pyx_f[0], 255, 0, 0, 0, __PYX_ERR(0, 255, __pyx_L1_error)); - /* "hunter/_event.pyx":231 + /* "hunter/_event.pyx":257 * @property - * def code(self): + * def lineno(self): + * return self.lineno_getter() # <<<<<<<<<<<<<< + * + * cdef inline CodeType code_getter(self): +*/ + __Pyx_TraceLine(257,1,0,__PYX_ERR(0, 257, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6hunter_6_event_5Event_lineno_getter(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 257, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 257, __pyx_L1_error)); + goto __pyx_L0; + + /* "hunter/_event.pyx":255 + * return self._lineno + * + * @property # <<<<<<<<<<<<<< + * def lineno(self): + * return self.lineno_getter() +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 255, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.Event.lineno.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/_event.pyx":259 + * return self.lineno_getter() + * + * cdef inline CodeType code_getter(self): # <<<<<<<<<<<<<< + * if self._code is UNSET: + * return Hunter_PyFrame_GetCode(self.frame) +*/ + +static PyCodeObject *__pyx_f_6hunter_6_event_5Event_code_getter(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { + PyCodeObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[24])) + __Pyx_RefNannySetupContext("code_getter", 0); + __Pyx_TraceStartFunc("code_getter", __pyx_f[0], 259, 0, 0, 0, __PYX_ERR(0, 259, __pyx_L1_error)); + + /* "hunter/_event.pyx":260 + * + * cdef inline CodeType code_getter(self): * if self._code is UNSET: # <<<<<<<<<<<<<< - * return self.frame.f_code + * return Hunter_PyFrame_GetCode(self.frame) * else: - */ - __Pyx_TraceLine(231,0,__PYX_ERR(0, 231, __pyx_L1_error)) +*/ + __Pyx_TraceLine(260,5,0,__PYX_ERR(0, 260, __pyx_L1_error)) __pyx_t_1 = (__pyx_v_self->_code == __pyx_v_6hunter_6_event_UNSET); - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { + if (__pyx_t_1) { - /* "hunter/_event.pyx":232 - * def code(self): + /* "hunter/_event.pyx":261 + * cdef inline CodeType code_getter(self): * if self._code is UNSET: - * return self.frame.f_code # <<<<<<<<<<<<<< + * return Hunter_PyFrame_GetCode(self.frame) # <<<<<<<<<<<<<< * else: * return self._code - */ - __Pyx_TraceLine(232,0,__PYX_ERR(0, 232, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_self->frame->f_code)); - __pyx_r = ((PyObject *)__pyx_v_self->frame->f_code); +*/ + __Pyx_TraceLine(261,6,0,__PYX_ERR(0, 261, __pyx_L1_error)) + __Pyx_XDECREF((PyObject *)__pyx_r); + __pyx_t_2 = ((PyObject *)__pyx_v_self->frame); + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = ((PyObject *)Hunter_PyFrame_GetCode(((FrameType)__pyx_t_2))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = ((PyCodeObject *)__pyx_t_3); + __pyx_t_3 = 0; + __Pyx_TraceReturnValue((PyObject *)__pyx_r, 6, 0, __PYX_ERR(0, 261, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_event.pyx":231 - * @property - * def code(self): + /* "hunter/_event.pyx":260 + * + * cdef inline CodeType code_getter(self): * if self._code is UNSET: # <<<<<<<<<<<<<< - * return self.frame.f_code + * return Hunter_PyFrame_GetCode(self.frame) * else: - */ +*/ } - /* "hunter/_event.pyx":234 - * return self.frame.f_code + /* "hunter/_event.pyx":263 + * return Hunter_PyFrame_GetCode(self.frame) * else: * return self._code # <<<<<<<<<<<<<< * * @property - */ - __Pyx_TraceLine(234,0,__PYX_ERR(0, 234, __pyx_L1_error)) +*/ + __Pyx_TraceLine(263,11,0,__PYX_ERR(0, 263, __pyx_L1_error)) /*else*/ { - __Pyx_XDECREF(__pyx_r); + __Pyx_XDECREF((PyObject *)__pyx_r); + if (!(likely(((__pyx_v_self->_code) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_self->_code, __pyx_mstate_global->__pyx_ptype_6hunter_6_event_CodeType))))) __PYX_ERR(0, 263, __pyx_L1_error) __Pyx_INCREF(__pyx_v_self->_code); - __pyx_r = __pyx_v_self->_code; + __pyx_r = ((PyCodeObject *)__pyx_v_self->_code); + __Pyx_TraceReturnValue((PyObject *)__pyx_r, 11, 0, __PYX_ERR(0, 263, __pyx_L1_error)); goto __pyx_L0; } - /* "hunter/_event.pyx":230 + /* "hunter/_event.pyx":259 + * return self.lineno_getter() * - * @property - * def code(self): # <<<<<<<<<<<<<< + * cdef inline CodeType code_getter(self): # <<<<<<<<<<<<<< * if self._code is UNSET: - * return self.frame.f_code - */ + * return Hunter_PyFrame_GetCode(self.frame) +*/ /* function exit code */ __pyx_L1_error:; - __Pyx_AddTraceback("hunter._event.Event.code.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 259, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.Event.code_getter", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_event.pyx":237 +/* "hunter/_event.pyx":265 + * return self._code * - * @property - * def stdlib(self): # <<<<<<<<<<<<<< - * if self._stdlib is UNSET: - * module_parts = self.module.split('.') - */ + * @property # <<<<<<<<<<<<<< + * def code(self): + * return self.code_getter() +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_6_event_5Event_6stdlib_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_6_event_5Event_6stdlib_1__get__(PyObject *__pyx_v_self) { +static PyObject *__pyx_pw_6hunter_6_event_5Event_4code_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_6_event_5Event_4code_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_6_event_5Event_6stdlib___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_6_event_5Event_4code___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_6_event_5Event_6stdlib___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { +static PyObject *__pyx_pf_6hunter_6_event_5Event_4code___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[25])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[0], 265, 0, 0, 0, __PYX_ERR(0, 265, __pyx_L1_error)); + + /* "hunter/_event.pyx":267 + * @property + * def code(self): + * return self.code_getter() # <<<<<<<<<<<<<< + * + * cdef inline stdlib_getter(self): +*/ + __Pyx_TraceLine(267,1,0,__PYX_ERR(0, 267, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_6hunter_6_event_5Event_code_getter(__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 267, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 267, __pyx_L1_error)); + goto __pyx_L0; + + /* "hunter/_event.pyx":265 + * return self._code + * + * @property # <<<<<<<<<<<<<< + * def code(self): + * return self.code_getter() +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 265, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.Event.code.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/_event.pyx":269 + * return self.code_getter() + * + * cdef inline stdlib_getter(self): # <<<<<<<<<<<<<< + * if self._stdlib is UNSET: + * module_parts = self.module.split('.') +*/ + +static PyObject *__pyx_f_6hunter_6_event_5Event_stdlib_getter(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { PyObject *__pyx_v_module_parts = NULL; PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations int __pyx_t_1; - int __pyx_t_2; + PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[0], 237, 0, __PYX_ERR(0, 237, __pyx_L1_error)); - - /* "hunter/_event.pyx":238 - * @property - * def stdlib(self): + size_t __pyx_t_5; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[26])) + __Pyx_RefNannySetupContext("stdlib_getter", 0); + __Pyx_TraceStartFunc("stdlib_getter", __pyx_f[0], 269, 0, 0, 0, __PYX_ERR(0, 269, __pyx_L1_error)); + + /* "hunter/_event.pyx":270 + * + * cdef inline stdlib_getter(self): * if self._stdlib is UNSET: # <<<<<<<<<<<<<< * module_parts = self.module.split('.') * if 'pkg_resources' in module_parts: - */ - __Pyx_TraceLine(238,0,__PYX_ERR(0, 238, __pyx_L1_error)) +*/ + __Pyx_TraceLine(270,5,0,__PYX_ERR(0, 270, __pyx_L1_error)) __pyx_t_1 = (__pyx_v_self->_stdlib == __pyx_v_6hunter_6_event_UNSET); - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { + if (__pyx_t_1) { - /* "hunter/_event.pyx":239 - * def stdlib(self): + /* "hunter/_event.pyx":271 + * cdef inline stdlib_getter(self): * if self._stdlib is UNSET: * module_parts = self.module.split('.') # <<<<<<<<<<<<<< * if 'pkg_resources' in module_parts: * # skip this over-vendored module - */ - __Pyx_TraceLine(239,0,__PYX_ERR(0, 239, __pyx_L1_error)) - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_module); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 239, __pyx_L1_error) +*/ + __Pyx_TraceLine(271,8,0,__PYX_ERR(0, 271, __pyx_L1_error)) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_module_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 271, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_split); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 239, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - } + __pyx_t_3 = __pyx_t_4; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u__4}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_split, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 271, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); } - __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_4, __pyx_kp_s__7) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_kp_s__7); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 239, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_module_parts = __pyx_t_3; - __pyx_t_3 = 0; + __pyx_v_module_parts = __pyx_t_2; + __pyx_t_2 = 0; - /* "hunter/_event.pyx":240 + /* "hunter/_event.pyx":272 * if self._stdlib is UNSET: * module_parts = self.module.split('.') * if 'pkg_resources' in module_parts: # <<<<<<<<<<<<<< * # skip this over-vendored module * self._stdlib = True - */ - __Pyx_TraceLine(240,0,__PYX_ERR(0, 240, __pyx_L1_error)) - __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_n_s_pkg_resources, __pyx_v_module_parts, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 240, __pyx_L1_error) - __pyx_t_1 = (__pyx_t_2 != 0); +*/ + __Pyx_TraceLine(272,15,0,__PYX_ERR(0, 272, __pyx_L1_error)) + __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_mstate_global->__pyx_n_u_pkg_resources, __pyx_v_module_parts, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 272, __pyx_L1_error) if (__pyx_t_1) { - /* "hunter/_event.pyx":242 + /* "hunter/_event.pyx":274 * if 'pkg_resources' in module_parts: * # skip this over-vendored module * self._stdlib = True # <<<<<<<<<<<<<< * elif self.filename == '' and (self.module.startswith('namedtuple_') or self.module == 'site'): * # skip namedtuple exec garbage - */ - __Pyx_TraceLine(242,0,__PYX_ERR(0, 242, __pyx_L1_error)) +*/ + __Pyx_TraceLine(274,16,0,__PYX_ERR(0, 274, __pyx_L1_error)) __Pyx_INCREF(Py_True); __Pyx_GIVEREF(Py_True); __Pyx_GOTREF(__pyx_v_self->_stdlib); __Pyx_DECREF(__pyx_v_self->_stdlib); __pyx_v_self->_stdlib = Py_True; - /* "hunter/_event.pyx":240 + /* "hunter/_event.pyx":272 * if self._stdlib is UNSET: * module_parts = self.module.split('.') * if 'pkg_resources' in module_parts: # <<<<<<<<<<<<<< * # skip this over-vendored module * self._stdlib = True - */ +*/ goto __pyx_L4; } - /* "hunter/_event.pyx":243 + /* "hunter/_event.pyx":275 * # skip this over-vendored module * self._stdlib = True * elif self.filename == '' and (self.module.startswith('namedtuple_') or self.module == 'site'): # <<<<<<<<<<<<<< * # skip namedtuple exec garbage * self._stdlib = True - */ - __Pyx_TraceLine(243,0,__PYX_ERR(0, 243, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_filename); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 243, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_kp_s_string, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 243, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_2) { +*/ + __Pyx_TraceLine(275,20,0,__PYX_ERR(0, 275, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_filename_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 275, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_mstate_global->__pyx_kp_u_string, Py_EQ)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 275, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_6) { } else { - __pyx_t_1 = __pyx_t_2; + __pyx_t_1 = __pyx_t_6; goto __pyx_L5_bool_binop_done; } - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_module); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 243, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_startswith); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 243, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - } - } - __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_n_s_namedtuple) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_n_s_namedtuple); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 243, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_module_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 243, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (!__pyx_t_2) { + __pyx_t_4 = __pyx_t_3; + __Pyx_INCREF(__pyx_t_4); + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_n_u_namedtuple}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_startswith, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 275, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 275, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (!__pyx_t_6) { } else { - __pyx_t_1 = __pyx_t_2; + __pyx_t_1 = __pyx_t_6; goto __pyx_L5_bool_binop_done; } - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_module); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 243, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_n_s_site, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 243, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_1 = __pyx_t_2; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_module_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 275, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_site, Py_EQ)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 275, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_1 = __pyx_t_6; __pyx_L5_bool_binop_done:; if (__pyx_t_1) { - /* "hunter/_event.pyx":245 + /* "hunter/_event.pyx":277 * elif self.filename == '' and (self.module.startswith('namedtuple_') or self.module == 'site'): * # skip namedtuple exec garbage * self._stdlib = True # <<<<<<<<<<<<<< * elif self.filename.startswith(SITE_PACKAGES_PATHS): - * # if it's in site-packages then its definitely not stdlib - */ - __Pyx_TraceLine(245,0,__PYX_ERR(0, 245, __pyx_L1_error)) + * # if in site-packages then definitely not stdlib +*/ + __Pyx_TraceLine(277,34,0,__PYX_ERR(0, 277, __pyx_L1_error)) __Pyx_INCREF(Py_True); __Pyx_GIVEREF(Py_True); __Pyx_GOTREF(__pyx_v_self->_stdlib); __Pyx_DECREF(__pyx_v_self->_stdlib); __pyx_v_self->_stdlib = Py_True; - /* "hunter/_event.pyx":243 + /* "hunter/_event.pyx":275 * # skip this over-vendored module * self._stdlib = True * elif self.filename == '' and (self.module.startswith('namedtuple_') or self.module == 'site'): # <<<<<<<<<<<<<< * # skip namedtuple exec garbage * self._stdlib = True - */ +*/ goto __pyx_L4; } - /* "hunter/_event.pyx":246 + /* "hunter/_event.pyx":278 * # skip namedtuple exec garbage * self._stdlib = True * elif self.filename.startswith(SITE_PACKAGES_PATHS): # <<<<<<<<<<<<<< - * # if it's in site-packages then its definitely not stdlib + * # if in site-packages then definitely not stdlib * self._stdlib = False - */ - __Pyx_TraceLine(246,0,__PYX_ERR(0, 246, __pyx_L1_error)) - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_filename); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 246, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_startswith); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 246, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_SITE_PACKAGES_PATHS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 246, __pyx_L1_error) +*/ + __Pyx_TraceLine(278,38,0,__PYX_ERR(0, 278, __pyx_L1_error)) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_filename_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 278, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_6 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_6)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_6); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - } + __pyx_t_3 = __pyx_t_4; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_SITE_PACKAGES_PATHS); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 278, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_7}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_startswith, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 278, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); } - __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4); - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 246, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 246, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 278, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__pyx_t_1) { - /* "hunter/_event.pyx":248 + /* "hunter/_event.pyx":280 * elif self.filename.startswith(SITE_PACKAGES_PATHS): - * # if it's in site-packages then its definitely not stdlib + * # if in site-packages then definitely not stdlib * self._stdlib = False # <<<<<<<<<<<<<< * elif self.filename.startswith(SYS_PREFIX_PATHS): * self._stdlib = True - */ - __Pyx_TraceLine(248,0,__PYX_ERR(0, 248, __pyx_L1_error)) +*/ + __Pyx_TraceLine(280,42,0,__PYX_ERR(0, 280, __pyx_L1_error)) __Pyx_INCREF(Py_False); __Pyx_GIVEREF(Py_False); __Pyx_GOTREF(__pyx_v_self->_stdlib); __Pyx_DECREF(__pyx_v_self->_stdlib); __pyx_v_self->_stdlib = Py_False; - /* "hunter/_event.pyx":246 + /* "hunter/_event.pyx":278 * # skip namedtuple exec garbage * self._stdlib = True * elif self.filename.startswith(SITE_PACKAGES_PATHS): # <<<<<<<<<<<<<< - * # if it's in site-packages then its definitely not stdlib + * # if in site-packages then definitely not stdlib * self._stdlib = False - */ +*/ goto __pyx_L4; } - /* "hunter/_event.pyx":249 - * # if it's in site-packages then its definitely not stdlib + /* "hunter/_event.pyx":281 + * # if in site-packages then definitely not stdlib * self._stdlib = False * elif self.filename.startswith(SYS_PREFIX_PATHS): # <<<<<<<<<<<<<< * self._stdlib = True * else: - */ - __Pyx_TraceLine(249,0,__PYX_ERR(0, 249, __pyx_L1_error)) - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_filename); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 249, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_startswith); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 249, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_SYS_PREFIX_PATHS); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 249, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_6)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_6); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - } - } - __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 249, __pyx_L1_error) +*/ + __Pyx_TraceLine(281,46,0,__PYX_ERR(0, 281, __pyx_L1_error)) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_filename_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_4 = __pyx_t_7; + __Pyx_INCREF(__pyx_t_4); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_SYS_PREFIX_PATHS); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 281, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 249, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_startswith, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 281, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__pyx_t_1) { - /* "hunter/_event.pyx":250 + /* "hunter/_event.pyx":282 * self._stdlib = False * elif self.filename.startswith(SYS_PREFIX_PATHS): * self._stdlib = True # <<<<<<<<<<<<<< * else: * self._stdlib = False - */ - __Pyx_TraceLine(250,0,__PYX_ERR(0, 250, __pyx_L1_error)) +*/ + __Pyx_TraceLine(282,50,0,__PYX_ERR(0, 282, __pyx_L1_error)) __Pyx_INCREF(Py_True); __Pyx_GIVEREF(Py_True); __Pyx_GOTREF(__pyx_v_self->_stdlib); __Pyx_DECREF(__pyx_v_self->_stdlib); __pyx_v_self->_stdlib = Py_True; - /* "hunter/_event.pyx":249 - * # if it's in site-packages then its definitely not stdlib + /* "hunter/_event.pyx":281 + * # if in site-packages then definitely not stdlib * self._stdlib = False * elif self.filename.startswith(SYS_PREFIX_PATHS): # <<<<<<<<<<<<<< * self._stdlib = True * else: - */ +*/ goto __pyx_L4; } - /* "hunter/_event.pyx":252 + /* "hunter/_event.pyx":284 * self._stdlib = True * else: * self._stdlib = False # <<<<<<<<<<<<<< * return self._stdlib * - */ - __Pyx_TraceLine(252,0,__PYX_ERR(0, 252, __pyx_L1_error)) +*/ + __Pyx_TraceLine(284,55,0,__PYX_ERR(0, 284, __pyx_L1_error)) /*else*/ { __Pyx_INCREF(Py_False); __Pyx_GIVEREF(Py_False); @@ -5838,84 +8063,155 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_6stdlib___get__(struct __pyx_ob } __pyx_L4:; - /* "hunter/_event.pyx":238 - * @property - * def stdlib(self): + /* "hunter/_event.pyx":270 + * + * cdef inline stdlib_getter(self): * if self._stdlib is UNSET: # <<<<<<<<<<<<<< * module_parts = self.module.split('.') * if 'pkg_resources' in module_parts: - */ +*/ } - /* "hunter/_event.pyx":253 + /* "hunter/_event.pyx":285 * else: * self._stdlib = False * return self._stdlib # <<<<<<<<<<<<<< * * @property - */ - __Pyx_TraceLine(253,0,__PYX_ERR(0, 253, __pyx_L1_error)) +*/ + __Pyx_TraceLine(285,56,0,__PYX_ERR(0, 285, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->_stdlib); __pyx_r = __pyx_v_self->_stdlib; + __Pyx_TraceReturnValue(__pyx_r, 56, 0, __PYX_ERR(0, 285, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_event.pyx":237 + /* "hunter/_event.pyx":269 + * return self.code_getter() * - * @property - * def stdlib(self): # <<<<<<<<<<<<<< + * cdef inline stdlib_getter(self): # <<<<<<<<<<<<<< * if self._stdlib is UNSET: * module_parts = self.module.split('.') - */ +*/ /* function exit code */ __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_AddTraceback("hunter._event.Event.stdlib.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_XDECREF(__pyx_t_7); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 269, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.Event.stdlib_getter", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_module_parts); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_event.pyx":256 - * - * @property - * def fullsource(self): # <<<<<<<<<<<<<< - * cdef list lines +/* "hunter/_event.pyx":287 + * return self._stdlib * - */ + * @property # <<<<<<<<<<<<<< + * def stdlib(self): + * return self.stdlib_getter() +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_6_event_5Event_10fullsource_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_6_event_5Event_10fullsource_1__get__(PyObject *__pyx_v_self) { +static PyObject *__pyx_pw_6hunter_6_event_5Event_6stdlib_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_6_event_5Event_6stdlib_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_6_event_5Event_10fullsource___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_6_event_5Event_6stdlib___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_6_event_5Event_10fullsource___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { +static PyObject *__pyx_pf_6hunter_6_event_5Event_6stdlib___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[27])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[0], 287, 0, 0, 0, __PYX_ERR(0, 287, __pyx_L1_error)); + + /* "hunter/_event.pyx":289 + * @property + * def stdlib(self): + * return self.stdlib_getter() # <<<<<<<<<<<<<< + * + * cdef inline fullsource_getter(self): +*/ + __Pyx_TraceLine(289,1,0,__PYX_ERR(0, 289, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6hunter_6_event_5Event_stdlib_getter(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 289, __pyx_L1_error)); + goto __pyx_L0; + + /* "hunter/_event.pyx":287 + * return self._stdlib + * + * @property # <<<<<<<<<<<<<< + * def stdlib(self): + * return self.stdlib_getter() +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 287, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.Event.stdlib.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/_event.pyx":291 + * return self.stdlib_getter() + * + * cdef inline fullsource_getter(self): # <<<<<<<<<<<<<< + * cdef list lines + * cdef CodeType code +*/ + +static PyObject *__pyx_f_6hunter_6_event_5Event_fullsource_getter(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { PyObject *__pyx_v_lines = 0; + PyCodeObject *__pyx_v_code = 0; CYTHON_UNUSED PyObject *__pyx_v__ = NULL; PyObject *__pyx_v_token = NULL; - CYTHON_UNUSED PyObject *__pyx_v_line = NULL; PyObject *__pyx_v_exc = NULL; PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations int __pyx_t_1; - int __pyx_t_2; + PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; @@ -5933,487 +8229,524 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_10fullsource___get__(struct __p PyObject *__pyx_t_17 = NULL; PyObject *__pyx_t_18 = NULL; PyObject *__pyx_t_19 = NULL; - int __pyx_t_20; + PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; - Py_ssize_t __pyx_t_22; - PyObject *(*__pyx_t_23)(PyObject *); - PyObject *(*__pyx_t_24)(PyObject *); - int __pyx_t_25; - char const *__pyx_t_26; - PyObject *__pyx_t_27 = NULL; - PyObject *__pyx_t_28 = NULL; - PyObject *__pyx_t_29 = NULL; - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[0], 256, 0, __PYX_ERR(0, 256, __pyx_L1_error)); - - /* "hunter/_event.pyx":259 - * cdef list lines + PyObject *__pyx_t_22 = NULL; + size_t __pyx_t_23; + Py_ssize_t __pyx_t_24; + PyObject *(*__pyx_t_25)(PyObject *); + PyObject *(*__pyx_t_26)(PyObject *); + int __pyx_t_27; + int __pyx_t_28; + char const *__pyx_t_29; + PyObject *__pyx_t_30 = NULL; + PyObject *__pyx_t_31 = NULL; + PyObject *__pyx_t_32 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[28])) + __Pyx_RefNannySetupContext("fullsource_getter", 0); + __Pyx_TraceStartFunc("fullsource_getter", __pyx_f[0], 291, 0, 0, 0, __PYX_ERR(0, 291, __pyx_L1_error)); + + /* "hunter/_event.pyx":295 + * cdef CodeType code * * if self._fullsource is UNSET: # <<<<<<<<<<<<<< * try: * self._fullsource = None - */ - __Pyx_TraceLine(259,0,__PYX_ERR(0, 259, __pyx_L1_error)) +*/ + __Pyx_TraceLine(295,5,0,__PYX_ERR(0, 295, __pyx_L1_error)) __pyx_t_1 = (__pyx_v_self->_fullsource == __pyx_v_6hunter_6_event_UNSET); - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { + if (__pyx_t_1) { - /* "hunter/_event.pyx":260 + /* "hunter/_event.pyx":296 * * if self._fullsource is UNSET: * try: # <<<<<<<<<<<<<< * self._fullsource = None - * - */ - __Pyx_TraceLine(260,0,__PYX_ERR(0, 260, __pyx_L1_error)) + * code = self.code_getter() +*/ + __Pyx_TraceLine(296,6,0,__PYX_ERR(0, 296, __pyx_L1_error)) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5); + __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); - __Pyx_XGOTREF(__pyx_t_5); /*try:*/ { - /* "hunter/_event.pyx":261 + /* "hunter/_event.pyx":297 * if self._fullsource is UNSET: * try: * self._fullsource = None # <<<<<<<<<<<<<< - * - * if self.kind == 'call' and self.frame.f_code.co_name != "": - */ - __Pyx_TraceLine(261,0,__PYX_ERR(0, 261, __pyx_L4_error)) + * code = self.code_getter() + * if self.kind == 'call' and code.co_name != '': +*/ + __Pyx_TraceLine(297,7,0,__PYX_ERR(0, 297, __pyx_L4_error)) __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->_fullsource); __Pyx_DECREF(__pyx_v_self->_fullsource); __pyx_v_self->_fullsource = Py_None; - /* "hunter/_event.pyx":263 + /* "hunter/_event.pyx":298 + * try: * self._fullsource = None - * - * if self.kind == 'call' and self.frame.f_code.co_name != "": # <<<<<<<<<<<<<< + * code = self.code_getter() # <<<<<<<<<<<<<< + * if self.kind == 'call' and code.co_name != '': + * lines = [] +*/ + __Pyx_TraceLine(298,13,0,__PYX_ERR(0, 298, __pyx_L4_error)) + __pyx_t_5 = ((PyObject *)__pyx_f_6hunter_6_event_5Event_code_getter(__pyx_v_self)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 298, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_v_code = ((PyCodeObject *)__pyx_t_5); + __pyx_t_5 = 0; + + /* "hunter/_event.pyx":299 + * self._fullsource = None + * code = self.code_getter() + * if self.kind == 'call' and code.co_name != '': # <<<<<<<<<<<<<< * lines = [] * try: - */ - __Pyx_TraceLine(263,0,__PYX_ERR(0, 263, __pyx_L4_error)) - __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_self->kind, __pyx_n_s_call, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 263, __pyx_L4_error) - __pyx_t_6 = (__pyx_t_1 != 0); +*/ + __Pyx_TraceLine(299,16,0,__PYX_ERR(0, 299, __pyx_L4_error)) + __pyx_t_6 = (__Pyx_PyUnicode_Equals(__pyx_v_self->kind, __pyx_mstate_global->__pyx_n_u_call, Py_EQ)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 299, __pyx_L4_error) if (__pyx_t_6) { } else { - __pyx_t_2 = __pyx_t_6; + __pyx_t_1 = __pyx_t_6; goto __pyx_L11_bool_binop_done; } - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->frame->f_code), __pyx_n_s_co_name); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 263, __pyx_L4_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_t_7, __pyx_kp_s_module_2, Py_NE)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 263, __pyx_L4_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_2 = __pyx_t_6; + __pyx_t_6 = (__Pyx_PyUnicode_Equals(__pyx_v_code->co_name, __pyx_mstate_global->__pyx_kp_u_module_4, Py_NE)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 299, __pyx_L4_error) + __pyx_t_1 = __pyx_t_6; __pyx_L11_bool_binop_done:; - if (__pyx_t_2) { + if (__pyx_t_1) { - /* "hunter/_event.pyx":264 - * - * if self.kind == 'call' and self.frame.f_code.co_name != "": + /* "hunter/_event.pyx":300 + * code = self.code_getter() + * if self.kind == 'call' and code.co_name != '': * lines = [] # <<<<<<<<<<<<<< * try: - * for _, token, _, _, line in generate_tokens(partial( - */ - __Pyx_TraceLine(264,0,__PYX_ERR(0, 264, __pyx_L4_error)) - __pyx_t_7 = PyList_New(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 264, __pyx_L4_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_v_lines = ((PyObject*)__pyx_t_7); - __pyx_t_7 = 0; - - /* "hunter/_event.pyx":265 - * if self.kind == 'call' and self.frame.f_code.co_name != "": + * for _, token, _, _, _ in generate_tokens( +*/ + __Pyx_TraceLine(300,25,0,__PYX_ERR(0, 300, __pyx_L4_error)) + __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 300, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_v_lines = ((PyObject*)__pyx_t_5); + __pyx_t_5 = 0; + + /* "hunter/_event.pyx":301 + * if self.kind == 'call' and code.co_name != '': * lines = [] * try: # <<<<<<<<<<<<<< - * for _, token, _, _, line in generate_tokens(partial( - * next, - */ - __Pyx_TraceLine(265,0,__PYX_ERR(0, 265, __pyx_L4_error)) + * for _, token, _, _, _ in generate_tokens( + * partial( +*/ + __Pyx_TraceLine(301,26,0,__PYX_ERR(0, 301, __pyx_L4_error)) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10); + __Pyx_ExceptionSave(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_7); __Pyx_XGOTREF(__pyx_t_8); __Pyx_XGOTREF(__pyx_t_9); - __Pyx_XGOTREF(__pyx_t_10); /*try:*/ { - /* "hunter/_event.pyx":266 + /* "hunter/_event.pyx":302 * lines = [] * try: - * for _, token, _, _, line in generate_tokens(partial( # <<<<<<<<<<<<<< + * for _, token, _, _, _ in generate_tokens( # <<<<<<<<<<<<<< + * partial( * next, - * yield_lines(self.filename, self.frame.f_globals, self.lineno - 1, lines) - */ - __Pyx_TraceLine(266,0,__PYX_ERR(0, 266, __pyx_L13_error)) - __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_generate_tokens); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 266, __pyx_L13_error) +*/ + __Pyx_TraceLine(302,34,0,__PYX_ERR(0, 302, __pyx_L13_error)) + __pyx_t_10 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_generate_tokens); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 302, __pyx_L13_error) __Pyx_GOTREF(__pyx_t_11); - __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_n_s_partial); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 266, __pyx_L13_error) - __Pyx_GOTREF(__pyx_t_13); - /* "hunter/_event.pyx":267 + /* "hunter/_event.pyx":303 * try: - * for _, token, _, _, line in generate_tokens(partial( - * next, # <<<<<<<<<<<<<< - * yield_lines(self.filename, self.frame.f_globals, self.lineno - 1, lines) - * )): - */ - __Pyx_TraceLine(267,0,__PYX_ERR(0, 267, __pyx_L13_error)) - __pyx_t_14 = __Pyx_GetBuiltinName(__pyx_n_s_next); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 267, __pyx_L13_error) + * for _, token, _, _, _ in generate_tokens( + * partial( # <<<<<<<<<<<<<< + * next, + * yield_lines( +*/ + __Pyx_TraceLine(303,36,0,__PYX_ERR(0, 303, __pyx_L13_error)) + __pyx_t_13 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_14, __pyx_mstate_global->__pyx_n_u_partial); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 303, __pyx_L13_error) __Pyx_GOTREF(__pyx_t_14); - /* "hunter/_event.pyx":268 - * for _, token, _, _, line in generate_tokens(partial( + /* "hunter/_event.pyx":304 + * for _, token, _, _, _ in generate_tokens( + * partial( + * next, # <<<<<<<<<<<<<< + * yield_lines( + * self.filename, +*/ + __Pyx_TraceLine(304,37,0,__PYX_ERR(0, 304, __pyx_L13_error)) + __pyx_t_15 = __Pyx_GetBuiltinName(__pyx_mstate_global->__pyx_n_u_next); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 304, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_15); + + /* "hunter/_event.pyx":305 + * partial( * next, - * yield_lines(self.filename, self.frame.f_globals, self.lineno - 1, lines) # <<<<<<<<<<<<<< - * )): - * if token in ("def", "class", "lambda"): - */ - __Pyx_TraceLine(268,0,__PYX_ERR(0, 268, __pyx_L13_error)) - __Pyx_GetModuleGlobalName(__pyx_t_16, __pyx_n_s_yield_lines); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 268, __pyx_L13_error) - __Pyx_GOTREF(__pyx_t_16); - __pyx_t_17 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_filename); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 268, __pyx_L13_error) - __Pyx_GOTREF(__pyx_t_17); - __pyx_t_18 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_lineno); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 268, __pyx_L13_error) + * yield_lines( # <<<<<<<<<<<<<< + * self.filename, + * self.frame.f_globals, +*/ + __Pyx_TraceLine(305,39,0,__PYX_ERR(0, 305, __pyx_L13_error)) + __pyx_t_17 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_18, __pyx_mstate_global->__pyx_n_u_yield_lines); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 305, __pyx_L13_error) __Pyx_GOTREF(__pyx_t_18); - __pyx_t_19 = __Pyx_PyInt_SubtractObjC(__pyx_t_18, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 268, __pyx_L13_error) + + /* "hunter/_event.pyx":306 + * next, + * yield_lines( + * self.filename, # <<<<<<<<<<<<<< + * self.frame.f_globals, + * self.lineno - 1, +*/ + __Pyx_TraceLine(306,41,0,__PYX_ERR(0, 306, __pyx_L13_error)) + __pyx_t_19 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_filename_2); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 306, __pyx_L13_error) __Pyx_GOTREF(__pyx_t_19); - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - __pyx_t_18 = NULL; - __pyx_t_20 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_16))) { - __pyx_t_18 = PyMethod_GET_SELF(__pyx_t_16); - if (likely(__pyx_t_18)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_16); - __Pyx_INCREF(__pyx_t_18); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_16, function); - __pyx_t_20 = 1; - } + + /* "hunter/_event.pyx":307 + * yield_lines( + * self.filename, + * self.frame.f_globals, # <<<<<<<<<<<<<< + * self.lineno - 1, + * lines, +*/ + __Pyx_TraceLine(307,44,0,__PYX_ERR(0, 307, __pyx_L13_error)) + __pyx_t_20 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->frame), __pyx_mstate_global->__pyx_n_u_f_globals); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 307, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_20); + + /* "hunter/_event.pyx":308 + * self.filename, + * self.frame.f_globals, + * self.lineno - 1, # <<<<<<<<<<<<<< + * lines, + * ), +*/ + __Pyx_TraceLine(308,46,0,__PYX_ERR(0, 308, __pyx_L13_error)) + __pyx_t_21 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_lineno_2); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 308, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_21); + __pyx_t_22 = __Pyx_PyLong_SubtractObjC(__pyx_t_21, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 308, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_22); + __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; + + /* "hunter/_event.pyx":309 + * self.frame.f_globals, + * self.lineno - 1, + * lines, # <<<<<<<<<<<<<< + * ), + * ) +*/ + __Pyx_TraceLine(309,49,0,__PYX_ERR(0, 309, __pyx_L13_error)) + __pyx_t_23 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_18))) { + __pyx_t_17 = PyMethod_GET_SELF(__pyx_t_18); + assert(__pyx_t_17); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_18); + __Pyx_INCREF(__pyx_t_17); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_18, __pyx__function); + __pyx_t_23 = 0; } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_16)) { - PyObject *__pyx_temp[5] = {__pyx_t_18, __pyx_t_17, __pyx_v_self->frame->f_globals, __pyx_t_19, __pyx_v_lines}; - __pyx_t_15 = __Pyx_PyFunction_FastCall(__pyx_t_16, __pyx_temp+1-__pyx_t_20, 4+__pyx_t_20); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 268, __pyx_L13_error) - __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; - __Pyx_GOTREF(__pyx_t_15); - __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; - __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_16)) { - PyObject *__pyx_temp[5] = {__pyx_t_18, __pyx_t_17, __pyx_v_self->frame->f_globals, __pyx_t_19, __pyx_v_lines}; - __pyx_t_15 = __Pyx_PyCFunction_FastCall(__pyx_t_16, __pyx_temp+1-__pyx_t_20, 4+__pyx_t_20); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 268, __pyx_L13_error) - __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; - __Pyx_GOTREF(__pyx_t_15); - __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; - __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - } else #endif { - __pyx_t_21 = PyTuple_New(4+__pyx_t_20); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 268, __pyx_L13_error) - __Pyx_GOTREF(__pyx_t_21); - if (__pyx_t_18) { - __Pyx_GIVEREF(__pyx_t_18); PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_18); __pyx_t_18 = NULL; - } - __Pyx_GIVEREF(__pyx_t_17); - PyTuple_SET_ITEM(__pyx_t_21, 0+__pyx_t_20, __pyx_t_17); - __Pyx_INCREF(__pyx_v_self->frame->f_globals); - __Pyx_GIVEREF(__pyx_v_self->frame->f_globals); - PyTuple_SET_ITEM(__pyx_t_21, 1+__pyx_t_20, __pyx_v_self->frame->f_globals); - __Pyx_GIVEREF(__pyx_t_19); - PyTuple_SET_ITEM(__pyx_t_21, 2+__pyx_t_20, __pyx_t_19); - __Pyx_INCREF(__pyx_v_lines); - __Pyx_GIVEREF(__pyx_v_lines); - PyTuple_SET_ITEM(__pyx_t_21, 3+__pyx_t_20, __pyx_v_lines); - __pyx_t_17 = 0; - __pyx_t_19 = 0; - __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_16, __pyx_t_21, NULL); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 268, __pyx_L13_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; + PyObject *__pyx_callargs[5] = {__pyx_t_17, __pyx_t_19, __pyx_t_20, __pyx_t_22, __pyx_v_lines}; + __pyx_t_16 = __Pyx_PyObject_FastCall(__pyx_t_18, __pyx_callargs+__pyx_t_23, (5-__pyx_t_23) | (__pyx_t_23*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 305, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_16); } - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_16 = NULL; - __pyx_t_20 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_13))) { - __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_13); - if (likely(__pyx_t_16)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); - __Pyx_INCREF(__pyx_t_16); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_13, function); - __pyx_t_20 = 1; - } + __pyx_t_23 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_14))) { + __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_14); + assert(__pyx_t_13); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_14); + __Pyx_INCREF(__pyx_t_13); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_14, __pyx__function); + __pyx_t_23 = 0; } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_13)) { - PyObject *__pyx_temp[3] = {__pyx_t_16, __pyx_t_14, __pyx_t_15}; - __pyx_t_12 = __Pyx_PyFunction_FastCall(__pyx_t_13, __pyx_temp+1-__pyx_t_20, 2+__pyx_t_20); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 266, __pyx_L13_error) - __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; - __Pyx_GOTREF(__pyx_t_12); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_13)) { - PyObject *__pyx_temp[3] = {__pyx_t_16, __pyx_t_14, __pyx_t_15}; - __pyx_t_12 = __Pyx_PyCFunction_FastCall(__pyx_t_13, __pyx_temp+1-__pyx_t_20, 2+__pyx_t_20); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 266, __pyx_L13_error) - __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; - __Pyx_GOTREF(__pyx_t_12); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - } else #endif { - __pyx_t_21 = PyTuple_New(2+__pyx_t_20); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 266, __pyx_L13_error) - __Pyx_GOTREF(__pyx_t_21); - if (__pyx_t_16) { - __Pyx_GIVEREF(__pyx_t_16); PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_16); __pyx_t_16 = NULL; - } - __Pyx_GIVEREF(__pyx_t_14); - PyTuple_SET_ITEM(__pyx_t_21, 0+__pyx_t_20, __pyx_t_14); - __Pyx_GIVEREF(__pyx_t_15); - PyTuple_SET_ITEM(__pyx_t_21, 1+__pyx_t_20, __pyx_t_15); - __pyx_t_14 = 0; - __pyx_t_15 = 0; - __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_13, __pyx_t_21, NULL); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 266, __pyx_L13_error) + PyObject *__pyx_callargs[3] = {__pyx_t_13, __pyx_t_15, __pyx_t_16}; + __pyx_t_12 = __Pyx_PyObject_FastCall(__pyx_t_14, __pyx_callargs+__pyx_t_23, (3-__pyx_t_23) | (__pyx_t_23*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 303, __pyx_L13_error) __Pyx_GOTREF(__pyx_t_12); - __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; } - __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; - __pyx_t_13 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_11))) { - __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_11); - if (likely(__pyx_t_13)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11); - __Pyx_INCREF(__pyx_t_13); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_11, function); - } + __pyx_t_23 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_11))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_11); + assert(__pyx_t_10); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_11); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_11, __pyx__function); + __pyx_t_23 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_t_12}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_11, __pyx_callargs+__pyx_t_23, (2-__pyx_t_23) | (__pyx_t_23*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 302, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_5); } - __pyx_t_7 = (__pyx_t_13) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_13, __pyx_t_12) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_12); - __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; - __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 266, __pyx_L13_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "hunter/_event.pyx":266 + /* "hunter/_event.pyx":302 * lines = [] * try: - * for _, token, _, _, line in generate_tokens(partial( # <<<<<<<<<<<<<< + * for _, token, _, _, _ in generate_tokens( # <<<<<<<<<<<<<< + * partial( * next, - * yield_lines(self.filename, self.frame.f_globals, self.lineno - 1, lines) - */ - __Pyx_TraceLine(266,0,__PYX_ERR(0, 266, __pyx_L13_error)) - if (likely(PyList_CheckExact(__pyx_t_7)) || PyTuple_CheckExact(__pyx_t_7)) { - __pyx_t_11 = __pyx_t_7; __Pyx_INCREF(__pyx_t_11); __pyx_t_22 = 0; - __pyx_t_23 = NULL; +*/ + __Pyx_TraceLine(302,33,0,__PYX_ERR(0, 302, __pyx_L13_error)) + if (likely(PyList_CheckExact(__pyx_t_5)) || PyTuple_CheckExact(__pyx_t_5)) { + __pyx_t_11 = __pyx_t_5; __Pyx_INCREF(__pyx_t_11); + __pyx_t_24 = 0; + __pyx_t_25 = NULL; } else { - __pyx_t_22 = -1; __pyx_t_11 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 266, __pyx_L13_error) + __pyx_t_24 = -1; __pyx_t_11 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 302, __pyx_L13_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_23 = Py_TYPE(__pyx_t_11)->tp_iternext; if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 266, __pyx_L13_error) + __pyx_t_25 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_11); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 302, __pyx_L13_error) } - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; for (;;) { - if (likely(!__pyx_t_23)) { + if (likely(!__pyx_t_25)) { if (likely(PyList_CheckExact(__pyx_t_11))) { - if (__pyx_t_22 >= PyList_GET_SIZE(__pyx_t_11)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_7 = PyList_GET_ITEM(__pyx_t_11, __pyx_t_22); __Pyx_INCREF(__pyx_t_7); __pyx_t_22++; if (unlikely(0 < 0)) __PYX_ERR(0, 266, __pyx_L13_error) - #else - __pyx_t_7 = PySequence_ITEM(__pyx_t_11, __pyx_t_22); __pyx_t_22++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 266, __pyx_L13_error) - __Pyx_GOTREF(__pyx_t_7); - #endif + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_11); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 302, __pyx_L13_error) + #endif + if (__pyx_t_24 >= __pyx_temp) break; + } + __pyx_t_5 = __Pyx_PyList_GetItemRef(__pyx_t_11, __pyx_t_24); + ++__pyx_t_24; } else { - if (__pyx_t_22 >= PyTuple_GET_SIZE(__pyx_t_11)) break; + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_11); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 302, __pyx_L13_error) + #endif + if (__pyx_t_24 >= __pyx_temp) break; + } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_11, __pyx_t_22); __Pyx_INCREF(__pyx_t_7); __pyx_t_22++; if (unlikely(0 < 0)) __PYX_ERR(0, 266, __pyx_L13_error) + __pyx_t_5 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_11, __pyx_t_24)); #else - __pyx_t_7 = PySequence_ITEM(__pyx_t_11, __pyx_t_22); __pyx_t_22++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 266, __pyx_L13_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_11, __pyx_t_24); #endif + ++__pyx_t_24; } + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 302, __pyx_L13_error) } else { - __pyx_t_7 = __pyx_t_23(__pyx_t_11); - if (unlikely(!__pyx_t_7)) { + __pyx_t_5 = __pyx_t_25(__pyx_t_11); + if (unlikely(!__pyx_t_5)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(0, 266, __pyx_L13_error) + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 302, __pyx_L13_error) + PyErr_Clear(); } break; } - __Pyx_GOTREF(__pyx_t_7); } - if ((likely(PyTuple_CheckExact(__pyx_t_7))) || (PyList_CheckExact(__pyx_t_7))) { - PyObject* sequence = __pyx_t_7; + __Pyx_GOTREF(__pyx_t_5); + if ((likely(PyTuple_CheckExact(__pyx_t_5))) || (PyList_CheckExact(__pyx_t_5))) { + PyObject* sequence = __pyx_t_5; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 5)) { if (size > 5) __Pyx_RaiseTooManyValuesError(5); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 266, __pyx_L13_error) + __PYX_ERR(0, 302, __pyx_L13_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_12 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_13 = PyTuple_GET_ITEM(sequence, 1); - __pyx_t_21 = PyTuple_GET_ITEM(sequence, 2); - __pyx_t_15 = PyTuple_GET_ITEM(sequence, 3); - __pyx_t_14 = PyTuple_GET_ITEM(sequence, 4); + __pyx_t_12 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_12); + __pyx_t_10 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_10); + __pyx_t_14 = PyTuple_GET_ITEM(sequence, 2); + __Pyx_INCREF(__pyx_t_14); + __pyx_t_16 = PyTuple_GET_ITEM(sequence, 3); + __Pyx_INCREF(__pyx_t_16); + __pyx_t_15 = PyTuple_GET_ITEM(sequence, 4); + __Pyx_INCREF(__pyx_t_15); } else { - __pyx_t_12 = PyList_GET_ITEM(sequence, 0); - __pyx_t_13 = PyList_GET_ITEM(sequence, 1); - __pyx_t_21 = PyList_GET_ITEM(sequence, 2); - __pyx_t_15 = PyList_GET_ITEM(sequence, 3); - __pyx_t_14 = PyList_GET_ITEM(sequence, 4); + __pyx_t_12 = __Pyx_PyList_GetItemRef(sequence, 0); + if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 302, __pyx_L13_error) + __Pyx_XGOTREF(__pyx_t_12); + __pyx_t_10 = __Pyx_PyList_GetItemRef(sequence, 1); + if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 302, __pyx_L13_error) + __Pyx_XGOTREF(__pyx_t_10); + __pyx_t_14 = __Pyx_PyList_GetItemRef(sequence, 2); + if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 302, __pyx_L13_error) + __Pyx_XGOTREF(__pyx_t_14); + __pyx_t_16 = __Pyx_PyList_GetItemRef(sequence, 3); + if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 302, __pyx_L13_error) + __Pyx_XGOTREF(__pyx_t_16); + __pyx_t_15 = __Pyx_PyList_GetItemRef(sequence, 4); + if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 302, __pyx_L13_error) + __Pyx_XGOTREF(__pyx_t_15); } - __Pyx_INCREF(__pyx_t_12); - __Pyx_INCREF(__pyx_t_13); - __Pyx_INCREF(__pyx_t_21); - __Pyx_INCREF(__pyx_t_15); - __Pyx_INCREF(__pyx_t_14); #else { Py_ssize_t i; - PyObject** temps[5] = {&__pyx_t_12,&__pyx_t_13,&__pyx_t_21,&__pyx_t_15,&__pyx_t_14}; + PyObject** temps[5] = {&__pyx_t_12,&__pyx_t_10,&__pyx_t_14,&__pyx_t_16,&__pyx_t_15}; for (i=0; i < 5; i++) { - PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 266, __pyx_L13_error) + PyObject* item = __Pyx_PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 302, __pyx_L13_error) __Pyx_GOTREF(item); *(temps[i]) = item; } } #endif - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else { Py_ssize_t index = -1; - PyObject** temps[5] = {&__pyx_t_12,&__pyx_t_13,&__pyx_t_21,&__pyx_t_15,&__pyx_t_14}; - __pyx_t_16 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 266, __pyx_L13_error) - __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_24 = Py_TYPE(__pyx_t_16)->tp_iternext; + PyObject** temps[5] = {&__pyx_t_12,&__pyx_t_10,&__pyx_t_14,&__pyx_t_16,&__pyx_t_15}; + __pyx_t_13 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 302, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_26 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_13); for (index=0; index < 5; index++) { - PyObject* item = __pyx_t_24(__pyx_t_16); if (unlikely(!item)) goto __pyx_L21_unpacking_failed; + PyObject* item = __pyx_t_26(__pyx_t_13); if (unlikely(!item)) goto __pyx_L21_unpacking_failed; __Pyx_GOTREF(item); *(temps[index]) = item; } - if (__Pyx_IternextUnpackEndCheck(__pyx_t_24(__pyx_t_16), 5) < 0) __PYX_ERR(0, 266, __pyx_L13_error) - __pyx_t_24 = NULL; - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + if (__Pyx_IternextUnpackEndCheck(__pyx_t_26(__pyx_t_13), 5) < 0) __PYX_ERR(0, 302, __pyx_L13_error) + __pyx_t_26 = NULL; + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; goto __pyx_L22_unpacking_done; __pyx_L21_unpacking_failed:; - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_24 = NULL; + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_26 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 266, __pyx_L13_error) + __PYX_ERR(0, 302, __pyx_L13_error) __pyx_L22_unpacking_done:; } __Pyx_XDECREF_SET(__pyx_v__, __pyx_t_12); __pyx_t_12 = 0; - __Pyx_XDECREF_SET(__pyx_v_token, __pyx_t_13); - __pyx_t_13 = 0; - __Pyx_DECREF_SET(__pyx_v__, __pyx_t_21); - __pyx_t_21 = 0; + __Pyx_XDECREF_SET(__pyx_v_token, __pyx_t_10); + __pyx_t_10 = 0; + __Pyx_DECREF_SET(__pyx_v__, __pyx_t_14); + __pyx_t_14 = 0; + __Pyx_DECREF_SET(__pyx_v__, __pyx_t_16); + __pyx_t_16 = 0; __Pyx_DECREF_SET(__pyx_v__, __pyx_t_15); __pyx_t_15 = 0; - __Pyx_XDECREF_SET(__pyx_v_line, __pyx_t_14); - __pyx_t_14 = 0; + __Pyx_TraceLine(302,27,0,__PYX_ERR(0, 302, __pyx_L13_error)) - /* "hunter/_event.pyx":270 - * yield_lines(self.filename, self.frame.f_globals, self.lineno - 1, lines) - * )): - * if token in ("def", "class", "lambda"): # <<<<<<<<<<<<<< + /* "hunter/_event.pyx":313 + * ) + * ): + * if token in ('def', 'class', 'lambda'): # <<<<<<<<<<<<<< * self._fullsource = ''.join(lines) * break - */ - __Pyx_TraceLine(270,0,__PYX_ERR(0, 270, __pyx_L13_error)) +*/ + __Pyx_TraceLine(313,51,0,__PYX_ERR(0, 313, __pyx_L13_error)) __Pyx_INCREF(__pyx_v_token); - __pyx_t_7 = __pyx_v_token; - __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_t_7, __pyx_n_s_def, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 270, __pyx_L13_error) + __pyx_t_5 = __pyx_v_token; + __pyx_t_6 = (__Pyx_PyUnicode_Equals(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_def, Py_EQ)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 313, __pyx_L13_error) if (!__pyx_t_6) { } else { - __pyx_t_2 = __pyx_t_6; + __pyx_t_1 = __pyx_t_6; goto __pyx_L24_bool_binop_done; } - __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_t_7, __pyx_n_s_class, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 270, __pyx_L13_error) + __pyx_t_6 = (__Pyx_PyUnicode_Equals(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_class, Py_EQ)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 313, __pyx_L13_error) if (!__pyx_t_6) { } else { - __pyx_t_2 = __pyx_t_6; + __pyx_t_1 = __pyx_t_6; goto __pyx_L24_bool_binop_done; } - __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_t_7, __pyx_n_s_lambda, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 270, __pyx_L13_error) - __pyx_t_2 = __pyx_t_6; + __pyx_t_6 = (__Pyx_PyUnicode_Equals(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_lambda, Py_EQ)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 313, __pyx_L13_error) + __pyx_t_1 = __pyx_t_6; __pyx_L24_bool_binop_done:; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_6 = (__pyx_t_2 != 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_6 = __pyx_t_1; if (__pyx_t_6) { - /* "hunter/_event.pyx":271 - * )): - * if token in ("def", "class", "lambda"): + /* "hunter/_event.pyx":314 + * ): + * if token in ('def', 'class', 'lambda'): * self._fullsource = ''.join(lines) # <<<<<<<<<<<<<< * break * except TokenError: - */ - __Pyx_TraceLine(271,0,__PYX_ERR(0, 271, __pyx_L13_error)) - __pyx_t_7 = __Pyx_PyString_Join(__pyx_kp_s_, __pyx_v_lines); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 271, __pyx_L13_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); +*/ + __Pyx_TraceLine(314,60,0,__PYX_ERR(0, 314, __pyx_L13_error)) + __pyx_t_5 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__2, __pyx_v_lines); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 314, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_5); __Pyx_GOTREF(__pyx_v_self->_fullsource); __Pyx_DECREF(__pyx_v_self->_fullsource); - __pyx_v_self->_fullsource = __pyx_t_7; - __pyx_t_7 = 0; + __pyx_v_self->_fullsource = __pyx_t_5; + __pyx_t_5 = 0; - /* "hunter/_event.pyx":272 - * if token in ("def", "class", "lambda"): + /* "hunter/_event.pyx":315 + * if token in ('def', 'class', 'lambda'): * self._fullsource = ''.join(lines) * break # <<<<<<<<<<<<<< * except TokenError: * pass - */ - __Pyx_TraceLine(272,0,__PYX_ERR(0, 272, __pyx_L13_error)) +*/ + __Pyx_TraceLine(315,62,0,__PYX_ERR(0, 315, __pyx_L13_error)) goto __pyx_L20_break; - /* "hunter/_event.pyx":270 - * yield_lines(self.filename, self.frame.f_globals, self.lineno - 1, lines) - * )): - * if token in ("def", "class", "lambda"): # <<<<<<<<<<<<<< + /* "hunter/_event.pyx":313 + * ) + * ): + * if token in ('def', 'class', 'lambda'): # <<<<<<<<<<<<<< * self._fullsource = ''.join(lines) * break - */ +*/ } - /* "hunter/_event.pyx":266 + /* "hunter/_event.pyx":302 * lines = [] * try: - * for _, token, _, _, line in generate_tokens(partial( # <<<<<<<<<<<<<< + * for _, token, _, _, _ in generate_tokens( # <<<<<<<<<<<<<< + * partial( * next, - * yield_lines(self.filename, self.frame.f_globals, self.lineno - 1, lines) - */ - __Pyx_TraceLine(266,0,__PYX_ERR(0, 266, __pyx_L13_error)) +*/ + __Pyx_TraceLine(302,27,0,__PYX_ERR(0, 302, __pyx_L13_error)) } + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + goto __pyx_L27_for_end; __pyx_L20_break:; __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + goto __pyx_L27_for_end; + __pyx_L27_for_end:; - /* "hunter/_event.pyx":265 - * if self.kind == 'call' and self.frame.f_code.co_name != "": + /* "hunter/_event.pyx":301 + * if self.kind == 'call' and code.co_name != '': * lines = [] * try: # <<<<<<<<<<<<<< - * for _, token, _, _, line in generate_tokens(partial( - * next, - */ + * for _, token, _, _, _ in generate_tokens( + * partial( +*/ } + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; goto __pyx_L18_try_end; __pyx_L13_error:; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; @@ -6423,166 +8756,155 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_10fullsource___get__(struct __p __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; + __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0; __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0; - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_TraceException(__pyx_lineno, 0, 0); - /* "hunter/_event.pyx":273 + /* "hunter/_event.pyx":316 * self._fullsource = ''.join(lines) * break * except TokenError: # <<<<<<<<<<<<<< * pass * if self._fullsource is None: - */ - __Pyx_TraceLine(273,0,__PYX_ERR(0, 273, __pyx_L15_except_error)) - __Pyx_ErrFetch(&__pyx_t_11, &__pyx_t_7, &__pyx_t_14); - __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_n_s_TokenError); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 273, __pyx_L15_except_error) - __Pyx_GOTREF(__pyx_t_15); - __pyx_t_20 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_11, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - __Pyx_ErrRestore(__pyx_t_11, __pyx_t_7, __pyx_t_14); - __pyx_t_11 = 0; __pyx_t_7 = 0; __pyx_t_14 = 0; - if (__pyx_t_20) { +*/ + __Pyx_TraceLine(316,0,0,__PYX_ERR(0, 316, __pyx_L15_except_error)) + __Pyx_ErrFetch(&__pyx_t_11, &__pyx_t_5, &__pyx_t_15); + __Pyx_GetModuleGlobalName(__pyx_t_16, __pyx_mstate_global->__pyx_n_u_TokenError); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 316, __pyx_L15_except_error) + __Pyx_GOTREF(__pyx_t_16); + __pyx_t_27 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_11, __pyx_t_16); + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_ErrRestore(__pyx_t_11, __pyx_t_5, __pyx_t_15); + __pyx_t_11 = 0; __pyx_t_5 = 0; __pyx_t_15 = 0; + if (__pyx_t_27) { + __Pyx_AddTraceback("hunter._event.Event.fullsource_getter", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceExceptionHandled(0); __Pyx_ErrRestore(0,0,0); + __Pyx_TraceExceptionDone(); + + /* "hunter/_event.pyx":317 + * break + * except TokenError: + * pass # <<<<<<<<<<<<<< + * if self._fullsource is None: + * self._fullsource = getline(self.filename, self.lineno, self.globals) +*/ + __Pyx_TraceLine(317,64,0,__PYX_ERR(0, 317, __pyx_L15_except_error)) goto __pyx_L14_exception_handled; } goto __pyx_L15_except_error; - __pyx_L15_except_error:; - /* "hunter/_event.pyx":265 - * if self.kind == 'call' and self.frame.f_code.co_name != "": + /* "hunter/_event.pyx":301 + * if self.kind == 'call' and code.co_name != '': * lines = [] * try: # <<<<<<<<<<<<<< - * for _, token, _, _, line in generate_tokens(partial( - * next, - */ + * for _, token, _, _, _ in generate_tokens( + * partial( +*/ + __pyx_L15_except_error:; + __Pyx_XGIVEREF(__pyx_t_7); __Pyx_XGIVEREF(__pyx_t_8); __Pyx_XGIVEREF(__pyx_t_9); - __Pyx_XGIVEREF(__pyx_t_10); - __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10); + __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); goto __pyx_L4_error; __pyx_L14_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_7); __Pyx_XGIVEREF(__pyx_t_8); __Pyx_XGIVEREF(__pyx_t_9); - __Pyx_XGIVEREF(__pyx_t_10); - __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10); + __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); __pyx_L18_try_end:; } - /* "hunter/_event.pyx":263 + /* "hunter/_event.pyx":299 * self._fullsource = None - * - * if self.kind == 'call' and self.frame.f_code.co_name != "": # <<<<<<<<<<<<<< + * code = self.code_getter() + * if self.kind == 'call' and code.co_name != '': # <<<<<<<<<<<<<< * lines = [] * try: - */ +*/ } - /* "hunter/_event.pyx":275 + /* "hunter/_event.pyx":318 * except TokenError: * pass * if self._fullsource is None: # <<<<<<<<<<<<<< - * self._fullsource = getline(self.filename, self.lineno, self.frame.f_globals) + * self._fullsource = getline(self.filename, self.lineno, self.globals) * except Exception as exc: - */ - __Pyx_TraceLine(275,0,__PYX_ERR(0, 275, __pyx_L4_error)) +*/ + __Pyx_TraceLine(318,69,0,__PYX_ERR(0, 318, __pyx_L4_error)) __pyx_t_6 = (__pyx_v_self->_fullsource == Py_None); - __pyx_t_2 = (__pyx_t_6 != 0); - if (__pyx_t_2) { + if (__pyx_t_6) { - /* "hunter/_event.pyx":276 + /* "hunter/_event.pyx":319 * pass * if self._fullsource is None: - * self._fullsource = getline(self.filename, self.lineno, self.frame.f_globals) # <<<<<<<<<<<<<< + * self._fullsource = getline(self.filename, self.lineno, self.globals) # <<<<<<<<<<<<<< * except Exception as exc: - * self._fullsource = "??? NO SOURCE: {!r}".format(exc) - */ - __Pyx_TraceLine(276,0,__PYX_ERR(0, 276, __pyx_L4_error)) - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_getline); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 276, __pyx_L4_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_11 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_filename); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 276, __pyx_L4_error) + * self._fullsource = f'??? NO SOURCE: {exc!r}' +*/ + __Pyx_TraceLine(319,73,0,__PYX_ERR(0, 319, __pyx_L4_error)) + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_getline); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 319, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_15 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_lineno); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 276, __pyx_L4_error) - __Pyx_GOTREF(__pyx_t_15); - __pyx_t_21 = NULL; - __pyx_t_20 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { - __pyx_t_21 = PyMethod_GET_SELF(__pyx_t_7); - if (likely(__pyx_t_21)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); - __Pyx_INCREF(__pyx_t_21); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_7, function); - __pyx_t_20 = 1; - } + __pyx_t_16 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_filename_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 319, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_16); + __pyx_t_14 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_lineno_2); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 319, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_14); + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_globals); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 319, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_23 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_11))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_11); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_11); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_11, __pyx__function); + __pyx_t_23 = 0; } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_7)) { - PyObject *__pyx_temp[4] = {__pyx_t_21, __pyx_t_11, __pyx_t_15, __pyx_v_self->frame->f_globals}; - __pyx_t_14 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_20, 3+__pyx_t_20); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 276, __pyx_L4_error) - __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0; - __Pyx_GOTREF(__pyx_t_14); - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { - PyObject *__pyx_temp[4] = {__pyx_t_21, __pyx_t_11, __pyx_t_15, __pyx_v_self->frame->f_globals}; - __pyx_t_14 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_20, 3+__pyx_t_20); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 276, __pyx_L4_error) - __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0; - __Pyx_GOTREF(__pyx_t_14); - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - } else #endif { - __pyx_t_13 = PyTuple_New(3+__pyx_t_20); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 276, __pyx_L4_error) - __Pyx_GOTREF(__pyx_t_13); - if (__pyx_t_21) { - __Pyx_GIVEREF(__pyx_t_21); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_21); __pyx_t_21 = NULL; - } - __Pyx_GIVEREF(__pyx_t_11); - PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_20, __pyx_t_11); - __Pyx_GIVEREF(__pyx_t_15); - PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_20, __pyx_t_15); - __Pyx_INCREF(__pyx_v_self->frame->f_globals); - __Pyx_GIVEREF(__pyx_v_self->frame->f_globals); - PyTuple_SET_ITEM(__pyx_t_13, 2+__pyx_t_20, __pyx_v_self->frame->f_globals); - __pyx_t_11 = 0; - __pyx_t_15 = 0; - __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_13, NULL); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 276, __pyx_L4_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + PyObject *__pyx_callargs[4] = {__pyx_t_5, __pyx_t_16, __pyx_t_14, __pyx_t_10}; + __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_11, __pyx_callargs+__pyx_t_23, (4-__pyx_t_23) | (__pyx_t_23*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 319, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_15); } - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_GIVEREF(__pyx_t_14); + __Pyx_GIVEREF(__pyx_t_15); __Pyx_GOTREF(__pyx_v_self->_fullsource); __Pyx_DECREF(__pyx_v_self->_fullsource); - __pyx_v_self->_fullsource = __pyx_t_14; - __pyx_t_14 = 0; + __pyx_v_self->_fullsource = __pyx_t_15; + __pyx_t_15 = 0; - /* "hunter/_event.pyx":275 + /* "hunter/_event.pyx":318 * except TokenError: * pass * if self._fullsource is None: # <<<<<<<<<<<<<< - * self._fullsource = getline(self.filename, self.lineno, self.frame.f_globals) + * self._fullsource = getline(self.filename, self.lineno, self.globals) * except Exception as exc: - */ +*/ } - /* "hunter/_event.pyx":260 + /* "hunter/_event.pyx":296 * * if self._fullsource is UNSET: * try: # <<<<<<<<<<<<<< * self._fullsource = None - * - */ + * code = self.code_getter() +*/ } + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; @@ -6592,177 +8914,174 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_10fullsource___get__(struct __p __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; + __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0; __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0; - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_TraceException(__pyx_lineno, 0, 0); - /* "hunter/_event.pyx":277 + /* "hunter/_event.pyx":320 * if self._fullsource is None: - * self._fullsource = getline(self.filename, self.lineno, self.frame.f_globals) + * self._fullsource = getline(self.filename, self.lineno, self.globals) * except Exception as exc: # <<<<<<<<<<<<<< - * self._fullsource = "??? NO SOURCE: {!r}".format(exc) + * self._fullsource = f'??? NO SOURCE: {exc!r}' * return self._fullsource - */ - __Pyx_TraceLine(277,0,__PYX_ERR(0, 277, __pyx_L6_except_error)) - __pyx_t_20 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); - if (__pyx_t_20) { - __Pyx_AddTraceback("hunter._event.Event.fullsource.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_14, &__pyx_t_7, &__pyx_t_13) < 0) __PYX_ERR(0, 277, __pyx_L6_except_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GOTREF(__pyx_t_7); - __Pyx_GOTREF(__pyx_t_13); - __Pyx_INCREF(__pyx_t_7); - __pyx_v_exc = __pyx_t_7; +*/ + __Pyx_TraceLine(320,81,0,__PYX_ERR(0, 320, __pyx_L6_except_error)) + __pyx_t_27 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception)))); + if (__pyx_t_27) { + __Pyx_AddTraceback("hunter._event.Event.fullsource_getter", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceExceptionHandled(80); + if (__Pyx_GetException(&__pyx_t_15, &__pyx_t_11, &__pyx_t_10) < 0) __PYX_ERR(0, 320, __pyx_L6_except_error) + __Pyx_XGOTREF(__pyx_t_15); + __Pyx_XGOTREF(__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_TraceExceptionDone(); + __Pyx_INCREF(__pyx_t_11); + __pyx_v_exc = __pyx_t_11; /*try:*/ { - /* "hunter/_event.pyx":278 - * self._fullsource = getline(self.filename, self.lineno, self.frame.f_globals) + /* "hunter/_event.pyx":321 + * self._fullsource = getline(self.filename, self.lineno, self.globals) * except Exception as exc: - * self._fullsource = "??? NO SOURCE: {!r}".format(exc) # <<<<<<<<<<<<<< + * self._fullsource = f'??? NO SOURCE: {exc!r}' # <<<<<<<<<<<<<< * return self._fullsource * - */ - __Pyx_TraceLine(278,0,__PYX_ERR(0, 278, __pyx_L33_error)) - __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_NO_SOURCE_r, __pyx_n_s_format); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 278, __pyx_L33_error) - __Pyx_GOTREF(__pyx_t_11); - __pyx_t_21 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) { - __pyx_t_21 = PyMethod_GET_SELF(__pyx_t_11); - if (likely(__pyx_t_21)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11); - __Pyx_INCREF(__pyx_t_21); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_11, function); - } - } - __pyx_t_15 = (__pyx_t_21) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_21, __pyx_v_exc) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_v_exc); - __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0; - if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 278, __pyx_L33_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __Pyx_GIVEREF(__pyx_t_15); +*/ + __Pyx_TraceLine(321,86,0,__PYX_ERR(0, 321, __pyx_L36_error)) + __pyx_t_14 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_exc), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 321, __pyx_L36_error) + __Pyx_GOTREF(__pyx_t_14); + __pyx_t_16 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_NO_SOURCE, __pyx_t_14); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 321, __pyx_L36_error) + __Pyx_GOTREF(__pyx_t_16); + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_GIVEREF(__pyx_t_16); __Pyx_GOTREF(__pyx_v_self->_fullsource); __Pyx_DECREF(__pyx_v_self->_fullsource); - __pyx_v_self->_fullsource = __pyx_t_15; - __pyx_t_15 = 0; + __pyx_v_self->_fullsource = __pyx_t_16; + __pyx_t_16 = 0; } - /* "hunter/_event.pyx":277 + /* "hunter/_event.pyx":320 * if self._fullsource is None: - * self._fullsource = getline(self.filename, self.lineno, self.frame.f_globals) + * self._fullsource = getline(self.filename, self.lineno, self.globals) * except Exception as exc: # <<<<<<<<<<<<<< - * self._fullsource = "??? NO SOURCE: {!r}".format(exc) + * self._fullsource = f'??? NO SOURCE: {exc!r}' * return self._fullsource - */ - __Pyx_TraceLine(277,0,__PYX_ERR(0, 277, __pyx_L33_error)) +*/ + __Pyx_TraceLine(320,80,0,__PYX_ERR(0, 320, __pyx_L36_error)) /*finally:*/ { /*normal exit:*/{ - __Pyx_DECREF(__pyx_v_exc); - __pyx_v_exc = NULL; - goto __pyx_L34; + __Pyx_DECREF(__pyx_v_exc); __pyx_v_exc = 0; + goto __pyx_L37; } - __pyx_L33_error:; + __pyx_L36_error:; /*exception exit:*/{ __Pyx_PyThreadState_declare + __Pyx_TraceException(__pyx_lineno, 0, 0); + __Pyx_TraceExceptionHandled(80); __Pyx_PyThreadState_assign - __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_8 = 0; __pyx_t_27 = 0; __pyx_t_28 = 0; __pyx_t_29 = 0; - __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_9 = 0; __pyx_t_8 = 0; __pyx_t_7 = 0; __pyx_t_30 = 0; __pyx_t_31 = 0; __pyx_t_32 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; - __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; + __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0; __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0; - if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_27, &__pyx_t_28, &__pyx_t_29); - if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_10, &__pyx_t_9, &__pyx_t_8) < 0)) __Pyx_ErrFetch(&__pyx_t_10, &__pyx_t_9, &__pyx_t_8); - __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_ExceptionSwap(&__pyx_t_30, &__pyx_t_31, &__pyx_t_32); + if ( unlikely(__Pyx_GetException(&__pyx_t_9, &__pyx_t_8, &__pyx_t_7) < 0)) __Pyx_ErrFetch(&__pyx_t_9, &__pyx_t_8, &__pyx_t_7); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_8); - __Pyx_XGOTREF(__pyx_t_27); - __Pyx_XGOTREF(__pyx_t_28); - __Pyx_XGOTREF(__pyx_t_29); - __pyx_t_20 = __pyx_lineno; __pyx_t_25 = __pyx_clineno; __pyx_t_26 = __pyx_filename; + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_30); + __Pyx_XGOTREF(__pyx_t_31); + __Pyx_XGOTREF(__pyx_t_32); + __pyx_t_27 = __pyx_lineno; __pyx_t_28 = __pyx_clineno; __pyx_t_29 = __pyx_filename; { - __Pyx_DECREF(__pyx_v_exc); - __pyx_v_exc = NULL; - } - if (PY_MAJOR_VERSION >= 3) { - __Pyx_XGIVEREF(__pyx_t_27); - __Pyx_XGIVEREF(__pyx_t_28); - __Pyx_XGIVEREF(__pyx_t_29); - __Pyx_ExceptionReset(__pyx_t_27, __pyx_t_28, __pyx_t_29); + __Pyx_DECREF(__pyx_v_exc); __pyx_v_exc = 0; } - __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_30); + __Pyx_XGIVEREF(__pyx_t_31); + __Pyx_XGIVEREF(__pyx_t_32); + __Pyx_ExceptionReset(__pyx_t_30, __pyx_t_31, __pyx_t_32); __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_8); - __Pyx_ErrRestore(__pyx_t_10, __pyx_t_9, __pyx_t_8); - __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_8 = 0; __pyx_t_27 = 0; __pyx_t_28 = 0; __pyx_t_29 = 0; - __pyx_lineno = __pyx_t_20; __pyx_clineno = __pyx_t_25; __pyx_filename = __pyx_t_26; + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_ErrRestore(__pyx_t_9, __pyx_t_8, __pyx_t_7); + __pyx_t_9 = 0; __pyx_t_8 = 0; __pyx_t_7 = 0; __pyx_t_30 = 0; __pyx_t_31 = 0; __pyx_t_32 = 0; + __pyx_lineno = __pyx_t_27; __pyx_clineno = __pyx_t_28; __pyx_filename = __pyx_t_29; + __Pyx_TraceException(80, 1, 0); goto __pyx_L6_except_error; } - __pyx_L34:; + __pyx_L37:; } - __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; goto __pyx_L5_exception_handled; } goto __pyx_L6_except_error; - __pyx_L6_except_error:; - /* "hunter/_event.pyx":260 + /* "hunter/_event.pyx":296 * * if self._fullsource is UNSET: * try: # <<<<<<<<<<<<<< * self._fullsource = None - * - */ + * code = self.code_getter() +*/ + __pyx_L6_except_error:; + __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); - __Pyx_XGIVEREF(__pyx_t_5); - __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); + __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); goto __pyx_L1_error; __pyx_L5_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); - __Pyx_XGIVEREF(__pyx_t_5); - __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); + __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); __pyx_L9_try_end:; } - /* "hunter/_event.pyx":259 - * cdef list lines + /* "hunter/_event.pyx":295 + * cdef CodeType code * * if self._fullsource is UNSET: # <<<<<<<<<<<<<< * try: * self._fullsource = None - */ +*/ } - /* "hunter/_event.pyx":279 + /* "hunter/_event.pyx":322 * except Exception as exc: - * self._fullsource = "??? NO SOURCE: {!r}".format(exc) + * self._fullsource = f'??? NO SOURCE: {exc!r}' * return self._fullsource # <<<<<<<<<<<<<< * * @property - */ - __Pyx_TraceLine(279,0,__PYX_ERR(0, 279, __pyx_L1_error)) +*/ + __Pyx_TraceLine(322,88,0,__PYX_ERR(0, 322, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->_fullsource); __pyx_r = __pyx_v_self->_fullsource; + __Pyx_TraceReturnValue(__pyx_r, 88, 0, __PYX_ERR(0, 322, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_event.pyx":256 + /* "hunter/_event.pyx":291 + * return self.stdlib_getter() * - * @property - * def fullsource(self): # <<<<<<<<<<<<<< + * cdef inline fullsource_getter(self): # <<<<<<<<<<<<<< * cdef list lines - * - */ + * cdef CodeType code +*/ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_10); __Pyx_XDECREF(__pyx_t_11); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); @@ -6772,353 +9091,351 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_10fullsource___get__(struct __p __Pyx_XDECREF(__pyx_t_17); __Pyx_XDECREF(__pyx_t_18); __Pyx_XDECREF(__pyx_t_19); + __Pyx_XDECREF(__pyx_t_20); __Pyx_XDECREF(__pyx_t_21); - __Pyx_AddTraceback("hunter._event.Event.fullsource.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_XDECREF(__pyx_t_22); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 291, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.Event.fullsource_getter", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_lines); + __Pyx_XDECREF((PyObject *)__pyx_v_code); __Pyx_XDECREF(__pyx_v__); __Pyx_XDECREF(__pyx_v_token); - __Pyx_XDECREF(__pyx_v_line); __Pyx_XDECREF(__pyx_v_exc); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_event.pyx":282 +/* "hunter/_event.pyx":324 + * return self._fullsource * - * @property - * def source(self): # <<<<<<<<<<<<<< - * if self._source is UNSET: - * if self.filename.endswith(('.so', '.pyd')): - */ + * @property # <<<<<<<<<<<<<< + * def fullsource(self): + * return self.fullsource_getter() +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_6_event_5Event_6source_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_6_event_5Event_6source_1__get__(PyObject *__pyx_v_self) { +static PyObject *__pyx_pw_6hunter_6_event_5Event_10fullsource_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_6_event_5Event_10fullsource_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_6_event_5Event_6source___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_6_event_5Event_10fullsource___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_6_event_5Event_6source___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { +static PyObject *__pyx_pf_6hunter_6_event_5Event_10fullsource___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[29])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[0], 324, 0, 0, 0, __PYX_ERR(0, 324, __pyx_L1_error)); + + /* "hunter/_event.pyx":326 + * @property + * def fullsource(self): + * return self.fullsource_getter() # <<<<<<<<<<<<<< + * + * cdef inline source_getter(self): +*/ + __Pyx_TraceLine(326,1,0,__PYX_ERR(0, 326, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6hunter_6_event_5Event_fullsource_getter(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 326, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 326, __pyx_L1_error)); + goto __pyx_L0; + + /* "hunter/_event.pyx":324 + * return self._fullsource + * + * @property # <<<<<<<<<<<<<< + * def fullsource(self): + * return self.fullsource_getter() +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 324, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.Event.fullsource.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/_event.pyx":328 + * return self.fullsource_getter() + * + * cdef inline source_getter(self): # <<<<<<<<<<<<<< + * if self._source is UNSET: + * if self.filename.endswith(('.so', '.pyd')): +*/ + +static PyObject *__pyx_f_6hunter_6_event_5Event_source_getter(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { PyObject *__pyx_v_exc = NULL; PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations int __pyx_t_1; - int __pyx_t_2; + PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; + size_t __pyx_t_5; PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_7[3]; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; - PyObject *__pyx_t_13 = NULL; + int __pyx_t_13; int __pyx_t_14; - int __pyx_t_15; - char const *__pyx_t_16; + char const *__pyx_t_15; + PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; PyObject *__pyx_t_18 = NULL; PyObject *__pyx_t_19 = NULL; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; - PyObject *__pyx_t_22 = NULL; - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[0], 282, 0, __PYX_ERR(0, 282, __pyx_L1_error)); - - /* "hunter/_event.pyx":283 - * @property - * def source(self): + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[30])) + __Pyx_RefNannySetupContext("source_getter", 0); + __Pyx_TraceStartFunc("source_getter", __pyx_f[0], 328, 0, 0, 0, __PYX_ERR(0, 328, __pyx_L1_error)); + + /* "hunter/_event.pyx":329 + * + * cdef inline source_getter(self): * if self._source is UNSET: # <<<<<<<<<<<<<< * if self.filename.endswith(('.so', '.pyd')): - * self._source = "??? NO SOURCE: not reading {} file".format(splitext(basename(self.filename))[1]) - */ - __Pyx_TraceLine(283,0,__PYX_ERR(0, 283, __pyx_L1_error)) + * self._source = f'??? NO SOURCE: not reading binary {splitext(basename(self.filename))[1]} file' +*/ + __Pyx_TraceLine(329,5,0,__PYX_ERR(0, 329, __pyx_L1_error)) __pyx_t_1 = (__pyx_v_self->_source == __pyx_v_6hunter_6_event_UNSET); - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { + if (__pyx_t_1) { - /* "hunter/_event.pyx":284 - * def source(self): + /* "hunter/_event.pyx":330 + * cdef inline source_getter(self): * if self._source is UNSET: * if self.filename.endswith(('.so', '.pyd')): # <<<<<<<<<<<<<< - * self._source = "??? NO SOURCE: not reading {} file".format(splitext(basename(self.filename))[1]) + * self._source = f'??? NO SOURCE: not reading binary {splitext(basename(self.filename))[1]} file' * try: - */ - __Pyx_TraceLine(284,0,__PYX_ERR(0, 284, __pyx_L1_error)) - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_filename); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 284, __pyx_L1_error) +*/ + __Pyx_TraceLine(330,8,0,__PYX_ERR(0, 330, __pyx_L1_error)) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_filename_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 330, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_endswith); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 284, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - } + __pyx_t_3 = __pyx_t_4; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_tuple[2]}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_endswith, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 330, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); } - __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_4, __pyx_tuple__5) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_tuple__5); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 284, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 284, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_2) { + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 330, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_1) { - /* "hunter/_event.pyx":285 + /* "hunter/_event.pyx":331 * if self._source is UNSET: * if self.filename.endswith(('.so', '.pyd')): - * self._source = "??? NO SOURCE: not reading {} file".format(splitext(basename(self.filename))[1]) # <<<<<<<<<<<<<< + * self._source = f'??? NO SOURCE: not reading binary {splitext(basename(self.filename))[1]} file' # <<<<<<<<<<<<<< * try: - * self._source = getline(self.filename, self.lineno, self.frame.f_globals) - */ - __Pyx_TraceLine(285,0,__PYX_ERR(0, 285, __pyx_L1_error)) - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_NO_SOURCE_not_reading_file, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 285, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_splitext); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 285, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_basename); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 285, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_filename); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 285, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_10 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { - __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_8); - if (likely(__pyx_t_10)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); - __Pyx_INCREF(__pyx_t_10); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_8, function); - } - } - __pyx_t_7 = (__pyx_t_10) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_10, __pyx_t_9) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_9); - __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 285, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); - if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); - __Pyx_INCREF(__pyx_t_8); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_6, function); - } - } - __pyx_t_4 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_8, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 285, __pyx_L1_error) + * self._source = getline(self.filename, self.lineno, self.globals) +*/ + __Pyx_TraceLine(331,17,0,__PYX_ERR(0, 331, __pyx_L1_error)) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_splitext); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_basename); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 331, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_4, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 285, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_filename_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 331, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - } - } - __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_4, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 285, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_3, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_t_6, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 331, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_GIVEREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_7[0] = __pyx_mstate_global->__pyx_kp_u_NO_SOURCE_not_reading_binary; + __pyx_t_7[1] = __pyx_t_3; + __pyx_t_7[2] = __pyx_mstate_global->__pyx_kp_u_file_2; + __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, 34 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + 5, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3)); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GIVEREF(__pyx_t_6); __Pyx_GOTREF(__pyx_v_self->_source); __Pyx_DECREF(__pyx_v_self->_source); - __pyx_v_self->_source = __pyx_t_3; - __pyx_t_3 = 0; + __pyx_v_self->_source = __pyx_t_6; + __pyx_t_6 = 0; - /* "hunter/_event.pyx":284 - * def source(self): + /* "hunter/_event.pyx":330 + * cdef inline source_getter(self): * if self._source is UNSET: * if self.filename.endswith(('.so', '.pyd')): # <<<<<<<<<<<<<< - * self._source = "??? NO SOURCE: not reading {} file".format(splitext(basename(self.filename))[1]) + * self._source = f'??? NO SOURCE: not reading binary {splitext(basename(self.filename))[1]} file' * try: - */ +*/ } - /* "hunter/_event.pyx":286 + /* "hunter/_event.pyx":332 * if self.filename.endswith(('.so', '.pyd')): - * self._source = "??? NO SOURCE: not reading {} file".format(splitext(basename(self.filename))[1]) + * self._source = f'??? NO SOURCE: not reading binary {splitext(basename(self.filename))[1]} file' * try: # <<<<<<<<<<<<<< - * self._source = getline(self.filename, self.lineno, self.frame.f_globals) + * self._source = getline(self.filename, self.lineno, self.globals) * except Exception as exc: - */ - __Pyx_TraceLine(286,0,__PYX_ERR(0, 286, __pyx_L1_error)) +*/ + __Pyx_TraceLine(332,25,0,__PYX_ERR(0, 332, __pyx_L1_error)) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13); - __Pyx_XGOTREF(__pyx_t_11); - __Pyx_XGOTREF(__pyx_t_12); - __Pyx_XGOTREF(__pyx_t_13); + __Pyx_ExceptionSave(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_10); /*try:*/ { - /* "hunter/_event.pyx":287 - * self._source = "??? NO SOURCE: not reading {} file".format(splitext(basename(self.filename))[1]) + /* "hunter/_event.pyx":333 + * self._source = f'??? NO SOURCE: not reading binary {splitext(basename(self.filename))[1]} file' * try: - * self._source = getline(self.filename, self.lineno, self.frame.f_globals) # <<<<<<<<<<<<<< + * self._source = getline(self.filename, self.lineno, self.globals) # <<<<<<<<<<<<<< * except Exception as exc: - * self._source = "??? NO SOURCE: {!r}".format(exc) - */ - __Pyx_TraceLine(287,0,__PYX_ERR(0, 287, __pyx_L5_error)) - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_getline); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 287, __pyx_L5_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_filename); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 287, __pyx_L5_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_lineno); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 287, __pyx_L5_error) + * self._source = f'??? NO SOURCE: {exc!r}' +*/ + __Pyx_TraceLine(333,29,0,__PYX_ERR(0, 333, __pyx_L5_error)) + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_getline); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 333, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_filename_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 333, __pyx_L5_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_7 = NULL; - __pyx_t_14 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_7)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_7); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - __pyx_t_14 = 1; - } + __pyx_t_11 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_lineno_2); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 333, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_12 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_globals); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 333, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_2, __pyx__function); + __pyx_t_5 = 0; } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_5)) { - PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_6, __pyx_t_4, __pyx_v_self->frame->f_globals}; - __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_14, 3+__pyx_t_14); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 287, __pyx_L5_error) - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { - PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_6, __pyx_t_4, __pyx_v_self->frame->f_globals}; - __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_14, 3+__pyx_t_14); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 287, __pyx_L5_error) - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - } else #endif { - __pyx_t_8 = PyTuple_New(3+__pyx_t_14); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 287, __pyx_L5_error) - __Pyx_GOTREF(__pyx_t_8); - if (__pyx_t_7) { - __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL; - } - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_14, __pyx_t_6); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_14, __pyx_t_4); - __Pyx_INCREF(__pyx_v_self->frame->f_globals); - __Pyx_GIVEREF(__pyx_v_self->frame->f_globals); - PyTuple_SET_ITEM(__pyx_t_8, 2+__pyx_t_14, __pyx_v_self->frame->f_globals); - __pyx_t_6 = 0; - __pyx_t_4 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 287, __pyx_L5_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + PyObject *__pyx_callargs[4] = {__pyx_t_3, __pyx_t_4, __pyx_t_11, __pyx_t_12}; + __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_5, (4-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 333, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_6); } - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_6); __Pyx_GOTREF(__pyx_v_self->_source); __Pyx_DECREF(__pyx_v_self->_source); - __pyx_v_self->_source = __pyx_t_3; - __pyx_t_3 = 0; + __pyx_v_self->_source = __pyx_t_6; + __pyx_t_6 = 0; - /* "hunter/_event.pyx":286 + /* "hunter/_event.pyx":332 * if self.filename.endswith(('.so', '.pyd')): - * self._source = "??? NO SOURCE: not reading {} file".format(splitext(basename(self.filename))[1]) + * self._source = f'??? NO SOURCE: not reading binary {splitext(basename(self.filename))[1]} file' * try: # <<<<<<<<<<<<<< - * self._source = getline(self.filename, self.lineno, self.frame.f_globals) + * self._source = getline(self.filename, self.lineno, self.globals) * except Exception as exc: - */ +*/ } - __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; - __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; - __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; goto __pyx_L10_try_end; __pyx_L5_error:; - __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_TraceException(__pyx_lineno, 0, 0); - /* "hunter/_event.pyx":288 + /* "hunter/_event.pyx":334 * try: - * self._source = getline(self.filename, self.lineno, self.frame.f_globals) + * self._source = getline(self.filename, self.lineno, self.globals) * except Exception as exc: # <<<<<<<<<<<<<< - * self._source = "??? NO SOURCE: {!r}".format(exc) + * self._source = f'??? NO SOURCE: {exc!r}' * - */ - __Pyx_TraceLine(288,0,__PYX_ERR(0, 288, __pyx_L7_except_error)) - __pyx_t_14 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); - if (__pyx_t_14) { - __Pyx_AddTraceback("hunter._event.Event.source.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_5, &__pyx_t_8) < 0) __PYX_ERR(0, 288, __pyx_L7_except_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GOTREF(__pyx_t_8); - __Pyx_INCREF(__pyx_t_5); - __pyx_v_exc = __pyx_t_5; +*/ + __Pyx_TraceLine(334,37,0,__PYX_ERR(0, 334, __pyx_L7_except_error)) + __pyx_t_13 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception)))); + if (__pyx_t_13) { + __Pyx_AddTraceback("hunter._event.Event.source_getter", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceExceptionHandled(36); + if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_2, &__pyx_t_12) < 0) __PYX_ERR(0, 334, __pyx_L7_except_error) + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_12); + __Pyx_TraceExceptionDone(); + __Pyx_INCREF(__pyx_t_2); + __pyx_v_exc = __pyx_t_2; /*try:*/ { - /* "hunter/_event.pyx":289 - * self._source = getline(self.filename, self.lineno, self.frame.f_globals) + /* "hunter/_event.pyx":335 + * self._source = getline(self.filename, self.lineno, self.globals) * except Exception as exc: - * self._source = "??? NO SOURCE: {!r}".format(exc) # <<<<<<<<<<<<<< + * self._source = f'??? NO SOURCE: {exc!r}' # <<<<<<<<<<<<<< * * return self._source - */ - __Pyx_TraceLine(289,0,__PYX_ERR(0, 289, __pyx_L16_error)) - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_NO_SOURCE_r, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 289, __pyx_L16_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); - if (likely(__pyx_t_7)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); - __Pyx_INCREF(__pyx_t_7); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_6, function); - } - } - __pyx_t_4 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_v_exc) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_exc); - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 289, __pyx_L16_error) +*/ + __Pyx_TraceLine(335,42,0,__PYX_ERR(0, 335, __pyx_L16_error)) + __pyx_t_11 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_exc), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 335, __pyx_L16_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_4 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_NO_SOURCE, __pyx_t_11); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 335, __pyx_L16_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_GIVEREF(__pyx_t_4); __Pyx_GOTREF(__pyx_v_self->_source); __Pyx_DECREF(__pyx_v_self->_source); @@ -7126,215 +9443,309 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_6source___get__(struct __pyx_ob __pyx_t_4 = 0; } - /* "hunter/_event.pyx":288 + /* "hunter/_event.pyx":334 * try: - * self._source = getline(self.filename, self.lineno, self.frame.f_globals) + * self._source = getline(self.filename, self.lineno, self.globals) * except Exception as exc: # <<<<<<<<<<<<<< - * self._source = "??? NO SOURCE: {!r}".format(exc) + * self._source = f'??? NO SOURCE: {exc!r}' * - */ - __Pyx_TraceLine(288,0,__PYX_ERR(0, 288, __pyx_L16_error)) +*/ + __Pyx_TraceLine(334,36,0,__PYX_ERR(0, 334, __pyx_L16_error)) /*finally:*/ { /*normal exit:*/{ - __Pyx_DECREF(__pyx_v_exc); - __pyx_v_exc = NULL; + __Pyx_DECREF(__pyx_v_exc); __pyx_v_exc = 0; goto __pyx_L17; } __pyx_L16_error:; /*exception exit:*/{ __Pyx_PyThreadState_declare + __Pyx_TraceException(__pyx_lineno, 0, 0); + __Pyx_TraceExceptionHandled(36); __Pyx_PyThreadState_assign - __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; - __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_20, &__pyx_t_21, &__pyx_t_22); - if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19) < 0)) __Pyx_ErrFetch(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19); + __Pyx_ExceptionSwap(&__pyx_t_19, &__pyx_t_20, &__pyx_t_21); + if ( unlikely(__Pyx_GetException(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18) < 0)) __Pyx_ErrFetch(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18); + __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_18); __Pyx_XGOTREF(__pyx_t_19); __Pyx_XGOTREF(__pyx_t_20); __Pyx_XGOTREF(__pyx_t_21); - __Pyx_XGOTREF(__pyx_t_22); - __pyx_t_14 = __pyx_lineno; __pyx_t_15 = __pyx_clineno; __pyx_t_16 = __pyx_filename; + __pyx_t_13 = __pyx_lineno; __pyx_t_14 = __pyx_clineno; __pyx_t_15 = __pyx_filename; { - __Pyx_DECREF(__pyx_v_exc); - __pyx_v_exc = NULL; - } - if (PY_MAJOR_VERSION >= 3) { - __Pyx_XGIVEREF(__pyx_t_20); - __Pyx_XGIVEREF(__pyx_t_21); - __Pyx_XGIVEREF(__pyx_t_22); - __Pyx_ExceptionReset(__pyx_t_20, __pyx_t_21, __pyx_t_22); + __Pyx_DECREF(__pyx_v_exc); __pyx_v_exc = 0; } + __Pyx_XGIVEREF(__pyx_t_19); + __Pyx_XGIVEREF(__pyx_t_20); + __Pyx_XGIVEREF(__pyx_t_21); + __Pyx_ExceptionReset(__pyx_t_19, __pyx_t_20, __pyx_t_21); + __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_18); - __Pyx_XGIVEREF(__pyx_t_19); - __Pyx_ErrRestore(__pyx_t_17, __pyx_t_18, __pyx_t_19); - __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; - __pyx_lineno = __pyx_t_14; __pyx_clineno = __pyx_t_15; __pyx_filename = __pyx_t_16; + __Pyx_ErrRestore(__pyx_t_16, __pyx_t_17, __pyx_t_18); + __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; + __pyx_lineno = __pyx_t_13; __pyx_clineno = __pyx_t_14; __pyx_filename = __pyx_t_15; + __Pyx_TraceException(36, 1, 0); goto __pyx_L7_except_error; } __pyx_L17:; } - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L6_exception_handled; } goto __pyx_L7_except_error; - __pyx_L7_except_error:; - /* "hunter/_event.pyx":286 + /* "hunter/_event.pyx":332 * if self.filename.endswith(('.so', '.pyd')): - * self._source = "??? NO SOURCE: not reading {} file".format(splitext(basename(self.filename))[1]) + * self._source = f'??? NO SOURCE: not reading binary {splitext(basename(self.filename))[1]} file' * try: # <<<<<<<<<<<<<< - * self._source = getline(self.filename, self.lineno, self.frame.f_globals) + * self._source = getline(self.filename, self.lineno, self.globals) * except Exception as exc: - */ - __Pyx_XGIVEREF(__pyx_t_11); - __Pyx_XGIVEREF(__pyx_t_12); - __Pyx_XGIVEREF(__pyx_t_13); - __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13); +*/ + __pyx_L7_except_error:; + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10); goto __pyx_L1_error; __pyx_L6_exception_handled:; - __Pyx_XGIVEREF(__pyx_t_11); - __Pyx_XGIVEREF(__pyx_t_12); - __Pyx_XGIVEREF(__pyx_t_13); - __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10); __pyx_L10_try_end:; } - /* "hunter/_event.pyx":283 - * @property - * def source(self): + /* "hunter/_event.pyx":329 + * + * cdef inline source_getter(self): * if self._source is UNSET: # <<<<<<<<<<<<<< * if self.filename.endswith(('.so', '.pyd')): - * self._source = "??? NO SOURCE: not reading {} file".format(splitext(basename(self.filename))[1]) - */ + * self._source = f'??? NO SOURCE: not reading binary {splitext(basename(self.filename))[1]} file' +*/ } - /* "hunter/_event.pyx":291 - * self._source = "??? NO SOURCE: {!r}".format(exc) + /* "hunter/_event.pyx":337 + * self._source = f'??? NO SOURCE: {exc!r}' * * return self._source # <<<<<<<<<<<<<< * - * def __getitem__(self, item): - */ - __Pyx_TraceLine(291,0,__PYX_ERR(0, 291, __pyx_L1_error)) + * @property +*/ + __Pyx_TraceLine(337,44,0,__PYX_ERR(0, 337, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->_source); __pyx_r = __pyx_v_self->_source; + __Pyx_TraceReturnValue(__pyx_r, 44, 0, __PYX_ERR(0, 337, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_event.pyx":282 + /* "hunter/_event.pyx":328 + * return self.fullsource_getter() * - * @property - * def source(self): # <<<<<<<<<<<<<< + * cdef inline source_getter(self): # <<<<<<<<<<<<<< * if self._source is UNSET: * if self.filename.endswith(('.so', '.pyd')): - */ +*/ /* function exit code */ __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_XDECREF(__pyx_t_9); - __Pyx_XDECREF(__pyx_t_10); - __Pyx_AddTraceback("hunter._event.Event.source.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 328, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.Event.source_getter", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_exc); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/_event.pyx":339 + * return self._source + * + * @property # <<<<<<<<<<<<<< + * def source(self): + * return self.source_getter() +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_6_event_5Event_6source_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_6_event_5Event_6source_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_6_event_5Event_6source___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); + + /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_event.pyx":293 +static PyObject *__pyx_pf_6hunter_6_event_5Event_6source___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[31])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[0], 339, 0, 0, 0, __PYX_ERR(0, 339, __pyx_L1_error)); + + /* "hunter/_event.pyx":341 + * @property + * def source(self): + * return self.source_getter() # <<<<<<<<<<<<<< + * + * def __getitem__(self, item): +*/ + __Pyx_TraceLine(341,1,0,__PYX_ERR(0, 341, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6hunter_6_event_5Event_source_getter(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 341, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 341, __pyx_L1_error)); + goto __pyx_L0; + + /* "hunter/_event.pyx":339 * return self._source * + * @property # <<<<<<<<<<<<<< + * def source(self): + * return self.source_getter() +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 339, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.Event.source.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/_event.pyx":343 + * return self.source_getter() + * * def __getitem__(self, item): # <<<<<<<<<<<<<< * return getattr(self, item) * - */ +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_6_event_5Event_5__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item); /*proto*/ -static PyObject *__pyx_pw_6hunter_6_event_5Event_5__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item) { +static PyObject *__pyx_pw_6hunter_6_event_5Event_11__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item); /*proto*/ +static PyObject *__pyx_pw_6hunter_6_event_5Event_11__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_6_event_5Event_4__getitem__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self), ((PyObject *)__pyx_v_item)); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_6_event_5Event_10__getitem__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self), ((PyObject *)__pyx_v_item)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_6_event_5Event_4__getitem__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self, PyObject *__pyx_v_item) { +static PyObject *__pyx_pf_6hunter_6_event_5Event_10__getitem__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self, PyObject *__pyx_v_item) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[32])) __Pyx_RefNannySetupContext("__getitem__", 0); - __Pyx_TraceCall("__getitem__", __pyx_f[0], 293, 0, __PYX_ERR(0, 293, __pyx_L1_error)); + __Pyx_TraceStartFunc("__getitem__", __pyx_f[0], 343, 0, 0, 0, __PYX_ERR(0, 343, __pyx_L1_error)); - /* "hunter/_event.pyx":294 + /* "hunter/_event.pyx":344 * * def __getitem__(self, item): * return getattr(self, item) # <<<<<<<<<<<<<< * * - */ - __Pyx_TraceLine(294,0,__PYX_ERR(0, 294, __pyx_L1_error)) +*/ + __Pyx_TraceLine(344,1,0,__PYX_ERR(0, 344, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_GetAttr(((PyObject *)__pyx_v_self), __pyx_v_item); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 294, __pyx_L1_error) + __pyx_t_1 = __Pyx_GetAttr(((PyObject *)__pyx_v_self), __pyx_v_item); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 344, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 344, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_event.pyx":293 - * return self._source + /* "hunter/_event.pyx":343 + * return self.source_getter() * * def __getitem__(self, item): # <<<<<<<<<<<<<< * return getattr(self, item) * - */ +*/ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 343, __pyx_L1_error)); + #endif __Pyx_AddTraceback("hunter._event.Event.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_event.pxd":13 +/* "hunter/_event.pxd":42 * cdef class Event: * cdef: * readonly FrameType frame # <<<<<<<<<<<<<< * readonly str kind * readonly object arg - */ +*/ /* Python wrapper */ static PyObject *__pyx_pw_6hunter_6_event_5Event_5frame_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_6hunter_6_event_5Event_5frame_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_6hunter_6_event_5Event_5frame___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); /* function exit code */ @@ -7344,40 +9755,53 @@ static PyObject *__pyx_pw_6hunter_6_event_5Event_5frame_1__get__(PyObject *__pyx static PyObject *__pyx_pf_6hunter_6_event_5Event_5frame___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[33])) __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 13, 0, __PYX_ERR(1, 13, __pyx_L1_error)); + __Pyx_TraceStartFunc("__get__", __pyx_f[1], 42, 0, 0, 0, __PYX_ERR(1, 42, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_self->frame)); + __Pyx_INCREF(__pyx_v_self->frame); __pyx_r = ((PyObject *)__pyx_v_self->frame); + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(1, 42, __pyx_L1_error)); goto __pyx_L0; /* function exit code */ __pyx_L1_error:; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 42, __pyx_L1_error)); + #endif __Pyx_AddTraceback("hunter._event.Event.frame.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_event.pxd":14 +/* "hunter/_event.pxd":43 * cdef: * readonly FrameType frame * readonly str kind # <<<<<<<<<<<<<< * readonly object arg * readonly int depth - */ +*/ /* Python wrapper */ static PyObject *__pyx_pw_6hunter_6_event_5Event_4kind_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_6hunter_6_event_5Event_4kind_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_6hunter_6_event_5Event_4kind___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); /* function exit code */ @@ -7387,40 +9811,53 @@ static PyObject *__pyx_pw_6hunter_6_event_5Event_4kind_1__get__(PyObject *__pyx_ static PyObject *__pyx_pf_6hunter_6_event_5Event_4kind___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[34])) __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 14, 0, __PYX_ERR(1, 14, __pyx_L1_error)); + __Pyx_TraceStartFunc("__get__", __pyx_f[1], 43, 0, 0, 0, __PYX_ERR(1, 43, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->kind); __pyx_r = __pyx_v_self->kind; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(1, 43, __pyx_L1_error)); goto __pyx_L0; /* function exit code */ __pyx_L1_error:; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 43, __pyx_L1_error)); + #endif __Pyx_AddTraceback("hunter._event.Event.kind.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_event.pxd":15 +/* "hunter/_event.pxd":44 * readonly FrameType frame * readonly str kind * readonly object arg # <<<<<<<<<<<<<< * readonly int depth * readonly int calls - */ +*/ /* Python wrapper */ static PyObject *__pyx_pw_6hunter_6_event_5Event_3arg_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_6hunter_6_event_5Event_3arg_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_6hunter_6_event_5Event_3arg___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); /* function exit code */ @@ -7430,40 +9867,53 @@ static PyObject *__pyx_pw_6hunter_6_event_5Event_3arg_1__get__(PyObject *__pyx_v static PyObject *__pyx_pf_6hunter_6_event_5Event_3arg___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[35])) __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 15, 0, __PYX_ERR(1, 15, __pyx_L1_error)); + __Pyx_TraceStartFunc("__get__", __pyx_f[1], 44, 0, 0, 0, __PYX_ERR(1, 44, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->arg); __pyx_r = __pyx_v_self->arg; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(1, 44, __pyx_L1_error)); goto __pyx_L0; /* function exit code */ __pyx_L1_error:; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 44, __pyx_L1_error)); + #endif __Pyx_AddTraceback("hunter._event.Event.arg.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_event.pxd":16 +/* "hunter/_event.pxd":45 * readonly str kind * readonly object arg * readonly int depth # <<<<<<<<<<<<<< * readonly int calls * readonly bint threading_support - */ +*/ /* Python wrapper */ static PyObject *__pyx_pw_6hunter_6_event_5Event_5depth_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_6hunter_6_event_5Event_5depth_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_6hunter_6_event_5Event_5depth___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); /* function exit code */ @@ -7473,44 +9923,57 @@ static PyObject *__pyx_pw_6hunter_6_event_5Event_5depth_1__get__(PyObject *__pyx static PyObject *__pyx_pf_6hunter_6_event_5Event_5depth___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[36])) __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 16, 0, __PYX_ERR(1, 16, __pyx_L1_error)); + __Pyx_TraceStartFunc("__get__", __pyx_f[1], 45, 0, 0, 0, __PYX_ERR(1, 45, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->depth); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 16, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->depth); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 45, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(1, 45, __pyx_L1_error)); goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 45, __pyx_L1_error)); + #endif __Pyx_AddTraceback("hunter._event.Event.depth.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_event.pxd":17 +/* "hunter/_event.pxd":46 * readonly object arg * readonly int depth * readonly int calls # <<<<<<<<<<<<<< * readonly bint threading_support * readonly bint detached - */ +*/ /* Python wrapper */ static PyObject *__pyx_pw_6hunter_6_event_5Event_5calls_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_6hunter_6_event_5Event_5calls_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_6hunter_6_event_5Event_5calls___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); /* function exit code */ @@ -7520,44 +9983,57 @@ static PyObject *__pyx_pw_6hunter_6_event_5Event_5calls_1__get__(PyObject *__pyx static PyObject *__pyx_pf_6hunter_6_event_5Event_5calls___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[37])) __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 17, 0, __PYX_ERR(1, 17, __pyx_L1_error)); + __Pyx_TraceStartFunc("__get__", __pyx_f[1], 46, 0, 0, 0, __PYX_ERR(1, 46, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->calls); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->calls); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 46, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(1, 46, __pyx_L1_error)); goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 46, __pyx_L1_error)); + #endif __Pyx_AddTraceback("hunter._event.Event.calls.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_event.pxd":18 +/* "hunter/_event.pxd":47 * readonly int depth * readonly int calls * readonly bint threading_support # <<<<<<<<<<<<<< * readonly bint detached - * - */ + * readonly object builtin +*/ /* Python wrapper */ static PyObject *__pyx_pw_6hunter_6_event_5Event_17threading_support_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_6hunter_6_event_5Event_17threading_support_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_6hunter_6_event_5Event_17threading_support___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); /* function exit code */ @@ -7567,44 +10043,57 @@ static PyObject *__pyx_pw_6hunter_6_event_5Event_17threading_support_1__get__(Py static PyObject *__pyx_pf_6hunter_6_event_5Event_17threading_support___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[38])) __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 18, 0, __PYX_ERR(1, 18, __pyx_L1_error)); + __Pyx_TraceStartFunc("__get__", __pyx_f[1], 47, 0, 0, 0, __PYX_ERR(1, 47, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->threading_support); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 18, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->threading_support); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 47, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(1, 47, __pyx_L1_error)); goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 47, __pyx_L1_error)); + #endif __Pyx_AddTraceback("hunter._event.Event.threading_support.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_event.pxd":19 +/* "hunter/_event.pxd":48 * readonly int calls * readonly bint threading_support * readonly bint detached # <<<<<<<<<<<<<< + * readonly object builtin * - * object _code - */ +*/ /* Python wrapper */ static PyObject *__pyx_pw_6hunter_6_event_5Event_8detached_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_6hunter_6_event_5Event_8detached_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_6hunter_6_event_5Event_8detached___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); /* function exit code */ @@ -7614,607 +10103,200 @@ static PyObject *__pyx_pw_6hunter_6_event_5Event_8detached_1__get__(PyObject *__ static PyObject *__pyx_pf_6hunter_6_event_5Event_8detached___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[39])) __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 19, 0, __PYX_ERR(1, 19, __pyx_L1_error)); + __Pyx_TraceStartFunc("__get__", __pyx_f[1], 48, 0, 0, 0, __PYX_ERR(1, 48, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->detached); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 19, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->detached); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 48, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(1, 48, __pyx_L1_error)); goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 48, __pyx_L1_error)); + #endif __Pyx_AddTraceback("hunter._event.Event.detached.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict - */ +/* "hunter/_event.pxd":49 + * readonly bint threading_support + * readonly bint detached + * readonly object builtin # <<<<<<<<<<<<<< + * + * object _code +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_6_event_5Event_7__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_pw_6hunter_6_event_5Event_7__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_6hunter_6_event_5Event_7builtin_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_6_event_5Event_7builtin_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_6_event_5Event_6__reduce_cython__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_6_event_5Event_7builtin___get__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_6_event_5Event_6__reduce_cython__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { - PyObject *__pyx_v_state = 0; - PyObject *__pyx_v__dict = 0; - int __pyx_v_use_setstate; +static PyObject *__pyx_pf_6hunter_6_event_5Event_7builtin___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - int __pyx_t_6; - int __pyx_t_7; - int __pyx_t_8; - __Pyx_RefNannySetupContext("__reduce_cython__", 0); - __Pyx_TraceCall("__reduce_cython__", __pyx_f[2], 1, 0, __PYX_ERR(2, 1, __pyx_L1_error)); - - /* "(tree fragment)":5 - * cdef object _dict - * cdef bint use_setstate - * state = (self._code, self._filename, self._fullsource, self._function, self._function_object, self._globals, self._lineno, self._locals, self._module, self._source, self._stdlib, self._thread, self._threadidn, self._threadname, self.arg, self.calls, self.depth, self.detached, self.frame, self.kind, self.threading_support) # <<<<<<<<<<<<<< - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: - */ - __Pyx_TraceLine(5,0,__PYX_ERR(2, 5, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->calls); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->depth); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_self->detached); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_self->threading_support); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyTuple_New(21); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_INCREF(__pyx_v_self->_code); - __Pyx_GIVEREF(__pyx_v_self->_code); - PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_self->_code); - __Pyx_INCREF(__pyx_v_self->_filename); - __Pyx_GIVEREF(__pyx_v_self->_filename); - PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_v_self->_filename); - __Pyx_INCREF(__pyx_v_self->_fullsource); - __Pyx_GIVEREF(__pyx_v_self->_fullsource); - PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_self->_fullsource); - __Pyx_INCREF(__pyx_v_self->_function); - __Pyx_GIVEREF(__pyx_v_self->_function); - PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_v_self->_function); - __Pyx_INCREF(__pyx_v_self->_function_object); - __Pyx_GIVEREF(__pyx_v_self->_function_object); - PyTuple_SET_ITEM(__pyx_t_5, 4, __pyx_v_self->_function_object); - __Pyx_INCREF(__pyx_v_self->_globals); - __Pyx_GIVEREF(__pyx_v_self->_globals); - PyTuple_SET_ITEM(__pyx_t_5, 5, __pyx_v_self->_globals); - __Pyx_INCREF(__pyx_v_self->_lineno); - __Pyx_GIVEREF(__pyx_v_self->_lineno); - PyTuple_SET_ITEM(__pyx_t_5, 6, __pyx_v_self->_lineno); - __Pyx_INCREF(__pyx_v_self->_locals); - __Pyx_GIVEREF(__pyx_v_self->_locals); - PyTuple_SET_ITEM(__pyx_t_5, 7, __pyx_v_self->_locals); - __Pyx_INCREF(__pyx_v_self->_module); - __Pyx_GIVEREF(__pyx_v_self->_module); - PyTuple_SET_ITEM(__pyx_t_5, 8, __pyx_v_self->_module); - __Pyx_INCREF(__pyx_v_self->_source); - __Pyx_GIVEREF(__pyx_v_self->_source); - PyTuple_SET_ITEM(__pyx_t_5, 9, __pyx_v_self->_source); - __Pyx_INCREF(__pyx_v_self->_stdlib); - __Pyx_GIVEREF(__pyx_v_self->_stdlib); - PyTuple_SET_ITEM(__pyx_t_5, 10, __pyx_v_self->_stdlib); - __Pyx_INCREF(__pyx_v_self->_thread); - __Pyx_GIVEREF(__pyx_v_self->_thread); - PyTuple_SET_ITEM(__pyx_t_5, 11, __pyx_v_self->_thread); - __Pyx_INCREF(__pyx_v_self->_threadidn); - __Pyx_GIVEREF(__pyx_v_self->_threadidn); - PyTuple_SET_ITEM(__pyx_t_5, 12, __pyx_v_self->_threadidn); - __Pyx_INCREF(__pyx_v_self->_threadname); - __Pyx_GIVEREF(__pyx_v_self->_threadname); - PyTuple_SET_ITEM(__pyx_t_5, 13, __pyx_v_self->_threadname); - __Pyx_INCREF(__pyx_v_self->arg); - __Pyx_GIVEREF(__pyx_v_self->arg); - PyTuple_SET_ITEM(__pyx_t_5, 14, __pyx_v_self->arg); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_5, 15, __pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_5, 16, __pyx_t_2); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_5, 17, __pyx_t_3); - __Pyx_INCREF(((PyObject *)__pyx_v_self->frame)); - __Pyx_GIVEREF(((PyObject *)__pyx_v_self->frame)); - PyTuple_SET_ITEM(__pyx_t_5, 18, ((PyObject *)__pyx_v_self->frame)); - __Pyx_INCREF(__pyx_v_self->kind); - __Pyx_GIVEREF(__pyx_v_self->kind); - PyTuple_SET_ITEM(__pyx_t_5, 19, __pyx_v_self->kind); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_5, 20, __pyx_t_4); - __pyx_t_1 = 0; - __pyx_t_2 = 0; - __pyx_t_3 = 0; - __pyx_t_4 = 0; - __pyx_v_state = ((PyObject*)__pyx_t_5); - __pyx_t_5 = 0; - - /* "(tree fragment)":6 - * cdef bint use_setstate - * state = (self._code, self._filename, self._fullsource, self._function, self._function_object, self._globals, self._lineno, self._locals, self._module, self._source, self._stdlib, self._thread, self._threadidn, self._threadname, self.arg, self.calls, self.depth, self.detached, self.frame, self.kind, self.threading_support) - * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< - * if _dict is not None: - * state += (_dict,) - */ - __Pyx_TraceLine(6,0,__PYX_ERR(2, 6, __pyx_L1_error)) - __pyx_t_5 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_v__dict = __pyx_t_5; - __pyx_t_5 = 0; - - /* "(tree fragment)":7 - * state = (self._code, self._filename, self._fullsource, self._function, self._function_object, self._globals, self._lineno, self._locals, self._module, self._source, self._stdlib, self._thread, self._threadidn, self._threadname, self.arg, self.calls, self.depth, self.detached, self.frame, self.kind, self.threading_support) - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: # <<<<<<<<<<<<<< - * state += (_dict,) - * use_setstate = True - */ - __Pyx_TraceLine(7,0,__PYX_ERR(2, 7, __pyx_L1_error)) - __pyx_t_6 = (__pyx_v__dict != Py_None); - __pyx_t_7 = (__pyx_t_6 != 0); - if (__pyx_t_7) { - - /* "(tree fragment)":8 - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: - * state += (_dict,) # <<<<<<<<<<<<<< - * use_setstate = True - * else: - */ - __Pyx_TraceLine(8,0,__PYX_ERR(2, 8, __pyx_L1_error)) - __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_INCREF(__pyx_v__dict); - __Pyx_GIVEREF(__pyx_v__dict); - PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v__dict); - __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4)); - __pyx_t_4 = 0; - - /* "(tree fragment)":9 - * if _dict is not None: - * state += (_dict,) - * use_setstate = True # <<<<<<<<<<<<<< - * else: - * use_setstate = self._code is not None or self._filename is not None or self._fullsource is not None or self._function is not None or self._function_object is not None or self._globals is not None or self._lineno is not None or self._locals is not None or self._module is not None or self._source is not None or self._stdlib is not None or self._thread is not None or self._threadidn is not None or self._threadname is not None or self.arg is not None or self.frame is not None or self.kind is not None - */ - __Pyx_TraceLine(9,0,__PYX_ERR(2, 9, __pyx_L1_error)) - __pyx_v_use_setstate = 1; - - /* "(tree fragment)":7 - * state = (self._code, self._filename, self._fullsource, self._function, self._function_object, self._globals, self._lineno, self._locals, self._module, self._source, self._stdlib, self._thread, self._threadidn, self._threadname, self.arg, self.calls, self.depth, self.detached, self.frame, self.kind, self.threading_support) - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: # <<<<<<<<<<<<<< - * state += (_dict,) - * use_setstate = True - */ - goto __pyx_L3; - } - - /* "(tree fragment)":11 - * use_setstate = True - * else: - * use_setstate = self._code is not None or self._filename is not None or self._fullsource is not None or self._function is not None or self._function_object is not None or self._globals is not None or self._lineno is not None or self._locals is not None or self._module is not None or self._source is not None or self._stdlib is not None or self._thread is not None or self._threadidn is not None or self._threadname is not None or self.arg is not None or self.frame is not None or self.kind is not None # <<<<<<<<<<<<<< - * if use_setstate: - * return __pyx_unpickle_Event, (type(self), 0x36bd738, None), state - */ - __Pyx_TraceLine(11,0,__PYX_ERR(2, 11, __pyx_L1_error)) - /*else*/ { - __pyx_t_6 = (__pyx_v_self->_code != Py_None); - __pyx_t_8 = (__pyx_t_6 != 0); - if (!__pyx_t_8) { - } else { - __pyx_t_7 = __pyx_t_8; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_8 = (__pyx_v_self->_filename != Py_None); - __pyx_t_6 = (__pyx_t_8 != 0); - if (!__pyx_t_6) { - } else { - __pyx_t_7 = __pyx_t_6; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_6 = (__pyx_v_self->_fullsource != Py_None); - __pyx_t_8 = (__pyx_t_6 != 0); - if (!__pyx_t_8) { - } else { - __pyx_t_7 = __pyx_t_8; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_8 = (__pyx_v_self->_function != Py_None); - __pyx_t_6 = (__pyx_t_8 != 0); - if (!__pyx_t_6) { - } else { - __pyx_t_7 = __pyx_t_6; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_6 = (__pyx_v_self->_function_object != Py_None); - __pyx_t_8 = (__pyx_t_6 != 0); - if (!__pyx_t_8) { - } else { - __pyx_t_7 = __pyx_t_8; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_8 = (__pyx_v_self->_globals != Py_None); - __pyx_t_6 = (__pyx_t_8 != 0); - if (!__pyx_t_6) { - } else { - __pyx_t_7 = __pyx_t_6; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_6 = (__pyx_v_self->_lineno != Py_None); - __pyx_t_8 = (__pyx_t_6 != 0); - if (!__pyx_t_8) { - } else { - __pyx_t_7 = __pyx_t_8; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_8 = (__pyx_v_self->_locals != Py_None); - __pyx_t_6 = (__pyx_t_8 != 0); - if (!__pyx_t_6) { - } else { - __pyx_t_7 = __pyx_t_6; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_6 = (__pyx_v_self->_module != Py_None); - __pyx_t_8 = (__pyx_t_6 != 0); - if (!__pyx_t_8) { - } else { - __pyx_t_7 = __pyx_t_8; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_8 = (__pyx_v_self->_source != Py_None); - __pyx_t_6 = (__pyx_t_8 != 0); - if (!__pyx_t_6) { - } else { - __pyx_t_7 = __pyx_t_6; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_6 = (__pyx_v_self->_stdlib != Py_None); - __pyx_t_8 = (__pyx_t_6 != 0); - if (!__pyx_t_8) { - } else { - __pyx_t_7 = __pyx_t_8; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_8 = (__pyx_v_self->_thread != Py_None); - __pyx_t_6 = (__pyx_t_8 != 0); - if (!__pyx_t_6) { - } else { - __pyx_t_7 = __pyx_t_6; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_6 = (__pyx_v_self->_threadidn != Py_None); - __pyx_t_8 = (__pyx_t_6 != 0); - if (!__pyx_t_8) { - } else { - __pyx_t_7 = __pyx_t_8; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_8 = (__pyx_v_self->_threadname != Py_None); - __pyx_t_6 = (__pyx_t_8 != 0); - if (!__pyx_t_6) { - } else { - __pyx_t_7 = __pyx_t_6; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_6 = (__pyx_v_self->arg != Py_None); - __pyx_t_8 = (__pyx_t_6 != 0); - if (!__pyx_t_8) { - } else { - __pyx_t_7 = __pyx_t_8; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_8 = (((PyObject *)__pyx_v_self->frame) != Py_None); - __pyx_t_6 = (__pyx_t_8 != 0); - if (!__pyx_t_6) { - } else { - __pyx_t_7 = __pyx_t_6; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_6 = (__pyx_v_self->kind != ((PyObject*)Py_None)); - __pyx_t_8 = (__pyx_t_6 != 0); - __pyx_t_7 = __pyx_t_8; - __pyx_L4_bool_binop_done:; - __pyx_v_use_setstate = __pyx_t_7; - } - __pyx_L3:; - - /* "(tree fragment)":12 - * else: - * use_setstate = self._code is not None or self._filename is not None or self._fullsource is not None or self._function is not None or self._function_object is not None or self._globals is not None or self._lineno is not None or self._locals is not None or self._module is not None or self._source is not None or self._stdlib is not None or self._thread is not None or self._threadidn is not None or self._threadname is not None or self.arg is not None or self.frame is not None or self.kind is not None - * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_Event, (type(self), 0x36bd738, None), state - * else: - */ - __Pyx_TraceLine(12,0,__PYX_ERR(2, 12, __pyx_L1_error)) - __pyx_t_7 = (__pyx_v_use_setstate != 0); - if (__pyx_t_7) { - - /* "(tree fragment)":13 - * use_setstate = self._code is not None or self._filename is not None or self._fullsource is not None or self._function is not None or self._function_object is not None or self._globals is not None or self._lineno is not None or self._locals is not None or self._module is not None or self._source is not None or self._stdlib is not None or self._thread is not None or self._threadidn is not None or self._threadname is not None or self.arg is not None or self.frame is not None or self.kind is not None - * if use_setstate: - * return __pyx_unpickle_Event, (type(self), 0x36bd738, None), state # <<<<<<<<<<<<<< - * else: - * return __pyx_unpickle_Event, (type(self), 0x36bd738, state) - */ - __Pyx_TraceLine(13,0,__PYX_ERR(2, 13, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Event); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - PyTuple_SET_ITEM(__pyx_t_5, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_INCREF(__pyx_int_57399096); - __Pyx_GIVEREF(__pyx_int_57399096); - PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_57399096); - __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(Py_None); - PyTuple_SET_ITEM(__pyx_t_5, 2, Py_None); - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); - __Pyx_GIVEREF(__pyx_t_5); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_5); - __Pyx_INCREF(__pyx_v_state); - __Pyx_GIVEREF(__pyx_v_state); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_state); - __pyx_t_4 = 0; - __pyx_t_5 = 0; - __pyx_r = __pyx_t_3; - __pyx_t_3 = 0; - goto __pyx_L0; - - /* "(tree fragment)":12 - * else: - * use_setstate = self._code is not None or self._filename is not None or self._fullsource is not None or self._function is not None or self._function_object is not None or self._globals is not None or self._lineno is not None or self._locals is not None or self._module is not None or self._source is not None or self._stdlib is not None or self._thread is not None or self._threadidn is not None or self._threadname is not None or self.arg is not None or self.frame is not None or self.kind is not None - * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_Event, (type(self), 0x36bd738, None), state - * else: - */ - } - - /* "(tree fragment)":15 - * return __pyx_unpickle_Event, (type(self), 0x36bd738, None), state - * else: - * return __pyx_unpickle_Event, (type(self), 0x36bd738, state) # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_Event__set_state(self, __pyx_state) - */ - __Pyx_TraceLine(15,0,__PYX_ERR(2, 15, __pyx_L1_error)) - /*else*/ { - __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_Event); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - PyTuple_SET_ITEM(__pyx_t_5, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_INCREF(__pyx_int_57399096); - __Pyx_GIVEREF(__pyx_int_57399096); - PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_57399096); - __Pyx_INCREF(__pyx_v_state); - __Pyx_GIVEREF(__pyx_v_state); - PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state); - __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); - __Pyx_GIVEREF(__pyx_t_5); - PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_5); - __pyx_t_3 = 0; - __pyx_t_5 = 0; - __pyx_r = __pyx_t_4; - __pyx_t_4 = 0; - goto __pyx_L0; - } - - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("hunter._event.Event.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_state); - __Pyx_XDECREF(__pyx_v__dict); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "(tree fragment)":16 - * else: - * return __pyx_unpickle_Event, (type(self), 0x36bd738, state) - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle_Event__set_state(self, __pyx_state) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_6_event_5Event_9__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static PyObject *__pyx_pw_6hunter_6_event_5Event_9__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_6_event_5Event_8__setstate_cython__(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6hunter_6_event_5Event_8__setstate_cython__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__setstate_cython__", 0); - __Pyx_TraceCall("__setstate_cython__", __pyx_f[2], 16, 0, __PYX_ERR(2, 16, __pyx_L1_error)); - - /* "(tree fragment)":17 - * return __pyx_unpickle_Event, (type(self), 0x36bd738, state) - * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_Event__set_state(self, __pyx_state) # <<<<<<<<<<<<<< - */ - __Pyx_TraceLine(17,0,__PYX_ERR(2, 17, __pyx_L1_error)) - if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(2, 17, __pyx_L1_error) - __pyx_t_1 = __pyx_f_6hunter_6_event___pyx_unpickle_Event__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 17, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "(tree fragment)":16 - * else: - * return __pyx_unpickle_Event, (type(self), 0x36bd738, state) - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle_Event__set_state(self, __pyx_state) - */ + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[40])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[1], 49, 0, 0, 0, __PYX_ERR(1, 49, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->builtin); + __pyx_r = __pyx_v_self->builtin; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(1, 49, __pyx_L1_error)); + goto __pyx_L0; /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._event.Event.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 49, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.Event.builtin.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_6hunter_6_event_2generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ -/* "hunter/_event.pyx":297 +/* "hunter/_event.pyx":347 * * * def yield_lines(filename, module_globals, start, list collector, # <<<<<<<<<<<<<< * limit=10): * dedent = None - */ +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_6_event_1yield_lines(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static PyMethodDef __pyx_mdef_6hunter_6_event_1yield_lines = {"yield_lines", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6hunter_6_event_1yield_lines, METH_VARARGS|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6hunter_6_event_1yield_lines(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_6hunter_6_event_1yield_lines(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_6_event_1yield_lines = {"yield_lines", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_6_event_1yield_lines, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_6_event_1yield_lines(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { PyObject *__pyx_v_filename = 0; PyObject *__pyx_v_module_globals = 0; PyObject *__pyx_v_start = 0; PyObject *__pyx_v_collector = 0; PyObject *__pyx_v_limit = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[5] = {0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("yield_lines (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,&__pyx_n_s_module_globals,&__pyx_n_s_start,&__pyx_n_s_collector,&__pyx_n_s_limit,0}; - PyObject* values[5] = {0,0,0,0,0}; - values[4] = ((PyObject *)__pyx_int_10); - if (unlikely(__pyx_kwds)) { - Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_filename_2,&__pyx_mstate_global->__pyx_n_u_module_globals,&__pyx_mstate_global->__pyx_n_u_start,&__pyx_mstate_global->__pyx_n_u_collector,&__pyx_mstate_global->__pyx_n_u_limit,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 347, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 347, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 347, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 347, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 347, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 347, __pyx_L3_error) 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_filename)) != 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_module_globals)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("yield_lines", 0, 4, 5, 1); __PYX_ERR(0, 297, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_start)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("yield_lines", 0, 4, 5, 2); __PYX_ERR(0, 297, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_collector)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("yield_lines", 0, 4, 5, 3); __PYX_ERR(0, 297, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_limit); - if (value) { values[4] = value; kw_args--; } - } - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "yield_lines") < 0)) __PYX_ERR(0, 297, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "yield_lines", 0) < 0) __PYX_ERR(0, 347, __pyx_L3_error) + if (!values[4]) values[4] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_int_10))); + for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("yield_lines", 0, 4, 5, i); __PYX_ERR(0, 347, __pyx_L3_error) } } } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + switch (__pyx_nargs) { + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 347, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); - values[2] = PyTuple_GET_ITEM(__pyx_args, 2); - values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 347, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 347, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 347, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 347, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } + if (!values[4]) values[4] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_int_10))); } __pyx_v_filename = values[0]; __pyx_v_module_globals = values[1]; @@ -8222,22 +10304,35 @@ static PyObject *__pyx_pw_6hunter_6_event_1yield_lines(PyObject *__pyx_self, PyO __pyx_v_collector = ((PyObject*)values[3]); __pyx_v_limit = values[4]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("yield_lines", 0, 4, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 297, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("yield_lines", 0, 4, 5, __pyx_nargs); __PYX_ERR(0, 347, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } __Pyx_AddTraceback("hunter._event.yield_lines", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_collector), (&PyList_Type), 1, "collector", 1))) __PYX_ERR(0, 297, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_collector), (&PyList_Type), 1, "collector", 1))) __PYX_ERR(0, 347, __pyx_L1_error) __pyx_r = __pyx_pf_6hunter_6_event_yield_lines(__pyx_self, __pyx_v_filename, __pyx_v_module_globals, __pyx_v_start, __pyx_v_collector, __pyx_v_limit); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -8246,14 +10341,17 @@ static PyObject *__pyx_pf_6hunter_6_event_yield_lines(CYTHON_UNUSED PyObject *__ struct __pyx_obj_6hunter_6_event___pyx_scope_struct__yield_lines *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("yield_lines", 0); - __pyx_cur_scope = (struct __pyx_obj_6hunter_6_event___pyx_scope_struct__yield_lines *)__pyx_tp_new_6hunter_6_event___pyx_scope_struct__yield_lines(__pyx_ptype_6hunter_6_event___pyx_scope_struct__yield_lines, __pyx_empty_tuple, NULL); + __pyx_cur_scope = (struct __pyx_obj_6hunter_6_event___pyx_scope_struct__yield_lines *)__pyx_tp_new_6hunter_6_event___pyx_scope_struct__yield_lines(__pyx_mstate_global->__pyx_ptype_6hunter_6_event___pyx_scope_struct__yield_lines, __pyx_mstate_global->__pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_6hunter_6_event___pyx_scope_struct__yield_lines *)Py_None); __Pyx_INCREF(Py_None); - __PYX_ERR(0, 297, __pyx_L1_error) + __PYX_ERR(0, 347, __pyx_L1_error) } else { - __Pyx_GOTREF(__pyx_cur_scope); + __Pyx_GOTREF((PyObject *)__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_filename = __pyx_v_filename; __Pyx_INCREF(__pyx_cur_scope->__pyx_v_filename); @@ -8271,7 +10369,7 @@ static PyObject *__pyx_pf_6hunter_6_event_yield_lines(CYTHON_UNUSED PyObject *__ __Pyx_INCREF(__pyx_cur_scope->__pyx_v_limit); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_limit); { - __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_6hunter_6_event_2generator, __pyx_codeobj__8, (PyObject *) __pyx_cur_scope, __pyx_n_s_yield_lines, __pyx_n_s_yield_lines, __pyx_n_s_hunter__event); if (unlikely(!gen)) __PYX_ERR(0, 297, __pyx_L1_error) + __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_6hunter_6_event_2generator, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[41]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_yield_lines, __pyx_mstate_global->__pyx_n_u_yield_lines, __pyx_mstate_global->__pyx_n_u_hunter__event); if (unlikely(!gen)) __PYX_ERR(0, 347, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; @@ -8281,7 +10379,7 @@ static PyObject *__pyx_pf_6hunter_6_event_yield_lines(CYTHON_UNUSED PyObject *__ __pyx_L1_error:; __Pyx_AddTraceback("hunter._event.yield_lines", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; - __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __Pyx_DECREF((PyObject *)__pyx_cur_scope); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -8291,1022 +10389,1468 @@ static PyObject *__pyx_gb_6hunter_6_event_2generator(__pyx_CoroutineObject *__py { struct __pyx_obj_6hunter_6_event___pyx_scope_struct__yield_lines *__pyx_cur_scope = ((struct __pyx_obj_6hunter_6_event___pyx_scope_struct__yield_lines *)__pyx_generator->closure); PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsGen PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - Py_ssize_t __pyx_t_6; - PyObject *(*__pyx_t_7)(PyObject *); - int __pyx_t_8; - int __pyx_t_9; + size_t __pyx_t_4; + Py_ssize_t __pyx_t_5; + PyObject *(*__pyx_t_6)(PyObject *); + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; Py_ssize_t __pyx_t_10; int __pyx_t_11; + int __pyx_t_12; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("yield_lines", 0); - __Pyx_TraceFrameInit(__pyx_codeobj__8) - __Pyx_TraceCall("yield_lines", __pyx_f[0], 297, 0, __PYX_ERR(0, 297, __pyx_L1_error)); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L7_resume_from_yield; default: /* CPython raises the right error here */ - __Pyx_TraceReturn(Py_None, 0); + __Pyx_TraceStartGen("yield_lines", __pyx_f[0], 347, 0, 0, 0, __PYX_ERR(0, 347, __pyx_L1_error)); + __Pyx_TraceReturnValue(Py_None, 0, 0, __PYX_ERR(0, 347, __pyx_L1_error)); __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; - if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 297, __pyx_L1_error) + __Pyx_TraceStartGen("yield_lines", __pyx_f[0], 347, 0, 0, 0, __PYX_ERR(0, 347, __pyx_L1_error)); + if (unlikely(__pyx_sent_value != Py_None)) { + if (unlikely(__pyx_sent_value)) PyErr_SetString(PyExc_TypeError, "can't send non-None value to a just-started generator"); + __PYX_ERR(0, 347, __pyx_L1_error) + } - /* "hunter/_event.pyx":299 + /* "hunter/_event.pyx":349 * def yield_lines(filename, module_globals, start, list collector, * limit=10): * dedent = None # <<<<<<<<<<<<<< * amount = 0 * for line in getlines(filename, module_globals)[start:start + limit]: - */ - __Pyx_TraceLine(299,0,__PYX_ERR(0, 299, __pyx_L1_error)) +*/ + __Pyx_TraceLine(349,0,0,__PYX_ERR(0, 349, __pyx_L1_error)) __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __pyx_cur_scope->__pyx_v_dedent = Py_None; - /* "hunter/_event.pyx":300 + /* "hunter/_event.pyx":350 * limit=10): * dedent = None * amount = 0 # <<<<<<<<<<<<<< * for line in getlines(filename, module_globals)[start:start + limit]: * if dedent is None: - */ - __Pyx_TraceLine(300,0,__PYX_ERR(0, 300, __pyx_L1_error)) +*/ + __Pyx_TraceLine(350,0,0,__PYX_ERR(0, 350, __pyx_L1_error)) __pyx_cur_scope->__pyx_v_amount = 0; - /* "hunter/_event.pyx":301 + /* "hunter/_event.pyx":351 * dedent = None * amount = 0 * for line in getlines(filename, module_globals)[start:start + limit]: # <<<<<<<<<<<<<< * if dedent is None: * dedent = LEADING_WHITESPACE_RE.findall(line) - */ - __Pyx_TraceLine(301,0,__PYX_ERR(0, 301, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_getlines); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 301, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - __pyx_t_4 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } +*/ + __Pyx_TraceLine(351,0,0,__PYX_ERR(0, 351, __pyx_L1_error)) + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_getlines); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_4 = 0; } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_2)) { - PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_cur_scope->__pyx_v_filename, __pyx_cur_scope->__pyx_v_module_globals}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 301, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_GOTREF(__pyx_t_1); - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { - PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_cur_scope->__pyx_v_filename, __pyx_cur_scope->__pyx_v_module_globals}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 301, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_GOTREF(__pyx_t_1); - } else #endif { - __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 301, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (__pyx_t_3) { - __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; - } - __Pyx_INCREF(__pyx_cur_scope->__pyx_v_filename); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_filename); - PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_4, __pyx_cur_scope->__pyx_v_filename); - __Pyx_INCREF(__pyx_cur_scope->__pyx_v_module_globals); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_module_globals); - PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_cur_scope->__pyx_v_module_globals); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 301, __pyx_L1_error) + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_cur_scope->__pyx_v_filename, __pyx_cur_scope->__pyx_v_module_globals}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 351, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = PyNumber_Add(__pyx_cur_scope->__pyx_v_start, __pyx_cur_scope->__pyx_v_limit); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 301, __pyx_L1_error) + __pyx_t_3 = PyNumber_Add(__pyx_cur_scope->__pyx_v_start, __pyx_cur_scope->__pyx_v_limit); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetSlice(__pyx_t_1, 0, 0, &__pyx_cur_scope->__pyx_v_start, &__pyx_t_3, NULL, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 351, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_5 = __Pyx_PyObject_GetSlice(__pyx_t_1, 0, 0, &__pyx_cur_scope->__pyx_v_start, &__pyx_t_2, NULL, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 301, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (likely(PyList_CheckExact(__pyx_t_5)) || PyTuple_CheckExact(__pyx_t_5)) { - __pyx_t_2 = __pyx_t_5; __Pyx_INCREF(__pyx_t_2); __pyx_t_6 = 0; - __pyx_t_7 = NULL; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) { + __pyx_t_3 = __pyx_t_2; __Pyx_INCREF(__pyx_t_3); + __pyx_t_5 = 0; + __pyx_t_6 = NULL; } else { - __pyx_t_6 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 301, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 301, __pyx_L1_error) + __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 351, __pyx_L1_error) } - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; for (;;) { - if (likely(!__pyx_t_7)) { - if (likely(PyList_CheckExact(__pyx_t_2))) { - if (__pyx_t_6 >= PyList_GET_SIZE(__pyx_t_2)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_5); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 301, __pyx_L1_error) - #else - __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 301, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - #endif + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_3))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 351, __pyx_L1_error) + #endif + if (__pyx_t_5 >= __pyx_temp) break; + } + __pyx_t_2 = __Pyx_PyList_GetItemRef(__pyx_t_3, __pyx_t_5); + ++__pyx_t_5; } else { - if (__pyx_t_6 >= PyTuple_GET_SIZE(__pyx_t_2)) break; + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 351, __pyx_L1_error) + #endif + if (__pyx_t_5 >= __pyx_temp) break; + } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_5); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 301, __pyx_L1_error) + __pyx_t_2 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5)); #else - __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 301, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_5); #endif + ++__pyx_t_5; } + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 351, __pyx_L1_error) } else { - __pyx_t_5 = __pyx_t_7(__pyx_t_2); - if (unlikely(!__pyx_t_5)) { + __pyx_t_2 = __pyx_t_6(__pyx_t_3); + if (unlikely(!__pyx_t_2)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(0, 301, __pyx_L1_error) + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 351, __pyx_L1_error) + PyErr_Clear(); } break; } - __Pyx_GOTREF(__pyx_t_5); } + __Pyx_GOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_line); - __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_line, __pyx_t_5); - __Pyx_GIVEREF(__pyx_t_5); - __pyx_t_5 = 0; + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_line, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __pyx_t_2 = 0; + __Pyx_TraceLine(351,0,0,__PYX_ERR(0, 351, __pyx_L1_error)) - /* "hunter/_event.pyx":302 + /* "hunter/_event.pyx":352 * amount = 0 * for line in getlines(filename, module_globals)[start:start + limit]: * if dedent is None: # <<<<<<<<<<<<<< * dedent = LEADING_WHITESPACE_RE.findall(line) - * dedent = dedent[0] if dedent else "" - */ - __Pyx_TraceLine(302,0,__PYX_ERR(0, 302, __pyx_L1_error)) - __pyx_t_8 = (__pyx_cur_scope->__pyx_v_dedent == Py_None); - __pyx_t_9 = (__pyx_t_8 != 0); - if (__pyx_t_9) { + * dedent = dedent[0] if dedent else '' +*/ + __Pyx_TraceLine(352,0,0,__PYX_ERR(0, 352, __pyx_L1_error)) + __pyx_t_7 = (__pyx_cur_scope->__pyx_v_dedent == Py_None); + if (__pyx_t_7) { - /* "hunter/_event.pyx":303 + /* "hunter/_event.pyx":353 * for line in getlines(filename, module_globals)[start:start + limit]: * if dedent is None: * dedent = LEADING_WHITESPACE_RE.findall(line) # <<<<<<<<<<<<<< - * dedent = dedent[0] if dedent else "" + * dedent = dedent[0] if dedent else '' * amount = len(dedent) - */ - __Pyx_TraceLine(303,0,__PYX_ERR(0, 303, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_LEADING_WHITESPACE_RE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 303, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_findall); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 303, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; +*/ + __Pyx_TraceLine(353,0,0,__PYX_ERR(0, 353, __pyx_L1_error)) __pyx_t_1 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_1)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_1); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - } + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_LEADING_WHITESPACE_RE); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_findall); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_4 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_9); + assert(__pyx_t_1); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_9, __pyx__function); + __pyx_t_4 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_cur_scope->__pyx_v_line}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); } - __pyx_t_5 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_cur_scope->__pyx_v_line) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_cur_scope->__pyx_v_line); - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 303, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_dedent); - __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_dedent, __pyx_t_5); - __Pyx_GIVEREF(__pyx_t_5); - __pyx_t_5 = 0; + __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_dedent, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __pyx_t_2 = 0; - /* "hunter/_event.pyx":304 + /* "hunter/_event.pyx":354 * if dedent is None: * dedent = LEADING_WHITESPACE_RE.findall(line) - * dedent = dedent[0] if dedent else "" # <<<<<<<<<<<<<< + * dedent = dedent[0] if dedent else '' # <<<<<<<<<<<<<< * amount = len(dedent) * elif not line.startswith(dedent): - */ - __Pyx_TraceLine(304,0,__PYX_ERR(0, 304, __pyx_L1_error)) - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_dedent); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 304, __pyx_L1_error) - if (__pyx_t_9) { - __pyx_t_3 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_dedent, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 304, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = __pyx_t_3; - __pyx_t_3 = 0; +*/ + __Pyx_TraceLine(354,0,0,__PYX_ERR(0, 354, __pyx_L1_error)) + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_dedent); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 354, __pyx_L1_error) + if (__pyx_t_7) { + __pyx_t_9 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_dedent, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 354, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_2 = __pyx_t_9; + __pyx_t_9 = 0; } else { - __Pyx_INCREF(__pyx_kp_s_); - __pyx_t_5 = __pyx_kp_s_; + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u__2); + __pyx_t_2 = __pyx_mstate_global->__pyx_kp_u__2; } __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_dedent); - __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_dedent, __pyx_t_5); - __Pyx_GIVEREF(__pyx_t_5); - __pyx_t_5 = 0; + __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_dedent, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __pyx_t_2 = 0; - /* "hunter/_event.pyx":305 + /* "hunter/_event.pyx":355 * dedent = LEADING_WHITESPACE_RE.findall(line) - * dedent = dedent[0] if dedent else "" + * dedent = dedent[0] if dedent else '' * amount = len(dedent) # <<<<<<<<<<<<<< * elif not line.startswith(dedent): * break - */ - __Pyx_TraceLine(305,0,__PYX_ERR(0, 305, __pyx_L1_error)) - __pyx_t_10 = PyObject_Length(__pyx_cur_scope->__pyx_v_dedent); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(0, 305, __pyx_L1_error) +*/ + __Pyx_TraceLine(355,0,0,__PYX_ERR(0, 355, __pyx_L1_error)) + __pyx_t_10 = PyObject_Length(__pyx_cur_scope->__pyx_v_dedent); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(0, 355, __pyx_L1_error) __pyx_cur_scope->__pyx_v_amount = __pyx_t_10; - /* "hunter/_event.pyx":302 + /* "hunter/_event.pyx":352 * amount = 0 * for line in getlines(filename, module_globals)[start:start + limit]: * if dedent is None: # <<<<<<<<<<<<<< * dedent = LEADING_WHITESPACE_RE.findall(line) - * dedent = dedent[0] if dedent else "" - */ + * dedent = dedent[0] if dedent else '' +*/ goto __pyx_L6; } - /* "hunter/_event.pyx":306 - * dedent = dedent[0] if dedent else "" + /* "hunter/_event.pyx":356 + * dedent = dedent[0] if dedent else '' * amount = len(dedent) * elif not line.startswith(dedent): # <<<<<<<<<<<<<< * break * collector.append(line) - */ - __Pyx_TraceLine(306,0,__PYX_ERR(0, 306, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_line, __pyx_n_s_startswith); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 306, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_1)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_1); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - } +*/ + __Pyx_TraceLine(356,0,0,__PYX_ERR(0, 356, __pyx_L1_error)) + __pyx_t_9 = __pyx_cur_scope->__pyx_v_line; + __Pyx_INCREF(__pyx_t_9); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_cur_scope->__pyx_v_dedent}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_startswith, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 356, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); } - __pyx_t_5 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_cur_scope->__pyx_v_dedent) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_cur_scope->__pyx_v_dedent); - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 306, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 306, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_8 = ((!__pyx_t_9) != 0); - if (__pyx_t_8) { + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 356, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_11 = (!__pyx_t_7); + if (__pyx_t_11) { - /* "hunter/_event.pyx":307 + /* "hunter/_event.pyx":357 * amount = len(dedent) * elif not line.startswith(dedent): * break # <<<<<<<<<<<<<< * collector.append(line) * yield line[amount:] - */ - __Pyx_TraceLine(307,0,__PYX_ERR(0, 307, __pyx_L1_error)) +*/ + __Pyx_TraceLine(357,0,0,__PYX_ERR(0, 357, __pyx_L1_error)) goto __pyx_L5_break; - /* "hunter/_event.pyx":306 - * dedent = dedent[0] if dedent else "" + /* "hunter/_event.pyx":356 + * dedent = dedent[0] if dedent else '' * amount = len(dedent) * elif not line.startswith(dedent): # <<<<<<<<<<<<<< * break * collector.append(line) - */ +*/ } __pyx_L6:; - /* "hunter/_event.pyx":308 + /* "hunter/_event.pyx":358 * elif not line.startswith(dedent): * break * collector.append(line) # <<<<<<<<<<<<<< * yield line[amount:] - */ - __Pyx_TraceLine(308,0,__PYX_ERR(0, 308, __pyx_L1_error)) + * +*/ + __Pyx_TraceLine(358,0,0,__PYX_ERR(0, 358, __pyx_L1_error)) if (unlikely(__pyx_cur_scope->__pyx_v_collector == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "append"); - __PYX_ERR(0, 308, __pyx_L1_error) + __PYX_ERR(0, 358, __pyx_L1_error) } - __pyx_t_11 = __Pyx_PyList_Append(__pyx_cur_scope->__pyx_v_collector, __pyx_cur_scope->__pyx_v_line); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(0, 308, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyList_Append(__pyx_cur_scope->__pyx_v_collector, __pyx_cur_scope->__pyx_v_line); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 358, __pyx_L1_error) - /* "hunter/_event.pyx":309 + /* "hunter/_event.pyx":359 * break * collector.append(line) * yield line[amount:] # <<<<<<<<<<<<<< - */ - __Pyx_TraceLine(309,0,__PYX_ERR(0, 309, __pyx_L1_error)) - __pyx_t_5 = __Pyx_PyObject_GetSlice(__pyx_cur_scope->__pyx_v_line, __pyx_cur_scope->__pyx_v_amount, 0, NULL, NULL, NULL, 1, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 309, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; - __Pyx_XGIVEREF(__pyx_t_2); - __pyx_cur_scope->__pyx_t_0 = __pyx_t_2; - __pyx_cur_scope->__pyx_t_1 = __pyx_t_6; - __pyx_cur_scope->__pyx_t_2 = __pyx_t_7; + * + * +*/ + __Pyx_TraceLine(359,0,0,__PYX_ERR(0, 359, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyObject_GetSlice(__pyx_cur_scope->__pyx_v_line, __pyx_cur_scope->__pyx_v_amount, 0, NULL, NULL, NULL, 1, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 359, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_XGIVEREF(__pyx_t_3); + __pyx_cur_scope->__pyx_t_0 = __pyx_t_3; + __pyx_cur_scope->__pyx_t_1 = __pyx_t_5; + __pyx_cur_scope->__pyx_t_2 = __pyx_t_6; + __Pyx_TraceYield(__pyx_r, 0, __PYX_ERR(0, 359, __pyx_L1_error)); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, yielding value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L7_resume_from_yield:; - __pyx_t_2 = __pyx_cur_scope->__pyx_t_0; + __Pyx_TraceResumeGen("yield_lines", __pyx_f[0], 347, 0, __PYX_ERR(0, 359, __pyx_L1_error)); + __pyx_t_3 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; - __Pyx_XGOTREF(__pyx_t_2); - __pyx_t_6 = __pyx_cur_scope->__pyx_t_1; - __pyx_t_7 = __pyx_cur_scope->__pyx_t_2; - if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 309, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_3); + __pyx_t_5 = __pyx_cur_scope->__pyx_t_1; + __pyx_t_6 = __pyx_cur_scope->__pyx_t_2; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 359, __pyx_L1_error) - /* "hunter/_event.pyx":301 + /* "hunter/_event.pyx":351 * dedent = None * amount = 0 * for line in getlines(filename, module_globals)[start:start + limit]: # <<<<<<<<<<<<<< * if dedent is None: * dedent = LEADING_WHITESPACE_RE.findall(line) - */ - __Pyx_TraceLine(301,0,__PYX_ERR(0, 301, __pyx_L1_error)) +*/ + __Pyx_TraceLine(351,0,0,__PYX_ERR(0, 351, __pyx_L1_error)) } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_for_end; __pyx_L5_break:; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_for_end; + __pyx_L8_for_end:; CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + __Pyx_TraceReturnValue(Py_None, 0, 0, __PYX_ERR(0, 347, __pyx_L1_error)); - /* "hunter/_event.pyx":297 + /* "hunter/_event.pyx":347 * * * def yield_lines(filename, module_globals, start, list collector, # <<<<<<<<<<<<<< * limit=10): * dedent = None - */ +*/ /* function exit code */ - PyErr_SetNone(PyExc_StopIteration); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("yield_lines", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + if (__Pyx_PyErr_Occurred()) { + __Pyx_TraceException(__pyx_lineno, 0, 0); + __Pyx_Generator_Replace_StopIteration(0); + __Pyx_AddTraceback("yield_lines", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceExceptionUnwind(0, 0); + } __pyx_L0:; - __Pyx_XDECREF(__pyx_r); __pyx_r = 0; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); - __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "(tree fragment)":1 - * def __pyx_unpickle_Event(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_6_event_4__pyx_unpickle_Event(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static PyMethodDef __pyx_mdef_6hunter_6_event_4__pyx_unpickle_Event = {"__pyx_unpickle_Event", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6hunter_6_event_4__pyx_unpickle_Event, METH_VARARGS|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6hunter_6_event_4__pyx_unpickle_Event(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v___pyx_type = 0; - long __pyx_v___pyx_checksum; - PyObject *__pyx_v___pyx_state = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__pyx_unpickle_Event (wrapper)", 0); - { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; - PyObject* values[3] = {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 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_pyx_type)) != 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_pyx_checksum)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Event", 1, 3, 3, 1); __PYX_ERR(2, 1, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Event", 1, 3, 3, 2); __PYX_ERR(2, 1, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_Event") < 0)) __PYX_ERR(2, 1, __pyx_L3_error) - } - } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { - 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); - } - __pyx_v___pyx_type = values[0]; - __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(2, 1, __pyx_L3_error) - __pyx_v___pyx_state = values[2]; - } - goto __pyx_L4_argument_unpacking_done; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Event", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1, __pyx_L3_error) - __pyx_L3_error:; - __Pyx_AddTraceback("hunter._event.__pyx_unpickle_Event", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6hunter_6_event_3__pyx_unpickle_Event(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} +/* "hunter/_event.pyx":362 + * + * + * cdef inline Event fast_detach(Event self, object value_filter): # <<<<<<<<<<<<<< + * event = Event.__new__(Event) + * +*/ -static PyObject *__pyx_pf_6hunter_6_event_3__pyx_unpickle_Event(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_v___pyx_PickleError = 0; - PyObject *__pyx_v___pyx_result = 0; - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations +static CYTHON_INLINE struct __pyx_obj_6hunter_6_event_Event *__pyx_f_6hunter_6_event_fast_detach(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self, PyObject *__pyx_v_value_filter) { + struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event = NULL; + PyObject *__pyx_7genexpr__pyx_v_key = NULL; + PyObject *__pyx_7genexpr__pyx_v_value = NULL; + PyObject *__pyx_8genexpr1__pyx_v_key = NULL; + PyObject *__pyx_8genexpr1__pyx_v_value = NULL; + struct __pyx_obj_6hunter_6_event_Event *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - int __pyx_t_1; + PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; + int __pyx_t_3; + Py_ssize_t __pyx_t_4; + Py_ssize_t __pyx_t_5; int __pyx_t_6; - __Pyx_TraceFrameInit(__pyx_codeobj__9) - __Pyx_RefNannySetupContext("__pyx_unpickle_Event", 0); - __Pyx_TraceCall("__pyx_unpickle_Event", __pyx_f[2], 1, 0, __PYX_ERR(2, 1, __pyx_L1_error)); - - /* "(tree fragment)":4 - * cdef object __pyx_PickleError - * cdef object __pyx_result - * if __pyx_checksum != 0x36bd738: # <<<<<<<<<<<<<< - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0x36bd738 = (_code, _filename, _fullsource, _function, _function_object, _globals, _lineno, _locals, _module, _source, _stdlib, _thread, _threadidn, _threadname, arg, calls, depth, detached, frame, kind, threading_support))" % __pyx_checksum) - */ - __Pyx_TraceLine(4,0,__PYX_ERR(2, 4, __pyx_L1_error)) - __pyx_t_1 = ((__pyx_v___pyx_checksum != 0x36bd738) != 0); - if (__pyx_t_1) { + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + size_t __pyx_t_11; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[42])) + __Pyx_RefNannySetupContext("fast_detach", 0); + __Pyx_TraceStartFunc("fast_detach", __pyx_f[0], 362, 0, 0, 0, __PYX_ERR(0, 362, __pyx_L1_error)); + + /* "hunter/_event.pyx":363 + * + * cdef inline Event fast_detach(Event self, object value_filter): + * event = Event.__new__(Event) # <<<<<<<<<<<<<< + * + * event._code = self.code_getter() +*/ + __Pyx_TraceLine(363,5,0,__PYX_ERR(0, 363, __pyx_L1_error)) + __pyx_t_1 = ((PyObject *)__pyx_tp_new_6hunter_6_event_Event(((PyTypeObject *)__pyx_mstate_global->__pyx_ptype_6hunter_6_event_Event), __pyx_mstate_global->__pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 363, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_1); + __pyx_t_2 = ((PyObject *)__pyx_t_1); + __Pyx_INCREF(__pyx_t_2); + __Pyx_DECREF((PyObject *)__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_event = ((struct __pyx_obj_6hunter_6_event_Event *)__pyx_t_2); + __pyx_t_2 = 0; - /* "(tree fragment)":5 - * cdef object __pyx_result - * if __pyx_checksum != 0x36bd738: - * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< - * raise __pyx_PickleError("Incompatible checksums (%s vs 0x36bd738 = (_code, _filename, _fullsource, _function, _function_object, _globals, _lineno, _locals, _module, _source, _stdlib, _thread, _threadidn, _threadname, arg, calls, depth, detached, frame, kind, threading_support))" % __pyx_checksum) - * __pyx_result = Event.__new__(__pyx_type) - */ - __Pyx_TraceLine(5,0,__PYX_ERR(2, 5, __pyx_L1_error)) - __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_n_s_PickleError); - __Pyx_GIVEREF(__pyx_n_s_PickleError); - PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_PickleError); - __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_t_2); - __pyx_v___pyx_PickleError = __pyx_t_2; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + /* "hunter/_event.pyx":365 + * event = Event.__new__(Event) + * + * event._code = self.code_getter() # <<<<<<<<<<<<<< + * event._filename = self.filename_getter() + * event._fullsource = self.fullsource_getter() +*/ + __Pyx_TraceLine(365,11,0,__PYX_ERR(0, 365, __pyx_L1_error)) + __pyx_t_2 = ((PyObject *)__pyx_f_6hunter_6_event_5Event_code_getter(__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 365, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->_code); + __Pyx_DECREF(__pyx_v_event->_code); + __pyx_v_event->_code = __pyx_t_2; + __pyx_t_2 = 0; - /* "(tree fragment)":6 - * if __pyx_checksum != 0x36bd738: - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0x36bd738 = (_code, _filename, _fullsource, _function, _function_object, _globals, _lineno, _locals, _module, _source, _stdlib, _thread, _threadidn, _threadname, arg, calls, depth, detached, frame, kind, threading_support))" % __pyx_checksum) # <<<<<<<<<<<<<< - * __pyx_result = Event.__new__(__pyx_type) - * if __pyx_state is not None: - */ - __Pyx_TraceLine(6,0,__PYX_ERR(2, 6, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_s_vs_0x36, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_INCREF(__pyx_v___pyx_PickleError); - __pyx_t_2 = __pyx_v___pyx_PickleError; __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - } - } - __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(2, 6, __pyx_L1_error) - - /* "(tree fragment)":4 - * cdef object __pyx_PickleError - * cdef object __pyx_result - * if __pyx_checksum != 0x36bd738: # <<<<<<<<<<<<<< - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0x36bd738 = (_code, _filename, _fullsource, _function, _function_object, _globals, _lineno, _locals, _module, _source, _stdlib, _thread, _threadidn, _threadname, arg, calls, depth, detached, frame, kind, threading_support))" % __pyx_checksum) - */ - } + /* "hunter/_event.pyx":366 + * + * event._code = self.code_getter() + * event._filename = self.filename_getter() # <<<<<<<<<<<<<< + * event._fullsource = self.fullsource_getter() + * event._function_object = self._function_object +*/ + __Pyx_TraceLine(366,16,0,__PYX_ERR(0, 366, __pyx_L1_error)) + __pyx_t_2 = __pyx_f_6hunter_6_event_5Event_filename_getter(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 366, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->_filename); + __Pyx_DECREF(__pyx_v_event->_filename); + __pyx_v_event->_filename = __pyx_t_2; + __pyx_t_2 = 0; - /* "(tree fragment)":7 - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0x36bd738 = (_code, _filename, _fullsource, _function, _function_object, _globals, _lineno, _locals, _module, _source, _stdlib, _thread, _threadidn, _threadname, arg, calls, depth, detached, frame, kind, threading_support))" % __pyx_checksum) - * __pyx_result = Event.__new__(__pyx_type) # <<<<<<<<<<<<<< - * if __pyx_state is not None: - * __pyx_unpickle_Event__set_state( __pyx_result, __pyx_state) - */ - __Pyx_TraceLine(7,0,__PYX_ERR(2, 7, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_6hunter_6_event_Event), __pyx_n_s_new); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 7, __pyx_L1_error) + /* "hunter/_event.pyx":367 + * event._code = self.code_getter() + * event._filename = self.filename_getter() + * event._fullsource = self.fullsource_getter() # <<<<<<<<<<<<<< + * event._function_object = self._function_object + * event._function = self.function_getter() +*/ + __Pyx_TraceLine(367,21,0,__PYX_ERR(0, 367, __pyx_L1_error)) + __pyx_t_2 = __pyx_f_6hunter_6_event_5Event_fullsource_getter(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 367, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - } - } - __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v___pyx_type); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v___pyx_result = __pyx_t_3; - __pyx_t_3 = 0; - - /* "(tree fragment)":8 - * raise __pyx_PickleError("Incompatible checksums (%s vs 0x36bd738 = (_code, _filename, _fullsource, _function, _function_object, _globals, _lineno, _locals, _module, _source, _stdlib, _thread, _threadidn, _threadname, arg, calls, depth, detached, frame, kind, threading_support))" % __pyx_checksum) - * __pyx_result = Event.__new__(__pyx_type) - * if __pyx_state is not None: # <<<<<<<<<<<<<< - * __pyx_unpickle_Event__set_state( __pyx_result, __pyx_state) - * return __pyx_result - */ - __Pyx_TraceLine(8,0,__PYX_ERR(2, 8, __pyx_L1_error)) - __pyx_t_1 = (__pyx_v___pyx_state != Py_None); - __pyx_t_6 = (__pyx_t_1 != 0); - if (__pyx_t_6) { - - /* "(tree fragment)":9 - * __pyx_result = Event.__new__(__pyx_type) - * if __pyx_state is not None: - * __pyx_unpickle_Event__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< - * return __pyx_result - * cdef __pyx_unpickle_Event__set_state(Event __pyx_result, tuple __pyx_state): - */ - __Pyx_TraceLine(9,0,__PYX_ERR(2, 9, __pyx_L1_error)) - if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(2, 9, __pyx_L1_error) - __pyx_t_3 = __pyx_f_6hunter_6_event___pyx_unpickle_Event__set_state(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->_fullsource); + __Pyx_DECREF(__pyx_v_event->_fullsource); + __pyx_v_event->_fullsource = __pyx_t_2; + __pyx_t_2 = 0; - /* "(tree fragment)":8 - * raise __pyx_PickleError("Incompatible checksums (%s vs 0x36bd738 = (_code, _filename, _fullsource, _function, _function_object, _globals, _lineno, _locals, _module, _source, _stdlib, _thread, _threadidn, _threadname, arg, calls, depth, detached, frame, kind, threading_support))" % __pyx_checksum) - * __pyx_result = Event.__new__(__pyx_type) - * if __pyx_state is not None: # <<<<<<<<<<<<<< - * __pyx_unpickle_Event__set_state( __pyx_result, __pyx_state) - * return __pyx_result - */ - } + /* "hunter/_event.pyx":368 + * event._filename = self.filename_getter() + * event._fullsource = self.fullsource_getter() + * event._function_object = self._function_object # <<<<<<<<<<<<<< + * event._function = self.function_getter() + * event._lineno = self.lineno_getter() +*/ + __Pyx_TraceLine(368,25,0,__PYX_ERR(0, 368, __pyx_L1_error)) + __pyx_t_2 = __pyx_v_self->_function_object; + __Pyx_INCREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->_function_object); + __Pyx_DECREF(__pyx_v_event->_function_object); + __pyx_v_event->_function_object = __pyx_t_2; + __pyx_t_2 = 0; - /* "(tree fragment)":10 - * if __pyx_state is not None: - * __pyx_unpickle_Event__set_state( __pyx_result, __pyx_state) - * return __pyx_result # <<<<<<<<<<<<<< - * cdef __pyx_unpickle_Event__set_state(Event __pyx_result, tuple __pyx_state): - * __pyx_result._code = __pyx_state[0]; __pyx_result._filename = __pyx_state[1]; __pyx_result._fullsource = __pyx_state[2]; __pyx_result._function = __pyx_state[3]; __pyx_result._function_object = __pyx_state[4]; __pyx_result._globals = __pyx_state[5]; __pyx_result._lineno = __pyx_state[6]; __pyx_result._locals = __pyx_state[7]; __pyx_result._module = __pyx_state[8]; __pyx_result._source = __pyx_state[9]; __pyx_result._stdlib = __pyx_state[10]; __pyx_result._thread = __pyx_state[11]; __pyx_result._threadidn = __pyx_state[12]; __pyx_result._threadname = __pyx_state[13]; __pyx_result.arg = __pyx_state[14]; __pyx_result.calls = __pyx_state[15]; __pyx_result.depth = __pyx_state[16]; __pyx_result.detached = __pyx_state[17]; __pyx_result.frame = __pyx_state[18]; __pyx_result.kind = __pyx_state[19]; __pyx_result.threading_support = __pyx_state[20] - */ - __Pyx_TraceLine(10,0,__PYX_ERR(2, 10, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v___pyx_result); - __pyx_r = __pyx_v___pyx_result; - goto __pyx_L0; + /* "hunter/_event.pyx":369 + * event._fullsource = self.fullsource_getter() + * event._function_object = self._function_object + * event._function = self.function_getter() # <<<<<<<<<<<<<< + * event._lineno = self.lineno_getter() + * event._module = self.module_getter() +*/ + __Pyx_TraceLine(369,30,0,__PYX_ERR(0, 369, __pyx_L1_error)) + __pyx_t_2 = __pyx_f_6hunter_6_event_5Event_function_getter(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 369, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->_function); + __Pyx_DECREF(__pyx_v_event->_function); + __pyx_v_event->_function = __pyx_t_2; + __pyx_t_2 = 0; - /* "(tree fragment)":1 - * def __pyx_unpickle_Event(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ + /* "hunter/_event.pyx":370 + * event._function_object = self._function_object + * event._function = self.function_getter() + * event._lineno = self.lineno_getter() # <<<<<<<<<<<<<< + * event._module = self.module_getter() + * event._source = self.source_getter() +*/ + __Pyx_TraceLine(370,35,0,__PYX_ERR(0, 370, __pyx_L1_error)) + __pyx_t_2 = __pyx_f_6hunter_6_event_5Event_lineno_getter(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 370, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->_lineno); + __Pyx_DECREF(__pyx_v_event->_lineno); + __pyx_v_event->_lineno = __pyx_t_2; + __pyx_t_2 = 0; - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("hunter._event.__pyx_unpickle_Event", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v___pyx_PickleError); - __Pyx_XDECREF(__pyx_v___pyx_result); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_event.pyx":371 + * event._function = self.function_getter() + * event._lineno = self.lineno_getter() + * event._module = self.module_getter() # <<<<<<<<<<<<<< + * event._source = self.source_getter() + * event._stdlib = self.stdlib_getter() +*/ + __Pyx_TraceLine(371,40,0,__PYX_ERR(0, 371, __pyx_L1_error)) + __pyx_t_2 = __pyx_f_6hunter_6_event_5Event_module_getter(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 371, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->_module); + __Pyx_DECREF(__pyx_v_event->_module); + __pyx_v_event->_module = __pyx_t_2; + __pyx_t_2 = 0; -/* "(tree fragment)":11 - * __pyx_unpickle_Event__set_state( __pyx_result, __pyx_state) - * return __pyx_result - * cdef __pyx_unpickle_Event__set_state(Event __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< - * __pyx_result._code = __pyx_state[0]; __pyx_result._filename = __pyx_state[1]; __pyx_result._fullsource = __pyx_state[2]; __pyx_result._function = __pyx_state[3]; __pyx_result._function_object = __pyx_state[4]; __pyx_result._globals = __pyx_state[5]; __pyx_result._lineno = __pyx_state[6]; __pyx_result._locals = __pyx_state[7]; __pyx_result._module = __pyx_state[8]; __pyx_result._source = __pyx_state[9]; __pyx_result._stdlib = __pyx_state[10]; __pyx_result._thread = __pyx_state[11]; __pyx_result._threadidn = __pyx_state[12]; __pyx_result._threadname = __pyx_state[13]; __pyx_result.arg = __pyx_state[14]; __pyx_result.calls = __pyx_state[15]; __pyx_result.depth = __pyx_state[16]; __pyx_result.detached = __pyx_state[17]; __pyx_result.frame = __pyx_state[18]; __pyx_result.kind = __pyx_state[19]; __pyx_result.threading_support = __pyx_state[20] - * if len(__pyx_state) > 21 and hasattr(__pyx_result, '__dict__'): - */ + /* "hunter/_event.pyx":372 + * event._lineno = self.lineno_getter() + * event._module = self.module_getter() + * event._source = self.source_getter() # <<<<<<<<<<<<<< + * event._stdlib = self.stdlib_getter() + * event._threadidn = self.threadid_getter() +*/ + __Pyx_TraceLine(372,45,0,__PYX_ERR(0, 372, __pyx_L1_error)) + __pyx_t_2 = __pyx_f_6hunter_6_event_5Event_source_getter(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 372, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->_source); + __Pyx_DECREF(__pyx_v_event->_source); + __pyx_v_event->_source = __pyx_t_2; + __pyx_t_2 = 0; -static PyObject *__pyx_f_6hunter_6_event___pyx_unpickle_Event__set_state(struct __pyx_obj_6hunter_6_event_Event *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_t_2; - int __pyx_t_3; - Py_ssize_t __pyx_t_4; - int __pyx_t_5; - int __pyx_t_6; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - PyObject *__pyx_t_9 = NULL; - __Pyx_RefNannySetupContext("__pyx_unpickle_Event__set_state", 0); - __Pyx_TraceCall("__pyx_unpickle_Event__set_state", __pyx_f[2], 11, 0, __PYX_ERR(2, 11, __pyx_L1_error)); - - /* "(tree fragment)":12 - * return __pyx_result - * cdef __pyx_unpickle_Event__set_state(Event __pyx_result, tuple __pyx_state): - * __pyx_result._code = __pyx_state[0]; __pyx_result._filename = __pyx_state[1]; __pyx_result._fullsource = __pyx_state[2]; __pyx_result._function = __pyx_state[3]; __pyx_result._function_object = __pyx_state[4]; __pyx_result._globals = __pyx_state[5]; __pyx_result._lineno = __pyx_state[6]; __pyx_result._locals = __pyx_state[7]; __pyx_result._module = __pyx_state[8]; __pyx_result._source = __pyx_state[9]; __pyx_result._stdlib = __pyx_state[10]; __pyx_result._thread = __pyx_state[11]; __pyx_result._threadidn = __pyx_state[12]; __pyx_result._threadname = __pyx_state[13]; __pyx_result.arg = __pyx_state[14]; __pyx_result.calls = __pyx_state[15]; __pyx_result.depth = __pyx_state[16]; __pyx_result.detached = __pyx_state[17]; __pyx_result.frame = __pyx_state[18]; __pyx_result.kind = __pyx_state[19]; __pyx_result.threading_support = __pyx_state[20] # <<<<<<<<<<<<<< - * if len(__pyx_state) > 21 and hasattr(__pyx_result, '__dict__'): - * __pyx_result.__dict__.update(__pyx_state[21]) - */ - __Pyx_TraceLine(12,0,__PYX_ERR(2, 12, __pyx_L1_error)) - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->_code); - __Pyx_DECREF(__pyx_v___pyx_result->_code); - __pyx_v___pyx_result->_code = __pyx_t_1; - __pyx_t_1 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->_filename); - __Pyx_DECREF(__pyx_v___pyx_result->_filename); - __pyx_v___pyx_result->_filename = __pyx_t_1; - __pyx_t_1 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->_fullsource); - __Pyx_DECREF(__pyx_v___pyx_result->_fullsource); - __pyx_v___pyx_result->_fullsource = __pyx_t_1; - __pyx_t_1 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->_function); - __Pyx_DECREF(__pyx_v___pyx_result->_function); - __pyx_v___pyx_result->_function = __pyx_t_1; - __pyx_t_1 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 4, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->_function_object); - __Pyx_DECREF(__pyx_v___pyx_result->_function_object); - __pyx_v___pyx_result->_function_object = __pyx_t_1; - __pyx_t_1 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 5, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->_globals); - __Pyx_DECREF(__pyx_v___pyx_result->_globals); - __pyx_v___pyx_result->_globals = __pyx_t_1; - __pyx_t_1 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 6, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->_lineno); - __Pyx_DECREF(__pyx_v___pyx_result->_lineno); - __pyx_v___pyx_result->_lineno = __pyx_t_1; - __pyx_t_1 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 7, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->_locals); - __Pyx_DECREF(__pyx_v___pyx_result->_locals); - __pyx_v___pyx_result->_locals = __pyx_t_1; - __pyx_t_1 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 8, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->_module); - __Pyx_DECREF(__pyx_v___pyx_result->_module); - __pyx_v___pyx_result->_module = __pyx_t_1; - __pyx_t_1 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 9, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->_source); - __Pyx_DECREF(__pyx_v___pyx_result->_source); - __pyx_v___pyx_result->_source = __pyx_t_1; - __pyx_t_1 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 10, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->_stdlib); - __Pyx_DECREF(__pyx_v___pyx_result->_stdlib); - __pyx_v___pyx_result->_stdlib = __pyx_t_1; - __pyx_t_1 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 11, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->_thread); - __Pyx_DECREF(__pyx_v___pyx_result->_thread); - __pyx_v___pyx_result->_thread = __pyx_t_1; - __pyx_t_1 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 12, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->_threadidn); - __Pyx_DECREF(__pyx_v___pyx_result->_threadidn); - __pyx_v___pyx_result->_threadidn = __pyx_t_1; - __pyx_t_1 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 13, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->_threadname); - __Pyx_DECREF(__pyx_v___pyx_result->_threadname); - __pyx_v___pyx_result->_threadname = __pyx_t_1; - __pyx_t_1 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 14, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->arg); - __Pyx_DECREF(__pyx_v___pyx_result->arg); - __pyx_v___pyx_result->arg = __pyx_t_1; - __pyx_t_1 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 15, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v___pyx_result->calls = __pyx_t_2; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 16, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v___pyx_result->depth = __pyx_t_2; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 17, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v___pyx_result->detached = __pyx_t_3; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 18, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_6hunter_7_tracer_FrameType))))) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->frame); - __Pyx_DECREF(((PyObject *)__pyx_v___pyx_result->frame)); - __pyx_v___pyx_result->frame = ((PyFrameObject *)__pyx_t_1); - __pyx_t_1 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 19, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (!(likely(PyString_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->kind); - __Pyx_DECREF(__pyx_v___pyx_result->kind); - __pyx_v___pyx_result->kind = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 20, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v___pyx_result->threading_support = __pyx_t_3; + /* "hunter/_event.pyx":373 + * event._module = self.module_getter() + * event._source = self.source_getter() + * event._stdlib = self.stdlib_getter() # <<<<<<<<<<<<<< + * event._threadidn = self.threadid_getter() + * event._threadname = self.threadname_getter() +*/ + __Pyx_TraceLine(373,50,0,__PYX_ERR(0, 373, __pyx_L1_error)) + __pyx_t_2 = __pyx_f_6hunter_6_event_5Event_stdlib_getter(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 373, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->_stdlib); + __Pyx_DECREF(__pyx_v_event->_stdlib); + __pyx_v_event->_stdlib = __pyx_t_2; + __pyx_t_2 = 0; - /* "(tree fragment)":13 - * cdef __pyx_unpickle_Event__set_state(Event __pyx_result, tuple __pyx_state): - * __pyx_result._code = __pyx_state[0]; __pyx_result._filename = __pyx_state[1]; __pyx_result._fullsource = __pyx_state[2]; __pyx_result._function = __pyx_state[3]; __pyx_result._function_object = __pyx_state[4]; __pyx_result._globals = __pyx_state[5]; __pyx_result._lineno = __pyx_state[6]; __pyx_result._locals = __pyx_state[7]; __pyx_result._module = __pyx_state[8]; __pyx_result._source = __pyx_state[9]; __pyx_result._stdlib = __pyx_state[10]; __pyx_result._thread = __pyx_state[11]; __pyx_result._threadidn = __pyx_state[12]; __pyx_result._threadname = __pyx_state[13]; __pyx_result.arg = __pyx_state[14]; __pyx_result.calls = __pyx_state[15]; __pyx_result.depth = __pyx_state[16]; __pyx_result.detached = __pyx_state[17]; __pyx_result.frame = __pyx_state[18]; __pyx_result.kind = __pyx_state[19]; __pyx_result.threading_support = __pyx_state[20] - * if len(__pyx_state) > 21 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< - * __pyx_result.__dict__.update(__pyx_state[21]) - */ - __Pyx_TraceLine(13,0,__PYX_ERR(2, 13, __pyx_L1_error)) - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(2, 13, __pyx_L1_error) - } - __pyx_t_4 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(2, 13, __pyx_L1_error) - __pyx_t_5 = ((__pyx_t_4 > 21) != 0); - if (__pyx_t_5) { - } else { - __pyx_t_3 = __pyx_t_5; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_5 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(2, 13, __pyx_L1_error) - __pyx_t_6 = (__pyx_t_5 != 0); - __pyx_t_3 = __pyx_t_6; - __pyx_L4_bool_binop_done:; + /* "hunter/_event.pyx":374 + * event._source = self.source_getter() + * event._stdlib = self.stdlib_getter() + * event._threadidn = self.threadid_getter() # <<<<<<<<<<<<<< + * event._threadname = self.threadname_getter() + * event._instruction = self.instruction_getter() +*/ + __Pyx_TraceLine(374,55,0,__PYX_ERR(0, 374, __pyx_L1_error)) + __pyx_t_2 = __pyx_f_6hunter_6_event_5Event_threadid_getter(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 374, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->_threadidn); + __Pyx_DECREF(__pyx_v_event->_threadidn); + __pyx_v_event->_threadidn = __pyx_t_2; + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":375 + * event._stdlib = self.stdlib_getter() + * event._threadidn = self.threadid_getter() + * event._threadname = self.threadname_getter() # <<<<<<<<<<<<<< + * event._instruction = self.instruction_getter() + * +*/ + __Pyx_TraceLine(375,60,0,__PYX_ERR(0, 375, __pyx_L1_error)) + __pyx_t_2 = __pyx_f_6hunter_6_event_5Event_threadname_getter(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 375, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->_threadname); + __Pyx_DECREF(__pyx_v_event->_threadname); + __pyx_v_event->_threadname = __pyx_t_2; + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":376 + * event._threadidn = self.threadid_getter() + * event._threadname = self.threadname_getter() + * event._instruction = self.instruction_getter() # <<<<<<<<<<<<<< + * + * if value_filter: +*/ + __Pyx_TraceLine(376,65,0,__PYX_ERR(0, 376, __pyx_L1_error)) + __pyx_t_2 = __pyx_f_6hunter_6_event_5Event_instruction_getter(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 376, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->_instruction); + __Pyx_DECREF(__pyx_v_event->_instruction); + __pyx_v_event->_instruction = __pyx_t_2; + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":378 + * event._instruction = self.instruction_getter() + * + * if value_filter: # <<<<<<<<<<<<<< + * event._globals = {key: value_filter(value) for key, value in self.globals.items()} + * event._locals = {key: value_filter(value) for key, value in self.locals.items()} +*/ + __Pyx_TraceLine(378,67,0,__PYX_ERR(0, 378, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_value_filter); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 378, __pyx_L1_error) if (__pyx_t_3) { - /* "(tree fragment)":14 - * __pyx_result._code = __pyx_state[0]; __pyx_result._filename = __pyx_state[1]; __pyx_result._fullsource = __pyx_state[2]; __pyx_result._function = __pyx_state[3]; __pyx_result._function_object = __pyx_state[4]; __pyx_result._globals = __pyx_state[5]; __pyx_result._lineno = __pyx_state[6]; __pyx_result._locals = __pyx_state[7]; __pyx_result._module = __pyx_state[8]; __pyx_result._source = __pyx_state[9]; __pyx_result._stdlib = __pyx_state[10]; __pyx_result._thread = __pyx_state[11]; __pyx_result._threadidn = __pyx_state[12]; __pyx_result._threadname = __pyx_state[13]; __pyx_result.arg = __pyx_state[14]; __pyx_result.calls = __pyx_state[15]; __pyx_result.depth = __pyx_state[16]; __pyx_result.detached = __pyx_state[17]; __pyx_result.frame = __pyx_state[18]; __pyx_result.kind = __pyx_state[19]; __pyx_result.threading_support = __pyx_state[20] - * if len(__pyx_state) > 21 and hasattr(__pyx_result, '__dict__'): - * __pyx_result.__dict__.update(__pyx_state[21]) # <<<<<<<<<<<<<< - */ - __Pyx_TraceLine(14,0,__PYX_ERR(2, 14, __pyx_L1_error)) - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_update); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 14, __pyx_L1_error) - } - __pyx_t_7 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 21, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_9 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) { - __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); - if (likely(__pyx_t_9)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); - __Pyx_INCREF(__pyx_t_9); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_8, function); + /* "hunter/_event.pyx":379 + * + * if value_filter: + * event._globals = {key: value_filter(value) for key, value in self.globals.items()} # <<<<<<<<<<<<<< + * event._locals = {key: value_filter(value) for key, value in self.locals.items()} + * event.arg = value_filter(self.arg) +*/ + __Pyx_TraceLine(379,70,0,__PYX_ERR(0, 379, __pyx_L1_error)) + { /* enter inner scope */ + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 379, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = 0; + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_globals); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 379, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_7); + if (unlikely(__pyx_t_7 == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items"); + __PYX_ERR(0, 379, __pyx_L6_error) + } + __pyx_t_8 = __Pyx_dict_iterator(__pyx_t_7, 0, __pyx_mstate_global->__pyx_n_u_items, (&__pyx_t_5), (&__pyx_t_6)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 379, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_1); + __pyx_t_1 = __pyx_t_8; + __pyx_t_8 = 0; + while (1) { + __pyx_t_9 = __Pyx_dict_iter_next(__pyx_t_1, __pyx_t_5, &__pyx_t_4, &__pyx_t_8, &__pyx_t_7, NULL, __pyx_t_6); + if (unlikely(__pyx_t_9 == 0)) break; + if (unlikely(__pyx_t_9 == -1)) __PYX_ERR(0, 379, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GOTREF(__pyx_t_7); + __Pyx_XDECREF_SET(__pyx_7genexpr__pyx_v_key, __pyx_t_8); + __pyx_t_8 = 0; + __Pyx_XDECREF_SET(__pyx_7genexpr__pyx_v_value, __pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_8 = NULL; + __Pyx_INCREF(__pyx_v_value_filter); + __pyx_t_10 = __pyx_v_value_filter; + __pyx_t_11 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_10))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_10); + assert(__pyx_t_8); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_10); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_10, __pyx__function); + __pyx_t_11 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_7genexpr__pyx_v_value}; + __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 379, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_7); + } + if (unlikely(PyDict_SetItem(__pyx_t_2, (PyObject*)__pyx_7genexpr__pyx_v_key, (PyObject*)__pyx_t_7))) __PYX_ERR(0, 379, __pyx_L6_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_7genexpr__pyx_v_key); __pyx_7genexpr__pyx_v_key = 0; + __Pyx_XDECREF(__pyx_7genexpr__pyx_v_value); __pyx_7genexpr__pyx_v_value = 0; + goto __pyx_L9_exit_scope; + __pyx_L6_error:; + __Pyx_XDECREF(__pyx_7genexpr__pyx_v_key); __pyx_7genexpr__pyx_v_key = 0; + __Pyx_XDECREF(__pyx_7genexpr__pyx_v_value); __pyx_7genexpr__pyx_v_value = 0; + goto __pyx_L1_error; + __pyx_L9_exit_scope:; + } /* exit inner scope */ + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->_globals); + __Pyx_DECREF(__pyx_v_event->_globals); + __pyx_v_event->_globals = __pyx_t_2; + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":380 + * if value_filter: + * event._globals = {key: value_filter(value) for key, value in self.globals.items()} + * event._locals = {key: value_filter(value) for key, value in self.locals.items()} # <<<<<<<<<<<<<< + * event.arg = value_filter(self.arg) + * else: +*/ + __Pyx_TraceLine(380,84,0,__PYX_ERR(0, 380, __pyx_L1_error)) + { /* enter inner scope */ + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 380, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = 0; + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_locals); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 380, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_7); + if (unlikely(__pyx_t_7 == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items"); + __PYX_ERR(0, 380, __pyx_L12_error) + } + __pyx_t_10 = __Pyx_dict_iterator(__pyx_t_7, 0, __pyx_mstate_global->__pyx_n_u_items, (&__pyx_t_4), (&__pyx_t_6)); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 380, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_1); + __pyx_t_1 = __pyx_t_10; + __pyx_t_10 = 0; + while (1) { + __pyx_t_9 = __Pyx_dict_iter_next(__pyx_t_1, __pyx_t_4, &__pyx_t_5, &__pyx_t_10, &__pyx_t_7, NULL, __pyx_t_6); + if (unlikely(__pyx_t_9 == 0)) break; + if (unlikely(__pyx_t_9 == -1)) __PYX_ERR(0, 380, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GOTREF(__pyx_t_7); + __Pyx_XDECREF_SET(__pyx_8genexpr1__pyx_v_key, __pyx_t_10); + __pyx_t_10 = 0; + __Pyx_XDECREF_SET(__pyx_8genexpr1__pyx_v_value, __pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_10 = NULL; + __Pyx_INCREF(__pyx_v_value_filter); + __pyx_t_8 = __pyx_v_value_filter; + __pyx_t_11 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_8); + assert(__pyx_t_10); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_8, __pyx__function); + __pyx_t_11 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_8genexpr1__pyx_v_value}; + __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 380, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_7); + } + if (unlikely(PyDict_SetItem(__pyx_t_2, (PyObject*)__pyx_8genexpr1__pyx_v_key, (PyObject*)__pyx_t_7))) __PYX_ERR(0, 380, __pyx_L12_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_key); __pyx_8genexpr1__pyx_v_key = 0; + __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_value); __pyx_8genexpr1__pyx_v_value = 0; + goto __pyx_L15_exit_scope; + __pyx_L12_error:; + __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_key); __pyx_8genexpr1__pyx_v_key = 0; + __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_value); __pyx_8genexpr1__pyx_v_value = 0; + goto __pyx_L1_error; + __pyx_L15_exit_scope:; + } /* exit inner scope */ + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->_locals); + __Pyx_DECREF(__pyx_v_event->_locals); + __pyx_v_event->_locals = __pyx_t_2; + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":381 + * event._globals = {key: value_filter(value) for key, value in self.globals.items()} + * event._locals = {key: value_filter(value) for key, value in self.locals.items()} + * event.arg = value_filter(self.arg) # <<<<<<<<<<<<<< + * else: + * event._globals = {} +*/ + __Pyx_TraceLine(381,99,0,__PYX_ERR(0, 381, __pyx_L1_error)) + __pyx_t_1 = NULL; + __Pyx_INCREF(__pyx_v_value_filter); + __pyx_t_7 = __pyx_v_value_filter; + __pyx_t_11 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_7); + assert(__pyx_t_1); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_7, __pyx__function); + __pyx_t_11 = 0; } - __pyx_t_1 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_9, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); - __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "(tree fragment)":13 - * cdef __pyx_unpickle_Event__set_state(Event __pyx_result, tuple __pyx_state): - * __pyx_result._code = __pyx_state[0]; __pyx_result._filename = __pyx_state[1]; __pyx_result._fullsource = __pyx_state[2]; __pyx_result._function = __pyx_state[3]; __pyx_result._function_object = __pyx_state[4]; __pyx_result._globals = __pyx_state[5]; __pyx_result._lineno = __pyx_state[6]; __pyx_result._locals = __pyx_state[7]; __pyx_result._module = __pyx_state[8]; __pyx_result._source = __pyx_state[9]; __pyx_result._stdlib = __pyx_state[10]; __pyx_result._thread = __pyx_state[11]; __pyx_result._threadidn = __pyx_state[12]; __pyx_result._threadname = __pyx_state[13]; __pyx_result.arg = __pyx_state[14]; __pyx_result.calls = __pyx_state[15]; __pyx_result.depth = __pyx_state[16]; __pyx_result.detached = __pyx_state[17]; __pyx_result.frame = __pyx_state[18]; __pyx_result.kind = __pyx_state[19]; __pyx_result.threading_support = __pyx_state[20] - * if len(__pyx_state) > 21 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< - * __pyx_result.__dict__.update(__pyx_state[21]) - */ + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_v_self->arg}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 381, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->arg); + __Pyx_DECREF(__pyx_v_event->arg); + __pyx_v_event->arg = __pyx_t_2; + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":378 + * event._instruction = self.instruction_getter() + * + * if value_filter: # <<<<<<<<<<<<<< + * event._globals = {key: value_filter(value) for key, value in self.globals.items()} + * event._locals = {key: value_filter(value) for key, value in self.locals.items()} +*/ + goto __pyx_L3; } - /* "(tree fragment)":11 - * __pyx_unpickle_Event__set_state( __pyx_result, __pyx_state) - * return __pyx_result - * cdef __pyx_unpickle_Event__set_state(Event __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< - * __pyx_result._code = __pyx_state[0]; __pyx_result._filename = __pyx_state[1]; __pyx_result._fullsource = __pyx_state[2]; __pyx_result._function = __pyx_state[3]; __pyx_result._function_object = __pyx_state[4]; __pyx_result._globals = __pyx_state[5]; __pyx_result._lineno = __pyx_state[6]; __pyx_result._locals = __pyx_state[7]; __pyx_result._module = __pyx_state[8]; __pyx_result._source = __pyx_state[9]; __pyx_result._stdlib = __pyx_state[10]; __pyx_result._thread = __pyx_state[11]; __pyx_result._threadidn = __pyx_state[12]; __pyx_result._threadname = __pyx_state[13]; __pyx_result.arg = __pyx_state[14]; __pyx_result.calls = __pyx_state[15]; __pyx_result.depth = __pyx_state[16]; __pyx_result.detached = __pyx_state[17]; __pyx_result.frame = __pyx_state[18]; __pyx_result.kind = __pyx_state[19]; __pyx_result.threading_support = __pyx_state[20] - * if len(__pyx_state) > 21 and hasattr(__pyx_result, '__dict__'): - */ + /* "hunter/_event.pyx":383 + * event.arg = value_filter(self.arg) + * else: + * event._globals = {} # <<<<<<<<<<<<<< + * event._locals = {} + * event.arg = None +*/ + __Pyx_TraceLine(383,102,0,__PYX_ERR(0, 383, __pyx_L1_error)) + /*else*/ { + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 383, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->_globals); + __Pyx_DECREF(__pyx_v_event->_globals); + __pyx_v_event->_globals = __pyx_t_2; + __pyx_t_2 = 0; - /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); + /* "hunter/_event.pyx":384 + * else: + * event._globals = {} + * event._locals = {} # <<<<<<<<<<<<<< + * event.arg = None + * +*/ + __Pyx_TraceLine(384,107,0,__PYX_ERR(0, 384, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 384, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->_locals); + __Pyx_DECREF(__pyx_v_event->_locals); + __pyx_v_event->_locals = __pyx_t_2; + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":385 + * event._globals = {} + * event._locals = {} + * event.arg = None # <<<<<<<<<<<<<< + * + * event.builtin = self.builtin +*/ + __Pyx_TraceLine(385,108,0,__PYX_ERR(0, 385, __pyx_L1_error)) + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_event->arg); + __Pyx_DECREF(__pyx_v_event->arg); + __pyx_v_event->arg = Py_None; + } + __pyx_L3:; + + /* "hunter/_event.pyx":387 + * event.arg = None + * + * event.builtin = self.builtin # <<<<<<<<<<<<<< + * event.calls = self.calls + * event.depth = self.depth +*/ + __Pyx_TraceLine(387,114,0,__PYX_ERR(0, 387, __pyx_L1_error)) + __pyx_t_2 = __pyx_v_self->builtin; + __Pyx_INCREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->builtin); + __Pyx_DECREF(__pyx_v_event->builtin); + __pyx_v_event->builtin = __pyx_t_2; + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":388 + * + * event.builtin = self.builtin + * event.calls = self.calls # <<<<<<<<<<<<<< + * event.depth = self.depth + * event.detached = True +*/ + __Pyx_TraceLine(388,118,0,__PYX_ERR(0, 388, __pyx_L1_error)) + __pyx_t_6 = __pyx_v_self->calls; + __pyx_v_event->calls = __pyx_t_6; + + /* "hunter/_event.pyx":389 + * event.builtin = self.builtin + * event.calls = self.calls + * event.depth = self.depth # <<<<<<<<<<<<<< + * event.detached = True + * event.kind = self.kind +*/ + __Pyx_TraceLine(389,122,0,__PYX_ERR(0, 389, __pyx_L1_error)) + __pyx_t_6 = __pyx_v_self->depth; + __pyx_v_event->depth = __pyx_t_6; + + /* "hunter/_event.pyx":390 + * event.calls = self.calls + * event.depth = self.depth + * event.detached = True # <<<<<<<<<<<<<< + * event.kind = self.kind + * event.threading_support = self.threading_support +*/ + __Pyx_TraceLine(390,123,0,__PYX_ERR(0, 390, __pyx_L1_error)) + __pyx_v_event->detached = 1; + + /* "hunter/_event.pyx":391 + * event.depth = self.depth + * event.detached = True + * event.kind = self.kind # <<<<<<<<<<<<<< + * event.threading_support = self.threading_support + * +*/ + __Pyx_TraceLine(391,129,0,__PYX_ERR(0, 391, __pyx_L1_error)) + __pyx_t_2 = __pyx_v_self->kind; + __Pyx_INCREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->kind); + __Pyx_DECREF(__pyx_v_event->kind); + __pyx_v_event->kind = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":392 + * event.detached = True + * event.kind = self.kind + * event.threading_support = self.threading_support # <<<<<<<<<<<<<< + * + * return event +*/ + __Pyx_TraceLine(392,133,0,__PYX_ERR(0, 392, __pyx_L1_error)) + __pyx_t_3 = __pyx_v_self->threading_support; + __pyx_v_event->threading_support = __pyx_t_3; + + /* "hunter/_event.pyx":394 + * event.threading_support = self.threading_support + * + * return event # <<<<<<<<<<<<<< + * + * cdef inline Event fast_clone(Event self): +*/ + __Pyx_TraceLine(394,134,0,__PYX_ERR(0, 394, __pyx_L1_error)) + __Pyx_XDECREF((PyObject *)__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_event); + __pyx_r = __pyx_v_event; + __Pyx_TraceReturnValue((PyObject *)__pyx_r, 134, 0, __PYX_ERR(0, 394, __pyx_L1_error)); goto __pyx_L0; + + /* "hunter/_event.pyx":362 + * + * + * cdef inline Event fast_detach(Event self, object value_filter): # <<<<<<<<<<<<<< + * event = Event.__new__(Event) + * +*/ + + /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); - __Pyx_XDECREF(__pyx_t_9); - __Pyx_AddTraceback("hunter._event.__pyx_unpickle_Event__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 362, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.fast_detach", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_XDECREF((PyObject *)__pyx_v_event); + __Pyx_XDECREF(__pyx_7genexpr__pyx_v_key); + __Pyx_XDECREF(__pyx_7genexpr__pyx_v_value); + __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_key); + __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_value); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -static struct __pyx_vtabstruct_6hunter_6_event_Event __pyx_vtable_6hunter_6_event_Event; -static PyObject *__pyx_tp_new_6hunter_6_event_Event(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { - struct __pyx_obj_6hunter_6_event_Event *p; - PyObject *o; - o = (*t->tp_alloc)(t, 0); - if (unlikely(!o)) return 0; - p = ((struct __pyx_obj_6hunter_6_event_Event *)o); - p->__pyx_vtab = __pyx_vtabptr_6hunter_6_event_Event; - p->frame = ((PyFrameObject *)Py_None); Py_INCREF(Py_None); - p->kind = ((PyObject*)Py_None); Py_INCREF(Py_None); - p->arg = Py_None; Py_INCREF(Py_None); - p->_code = Py_None; Py_INCREF(Py_None); - p->_filename = Py_None; Py_INCREF(Py_None); - p->_fullsource = Py_None; Py_INCREF(Py_None); - p->_function = Py_None; Py_INCREF(Py_None); - p->_function_object = Py_None; Py_INCREF(Py_None); - p->_globals = Py_None; Py_INCREF(Py_None); - p->_lineno = Py_None; Py_INCREF(Py_None); +/* "hunter/_event.pyx":396 + * return event + * + * cdef inline Event fast_clone(Event self): # <<<<<<<<<<<<<< + * event = Event.__new__(Event) + * event.arg = self.arg +*/ + +static CYTHON_INLINE struct __pyx_obj_6hunter_6_event_Event *__pyx_f_6hunter_6_event_fast_clone(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { + struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event = NULL; + struct __pyx_obj_6hunter_6_event_Event *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[43])) + __Pyx_RefNannySetupContext("fast_clone", 0); + __Pyx_TraceStartFunc("fast_clone", __pyx_f[0], 396, 0, 0, 0, __PYX_ERR(0, 396, __pyx_L1_error)); + + /* "hunter/_event.pyx":397 + * + * cdef inline Event fast_clone(Event self): + * event = Event.__new__(Event) # <<<<<<<<<<<<<< + * event.arg = self.arg + * event.builtin = self.builtin +*/ + __Pyx_TraceLine(397,5,0,__PYX_ERR(0, 397, __pyx_L1_error)) + __pyx_t_1 = ((PyObject *)__pyx_tp_new_6hunter_6_event_Event(((PyTypeObject *)__pyx_mstate_global->__pyx_ptype_6hunter_6_event_Event), __pyx_mstate_global->__pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 397, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_1); + __pyx_t_2 = ((PyObject *)__pyx_t_1); + __Pyx_INCREF(__pyx_t_2); + __Pyx_DECREF((PyObject *)__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_event = ((struct __pyx_obj_6hunter_6_event_Event *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":398 + * cdef inline Event fast_clone(Event self): + * event = Event.__new__(Event) + * event.arg = self.arg # <<<<<<<<<<<<<< + * event.builtin = self.builtin + * event.calls = self.calls +*/ + __Pyx_TraceLine(398,10,0,__PYX_ERR(0, 398, __pyx_L1_error)) + __pyx_t_2 = __pyx_v_self->arg; + __Pyx_INCREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->arg); + __Pyx_DECREF(__pyx_v_event->arg); + __pyx_v_event->arg = __pyx_t_2; + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":399 + * event = Event.__new__(Event) + * event.arg = self.arg + * event.builtin = self.builtin # <<<<<<<<<<<<<< + * event.calls = self.calls + * event.depth = self.depth +*/ + __Pyx_TraceLine(399,14,0,__PYX_ERR(0, 399, __pyx_L1_error)) + __pyx_t_2 = __pyx_v_self->builtin; + __Pyx_INCREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->builtin); + __Pyx_DECREF(__pyx_v_event->builtin); + __pyx_v_event->builtin = __pyx_t_2; + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":400 + * event.arg = self.arg + * event.builtin = self.builtin + * event.calls = self.calls # <<<<<<<<<<<<<< + * event.depth = self.depth + * event.detached = False +*/ + __Pyx_TraceLine(400,18,0,__PYX_ERR(0, 400, __pyx_L1_error)) + __pyx_t_3 = __pyx_v_self->calls; + __pyx_v_event->calls = __pyx_t_3; + + /* "hunter/_event.pyx":401 + * event.builtin = self.builtin + * event.calls = self.calls + * event.depth = self.depth # <<<<<<<<<<<<<< + * event.detached = False + * event.frame = self.frame +*/ + __Pyx_TraceLine(401,22,0,__PYX_ERR(0, 401, __pyx_L1_error)) + __pyx_t_3 = __pyx_v_self->depth; + __pyx_v_event->depth = __pyx_t_3; + + /* "hunter/_event.pyx":402 + * event.calls = self.calls + * event.depth = self.depth + * event.detached = False # <<<<<<<<<<<<<< + * event.frame = self.frame + * event.kind = self.kind +*/ + __Pyx_TraceLine(402,23,0,__PYX_ERR(0, 402, __pyx_L1_error)) + __pyx_v_event->detached = 0; + + /* "hunter/_event.pyx":403 + * event.depth = self.depth + * event.detached = False + * event.frame = self.frame # <<<<<<<<<<<<<< + * event.kind = self.kind + * event.threading_support = self.threading_support +*/ + __Pyx_TraceLine(403,29,0,__PYX_ERR(0, 403, __pyx_L1_error)) + __pyx_t_2 = ((PyObject *)__pyx_v_self->frame); + __Pyx_INCREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->frame); + __Pyx_DECREF(__pyx_v_event->frame); + __pyx_v_event->frame = ((FrameType)__pyx_t_2); + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":404 + * event.detached = False + * event.frame = self.frame + * event.kind = self.kind # <<<<<<<<<<<<<< + * event.threading_support = self.threading_support + * event._code = self._code +*/ + __Pyx_TraceLine(404,33,0,__PYX_ERR(0, 404, __pyx_L1_error)) + __pyx_t_2 = __pyx_v_self->kind; + __Pyx_INCREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->kind); + __Pyx_DECREF(__pyx_v_event->kind); + __pyx_v_event->kind = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":405 + * event.frame = self.frame + * event.kind = self.kind + * event.threading_support = self.threading_support # <<<<<<<<<<<<<< + * event._code = self._code + * event._filename = self._filename +*/ + __Pyx_TraceLine(405,37,0,__PYX_ERR(0, 405, __pyx_L1_error)) + __pyx_t_4 = __pyx_v_self->threading_support; + __pyx_v_event->threading_support = __pyx_t_4; + + /* "hunter/_event.pyx":406 + * event.kind = self.kind + * event.threading_support = self.threading_support + * event._code = self._code # <<<<<<<<<<<<<< + * event._filename = self._filename + * event._fullsource = self._fullsource +*/ + __Pyx_TraceLine(406,41,0,__PYX_ERR(0, 406, __pyx_L1_error)) + __pyx_t_2 = __pyx_v_self->_code; + __Pyx_INCREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->_code); + __Pyx_DECREF(__pyx_v_event->_code); + __pyx_v_event->_code = __pyx_t_2; + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":407 + * event.threading_support = self.threading_support + * event._code = self._code + * event._filename = self._filename # <<<<<<<<<<<<<< + * event._fullsource = self._fullsource + * event._function_object = self._function_object +*/ + __Pyx_TraceLine(407,45,0,__PYX_ERR(0, 407, __pyx_L1_error)) + __pyx_t_2 = __pyx_v_self->_filename; + __Pyx_INCREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->_filename); + __Pyx_DECREF(__pyx_v_event->_filename); + __pyx_v_event->_filename = __pyx_t_2; + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":408 + * event._code = self._code + * event._filename = self._filename + * event._fullsource = self._fullsource # <<<<<<<<<<<<<< + * event._function_object = self._function_object + * event._function = self._function +*/ + __Pyx_TraceLine(408,49,0,__PYX_ERR(0, 408, __pyx_L1_error)) + __pyx_t_2 = __pyx_v_self->_fullsource; + __Pyx_INCREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->_fullsource); + __Pyx_DECREF(__pyx_v_event->_fullsource); + __pyx_v_event->_fullsource = __pyx_t_2; + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":409 + * event._filename = self._filename + * event._fullsource = self._fullsource + * event._function_object = self._function_object # <<<<<<<<<<<<<< + * event._function = self._function + * event._globals = self._globals +*/ + __Pyx_TraceLine(409,53,0,__PYX_ERR(0, 409, __pyx_L1_error)) + __pyx_t_2 = __pyx_v_self->_function_object; + __Pyx_INCREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->_function_object); + __Pyx_DECREF(__pyx_v_event->_function_object); + __pyx_v_event->_function_object = __pyx_t_2; + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":410 + * event._fullsource = self._fullsource + * event._function_object = self._function_object + * event._function = self._function # <<<<<<<<<<<<<< + * event._globals = self._globals + * event._lineno = self._lineno +*/ + __Pyx_TraceLine(410,57,0,__PYX_ERR(0, 410, __pyx_L1_error)) + __pyx_t_2 = __pyx_v_self->_function; + __Pyx_INCREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->_function); + __Pyx_DECREF(__pyx_v_event->_function); + __pyx_v_event->_function = __pyx_t_2; + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":411 + * event._function_object = self._function_object + * event._function = self._function + * event._globals = self._globals # <<<<<<<<<<<<<< + * event._lineno = self._lineno + * event._locals = self._locals +*/ + __Pyx_TraceLine(411,61,0,__PYX_ERR(0, 411, __pyx_L1_error)) + __pyx_t_2 = __pyx_v_self->_globals; + __Pyx_INCREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->_globals); + __Pyx_DECREF(__pyx_v_event->_globals); + __pyx_v_event->_globals = __pyx_t_2; + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":412 + * event._function = self._function + * event._globals = self._globals + * event._lineno = self._lineno # <<<<<<<<<<<<<< + * event._locals = self._locals + * event._module = self._module +*/ + __Pyx_TraceLine(412,65,0,__PYX_ERR(0, 412, __pyx_L1_error)) + __pyx_t_2 = __pyx_v_self->_lineno; + __Pyx_INCREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->_lineno); + __Pyx_DECREF(__pyx_v_event->_lineno); + __pyx_v_event->_lineno = __pyx_t_2; + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":413 + * event._globals = self._globals + * event._lineno = self._lineno + * event._locals = self._locals # <<<<<<<<<<<<<< + * event._module = self._module + * event._source = self._source +*/ + __Pyx_TraceLine(413,69,0,__PYX_ERR(0, 413, __pyx_L1_error)) + __pyx_t_2 = __pyx_v_self->_locals; + __Pyx_INCREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->_locals); + __Pyx_DECREF(__pyx_v_event->_locals); + __pyx_v_event->_locals = __pyx_t_2; + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":414 + * event._lineno = self._lineno + * event._locals = self._locals + * event._module = self._module # <<<<<<<<<<<<<< + * event._source = self._source + * event._stdlib = self._stdlib +*/ + __Pyx_TraceLine(414,73,0,__PYX_ERR(0, 414, __pyx_L1_error)) + __pyx_t_2 = __pyx_v_self->_module; + __Pyx_INCREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->_module); + __Pyx_DECREF(__pyx_v_event->_module); + __pyx_v_event->_module = __pyx_t_2; + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":415 + * event._locals = self._locals + * event._module = self._module + * event._source = self._source # <<<<<<<<<<<<<< + * event._stdlib = self._stdlib + * event._threadidn = self._threadidn +*/ + __Pyx_TraceLine(415,77,0,__PYX_ERR(0, 415, __pyx_L1_error)) + __pyx_t_2 = __pyx_v_self->_source; + __Pyx_INCREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->_source); + __Pyx_DECREF(__pyx_v_event->_source); + __pyx_v_event->_source = __pyx_t_2; + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":416 + * event._module = self._module + * event._source = self._source + * event._stdlib = self._stdlib # <<<<<<<<<<<<<< + * event._threadidn = self._threadidn + * event._threadname = self._threadname +*/ + __Pyx_TraceLine(416,81,0,__PYX_ERR(0, 416, __pyx_L1_error)) + __pyx_t_2 = __pyx_v_self->_stdlib; + __Pyx_INCREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->_stdlib); + __Pyx_DECREF(__pyx_v_event->_stdlib); + __pyx_v_event->_stdlib = __pyx_t_2; + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":417 + * event._source = self._source + * event._stdlib = self._stdlib + * event._threadidn = self._threadidn # <<<<<<<<<<<<<< + * event._threadname = self._threadname + * event._thread = self._thread +*/ + __Pyx_TraceLine(417,85,0,__PYX_ERR(0, 417, __pyx_L1_error)) + __pyx_t_2 = __pyx_v_self->_threadidn; + __Pyx_INCREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->_threadidn); + __Pyx_DECREF(__pyx_v_event->_threadidn); + __pyx_v_event->_threadidn = __pyx_t_2; + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":418 + * event._stdlib = self._stdlib + * event._threadidn = self._threadidn + * event._threadname = self._threadname # <<<<<<<<<<<<<< + * event._thread = self._thread + * event._instruction = self._instruction +*/ + __Pyx_TraceLine(418,89,0,__PYX_ERR(0, 418, __pyx_L1_error)) + __pyx_t_2 = __pyx_v_self->_threadname; + __Pyx_INCREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->_threadname); + __Pyx_DECREF(__pyx_v_event->_threadname); + __pyx_v_event->_threadname = __pyx_t_2; + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":419 + * event._threadidn = self._threadidn + * event._threadname = self._threadname + * event._thread = self._thread # <<<<<<<<<<<<<< + * event._instruction = self._instruction + * return event +*/ + __Pyx_TraceLine(419,93,0,__PYX_ERR(0, 419, __pyx_L1_error)) + __pyx_t_2 = __pyx_v_self->_thread; + __Pyx_INCREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->_thread); + __Pyx_DECREF(__pyx_v_event->_thread); + __pyx_v_event->_thread = __pyx_t_2; + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":420 + * event._threadname = self._threadname + * event._thread = self._thread + * event._instruction = self._instruction # <<<<<<<<<<<<<< + * return event +*/ + __Pyx_TraceLine(420,97,0,__PYX_ERR(0, 420, __pyx_L1_error)) + __pyx_t_2 = __pyx_v_self->_instruction; + __Pyx_INCREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_event->_instruction); + __Pyx_DECREF(__pyx_v_event->_instruction); + __pyx_v_event->_instruction = __pyx_t_2; + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":421 + * event._thread = self._thread + * event._instruction = self._instruction + * return event # <<<<<<<<<<<<<< +*/ + __Pyx_TraceLine(421,98,0,__PYX_ERR(0, 421, __pyx_L1_error)) + __Pyx_XDECREF((PyObject *)__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_event); + __pyx_r = __pyx_v_event; + __Pyx_TraceReturnValue((PyObject *)__pyx_r, 98, 0, __PYX_ERR(0, 421, __pyx_L1_error)); + goto __pyx_L0; + + /* "hunter/_event.pyx":396 + * return event + * + * cdef inline Event fast_clone(Event self): # <<<<<<<<<<<<<< + * event = Event.__new__(Event) + * event.arg = self.arg +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 396, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._event.fast_clone", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_event); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +/* #### Code section: module_exttypes ### */ +static struct __pyx_vtabstruct_6hunter_6_event_Event __pyx_vtable_6hunter_6_event_Event; + +static PyObject *__pyx_tp_new_6hunter_6_event_Event(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_6hunter_6_event_Event *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_6hunter_6_event_Event *)o); + p->__pyx_vtab = __pyx_vtabptr_6hunter_6_event_Event; + p->frame = ((FrameType)Py_None); Py_INCREF(Py_None); + p->kind = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->arg = Py_None; Py_INCREF(Py_None); + p->builtin = Py_None; Py_INCREF(Py_None); + p->_code = Py_None; Py_INCREF(Py_None); + p->_filename = Py_None; Py_INCREF(Py_None); + p->_fullsource = Py_None; Py_INCREF(Py_None); + p->_function = Py_None; Py_INCREF(Py_None); + p->_function_object = Py_None; Py_INCREF(Py_None); + p->_globals = Py_None; Py_INCREF(Py_None); + p->_lineno = Py_None; Py_INCREF(Py_None); p->_locals = Py_None; Py_INCREF(Py_None); p->_module = Py_None; Py_INCREF(Py_None); p->_source = Py_None; Py_INCREF(Py_None); @@ -9314,6 +11858,7 @@ static PyObject *__pyx_tp_new_6hunter_6_event_Event(PyTypeObject *t, CYTHON_UNUS p->_thread = Py_None; Py_INCREF(Py_None); p->_threadidn = Py_None; Py_INCREF(Py_None); p->_threadname = Py_None; Py_INCREF(Py_None); + p->_instruction = Py_None; Py_INCREF(Py_None); return o; } @@ -9323,6 +11868,7 @@ static void __pyx_tp_dealloc_6hunter_6_event_Event(PyObject *o) { Py_CLEAR(p->frame); Py_CLEAR(p->kind); Py_CLEAR(p->arg); + Py_CLEAR(p->builtin); Py_CLEAR(p->_code); Py_CLEAR(p->_filename); Py_CLEAR(p->_fullsource); @@ -9337,18 +11883,33 @@ static void __pyx_tp_dealloc_6hunter_6_event_Event(PyObject *o) { Py_CLEAR(p->_thread); Py_CLEAR(p->_threadidn); Py_CLEAR(p->_threadname); + Py_CLEAR(p->_instruction); + #if CYTHON_USE_TYPE_SLOTS (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif } static int __pyx_tp_traverse_6hunter_6_event_Event(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_6hunter_6_event_Event *p = (struct __pyx_obj_6hunter_6_event_Event *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } if (p->frame) { e = (*v)(((PyObject *)p->frame), a); if (e) return e; } if (p->arg) { e = (*v)(p->arg, a); if (e) return e; } + if (p->builtin) { + e = (*v)(p->builtin, a); if (e) return e; + } if (p->_code) { e = (*v)(p->_code, a); if (e) return e; } @@ -9391,6 +11952,9 @@ static int __pyx_tp_traverse_6hunter_6_event_Event(PyObject *o, visitproc v, voi if (p->_threadname) { e = (*v)(p->_threadname, a); if (e) return e; } + if (p->_instruction) { + e = (*v)(p->_instruction, a); if (e) return e; + } return 0; } @@ -9398,11 +11962,14 @@ static int __pyx_tp_clear_6hunter_6_event_Event(PyObject *o) { PyObject* tmp; struct __pyx_obj_6hunter_6_event_Event *p = (struct __pyx_obj_6hunter_6_event_Event *)o; tmp = ((PyObject*)p->frame); - p->frame = ((PyFrameObject *)Py_None); Py_INCREF(Py_None); + p->frame = ((FrameType)Py_None); Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->arg); p->arg = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); + tmp = ((PyObject*)p->builtin); + p->builtin = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); tmp = ((PyObject*)p->_code); p->_code = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); @@ -9445,16 +12012,51 @@ static int __pyx_tp_clear_6hunter_6_event_Event(PyObject *o) { tmp = ((PyObject*)p->_threadname); p->_threadname = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); + tmp = ((PyObject*)p->_instruction); + p->_instruction = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); return 0; } + static PyObject *__pyx_sq_item_6hunter_6_event_Event(PyObject *o, Py_ssize_t i) { PyObject *r; - PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; + PyObject *x = PyLong_FromSsize_t(i); if(!x) return 0; + #if CYTHON_USE_TYPE_SLOTS || (!CYTHON_USE_TYPE_SPECS && __PYX_LIMITED_VERSION_HEX < 0x030A0000) r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); + #else + r = ((binaryfunc)PyType_GetSlot(Py_TYPE(o), Py_mp_subscript))(o, x); + #endif Py_DECREF(x); return r; } +static PyObject *__pyx_tp_richcompare_6hunter_6_event_Event(PyObject *o1, PyObject *o2, int op) { + switch (op) { + case Py_EQ: { + return __pyx_pw_6hunter_6_event_5Event_5__eq__(o1, o2); + } + case Py_NE: { + PyObject *ret; + ret = __pyx_pw_6hunter_6_event_5Event_5__eq__(o1, o2); + if (likely(ret && ret != Py_NotImplemented)) { + int b = __Pyx_PyObject_IsTrue(ret); + Py_DECREF(ret); + if (unlikely(b < 0)) return NULL; + ret = (b) ? Py_False : Py_True; + Py_INCREF(ret); + } + return ret; + } + default: { + return __Pyx_NewRef(Py_NotImplemented); + } + } +} + +static PyObject *__pyx_getprop_6hunter_6_event_5Event_instruction(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_6_event_5Event_11instruction_1__get__(o); +} + static PyObject *__pyx_getprop_6hunter_6_event_5Event_threadid(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_6hunter_6_event_5Event_8threadid_1__get__(o); } @@ -9535,36 +12137,65 @@ static PyObject *__pyx_getprop_6hunter_6_event_5Event_detached(PyObject *o, CYTH return __pyx_pw_6hunter_6_event_5Event_8detached_1__get__(o); } +static PyObject *__pyx_getprop_6hunter_6_event_5Event_builtin(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_6_event_5Event_7builtin_1__get__(o); +} + static PyMethodDef __pyx_methods_6hunter_6_event_Event[] = { - {"detach", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6hunter_6_event_5Event_3detach, METH_VARARGS|METH_KEYWORDS, 0}, - {"__reduce_cython__", (PyCFunction)__pyx_pw_6hunter_6_event_5Event_7__reduce_cython__, METH_NOARGS, 0}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_6hunter_6_event_5Event_9__setstate_cython__, METH_O, 0}, + {"detach", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_6_event_5Event_7detach, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"clone", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_6_event_5Event_9clone, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_6hunter_6_event_Event[] = { - {(char *)"threadid", __pyx_getprop_6hunter_6_event_5Event_threadid, 0, (char *)0, 0}, - {(char *)"threadname", __pyx_getprop_6hunter_6_event_5Event_threadname, 0, (char *)0, 0}, - {(char *)"locals", __pyx_getprop_6hunter_6_event_5Event_locals, 0, (char *)0, 0}, - {(char *)"globals", __pyx_getprop_6hunter_6_event_5Event_globals, 0, (char *)0, 0}, - {(char *)"function", __pyx_getprop_6hunter_6_event_5Event_function, 0, (char *)0, 0}, - {(char *)"function_object", __pyx_getprop_6hunter_6_event_5Event_function_object, 0, (char *)0, 0}, - {(char *)"module", __pyx_getprop_6hunter_6_event_5Event_module, 0, (char *)0, 0}, - {(char *)"filename", __pyx_getprop_6hunter_6_event_5Event_filename, 0, (char *)0, 0}, - {(char *)"lineno", __pyx_getprop_6hunter_6_event_5Event_lineno, 0, (char *)0, 0}, - {(char *)"code", __pyx_getprop_6hunter_6_event_5Event_code, 0, (char *)0, 0}, - {(char *)"stdlib", __pyx_getprop_6hunter_6_event_5Event_stdlib, 0, (char *)0, 0}, - {(char *)"fullsource", __pyx_getprop_6hunter_6_event_5Event_fullsource, 0, (char *)0, 0}, - {(char *)"source", __pyx_getprop_6hunter_6_event_5Event_source, 0, (char *)0, 0}, - {(char *)"frame", __pyx_getprop_6hunter_6_event_5Event_frame, 0, (char *)0, 0}, - {(char *)"kind", __pyx_getprop_6hunter_6_event_5Event_kind, 0, (char *)0, 0}, - {(char *)"arg", __pyx_getprop_6hunter_6_event_5Event_arg, 0, (char *)0, 0}, - {(char *)"depth", __pyx_getprop_6hunter_6_event_5Event_depth, 0, (char *)0, 0}, - {(char *)"calls", __pyx_getprop_6hunter_6_event_5Event_calls, 0, (char *)0, 0}, - {(char *)"threading_support", __pyx_getprop_6hunter_6_event_5Event_threading_support, 0, (char *)0, 0}, - {(char *)"detached", __pyx_getprop_6hunter_6_event_5Event_detached, 0, (char *)0, 0}, + {"instruction", __pyx_getprop_6hunter_6_event_5Event_instruction, 0, 0, 0}, + {"threadid", __pyx_getprop_6hunter_6_event_5Event_threadid, 0, 0, 0}, + {"threadname", __pyx_getprop_6hunter_6_event_5Event_threadname, 0, 0, 0}, + {"locals", __pyx_getprop_6hunter_6_event_5Event_locals, 0, 0, 0}, + {"globals", __pyx_getprop_6hunter_6_event_5Event_globals, 0, 0, 0}, + {"function", __pyx_getprop_6hunter_6_event_5Event_function, 0, 0, 0}, + {"function_object", __pyx_getprop_6hunter_6_event_5Event_function_object, 0, 0, 0}, + {"module", __pyx_getprop_6hunter_6_event_5Event_module, 0, 0, 0}, + {"filename", __pyx_getprop_6hunter_6_event_5Event_filename, 0, 0, 0}, + {"lineno", __pyx_getprop_6hunter_6_event_5Event_lineno, 0, 0, 0}, + {"code", __pyx_getprop_6hunter_6_event_5Event_code, 0, 0, 0}, + {"stdlib", __pyx_getprop_6hunter_6_event_5Event_stdlib, 0, 0, 0}, + {"fullsource", __pyx_getprop_6hunter_6_event_5Event_fullsource, 0, 0, 0}, + {"source", __pyx_getprop_6hunter_6_event_5Event_source, 0, 0, 0}, + {"frame", __pyx_getprop_6hunter_6_event_5Event_frame, 0, 0, 0}, + {"kind", __pyx_getprop_6hunter_6_event_5Event_kind, 0, 0, 0}, + {"arg", __pyx_getprop_6hunter_6_event_5Event_arg, 0, 0, 0}, + {"depth", __pyx_getprop_6hunter_6_event_5Event_depth, 0, 0, 0}, + {"calls", __pyx_getprop_6hunter_6_event_5Event_calls, 0, 0, 0}, + {"threading_support", __pyx_getprop_6hunter_6_event_5Event_threading_support, 0, 0, 0}, + {"detached", __pyx_getprop_6hunter_6_event_5Event_detached, 0, 0, 0}, + {"builtin", __pyx_getprop_6hunter_6_event_5Event_builtin, 0, 0, 0}, {0, 0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_6hunter_6_event_Event_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_6hunter_6_event_Event}, + {Py_tp_repr, (void *)__pyx_pw_6hunter_6_event_5Event_3__repr__}, + {Py_sq_item, (void *)__pyx_sq_item_6hunter_6_event_Event}, + {Py_mp_subscript, (void *)__pyx_pw_6hunter_6_event_5Event_11__getitem__}, + {Py_tp_doc, (void *)PyDoc_STR("\n A wrapper object for Frame objects. Instances of this are passed to your custom functions or predicates.\n\n Provides few convenience properties.\n\n Args:\n frame (Frame): A python `Frame `_ object.\n kind (str): A string like ``'call'``, ``'line'``, ``'return'`` or ``'exception'``.\n arg: A value that depends on ``kind``. Usually is ``None`` but for ``'return'`` or ``'exception'`` other values\n may be expected.\n ")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_6hunter_6_event_Event}, + {Py_tp_clear, (void *)__pyx_tp_clear_6hunter_6_event_Event}, + {Py_tp_richcompare, (void *)__pyx_tp_richcompare_6hunter_6_event_Event}, + {Py_tp_methods, (void *)__pyx_methods_6hunter_6_event_Event}, + {Py_tp_getset, (void *)__pyx_getsets_6hunter_6_event_Event}, + {Py_tp_init, (void *)__pyx_pw_6hunter_6_event_5Event_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_6hunter_6_event_Event}, + {0, 0}, +}; +static PyType_Spec __pyx_type_6hunter_6_event_Event_spec = { + "hunter._event.Event", + sizeof(struct __pyx_obj_6hunter_6_event_Event), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, + __pyx_type_6hunter_6_event_Event_slots, +}; +#else static PySequenceMethods __pyx_tp_as_sequence_Event = { 0, /*sq_length*/ @@ -9581,13 +12212,13 @@ static PySequenceMethods __pyx_tp_as_sequence_Event = { static PyMappingMethods __pyx_tp_as_mapping_Event = { 0, /*mp_length*/ - __pyx_pw_6hunter_6_event_5Event_5__getitem__, /*mp_subscript*/ + __pyx_pw_6hunter_6_event_5Event_11__getitem__, /*mp_subscript*/ 0, /*mp_ass_subscript*/ }; static PyTypeObject __pyx_type_6hunter_6_event_Event = { PyVarObject_HEAD_INIT(0, 0) - "hunter._event.Event", /*tp_name*/ + "hunter._event.""Event", /*tp_name*/ sizeof(struct __pyx_obj_6hunter_6_event_Event), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_6hunter_6_event_Event, /*tp_dealloc*/ @@ -9599,13 +12230,8 @@ static PyTypeObject __pyx_type_6hunter_6_event_Event = { #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ - #endif - 0, /*tp_repr*/ + __pyx_pw_6hunter_6_event_5Event_3__repr__, /*tp_repr*/ 0, /*tp_as_number*/ &__pyx_tp_as_sequence_Event, /*tp_as_sequence*/ &__pyx_tp_as_mapping_Event, /*tp_as_mapping*/ @@ -9616,10 +12242,10 @@ static PyTypeObject __pyx_type_6hunter_6_event_Event = { 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - "\n A wrapper object for Frame objects. Instances of this are passed to your custom functions or predicates.\n\n Provides few convenience properties.\n\n Args:\n frame (Frame): A python `Frame `_ object.\n kind (str): A string like ``'call'``, ``'line'``, ``'return'`` or ``'exception'``.\n arg: A value that depends on ``kind``. Usually is ``None`` but for ``'return'`` or ``'exception'`` other values\n may be expected.\n tracer (:class:`hunter.tracer.Tracer`): The :class:`~hunter.tracer.Tracer` instance that created the event.\n Needed for the ``calls`` and ``depth`` fields.\n ", /*tp_doc*/ + PyDoc_STR("\n A wrapper object for Frame objects. Instances of this are passed to your custom functions or predicates.\n\n Provides few convenience properties.\n\n Args:\n frame (Frame): A python `Frame `_ object.\n kind (str): A string like ``'call'``, ``'line'``, ``'return'`` or ``'exception'``.\n arg: A value that depends on ``kind``. Usually is ``None`` but for ``'return'`` or ``'exception'`` other values\n may be expected.\n "), /*tp_doc*/ __pyx_tp_traverse_6hunter_6_event_Event, /*tp_traverse*/ __pyx_tp_clear_6hunter_6_event_Event, /*tp_clear*/ - 0, /*tp_richcompare*/ + __pyx_tp_richcompare_6hunter_6_event_Event, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ @@ -9630,7 +12256,9 @@ static PyTypeObject __pyx_type_6hunter_6_event_Event = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif __pyx_pw_6hunter_6_event_5Event_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_6hunter_6_event_Event, /*tp_new*/ @@ -9643,36 +12271,60 @@ static PyTypeObject __pyx_type_6hunter_6_event_Event = { 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ #endif - #if PY_VERSION_HEX >= 0x030800b1 + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif }; - -static struct __pyx_obj_6hunter_6_event___pyx_scope_struct__yield_lines *__pyx_freelist_6hunter_6_event___pyx_scope_struct__yield_lines[8]; -static int __pyx_freecount_6hunter_6_event___pyx_scope_struct__yield_lines = 0; +#endif static PyObject *__pyx_tp_new_6hunter_6_event___pyx_scope_struct__yield_lines(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; - if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6hunter_6_event___pyx_scope_struct__yield_lines > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6hunter_6_event___pyx_scope_struct__yield_lines)))) { - o = (PyObject*)__pyx_freelist_6hunter_6_event___pyx_scope_struct__yield_lines[--__pyx_freecount_6hunter_6_event___pyx_scope_struct__yield_lines]; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_mstate_global->__pyx_freecount_6hunter_6_event___pyx_scope_struct__yield_lines > 0) & (int)(t->tp_basicsize == sizeof(struct __pyx_obj_6hunter_6_event___pyx_scope_struct__yield_lines)))) { + o = (PyObject*)__pyx_mstate_global->__pyx_freelist_6hunter_6_event___pyx_scope_struct__yield_lines[--__pyx_mstate_global->__pyx_freecount_6hunter_6_event___pyx_scope_struct__yield_lines]; memset(o, 0, sizeof(struct __pyx_obj_6hunter_6_event___pyx_scope_struct__yield_lines)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); - } else { + } else + #endif + { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } + #endif return o; } static void __pyx_tp_dealloc_6hunter_6_event___pyx_scope_struct__yield_lines(PyObject *o) { struct __pyx_obj_6hunter_6_event___pyx_scope_struct__yield_lines *p = (struct __pyx_obj_6hunter_6_event___pyx_scope_struct__yield_lines *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_6hunter_6_event___pyx_scope_struct__yield_lines) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_collector); Py_CLEAR(p->__pyx_v_dedent); @@ -9682,16 +12334,30 @@ static void __pyx_tp_dealloc_6hunter_6_event___pyx_scope_struct__yield_lines(PyO Py_CLEAR(p->__pyx_v_module_globals); Py_CLEAR(p->__pyx_v_start); Py_CLEAR(p->__pyx_t_0); - if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6hunter_6_event___pyx_scope_struct__yield_lines < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6hunter_6_event___pyx_scope_struct__yield_lines)))) { - __pyx_freelist_6hunter_6_event___pyx_scope_struct__yield_lines[__pyx_freecount_6hunter_6_event___pyx_scope_struct__yield_lines++] = ((struct __pyx_obj_6hunter_6_event___pyx_scope_struct__yield_lines *)o); - } else { + #if CYTHON_USE_FREELISTS + if (((int)(__pyx_mstate_global->__pyx_freecount_6hunter_6_event___pyx_scope_struct__yield_lines < 8) & (int)(Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6hunter_6_event___pyx_scope_struct__yield_lines)))) { + __pyx_mstate_global->__pyx_freelist_6hunter_6_event___pyx_scope_struct__yield_lines[__pyx_mstate_global->__pyx_freecount_6hunter_6_event___pyx_scope_struct__yield_lines++] = ((struct __pyx_obj_6hunter_6_event___pyx_scope_struct__yield_lines *)o); + } else + #endif + { + #if CYTHON_USE_TYPE_SLOTS (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif } } static int __pyx_tp_traverse_6hunter_6_event___pyx_scope_struct__yield_lines(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_6hunter_6_event___pyx_scope_struct__yield_lines *p = (struct __pyx_obj_6hunter_6_event___pyx_scope_struct__yield_lines *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } if (p->__pyx_v_collector) { e = (*v)(p->__pyx_v_collector, a); if (e) return e; } @@ -9718,10 +12384,25 @@ static int __pyx_tp_traverse_6hunter_6_event___pyx_scope_struct__yield_lines(PyO } return 0; } +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_6hunter_6_event___pyx_scope_struct__yield_lines_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_6hunter_6_event___pyx_scope_struct__yield_lines}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_6hunter_6_event___pyx_scope_struct__yield_lines}, + {Py_tp_new, (void *)__pyx_tp_new_6hunter_6_event___pyx_scope_struct__yield_lines}, + {0, 0}, +}; +static PyType_Spec __pyx_type_6hunter_6_event___pyx_scope_struct__yield_lines_spec = { + "hunter._event.__pyx_scope_struct__yield_lines", + sizeof(struct __pyx_obj_6hunter_6_event___pyx_scope_struct__yield_lines), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, + __pyx_type_6hunter_6_event___pyx_scope_struct__yield_lines_slots, +}; +#else static PyTypeObject __pyx_type_6hunter_6_event___pyx_scope_struct__yield_lines = { PyVarObject_HEAD_INIT(0, 0) - "hunter._event.__pyx_scope_struct__yield_lines", /*tp_name*/ + "hunter._event.""__pyx_scope_struct__yield_lines", /*tp_name*/ sizeof(struct __pyx_obj_6hunter_6_event___pyx_scope_struct__yield_lines), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_6hunter_6_event___pyx_scope_struct__yield_lines, /*tp_dealloc*/ @@ -9733,12 +12414,7 @@ static PyTypeObject __pyx_type_6hunter_6_event___pyx_scope_struct__yield_lines = #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ - #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ @@ -9749,7 +12425,7 @@ static PyTypeObject __pyx_type_6hunter_6_event___pyx_scope_struct__yield_lines = 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_6hunter_6_event___pyx_scope_struct__yield_lines, /*tp_traverse*/ 0, /*tp_clear*/ @@ -9764,7 +12440,9 @@ static PyTypeObject __pyx_type_6hunter_6_event___pyx_scope_struct__yield_lines = 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_6hunter_6_event___pyx_scope_struct__yield_lines, /*tp_new*/ @@ -9777,460 +12455,327 @@ static PyTypeObject __pyx_type_6hunter_6_event___pyx_scope_struct__yield_lines = 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ #endif - #if PY_VERSION_HEX >= 0x030800b1 + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif -}; - -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__event(PyObject* module); /*proto*/ -static PyModuleDef_Slot __pyx_moduledef_slots[] = { - {Py_mod_create, (void*)__pyx_pymod_create}, - {Py_mod_exec, (void*)__pyx_pymod_exec__event}, - {0, NULL} -}; -#endif - -static struct PyModuleDef __pyx_moduledef = { - PyModuleDef_HEAD_INIT, - "_event", - 0, /* m_doc */ - #if CYTHON_PEP489_MULTI_PHASE_INIT - 0, /* m_size */ - #else - -1, /* m_size */ + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ #endif - __pyx_methods /* m_methods */, - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_moduledef_slots, /* m_slots */ - #else - NULL, /* m_reload */ + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ #endif - NULL, /* m_traverse */ - NULL, /* m_clear */ - NULL /* m_free */ }; #endif -#ifndef CYTHON_SMALL_CODE -#if defined(__clang__) - #define CYTHON_SMALL_CODE -#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) - #define CYTHON_SMALL_CODE __attribute__((cold)) -#else - #define CYTHON_SMALL_CODE -#endif -#endif -static __Pyx_StringTabEntry __pyx_string_tab[] = { - {&__pyx_kp_s_, __pyx_k_, sizeof(__pyx_k_), 0, 0, 1, 0}, - {&__pyx_n_s_CYTHON_SUFFIX_RE, __pyx_k_CYTHON_SUFFIX_RE, sizeof(__pyx_k_CYTHON_SUFFIX_RE), 0, 0, 1, 1}, - {&__pyx_n_s_Event, __pyx_k_Event, sizeof(__pyx_k_Event), 0, 0, 1, 1}, - {&__pyx_kp_s_Incompatible_checksums_s_vs_0x36, __pyx_k_Incompatible_checksums_s_vs_0x36, sizeof(__pyx_k_Incompatible_checksums_s_vs_0x36), 0, 0, 1, 0}, - {&__pyx_n_s_LEADING_WHITESPACE_RE, __pyx_k_LEADING_WHITESPACE_RE, sizeof(__pyx_k_LEADING_WHITESPACE_RE), 0, 0, 1, 1}, - {&__pyx_kp_s_NO_SOURCE_not_reading_file, __pyx_k_NO_SOURCE_not_reading_file, sizeof(__pyx_k_NO_SOURCE_not_reading_file), 0, 0, 1, 0}, - {&__pyx_kp_s_NO_SOURCE_r, __pyx_k_NO_SOURCE_r, sizeof(__pyx_k_NO_SOURCE_r), 0, 0, 1, 0}, - {&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 0, 1, 1}, - {&__pyx_n_s_SITE_PACKAGES_PATHS, __pyx_k_SITE_PACKAGES_PATHS, sizeof(__pyx_k_SITE_PACKAGES_PATHS), 0, 0, 1, 1}, - {&__pyx_n_s_SYS_PREFIX_PATHS, __pyx_k_SYS_PREFIX_PATHS, sizeof(__pyx_k_SYS_PREFIX_PATHS), 0, 0, 1, 1}, - {&__pyx_n_s_TokenError, __pyx_k_TokenError, sizeof(__pyx_k_TokenError), 0, 0, 1, 1}, - {&__pyx_kp_s__7, __pyx_k__7, sizeof(__pyx_k__7), 0, 0, 1, 0}, - {&__pyx_n_s_all, __pyx_k_all, sizeof(__pyx_k_all), 0, 0, 1, 1}, - {&__pyx_n_s_amount, __pyx_k_amount, sizeof(__pyx_k_amount), 0, 0, 1, 1}, - {&__pyx_n_s_arg, __pyx_k_arg, sizeof(__pyx_k_arg), 0, 0, 1, 1}, - {&__pyx_n_s_args, __pyx_k_args, sizeof(__pyx_k_args), 0, 0, 1, 1}, - {&__pyx_n_s_basename, __pyx_k_basename, sizeof(__pyx_k_basename), 0, 0, 1, 1}, - {&__pyx_n_s_call, __pyx_k_call, sizeof(__pyx_k_call), 0, 0, 1, 1}, - {&__pyx_n_s_class, __pyx_k_class, sizeof(__pyx_k_class), 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_close, __pyx_k_close, sizeof(__pyx_k_close), 0, 0, 1, 1}, - {&__pyx_n_s_co_argcount, __pyx_k_co_argcount, sizeof(__pyx_k_co_argcount), 0, 0, 1, 1}, - {&__pyx_n_s_co_name, __pyx_k_co_name, sizeof(__pyx_k_co_name), 0, 0, 1, 1}, - {&__pyx_n_s_co_varnames, __pyx_k_co_varnames, sizeof(__pyx_k_co_varnames), 0, 0, 1, 1}, - {&__pyx_n_s_code, __pyx_k_code, sizeof(__pyx_k_code), 0, 0, 1, 1}, - {&__pyx_n_s_collector, __pyx_k_collector, sizeof(__pyx_k_collector), 0, 0, 1, 1}, - {&__pyx_n_s_const, __pyx_k_const, sizeof(__pyx_k_const), 0, 0, 1, 1}, - {&__pyx_n_s_current_thread, __pyx_k_current_thread, sizeof(__pyx_k_current_thread), 0, 0, 1, 1}, - {&__pyx_n_s_dedent, __pyx_k_dedent, sizeof(__pyx_k_dedent), 0, 0, 1, 1}, - {&__pyx_n_s_def, __pyx_k_def, sizeof(__pyx_k_def), 0, 0, 1, 1}, - {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1}, - {&__pyx_n_s_endswith, __pyx_k_endswith, sizeof(__pyx_k_endswith), 0, 0, 1, 1}, - {&__pyx_n_s_exists, __pyx_k_exists, sizeof(__pyx_k_exists), 0, 0, 1, 1}, - {&__pyx_n_s_file, __pyx_k_file, sizeof(__pyx_k_file), 0, 0, 1, 1}, - {&__pyx_n_s_filename, __pyx_k_filename, sizeof(__pyx_k_filename), 0, 0, 1, 1}, - {&__pyx_n_s_findall, __pyx_k_findall, sizeof(__pyx_k_findall), 0, 0, 1, 1}, - {&__pyx_n_s_format, __pyx_k_format, sizeof(__pyx_k_format), 0, 0, 1, 1}, - {&__pyx_n_s_frame, __pyx_k_frame, sizeof(__pyx_k_frame), 0, 0, 1, 1}, - {&__pyx_n_s_fullsource, __pyx_k_fullsource, sizeof(__pyx_k_fullsource), 0, 0, 1, 1}, - {&__pyx_n_s_function, __pyx_k_function, sizeof(__pyx_k_function), 0, 0, 1, 1}, - {&__pyx_n_s_functools, __pyx_k_functools, sizeof(__pyx_k_functools), 0, 0, 1, 1}, - {&__pyx_n_s_generate_tokens, __pyx_k_generate_tokens, sizeof(__pyx_k_generate_tokens), 0, 0, 1, 1}, - {&__pyx_n_s_get, __pyx_k_get, sizeof(__pyx_k_get), 0, 0, 1, 1}, - {&__pyx_n_s_get_func_in_mro, __pyx_k_get_func_in_mro, sizeof(__pyx_k_get_func_in_mro), 0, 0, 1, 1}, - {&__pyx_n_s_get_main_thread, __pyx_k_get_main_thread, sizeof(__pyx_k_get_main_thread), 0, 0, 1, 1}, - {&__pyx_n_s_getline, __pyx_k_getline, sizeof(__pyx_k_getline), 0, 0, 1, 1}, - {&__pyx_n_s_getlines, __pyx_k_getlines, sizeof(__pyx_k_getlines), 0, 0, 1, 1}, - {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, - {&__pyx_n_s_globals, __pyx_k_globals, sizeof(__pyx_k_globals), 0, 0, 1, 1}, - {&__pyx_n_s_hunter__event, __pyx_k_hunter__event, sizeof(__pyx_k_hunter__event), 0, 0, 1, 1}, - {&__pyx_n_s_ident, __pyx_k_ident, sizeof(__pyx_k_ident), 0, 0, 1, 1}, - {&__pyx_n_s_if_same_code, __pyx_k_if_same_code, sizeof(__pyx_k_if_same_code), 0, 0, 1, 1}, - {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, - {&__pyx_n_s_items, __pyx_k_items, sizeof(__pyx_k_items), 0, 0, 1, 1}, - {&__pyx_n_s_join, __pyx_k_join, sizeof(__pyx_k_join), 0, 0, 1, 1}, - {&__pyx_n_s_kind, __pyx_k_kind, sizeof(__pyx_k_kind), 0, 0, 1, 1}, - {&__pyx_n_s_lambda, __pyx_k_lambda, sizeof(__pyx_k_lambda), 0, 0, 1, 1}, - {&__pyx_n_s_limit, __pyx_k_limit, sizeof(__pyx_k_limit), 0, 0, 1, 1}, - {&__pyx_n_s_line, __pyx_k_line, sizeof(__pyx_k_line), 0, 0, 1, 1}, - {&__pyx_n_s_linecache, __pyx_k_linecache, sizeof(__pyx_k_linecache), 0, 0, 1, 1}, - {&__pyx_n_s_lineno, __pyx_k_lineno, sizeof(__pyx_k_lineno), 0, 0, 1, 1}, - {&__pyx_n_s_locals, __pyx_k_locals, sizeof(__pyx_k_locals), 0, 0, 1, 1}, - {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, - {&__pyx_n_s_module, __pyx_k_module, sizeof(__pyx_k_module), 0, 0, 1, 1}, - {&__pyx_kp_s_module_2, __pyx_k_module_2, sizeof(__pyx_k_module_2), 0, 0, 1, 0}, - {&__pyx_n_s_module_globals, __pyx_k_module_globals, sizeof(__pyx_k_module_globals), 0, 0, 1, 1}, - {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, - {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1}, - {&__pyx_n_s_namedtuple, __pyx_k_namedtuple, sizeof(__pyx_k_namedtuple), 0, 0, 1, 1}, - {&__pyx_n_s_new, __pyx_k_new, sizeof(__pyx_k_new), 0, 0, 1, 1}, - {&__pyx_n_s_next, __pyx_k_next, sizeof(__pyx_k_next), 0, 0, 1, 1}, - {&__pyx_n_s_object, __pyx_k_object, sizeof(__pyx_k_object), 0, 0, 1, 1}, - {&__pyx_n_s_os_path, __pyx_k_os_path, sizeof(__pyx_k_os_path), 0, 0, 1, 1}, - {&__pyx_n_s_partial, __pyx_k_partial, sizeof(__pyx_k_partial), 0, 0, 1, 1}, - {&__pyx_n_s_pickle, __pyx_k_pickle, sizeof(__pyx_k_pickle), 0, 0, 1, 1}, - {&__pyx_n_s_pkg_resources, __pyx_k_pkg_resources, sizeof(__pyx_k_pkg_resources), 0, 0, 1, 1}, - {&__pyx_kp_s_py, __pyx_k_py, sizeof(__pyx_k_py), 0, 0, 1, 0}, - {&__pyx_kp_s_pyc, __pyx_k_pyc, sizeof(__pyx_k_pyc), 0, 0, 1, 0}, - {&__pyx_kp_s_pyd, __pyx_k_pyd, sizeof(__pyx_k_pyd), 0, 0, 1, 0}, - {&__pyx_kp_s_pyo, __pyx_k_pyo, sizeof(__pyx_k_pyo), 0, 0, 1, 0}, - {&__pyx_kp_s_pyx, __pyx_k_pyx, sizeof(__pyx_k_pyx), 0, 0, 1, 0}, - {&__pyx_n_s_pyx_PickleError, __pyx_k_pyx_PickleError, sizeof(__pyx_k_pyx_PickleError), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_checksum, __pyx_k_pyx_checksum, sizeof(__pyx_k_pyx_checksum), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_result, __pyx_k_pyx_result, sizeof(__pyx_k_pyx_result), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_type, __pyx_k_pyx_type, sizeof(__pyx_k_pyx_type), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_unpickle_Event, __pyx_k_pyx_unpickle_Event, sizeof(__pyx_k_pyx_unpickle_Event), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, - {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, - {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, - {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, - {&__pyx_n_s_send, __pyx_k_send, sizeof(__pyx_k_send), 0, 0, 1, 1}, - {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, - {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, - {&__pyx_n_s_site, __pyx_k_site, sizeof(__pyx_k_site), 0, 0, 1, 1}, - {&__pyx_kp_s_so, __pyx_k_so, sizeof(__pyx_k_so), 0, 0, 1, 0}, - {&__pyx_n_s_source, __pyx_k_source, sizeof(__pyx_k_source), 0, 0, 1, 1}, - {&__pyx_n_s_split, __pyx_k_split, sizeof(__pyx_k_split), 0, 0, 1, 1}, - {&__pyx_n_s_splitext, __pyx_k_splitext, sizeof(__pyx_k_splitext), 0, 0, 1, 1}, - {&__pyx_kp_s_src_hunter__event_pyx, __pyx_k_src_hunter__event_pyx, sizeof(__pyx_k_src_hunter__event_pyx), 0, 0, 1, 0}, - {&__pyx_n_s_start, __pyx_k_start, sizeof(__pyx_k_start), 0, 0, 1, 1}, - {&__pyx_n_s_startswith, __pyx_k_startswith, sizeof(__pyx_k_startswith), 0, 0, 1, 1}, - {&__pyx_n_s_stdlib, __pyx_k_stdlib, sizeof(__pyx_k_stdlib), 0, 0, 1, 1}, - {&__pyx_kp_s_string, __pyx_k_string, sizeof(__pyx_k_string), 0, 0, 1, 0}, - {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0}, - {&__pyx_n_s_sub, __pyx_k_sub, sizeof(__pyx_k_sub), 0, 0, 1, 1}, - {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, - {&__pyx_n_s_threadid, __pyx_k_threadid, sizeof(__pyx_k_threadid), 0, 0, 1, 1}, - {&__pyx_n_s_threading, __pyx_k_threading, sizeof(__pyx_k_threading), 0, 0, 1, 1}, - {&__pyx_n_s_threadname, __pyx_k_threadname, sizeof(__pyx_k_threadname), 0, 0, 1, 1}, - {&__pyx_n_s_throw, __pyx_k_throw, sizeof(__pyx_k_throw), 0, 0, 1, 1}, - {&__pyx_n_s_tokenize, __pyx_k_tokenize, sizeof(__pyx_k_tokenize), 0, 0, 1, 1}, - {&__pyx_n_s_tracer, __pyx_k_tracer, sizeof(__pyx_k_tracer), 0, 0, 1, 1}, - {&__pyx_n_s_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1}, - {&__pyx_n_s_util, __pyx_k_util, sizeof(__pyx_k_util), 0, 0, 1, 1}, - {&__pyx_n_s_value_filter, __pyx_k_value_filter, sizeof(__pyx_k_value_filter), 0, 0, 1, 1}, - {&__pyx_n_s_values, __pyx_k_values, sizeof(__pyx_k_values), 0, 0, 1, 1}, - {&__pyx_n_s_yield_lines, __pyx_k_yield_lines, sizeof(__pyx_k_yield_lines), 0, 0, 1, 1}, - {0, 0, 0, 0, 0, 0, 0} +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} }; -static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { - __pyx_builtin_object = __Pyx_GetBuiltinName(__pyx_n_s_object); if (!__pyx_builtin_object) __PYX_ERR(0, 26, __pyx_L1_error) - return 0; - __pyx_L1_error:; - return -1; -} - -static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - - /* "hunter/_event.pyx":195 - * def module(self): - * if self._module is UNSET: - * module = self.frame.f_globals.get('__name__', '') # <<<<<<<<<<<<<< - * if module is None: - * module = '' - */ - __pyx_tuple__2 = PyTuple_Pack(2, __pyx_n_s_name_2, __pyx_kp_s_); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 195, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__2); - __Pyx_GIVEREF(__pyx_tuple__2); - - /* "hunter/_event.pyx":210 - * if not filename: - * filename = '' - * elif filename.endswith(('.pyc', '.pyo')): # <<<<<<<<<<<<<< - * filename = filename[:-1] - * elif filename.endswith(('.so', '.pyd')): - */ - __pyx_tuple__3 = PyTuple_Pack(2, __pyx_kp_s_pyc, __pyx_kp_s_pyo); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 210, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__3); - __Pyx_GIVEREF(__pyx_tuple__3); - - /* "hunter/_event.pyx":211 - * filename = '' - * elif filename.endswith(('.pyc', '.pyo')): - * filename = filename[:-1] # <<<<<<<<<<<<<< - * elif filename.endswith(('.so', '.pyd')): - * basename = CYTHON_SUFFIX_RE.sub('', filename) - */ - __pyx_slice__4 = PySlice_New(Py_None, __pyx_int_neg_1, Py_None); if (unlikely(!__pyx_slice__4)) __PYX_ERR(0, 211, __pyx_L1_error) - __Pyx_GOTREF(__pyx_slice__4); - __Pyx_GIVEREF(__pyx_slice__4); - - /* "hunter/_event.pyx":212 - * elif filename.endswith(('.pyc', '.pyo')): - * filename = filename[:-1] - * elif filename.endswith(('.so', '.pyd')): # <<<<<<<<<<<<<< - * basename = CYTHON_SUFFIX_RE.sub('', filename) - * for ext in ('.pyx', '.py'): - */ - __pyx_tuple__5 = PyTuple_Pack(2, __pyx_kp_s_so, __pyx_kp_s_pyd); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 212, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__5); - __Pyx_GIVEREF(__pyx_tuple__5); - - /* "hunter/_event.pyx":214 - * elif filename.endswith(('.so', '.pyd')): - * basename = CYTHON_SUFFIX_RE.sub('', filename) - * for ext in ('.pyx', '.py'): # <<<<<<<<<<<<<< - * cyfilename = basename + ext - * if exists(cyfilename): - */ - __pyx_tuple__6 = PyTuple_Pack(2, __pyx_kp_s_pyx, __pyx_kp_s_py); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 214, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__6); - __Pyx_GIVEREF(__pyx_tuple__6); - - /* "hunter/_event.pyx":24 - * from .util import if_same_code - * - * __all__ = 'Event', # <<<<<<<<<<<<<< - * - * cdef object UNSET = object() - */ - __pyx_tuple__10 = PyTuple_Pack(1, __pyx_n_s_Event); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 24, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__10); - __Pyx_GIVEREF(__pyx_tuple__10); - - /* "hunter/_event.pyx":297 - * - * - * def yield_lines(filename, module_globals, start, list collector, # <<<<<<<<<<<<<< - * limit=10): - * dedent = None - */ - __pyx_tuple__11 = PyTuple_Pack(8, __pyx_n_s_filename, __pyx_n_s_module_globals, __pyx_n_s_start, __pyx_n_s_collector, __pyx_n_s_limit, __pyx_n_s_dedent, __pyx_n_s_amount, __pyx_n_s_line); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 297, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__11); - __Pyx_GIVEREF(__pyx_tuple__11); - __pyx_codeobj__8 = (PyObject*)__Pyx_PyCode_New(5, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__11, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_hunter__event_pyx, __pyx_n_s_yield_lines, 297, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__8)) __PYX_ERR(0, 297, __pyx_L1_error) - - /* "(tree fragment)":1 - * def __pyx_unpickle_Event(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ - __pyx_tuple__12 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(2, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__12); - __Pyx_GIVEREF(__pyx_tuple__12); - __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Event, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(2, 1, __pyx_L1_error) - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_RefNannyFinishContext(); - return -1; -} - -static CYTHON_SMALL_CODE 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) - __pyx_int_10 = PyInt_FromLong(10); if (unlikely(!__pyx_int_10)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_57399096 = PyInt_FromLong(57399096L); if (unlikely(!__pyx_int_57399096)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error) - return 0; - __pyx_L1_error:; - return -1; -} - -static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ - -static int __Pyx_modinit_global_init_code(void) { +/* #### Code section: initfunc_declarations ### */ +static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate); /*proto*/ +/* #### Code section: init_module ### */ + +static int __Pyx_modinit_global_init_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); /*--- Global init code ---*/ __pyx_v_6hunter_6_event_UNSET = Py_None; Py_INCREF(Py_None); + __pyx_v_6hunter_6_event_CALL = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_6hunter_6_event_EXCEPTION = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_6hunter_6_event_LINE = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_6hunter_6_event_RETURN = ((PyObject*)Py_None); Py_INCREF(Py_None); __Pyx_RefNannyFinishContext(); return 0; } -static int __Pyx_modinit_variable_export_code(void) { +static int __Pyx_modinit_variable_export_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); /*--- Variable export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } -static int __Pyx_modinit_function_export_code(void) { +static int __Pyx_modinit_function_export_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); /*--- Function export code ---*/ + if (__Pyx_ExportFunction("fast_clone", (void (*)(void))__pyx_f_6hunter_6_event_fast_clone, "struct __pyx_obj_6hunter_6_event_Event *(struct __pyx_obj_6hunter_6_event_Event *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("fast_detach", (void (*)(void))__pyx_f_6hunter_6_event_fast_detach, "struct __pyx_obj_6hunter_6_event_Event *(struct __pyx_obj_6hunter_6_event_Event *, PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; } -static int __Pyx_modinit_type_init_code(void) { +static int __Pyx_modinit_type_init_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); /*--- Type init code ---*/ + __pyx_t_1 = PyImport_ImportModule("types"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_mstate->__pyx_ptype_6hunter_6_event_CodeType = __Pyx_ImportType_3_1_3(__pyx_t_1, "types", "CodeType", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyCodeObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(PyCodeObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyCodeObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(PyCodeObject), + #else + sizeof(PyCodeObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(PyCodeObject), + #endif + __Pyx_ImportType_CheckSize_Ignore_3_1_3); if (!__pyx_mstate->__pyx_ptype_6hunter_6_event_CodeType) __PYX_ERR(1, 7, __pyx_L1_error) __pyx_vtabptr_6hunter_6_event_Event = &__pyx_vtable_6hunter_6_event_Event; - __pyx_vtable_6hunter_6_event_Event.clone = (struct __pyx_obj_6hunter_6_event_Event *(*)(struct __pyx_obj_6hunter_6_event_Event *))__pyx_f_6hunter_6_event_5Event_clone; - if (PyType_Ready(&__pyx_type_6hunter_6_event_Event) < 0) __PYX_ERR(0, 29, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_6hunter_6_event_Event.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6hunter_6_event_Event.tp_dictoffset && __pyx_type_6hunter_6_event_Event.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_6hunter_6_event_Event.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; - } - if (__Pyx_SetVtable(__pyx_type_6hunter_6_event_Event.tp_dict, __pyx_vtabptr_6hunter_6_event_Event) < 0) __PYX_ERR(0, 29, __pyx_L1_error) - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Event, (PyObject *)&__pyx_type_6hunter_6_event_Event) < 0) __PYX_ERR(0, 29, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6hunter_6_event_Event) < 0) __PYX_ERR(0, 29, __pyx_L1_error) - __pyx_ptype_6hunter_6_event_Event = &__pyx_type_6hunter_6_event_Event; - if (PyType_Ready(&__pyx_type_6hunter_6_event___pyx_scope_struct__yield_lines) < 0) __PYX_ERR(0, 297, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_6hunter_6_event___pyx_scope_struct__yield_lines.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6hunter_6_event___pyx_scope_struct__yield_lines.tp_dictoffset && __pyx_type_6hunter_6_event___pyx_scope_struct__yield_lines.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_6hunter_6_event___pyx_scope_struct__yield_lines.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; - } - __pyx_ptype_6hunter_6_event___pyx_scope_struct__yield_lines = &__pyx_type_6hunter_6_event___pyx_scope_struct__yield_lines; + __pyx_vtable_6hunter_6_event_Event.code_getter = (PyCodeObject *(*)(struct __pyx_obj_6hunter_6_event_Event *))__pyx_f_6hunter_6_event_5Event_code_getter; + __pyx_vtable_6hunter_6_event_Event.filename_getter = (PyObject *(*)(struct __pyx_obj_6hunter_6_event_Event *))__pyx_f_6hunter_6_event_5Event_filename_getter; + __pyx_vtable_6hunter_6_event_Event.fullsource_getter = (PyObject *(*)(struct __pyx_obj_6hunter_6_event_Event *))__pyx_f_6hunter_6_event_5Event_fullsource_getter; + __pyx_vtable_6hunter_6_event_Event.function_getter = (PyObject *(*)(struct __pyx_obj_6hunter_6_event_Event *))__pyx_f_6hunter_6_event_5Event_function_getter; + __pyx_vtable_6hunter_6_event_Event.globals_getter = (PyObject *(*)(struct __pyx_obj_6hunter_6_event_Event *))__pyx_f_6hunter_6_event_5Event_globals_getter; + __pyx_vtable_6hunter_6_event_Event.lineno_getter = (PyObject *(*)(struct __pyx_obj_6hunter_6_event_Event *))__pyx_f_6hunter_6_event_5Event_lineno_getter; + __pyx_vtable_6hunter_6_event_Event.locals_getter = (PyObject *(*)(struct __pyx_obj_6hunter_6_event_Event *))__pyx_f_6hunter_6_event_5Event_locals_getter; + __pyx_vtable_6hunter_6_event_Event.module_getter = (PyObject *(*)(struct __pyx_obj_6hunter_6_event_Event *))__pyx_f_6hunter_6_event_5Event_module_getter; + __pyx_vtable_6hunter_6_event_Event.source_getter = (PyObject *(*)(struct __pyx_obj_6hunter_6_event_Event *))__pyx_f_6hunter_6_event_5Event_source_getter; + __pyx_vtable_6hunter_6_event_Event.stdlib_getter = (PyObject *(*)(struct __pyx_obj_6hunter_6_event_Event *))__pyx_f_6hunter_6_event_5Event_stdlib_getter; + __pyx_vtable_6hunter_6_event_Event.threadid_getter = (PyObject *(*)(struct __pyx_obj_6hunter_6_event_Event *))__pyx_f_6hunter_6_event_5Event_threadid_getter; + __pyx_vtable_6hunter_6_event_Event.threadname_getter = (PyObject *(*)(struct __pyx_obj_6hunter_6_event_Event *))__pyx_f_6hunter_6_event_5Event_threadname_getter; + __pyx_vtable_6hunter_6_event_Event.instruction_getter = (PyObject *(*)(struct __pyx_obj_6hunter_6_event_Event *))__pyx_f_6hunter_6_event_5Event_instruction_getter; + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_6hunter_6_event_Event = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6hunter_6_event_Event_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_6hunter_6_event_Event)) __PYX_ERR(0, 46, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_6_event_Event_spec, __pyx_mstate->__pyx_ptype_6hunter_6_event_Event) < 0) __PYX_ERR(0, 46, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_6hunter_6_event_Event = &__pyx_type_6hunter_6_event_Event; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_6hunter_6_event_Event) < 0) __PYX_ERR(0, 46, __pyx_L1_error) + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_6hunter_6_event_Event->tp_dictoffset && __pyx_mstate->__pyx_ptype_6hunter_6_event_Event->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_6hunter_6_event_Event->tp_getattro = PyObject_GenericGetAttr; + } + #endif + if (__Pyx_SetVtable(__pyx_mstate->__pyx_ptype_6hunter_6_event_Event, __pyx_vtabptr_6hunter_6_event_Event) < 0) __PYX_ERR(0, 46, __pyx_L1_error) + if (__Pyx_MergeVtables(__pyx_mstate->__pyx_ptype_6hunter_6_event_Event) < 0) __PYX_ERR(0, 46, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_Event, (PyObject *) __pyx_mstate->__pyx_ptype_6hunter_6_event_Event) < 0) __PYX_ERR(0, 46, __pyx_L1_error) + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_6hunter_6_event___pyx_scope_struct__yield_lines = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6hunter_6_event___pyx_scope_struct__yield_lines_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_6hunter_6_event___pyx_scope_struct__yield_lines)) __PYX_ERR(0, 347, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_6_event___pyx_scope_struct__yield_lines_spec, __pyx_mstate->__pyx_ptype_6hunter_6_event___pyx_scope_struct__yield_lines) < 0) __PYX_ERR(0, 347, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_6hunter_6_event___pyx_scope_struct__yield_lines = &__pyx_type_6hunter_6_event___pyx_scope_struct__yield_lines; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_6hunter_6_event___pyx_scope_struct__yield_lines) < 0) __PYX_ERR(0, 347, __pyx_L1_error) + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_6hunter_6_event___pyx_scope_struct__yield_lines->tp_dictoffset && __pyx_mstate->__pyx_ptype_6hunter_6_event___pyx_scope_struct__yield_lines->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_6hunter_6_event___pyx_scope_struct__yield_lines->tp_getattro = PyObject_GenericGetAttr; + } + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); __Pyx_RefNannyFinishContext(); return -1; } -static int __Pyx_modinit_type_import_code(void) { +static int __Pyx_modinit_type_import_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); /*--- Type import code ---*/ - __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 9, __pyx_L1_error) + __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", + __pyx_mstate->__pyx_ptype_7cpython_4type_type = __Pyx_ImportType_3_1_3(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 - sizeof(PyTypeObject), + sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(PyTypeObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + 0, 0, #else - sizeof(PyHeapTypeObject), + sizeof(PyHeapTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(PyHeapTypeObject), #endif - __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(3, 9, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyImport_ImportModule("types"); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_6hunter_7_tracer_CodeType = __Pyx_ImportType(__pyx_t_1, "types", "CodeType", sizeof(PyCodeObject), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_6hunter_7_tracer_CodeType) __PYX_ERR(4, 9, __pyx_L1_error) - __pyx_ptype_6hunter_7_tracer_FrameType = __Pyx_ImportType(__pyx_t_1, "types", "FrameType", sizeof(PyFrameObject), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_6hunter_7_tracer_FrameType) __PYX_ERR(4, 13, __pyx_L1_error) - __pyx_t_2 = PyImport_ImportModule("hunter._tracer"); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 28, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_ptype_6hunter_7_tracer_Tracer = __Pyx_ImportType(__pyx_t_2, "hunter._tracer", "Tracer", sizeof(struct __pyx_obj_6hunter_7_tracer_Tracer), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_6hunter_7_tracer_Tracer) __PYX_ERR(4, 28, __pyx_L1_error) + __Pyx_ImportType_CheckSize_Warn_3_1_3); if (!__pyx_mstate->__pyx_ptype_7cpython_4type_type) __PYX_ERR(2, 9, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); __Pyx_RefNannyFinishContext(); return -1; } -static int __Pyx_modinit_variable_import_code(void) { +static int __Pyx_modinit_variable_import_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); /*--- Variable import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } -static int __Pyx_modinit_function_import_code(void) { +static int __Pyx_modinit_function_import_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); /*--- Function import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec__event(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec__event}, + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + {Py_mod_gil, Py_MOD_GIL_NOT_USED}, + #endif + #if PY_VERSION_HEX >= 0x030C0000 && CYTHON_USE_MODULE_STATE + {Py_mod_multiple_interpreters, Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED}, + #endif + {0, NULL} +}; +#endif -#if PY_MAJOR_VERSION < 3 -#ifdef CYTHON_NO_PYINIT_EXPORT -#define __Pyx_PyMODINIT_FUNC void -#else -#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#ifdef __cplusplus +namespace { + struct PyModuleDef __pyx_moduledef = + #else + static struct PyModuleDef __pyx_moduledef = + #endif + { + PyModuleDef_HEAD_INIT, + "_event", + 0, /* m_doc */ + #if CYTHON_USE_MODULE_STATE + sizeof(__pyx_mstatetype), /* m_size */ + #else + (CYTHON_PEP489_MULTI_PHASE_INIT) ? 0 : -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + #if CYTHON_USE_MODULE_STATE + __pyx_m_traverse, /* m_traverse */ + __pyx_m_clear, /* m_clear */ + NULL /* m_free */ + #else + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ + #endif + }; + #ifdef __cplusplus +} /* anonymous namespace */ #endif + +/* PyModInitFuncType */ +#ifndef CYTHON_NO_PYINIT_EXPORT + #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #else -#ifdef CYTHON_NO_PYINIT_EXPORT -#define __Pyx_PyMODINIT_FUNC PyObject * -#else -#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC -#endif + #ifdef __cplusplus + #define __Pyx_PyMODINIT_FUNC extern "C" PyObject * + #else + #define __Pyx_PyMODINIT_FUNC PyObject * + #endif #endif - -#if PY_MAJOR_VERSION < 3 -__Pyx_PyMODINIT_FUNC init_event(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC init_event(void) -#else __Pyx_PyMODINIT_FUNC PyInit__event(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC PyInit__event(void) #if CYTHON_PEP489_MULTI_PHASE_INIT { return PyModuleDef_Init(&__pyx_moduledef); } +/* ModuleCreationPEP489 */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x03090000 +static PY_INT64_T __Pyx_GetCurrentInterpreterId(void) { + { + PyObject *module = PyImport_ImportModule("_interpreters"); // 3.13+ I think + if (!module) { + PyErr_Clear(); // just try the 3.8-3.12 version + module = PyImport_ImportModule("_xxsubinterpreters"); + if (!module) goto bad; + } + PyObject *current = PyObject_CallMethod(module, "get_current", NULL); + Py_DECREF(module); + if (!current) goto bad; + if (PyTuple_Check(current)) { + PyObject *new_current = PySequence_GetItem(current, 0); + Py_DECREF(current); + current = new_current; + if (!new_current) goto bad; + } + long long as_c_int = PyLong_AsLongLong(current); + Py_DECREF(current); + return as_c_int; + } + bad: + PySys_WriteStderr("__Pyx_GetCurrentInterpreterId failed. Try setting the C define CYTHON_PEP489_MULTI_PHASE_INIT=0\n"); + return -1; +} +#endif +#if !CYTHON_USE_MODULE_STATE static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { - #if PY_VERSION_HEX >= 0x030700A1 static PY_INT64_T main_interpreter_id = -1; +#if CYTHON_COMPILING_IN_GRAAL + PY_INT64_T current_id = PyInterpreterState_GetIDFromThreadState(PyThreadState_Get()); +#elif CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX >= 0x03090000 + PY_INT64_T current_id = PyInterpreterState_GetID(PyInterpreterState_Get()); +#elif CYTHON_COMPILING_IN_LIMITED_API + PY_INT64_T current_id = __Pyx_GetCurrentInterpreterId(); +#else PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); +#endif + if (unlikely(current_id == -1)) { + return -1; + } if (main_interpreter_id == -1) { main_interpreter_id = current_id; - return (unlikely(current_id == -1)) ? -1 : 0; - } else if (unlikely(main_interpreter_id != current_id)) - #else - static PyInterpreterState *main_interpreter = NULL; - PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; - if (!main_interpreter) { - main_interpreter = current_interpreter; - } else if (unlikely(main_interpreter != current_interpreter)) - #endif - { + return 0; + } else if (unlikely(main_interpreter_id != current_id)) { PyErr_SetString( PyExc_ImportError, "Interpreter change detected - this module can only be loaded into one interpreter per process."); @@ -10238,7 +12783,9 @@ static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { } return 0; } -static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { +#endif +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) +{ PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { @@ -10253,10 +12800,13 @@ static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject } return result; } -static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; + CYTHON_UNUSED_VAR(def); + #if !CYTHON_USE_MODULE_STATE if (__Pyx_check_single_interpreter()) return NULL; + #endif if (__pyx_m) return __Pyx_NewRef(__pyx_m); modname = PyObject_GetAttrString(spec, "name"); @@ -10279,11 +12829,22 @@ static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNU static CYTHON_SMALL_CODE int __pyx_pymod_exec__event(PyObject *__pyx_pyinit_module) #endif -#endif { - __Pyx_TraceDeclarations + int stringtab_initialized = 0; + #if CYTHON_USE_MODULE_STATE + int pystate_addmodule_run = 0; + #endif + __pyx_mstatetype *__pyx_mstate = NULL; + __Pyx_TraceDeclarationsFunc PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + size_t __pyx_t_5; + static PyObject const *__pyx_t_6[7]; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannyDeclarations #if CYTHON_PEP489_MULTI_PHASE_INIT if (__pyx_m) { @@ -10291,9 +12852,37 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec__event(PyObject *__pyx_pyinit_modu PyErr_SetString(PyExc_RuntimeError, "Module '_event' has already been imported. Re-initialisation is not supported."); return -1; } - #elif PY_MAJOR_VERSION >= 3 + #else if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_t_1 = __pyx_pyinit_module; + Py_INCREF(__pyx_t_1); + #else + __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #if CYTHON_USE_MODULE_STATE + { + int add_module_result = __Pyx_State_AddModule(__pyx_t_1, &__pyx_moduledef); + __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "_event" pseudovariable */ + if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + pystate_addmodule_run = 1; + } + #else + __pyx_m = __pyx_t_1; + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + PyUnstable_Module_SetGIL(__pyx_m, Py_MOD_GIL_NOT_USED); + #endif + __pyx_mstate = __pyx_mstate_global; + CYTHON_UNUSED_VAR(__pyx_t_1); + __pyx_mstate->__pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_mstate->__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_mstate->__pyx_d); + __pyx_mstate->__pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_mstate->__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_cython_runtime = __Pyx_PyImport_AddModuleRef("cython_runtime"); if (unlikely(!__pyx_mstate->__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_mstate->__pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /* ImportRefnannyAPI */ #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { @@ -10303,535 +12892,699 @@ if (!__Pyx_RefNanny) { Py_FatalError("failed to import 'refnanny' module"); } #endif - __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit__event(void)", 0); - if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + +__Pyx_RefNannySetupContext("PyInit__event", 0); + if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pxy_PyFrame_Initialize_Offsets __Pxy_PyFrame_Initialize_Offsets(); #endif - __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) + __pyx_mstate->__pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_mstate->__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_mstate->__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_mstate->__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitConstants(__pyx_mstate) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + stringtab_initialized = 1; + if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #if 0 || defined(__Pyx_CyFunction_USED) || defined(__Pyx_FusedFunction_USED) || defined(__Pyx_Coroutine_USED) || defined(__Pyx_Generator_USED) || defined(__Pyx_AsyncGen_USED) + if (__pyx_CommonTypesMetaclass_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif #ifdef __Pyx_CyFunction_USED - if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_CyFunction_init(__pyx_m) < 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) + if (__pyx_FusedFunction_init(__pyx_m) < 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) + if (__pyx_Coroutine_init(__pyx_m) < 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) + if (__pyx_Generator_init(__pyx_m) < 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) + if (__pyx_AsyncGen_init(__pyx_m) < 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("_event", __pyx_methods, 0, 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) - Py_INCREF(__pyx_b); - __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_cython_runtime); - 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_hunter___event) { - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name_2, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_name_2, __pyx_mstate_global->__pyx_n_u_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, "hunter._event")) { - if (unlikely(PyDict_SetItemString(modules, "hunter._event", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + if (unlikely((PyDict_SetItemString(modules, "hunter._event", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) } } - #endif /*--- Builtin init code ---*/ - if (__Pyx_InitCachedBuiltins() < 0) goto __pyx_L1_error; + if (__Pyx_InitCachedBuiltins(__pyx_mstate) < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Constants init code ---*/ - if (__Pyx_InitCachedConstants() < 0) goto __pyx_L1_error; + if (__Pyx_InitCachedConstants(__pyx_mstate) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_CreateCodeObjects(__pyx_mstate) < 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(); - if (unlikely(__Pyx_modinit_type_init_code() != 0)) goto __pyx_L1_error; - if (unlikely(__Pyx_modinit_type_import_code() != 0)) goto __pyx_L1_error; - (void)__Pyx_modinit_variable_import_code(); - (void)__Pyx_modinit_function_import_code(); + (void)__Pyx_modinit_global_init_code(__pyx_mstate); + (void)__Pyx_modinit_variable_export_code(__pyx_mstate); + if (unlikely((__Pyx_modinit_function_export_code(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_type_init_code(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_type_import_code(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + (void)__Pyx_modinit_variable_import_code(__pyx_mstate); + (void)__Pyx_modinit_function_import_code(__pyx_mstate); /*--- Execution code ---*/ - #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) - if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - __Pyx_TraceCall("__Pyx_PyMODINIT_FUNC PyInit__event(void)", __pyx_f[0], 1, 0, __PYX_ERR(0, 1, __pyx_L1_error)); + __Pyx_TraceStartFunc("PyInit__event", __pyx_f[0], 1, 0, 0, 0, __PYX_ERR(0, 1, __pyx_L1_error)); - /* "hunter/_event.pyx":2 - * # cython: linetrace=True, language_level=3str + /* "hunter/_event.pyx":4 + * cimport cython + * * from functools import partial # <<<<<<<<<<<<<< * from linecache import getline * from linecache import getlines - */ - __Pyx_TraceLine(2,0,__PYX_ERR(0, 2, __pyx_L1_error)) - __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_n_s_partial); - __Pyx_GIVEREF(__pyx_n_s_partial); - PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_partial); - __pyx_t_2 = __Pyx_Import(__pyx_n_s_functools, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2, __pyx_L1_error) +*/ + __Pyx_TraceLine(4,4,0,__PYX_ERR(0, 4, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_partial); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_partial); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_partial, __pyx_t_1) < 0) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_functools, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_partial); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_partial, __pyx_t_2) < 0) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "hunter/_event.pyx":3 - * # cython: linetrace=True, language_level=3str + /* "hunter/_event.pyx":5 + * * from functools import partial * from linecache import getline # <<<<<<<<<<<<<< * from linecache import getlines * from os.path import basename - */ - __Pyx_TraceLine(3,0,__PYX_ERR(0, 3, __pyx_L1_error)) - __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_n_s_getline); - __Pyx_GIVEREF(__pyx_n_s_getline); - PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_getline); - __pyx_t_1 = __Pyx_Import(__pyx_n_s_linecache, __pyx_t_2, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_getline); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) +*/ + __Pyx_TraceLine(5,7,0,__PYX_ERR(0, 5, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_getline); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_linecache, __pyx_t_3, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_getline, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_getline); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_getline, __pyx_t_3) < 0) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "hunter/_event.pyx":4 + /* "hunter/_event.pyx":6 * from functools import partial * from linecache import getline * from linecache import getlines # <<<<<<<<<<<<<< * from os.path import basename * from os.path import exists - */ - __Pyx_TraceLine(4,0,__PYX_ERR(0, 4, __pyx_L1_error)) - __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_n_s_getlines); - __Pyx_GIVEREF(__pyx_n_s_getlines); - PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_getlines); - __pyx_t_2 = __Pyx_Import(__pyx_n_s_linecache, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4, __pyx_L1_error) +*/ + __Pyx_TraceLine(6,10,0,__PYX_ERR(0, 6, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_getlines); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_getlines); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_getlines, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_linecache, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_getlines); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_getlines, __pyx_t_2) < 0) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "hunter/_event.pyx":5 + /* "hunter/_event.pyx":7 * from linecache import getline * from linecache import getlines * from os.path import basename # <<<<<<<<<<<<<< * from os.path import exists * from os.path import splitext - */ - __Pyx_TraceLine(5,0,__PYX_ERR(0, 5, __pyx_L1_error)) - __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5, __pyx_L1_error) +*/ + __Pyx_TraceLine(7,13,0,__PYX_ERR(0, 7, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_basename); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_os_path, __pyx_t_3, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_n_s_basename); - __Pyx_GIVEREF(__pyx_n_s_basename); - PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_basename); - __pyx_t_1 = __Pyx_Import(__pyx_n_s_os_path, __pyx_t_2, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_basename); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_basename, __pyx_t_3) < 0) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_basename); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_basename, __pyx_t_2) < 0) __PYX_ERR(0, 5, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "hunter/_event.pyx":6 + /* "hunter/_event.pyx":8 * from linecache import getlines * from os.path import basename * from os.path import exists # <<<<<<<<<<<<<< * from os.path import splitext * from threading import current_thread - */ - __Pyx_TraceLine(6,0,__PYX_ERR(0, 6, __pyx_L1_error)) - __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(__pyx_n_s_exists); - __Pyx_GIVEREF(__pyx_n_s_exists); - PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_exists); - __pyx_t_2 = __Pyx_Import(__pyx_n_s_os_path, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error) +*/ + __Pyx_TraceLine(8,16,0,__PYX_ERR(0, 8, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_exists); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_exists); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_exists, __pyx_t_1) < 0) __PYX_ERR(0, 6, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_os_path, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_exists); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_exists, __pyx_t_2) < 0) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "hunter/_event.pyx":7 + /* "hunter/_event.pyx":9 * from os.path import basename * from os.path import exists * from os.path import splitext # <<<<<<<<<<<<<< * from threading import current_thread * from tokenize import TokenError - */ - __Pyx_TraceLine(7,0,__PYX_ERR(0, 7, __pyx_L1_error)) - __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_n_s_splitext); - __Pyx_GIVEREF(__pyx_n_s_splitext); - PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_splitext); - __pyx_t_1 = __Pyx_Import(__pyx_n_s_os_path, __pyx_t_2, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_splitext); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 7, __pyx_L1_error) +*/ + __Pyx_TraceLine(9,19,0,__PYX_ERR(0, 9, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_splitext); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_os_path, __pyx_t_3, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_splitext, __pyx_t_2) < 0) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_splitext); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_splitext, __pyx_t_3) < 0) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "hunter/_event.pyx":8 + /* "hunter/_event.pyx":10 * from os.path import exists * from os.path import splitext * from threading import current_thread # <<<<<<<<<<<<<< * from tokenize import TokenError * from tokenize import generate_tokens - */ - __Pyx_TraceLine(8,0,__PYX_ERR(0, 8, __pyx_L1_error)) - __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_n_s_current_thread); - __Pyx_GIVEREF(__pyx_n_s_current_thread); - PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_current_thread); - __pyx_t_2 = __Pyx_Import(__pyx_n_s_threading, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 8, __pyx_L1_error) +*/ + __Pyx_TraceLine(10,22,0,__PYX_ERR(0, 10, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_current_thread); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 10, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_current_thread); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_current_thread, __pyx_t_1) < 0) __PYX_ERR(0, 8, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_threading, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_current_thread); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_current_thread, __pyx_t_2) < 0) __PYX_ERR(0, 10, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "hunter/_event.pyx":9 + /* "hunter/_event.pyx":11 * from os.path import splitext * from threading import current_thread * from tokenize import TokenError # <<<<<<<<<<<<<< * from tokenize import generate_tokens * - */ - __Pyx_TraceLine(9,0,__PYX_ERR(0, 9, __pyx_L1_error)) - __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_n_s_TokenError); - __Pyx_GIVEREF(__pyx_n_s_TokenError); - PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_TokenError); - __pyx_t_1 = __Pyx_Import(__pyx_n_s_tokenize, __pyx_t_2, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_TokenError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 9, __pyx_L1_error) +*/ + __Pyx_TraceLine(11,25,0,__PYX_ERR(0, 11, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_TokenError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 11, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_tokenize, __pyx_t_3, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 11, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TokenError, __pyx_t_2) < 0) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_TokenError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 11, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TokenError, __pyx_t_3) < 0) __PYX_ERR(0, 11, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "hunter/_event.pyx":10 + /* "hunter/_event.pyx":12 * from threading import current_thread * from tokenize import TokenError * from tokenize import generate_tokens # <<<<<<<<<<<<<< * * from cpython.pythread cimport PyThread_get_thread_ident - */ - __Pyx_TraceLine(10,0,__PYX_ERR(0, 10, __pyx_L1_error)) - __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 10, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_n_s_generate_tokens); - __Pyx_GIVEREF(__pyx_n_s_generate_tokens); - PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_generate_tokens); - __pyx_t_2 = __Pyx_Import(__pyx_n_s_tokenize, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 10, __pyx_L1_error) +*/ + __Pyx_TraceLine(12,28,0,__PYX_ERR(0, 12, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_generate_tokens); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_generate_tokens); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 10, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_generate_tokens, __pyx_t_1) < 0) __PYX_ERR(0, 10, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_tokenize, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_generate_tokens); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_generate_tokens, __pyx_t_2) < 0) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "hunter/_event.pyx":16 - * from ._tracer cimport Tracer + /* "hunter/_event.pyx":17 + * from cpython.ref cimport PyObject * * from .const import SITE_PACKAGES_PATHS # <<<<<<<<<<<<<< * from .const import SYS_PREFIX_PATHS * from .util import CYTHON_SUFFIX_RE - */ - __Pyx_TraceLine(16,0,__PYX_ERR(0, 16, __pyx_L1_error)) - __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 16, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_n_s_SITE_PACKAGES_PATHS); - __Pyx_GIVEREF(__pyx_n_s_SITE_PACKAGES_PATHS); - PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_SITE_PACKAGES_PATHS); - __pyx_t_1 = __Pyx_Import(__pyx_n_s_const, __pyx_t_2, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 16, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_SITE_PACKAGES_PATHS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 16, __pyx_L1_error) +*/ + __Pyx_TraceLine(17,33,0,__PYX_ERR(0, 17, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_SITE_PACKAGES_PATHS); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_const, __pyx_t_3, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 17, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_SITE_PACKAGES_PATHS, __pyx_t_2) < 0) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_SITE_PACKAGES_PATHS); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SITE_PACKAGES_PATHS, __pyx_t_3) < 0) __PYX_ERR(0, 17, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "hunter/_event.pyx":17 + /* "hunter/_event.pyx":18 * * from .const import SITE_PACKAGES_PATHS * from .const import SYS_PREFIX_PATHS # <<<<<<<<<<<<<< * from .util import CYTHON_SUFFIX_RE * from .util import LEADING_WHITESPACE_RE - */ - __Pyx_TraceLine(17,0,__PYX_ERR(0, 17, __pyx_L1_error)) - __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_n_s_SYS_PREFIX_PATHS); - __Pyx_GIVEREF(__pyx_n_s_SYS_PREFIX_PATHS); - PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_SYS_PREFIX_PATHS); - __pyx_t_2 = __Pyx_Import(__pyx_n_s_const, __pyx_t_1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 17, __pyx_L1_error) +*/ + __Pyx_TraceLine(18,36,0,__PYX_ERR(0, 18, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_SYS_PREFIX_PATHS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_SYS_PREFIX_PATHS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_SYS_PREFIX_PATHS, __pyx_t_1) < 0) __PYX_ERR(0, 17, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_const, __pyx_t_2, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_SYS_PREFIX_PATHS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SYS_PREFIX_PATHS, __pyx_t_2) < 0) __PYX_ERR(0, 18, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "hunter/_event.pyx":18 + /* "hunter/_event.pyx":19 * from .const import SITE_PACKAGES_PATHS * from .const import SYS_PREFIX_PATHS * from .util import CYTHON_SUFFIX_RE # <<<<<<<<<<<<<< * from .util import LEADING_WHITESPACE_RE * from .util import get_func_in_mro - */ - __Pyx_TraceLine(18,0,__PYX_ERR(0, 18, __pyx_L1_error)) - __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_n_s_CYTHON_SUFFIX_RE); - __Pyx_GIVEREF(__pyx_n_s_CYTHON_SUFFIX_RE); - PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_CYTHON_SUFFIX_RE); - __pyx_t_1 = __Pyx_Import(__pyx_n_s_util, __pyx_t_2, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 18, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_CYTHON_SUFFIX_RE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error) +*/ + __Pyx_TraceLine(19,39,0,__PYX_ERR(0, 19, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_CYTHON_SUFFIX_RE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_util, __pyx_t_3, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_CYTHON_SUFFIX_RE, __pyx_t_2) < 0) __PYX_ERR(0, 18, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_CYTHON_SUFFIX_RE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CYTHON_SUFFIX_RE, __pyx_t_3) < 0) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "hunter/_event.pyx":19 + /* "hunter/_event.pyx":20 * from .const import SYS_PREFIX_PATHS * from .util import CYTHON_SUFFIX_RE * from .util import LEADING_WHITESPACE_RE # <<<<<<<<<<<<<< * from .util import get_func_in_mro * from .util import get_main_thread - */ - __Pyx_TraceLine(19,0,__PYX_ERR(0, 19, __pyx_L1_error)) - __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_n_s_LEADING_WHITESPACE_RE); - __Pyx_GIVEREF(__pyx_n_s_LEADING_WHITESPACE_RE); - PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_LEADING_WHITESPACE_RE); - __pyx_t_2 = __Pyx_Import(__pyx_n_s_util, __pyx_t_1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 19, __pyx_L1_error) +*/ + __Pyx_TraceLine(20,42,0,__PYX_ERR(0, 20, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_LEADING_WHITESPACE_RE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 20, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_LEADING_WHITESPACE_RE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_LEADING_WHITESPACE_RE, __pyx_t_1) < 0) __PYX_ERR(0, 19, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_util, __pyx_t_2, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 20, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_LEADING_WHITESPACE_RE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 20, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_LEADING_WHITESPACE_RE, __pyx_t_2) < 0) __PYX_ERR(0, 20, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "hunter/_event.pyx":20 + /* "hunter/_event.pyx":21 * from .util import CYTHON_SUFFIX_RE * from .util import LEADING_WHITESPACE_RE * from .util import get_func_in_mro # <<<<<<<<<<<<<< * from .util import get_main_thread * from .util import if_same_code - */ - __Pyx_TraceLine(20,0,__PYX_ERR(0, 20, __pyx_L1_error)) - __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 20, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_n_s_get_func_in_mro); - __Pyx_GIVEREF(__pyx_n_s_get_func_in_mro); - PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_get_func_in_mro); - __pyx_t_1 = __Pyx_Import(__pyx_n_s_util, __pyx_t_2, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 20, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_get_func_in_mro); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 20, __pyx_L1_error) +*/ + __Pyx_TraceLine(21,45,0,__PYX_ERR(0, 21, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_get_func_in_mro); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 21, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_util, __pyx_t_3, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 21, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_func_in_mro, __pyx_t_2) < 0) __PYX_ERR(0, 20, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_get_func_in_mro); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 21, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_get_func_in_mro, __pyx_t_3) < 0) __PYX_ERR(0, 21, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "hunter/_event.pyx":21 + /* "hunter/_event.pyx":22 * from .util import LEADING_WHITESPACE_RE * from .util import get_func_in_mro * from .util import get_main_thread # <<<<<<<<<<<<<< * from .util import if_same_code * - */ - __Pyx_TraceLine(21,0,__PYX_ERR(0, 21, __pyx_L1_error)) - __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_n_s_get_main_thread); - __Pyx_GIVEREF(__pyx_n_s_get_main_thread); - PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_get_main_thread); - __pyx_t_2 = __Pyx_Import(__pyx_n_s_util, __pyx_t_1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 21, __pyx_L1_error) +*/ + __Pyx_TraceLine(22,48,0,__PYX_ERR(0, 22, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_get_main_thread); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_get_main_thread); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_main_thread, __pyx_t_1) < 0) __PYX_ERR(0, 21, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_util, __pyx_t_2, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_get_main_thread); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_get_main_thread, __pyx_t_2) < 0) __PYX_ERR(0, 22, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "hunter/_event.pyx":22 + /* "hunter/_event.pyx":23 * from .util import get_func_in_mro * from .util import get_main_thread * from .util import if_same_code # <<<<<<<<<<<<<< * * __all__ = 'Event', - */ - __Pyx_TraceLine(22,0,__PYX_ERR(0, 22, __pyx_L1_error)) - __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_n_s_if_same_code); - __Pyx_GIVEREF(__pyx_n_s_if_same_code); - PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_if_same_code); - __pyx_t_1 = __Pyx_Import(__pyx_n_s_util, __pyx_t_2, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_if_same_code); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error) +*/ + __Pyx_TraceLine(23,51,0,__PYX_ERR(0, 23, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_if_same_code); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_util, __pyx_t_3, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 23, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_if_same_code, __pyx_t_2) < 0) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_if_same_code); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_if_same_code, __pyx_t_3) < 0) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "hunter/_event.pyx":24 + /* "hunter/_event.pyx":25 * from .util import if_same_code * * __all__ = 'Event', # <<<<<<<<<<<<<< * * cdef object UNSET = object() - */ - __Pyx_TraceLine(24,0,__PYX_ERR(0, 24, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_d, __pyx_n_s_all, __pyx_tuple__10) < 0) __PYX_ERR(0, 24, __pyx_L1_error) +*/ + __Pyx_TraceLine(25,53,0,__PYX_ERR(0, 25, __pyx_L1_error)) + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_all, __pyx_mstate_global->__pyx_tuple[4]) < 0) __PYX_ERR(0, 25, __pyx_L1_error) - /* "hunter/_event.pyx":26 + /* "hunter/_event.pyx":27 * __all__ = 'Event', * * cdef object UNSET = object() # <<<<<<<<<<<<<< * * - */ - __Pyx_TraceLine(26,0,__PYX_ERR(0, 26, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_builtin_object); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 26, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); +*/ + __Pyx_TraceLine(27,56,0,__PYX_ERR(0, 27, __pyx_L1_error)) + __pyx_t_3 = NULL; + __Pyx_INCREF(__pyx_builtin_object); + __pyx_t_4 = __pyx_builtin_object; + __pyx_t_5 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 27, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } __Pyx_XGOTREF(__pyx_v_6hunter_6_event_UNSET); - __Pyx_DECREF_SET(__pyx_v_6hunter_6_event_UNSET, __pyx_t_1); - __Pyx_GIVEREF(__pyx_t_1); - __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_6hunter_6_event_UNSET, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __pyx_t_2 = 0; - /* "hunter/_event.pyx":100 - * return event + /* "hunter/_event.pyx":30 * - * cdef inline Event clone(self): # <<<<<<<<<<<<<< - * event = Event.__new__(Event) - * event.arg = self.arg - */ - __Pyx_TraceLine(100,0,__PYX_ERR(0, 100, __pyx_L1_error)) + * + * cdef str CALL = 'call' # <<<<<<<<<<<<<< + * cdef str EXCEPTION = 'exception' + * cdef str LINE = 'line' +*/ + __Pyx_TraceLine(30,57,0,__PYX_ERR(0, 30, __pyx_L1_error)) + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_call); + __Pyx_XGOTREF(__pyx_v_6hunter_6_event_CALL); + __Pyx_DECREF_SET(__pyx_v_6hunter_6_event_CALL, __pyx_mstate_global->__pyx_n_u_call); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_call); + + /* "hunter/_event.pyx":31 + * + * cdef str CALL = 'call' + * cdef str EXCEPTION = 'exception' # <<<<<<<<<<<<<< + * cdef str LINE = 'line' + * cdef str RETURN = 'return' +*/ + __Pyx_TraceLine(31,59,0,__PYX_ERR(0, 31, __pyx_L1_error)) + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_exception); + __Pyx_XGOTREF(__pyx_v_6hunter_6_event_EXCEPTION); + __Pyx_DECREF_SET(__pyx_v_6hunter_6_event_EXCEPTION, __pyx_mstate_global->__pyx_n_u_exception); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_exception); + + /* "hunter/_event.pyx":32 + * cdef str CALL = 'call' + * cdef str EXCEPTION = 'exception' + * cdef str LINE = 'line' # <<<<<<<<<<<<<< + * cdef str RETURN = 'return' + * +*/ + __Pyx_TraceLine(32,61,0,__PYX_ERR(0, 32, __pyx_L1_error)) + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_line); + __Pyx_XGOTREF(__pyx_v_6hunter_6_event_LINE); + __Pyx_DECREF_SET(__pyx_v_6hunter_6_event_LINE, __pyx_mstate_global->__pyx_n_u_line); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_line); + + /* "hunter/_event.pyx":33 + * cdef str EXCEPTION = 'exception' + * cdef str LINE = 'line' + * cdef str RETURN = 'return' # <<<<<<<<<<<<<< + * + * cdef const PyObject** KIND_NAMES = [ +*/ + __Pyx_TraceLine(33,63,0,__PYX_ERR(0, 33, __pyx_L1_error)) + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_return); + __Pyx_XGOTREF(__pyx_v_6hunter_6_event_RETURN); + __Pyx_DECREF_SET(__pyx_v_6hunter_6_event_RETURN, __pyx_mstate_global->__pyx_n_u_return); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_return); + + /* "hunter/_event.pyx":35 + * cdef str RETURN = 'return' + * + * cdef const PyObject** KIND_NAMES = [ # <<<<<<<<<<<<<< + * CALL, + * EXCEPTION, +*/ + __Pyx_TraceLine(35,66,0,__PYX_ERR(0, 35, __pyx_L1_error)) + __pyx_t_6[0] = ((PyObject *)__pyx_v_6hunter_6_event_CALL); + __pyx_t_6[1] = ((PyObject *)__pyx_v_6hunter_6_event_EXCEPTION); + __pyx_t_6[2] = ((PyObject *)__pyx_v_6hunter_6_event_LINE); + __pyx_t_6[3] = ((PyObject *)__pyx_v_6hunter_6_event_RETURN); + __pyx_t_6[4] = ((PyObject *)__pyx_v_6hunter_6_event_CALL); + __pyx_t_6[5] = ((PyObject *)__pyx_v_6hunter_6_event_EXCEPTION); + __pyx_t_6[6] = ((PyObject *)__pyx_v_6hunter_6_event_RETURN); + __pyx_v_6hunter_6_event_KIND_NAMES = __pyx_t_6; + + /* "hunter/_event.pyx":93 + * return self is other + * + * def detach(self, value_filter=None): # <<<<<<<<<<<<<< + * return fast_detach(self, value_filter) + * +*/ + __Pyx_TraceLine(93,93,0,__PYX_ERR(0, 93, __pyx_L1_error)) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_6_event_5Event_7detach, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Event_detach, NULL, __pyx_mstate_global->__pyx_n_u_hunter__event, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[3])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_mstate_global->__pyx_tuple[5]); + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6hunter_6_event_Event, __pyx_mstate_global->__pyx_n_u_detach, __pyx_t_2) < 0) __PYX_ERR(0, 93, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "hunter/_event.pyx":96 + * return fast_detach(self, value_filter) + * + * def clone(self): # <<<<<<<<<<<<<< + * return fast_clone(self) + * +*/ + __Pyx_TraceLine(96,95,0,__PYX_ERR(0, 96, __pyx_L1_error)) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_6_event_5Event_9clone, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Event_clone, NULL, __pyx_mstate_global->__pyx_n_u_hunter__event, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[4])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 96, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6hunter_6_event_Event, __pyx_mstate_global->__pyx_n_u_clone, __pyx_t_2) < 0) __PYX_ERR(0, 96, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "hunter/_event.pyx":99 + * return fast_clone(self) + * + * cdef inline instruction_getter(self): # <<<<<<<<<<<<<< + * cdef int position + * +*/ + __Pyx_TraceLine(99,96,0,__PYX_ERR(0, 99, __pyx_L1_error)) + + + /* "hunter/_event.pyx":115 + * return self.instruction_getter() + * + * cdef inline threadid_getter(self): # <<<<<<<<<<<<<< + * cdef long current + * +*/ + __Pyx_TraceLine(115,98,0,__PYX_ERR(0, 115, __pyx_L1_error)) + + + /* "hunter/_event.pyx":131 + * return self.threadid_getter() + * + * cdef inline threadname_getter(self): # <<<<<<<<<<<<<< + * if self._threadname is UNSET: + * if self._thread is UNSET: +*/ + __Pyx_TraceLine(131,100,0,__PYX_ERR(0, 131, __pyx_L1_error)) + + + /* "hunter/_event.pyx":142 + * return self.threadname_getter() + * + * cdef inline locals_getter(self): # <<<<<<<<<<<<<< + * if self._locals is UNSET: + * if self.builtin: +*/ + __Pyx_TraceLine(142,102,0,__PYX_ERR(0, 142, __pyx_L1_error)) + + + /* "hunter/_event.pyx":154 + * return self.locals_getter() + * + * cdef inline globals_getter(self): # <<<<<<<<<<<<<< + * if self._globals is UNSET: + * if self.builtin: +*/ + __Pyx_TraceLine(154,104,0,__PYX_ERR(0, 154, __pyx_L1_error)) + + + /* "hunter/_event.pyx":166 + * return self.globals_getter() + * + * cdef inline function_getter(self): # <<<<<<<<<<<<<< + * if self._function is UNSET: + * if self.builtin: +*/ + __Pyx_TraceLine(166,106,0,__PYX_ERR(0, 166, __pyx_L1_error)) + + + /* "hunter/_event.pyx":209 + * return self._function_object + * + * cdef inline module_getter(self): # <<<<<<<<<<<<<< + * if self._module is UNSET: + * if self.builtin: +*/ + __Pyx_TraceLine(209,109,0,__PYX_ERR(0, 209, __pyx_L1_error)) + + + /* "hunter/_event.pyx":224 + * return self.module_getter() + * + * cdef inline filename_getter(self): # <<<<<<<<<<<<<< + * cdef CodeType code + * if self._filename is UNSET: +*/ + __Pyx_TraceLine(224,111,0,__PYX_ERR(0, 224, __pyx_L1_error)) + + + /* "hunter/_event.pyx":250 + * return self.filename_getter() + * + * cdef inline lineno_getter(self): # <<<<<<<<<<<<<< + * if self._lineno is UNSET: + * self._lineno = Hunter_PyFrame_GetLineNumber(self.frame) +*/ + __Pyx_TraceLine(250,113,0,__PYX_ERR(0, 250, __pyx_L1_error)) + + + /* "hunter/_event.pyx":259 + * return self.lineno_getter() + * + * cdef inline CodeType code_getter(self): # <<<<<<<<<<<<<< + * if self._code is UNSET: + * return Hunter_PyFrame_GetCode(self.frame) +*/ + __Pyx_TraceLine(259,115,0,__PYX_ERR(0, 259, __pyx_L1_error)) + + /* "hunter/_event.pyx":269 + * return self.code_getter() + * + * cdef inline stdlib_getter(self): # <<<<<<<<<<<<<< + * if self._stdlib is UNSET: + * module_parts = self.module.split('.') +*/ + __Pyx_TraceLine(269,117,0,__PYX_ERR(0, 269, __pyx_L1_error)) + + + /* "hunter/_event.pyx":291 + * return self.stdlib_getter() + * + * cdef inline fullsource_getter(self): # <<<<<<<<<<<<<< + * cdef list lines + * cdef CodeType code +*/ + __Pyx_TraceLine(291,119,0,__PYX_ERR(0, 291, __pyx_L1_error)) - /* "hunter/_event.pyx":297 + + /* "hunter/_event.pyx":328 + * return self.fullsource_getter() + * + * cdef inline source_getter(self): # <<<<<<<<<<<<<< + * if self._source is UNSET: + * if self.filename.endswith(('.so', '.pyd')): +*/ + __Pyx_TraceLine(328,121,0,__PYX_ERR(0, 328, __pyx_L1_error)) + + + /* "hunter/_event.pyx":347 * * * def yield_lines(filename, module_globals, start, list collector, # <<<<<<<<<<<<<< * limit=10): * dedent = None - */ - __Pyx_TraceLine(297,0,__PYX_ERR(0, 297, __pyx_L1_error)) - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6hunter_6_event_1yield_lines, NULL, __pyx_n_s_hunter__event); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 297, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_yield_lines, __pyx_t_1) < 0) __PYX_ERR(0, 297, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; +*/ + __Pyx_TraceLine(347,124,0,__PYX_ERR(0, 347, __pyx_L1_error)) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_6_event_1yield_lines, 0, __pyx_mstate_global->__pyx_n_u_yield_lines, NULL, __pyx_mstate_global->__pyx_n_u_hunter__event, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[41])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_mstate_global->__pyx_tuple[6]); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_yield_lines, __pyx_t_2) < 0) __PYX_ERR(0, 347, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "(tree fragment)":1 - * def __pyx_unpickle_Event(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ - __Pyx_TraceLine(1,0,__PYX_ERR(2, 1, __pyx_L1_error)) - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6hunter_6_event_4__pyx_unpickle_Event, NULL, __pyx_n_s_hunter__event); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Event, __pyx_t_1) < 0) __PYX_ERR(2, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /* "hunter/_event.pyx":362 + * + * + * cdef inline Event fast_detach(Event self, object value_filter): # <<<<<<<<<<<<<< + * event = Event.__new__(Event) + * +*/ + __Pyx_TraceLine(362,126,0,__PYX_ERR(0, 362, __pyx_L1_error)) - /* "(tree fragment)":11 - * __pyx_unpickle_Event__set_state( __pyx_result, __pyx_state) - * return __pyx_result - * cdef __pyx_unpickle_Event__set_state(Event __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< - * __pyx_result._code = __pyx_state[0]; __pyx_result._filename = __pyx_state[1]; __pyx_result._fullsource = __pyx_state[2]; __pyx_result._function = __pyx_state[3]; __pyx_result._function_object = __pyx_state[4]; __pyx_result._globals = __pyx_state[5]; __pyx_result._lineno = __pyx_state[6]; __pyx_result._locals = __pyx_state[7]; __pyx_result._module = __pyx_state[8]; __pyx_result._source = __pyx_state[9]; __pyx_result._stdlib = __pyx_state[10]; __pyx_result._thread = __pyx_state[11]; __pyx_result._threadidn = __pyx_state[12]; __pyx_result._threadname = __pyx_state[13]; __pyx_result.arg = __pyx_state[14]; __pyx_result.calls = __pyx_state[15]; __pyx_result.depth = __pyx_state[16]; __pyx_result.detached = __pyx_state[17]; __pyx_result.frame = __pyx_state[18]; __pyx_result.kind = __pyx_state[19]; __pyx_result.threading_support = __pyx_state[20] - * if len(__pyx_state) > 21 and hasattr(__pyx_result, '__dict__'): - */ - __Pyx_TraceLine(11,0,__PYX_ERR(2, 11, __pyx_L1_error)) + + /* "hunter/_event.pyx":396 + * return event + * + * cdef inline Event fast_clone(Event self): # <<<<<<<<<<<<<< + * event = Event.__new__(Event) + * event.arg = self.arg +*/ + __Pyx_TraceLine(396,127,0,__PYX_ERR(0, 396, __pyx_L1_error)) /* "hunter/_event.pyx":1 - * # cython: linetrace=True, language_level=3str # <<<<<<<<<<<<<< - * from functools import partial - * from linecache import getline - */ - __Pyx_TraceLine(1,0,__PYX_ERR(0, 1, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_TraceReturn(Py_None, 0); + * # cython: linetrace=True, language_level=3str, c_string_encoding=ascii, freethreading_compatible=True # <<<<<<<<<<<<<< + * cimport cython + * +*/ + __Pyx_TraceLine(1,0,0,__PYX_ERR(0, 1, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_TraceReturnValue(Py_None, 0, 0, __PYX_ERR(0, 1, __pyx_L1_error)); + __Pyx_PyMonitoring_ExitScope(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); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_TraceException(__pyx_lineno, 0, 0); + __Pyx_TraceExceptionUnwind(0, 0); if (__pyx_m) { - if (__pyx_d) { + if (__pyx_mstate->__pyx_d && stringtab_initialized) { __Pyx_AddTraceback("init hunter._event", __pyx_clineno, __pyx_lineno, __pyx_filename); } + #if !CYTHON_USE_MODULE_STATE Py_CLEAR(__pyx_m); + #else + Py_DECREF(__pyx_m); + if (pystate_addmodule_run) { + PyObject *tp, *value, *tb; + PyErr_Fetch(&tp, &value, &tb); + PyState_RemoveModule(&__pyx_moduledef); + PyErr_Restore(tp, value, tb); + } + #endif } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init hunter._event"); } @@ -10839,2351 +13592,5342 @@ if (!__Pyx_RefNanny) { __Pyx_RefNannyFinishContext(); #if CYTHON_PEP489_MULTI_PHASE_INIT return (__pyx_m != NULL) ? 0 : -1; - #elif PY_MAJOR_VERSION >= 3 - return __pyx_m; #else - return; + return __pyx_m; #endif } +/* #### Code section: pystring_table ### */ -/* --- 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(modname); - if (!m) goto end; - p = PyObject_GetAttrString(m, "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 +typedef struct { + const char *s; +#if 179 <= 65535 + const unsigned short n; +#elif 179 / 2 < INT_MAX + const unsigned int n; +#elif 179 / 2 < LONG_MAX + const unsigned long n; +#else + const Py_ssize_t n; +#endif +#if 1 <= 31 + const unsigned int encoding : 5; +#elif 1 <= 255 + const unsigned char encoding; +#elif 1 <= 65535 + const unsigned short encoding; +#else + const Py_ssize_t encoding; +#endif + const unsigned int is_unicode : 1; + const unsigned int intern : 1; +} __Pyx_StringTabEntry; +static const char * const __pyx_string_tab_encodings[] = { 0 }; +static const __Pyx_StringTabEntry __pyx_string_tab[] = { + {__pyx_k_, sizeof(__pyx_k_), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_ */ + {__pyx_k_CALL, sizeof(__pyx_k_CALL), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CALL */ + {__pyx_k_CYTHON_SUFFIX_RE, sizeof(__pyx_k_CYTHON_SUFFIX_RE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CYTHON_SUFFIX_RE */ + {__pyx_k_EXCEPTION, sizeof(__pyx_k_EXCEPTION), 0, 1, 1}, /* PyObject cname: __pyx_n_u_EXCEPTION */ + {__pyx_k_Event, sizeof(__pyx_k_Event), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Event */ + {__pyx_k_Event_clone, sizeof(__pyx_k_Event_clone), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Event_clone */ + {__pyx_k_Event_detach, sizeof(__pyx_k_Event_detach), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Event_detach */ + {__pyx_k_Event_kind, sizeof(__pyx_k_Event_kind), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Event_kind */ + {__pyx_k_KIND_NAMES, sizeof(__pyx_k_KIND_NAMES), 0, 1, 1}, /* PyObject cname: __pyx_n_u_KIND_NAMES */ + {__pyx_k_LEADING_WHITESPACE_RE, sizeof(__pyx_k_LEADING_WHITESPACE_RE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_LEADING_WHITESPACE_RE */ + {__pyx_k_LINE, sizeof(__pyx_k_LINE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_LINE */ + {__pyx_k_NO_SOURCE, sizeof(__pyx_k_NO_SOURCE), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_NO_SOURCE */ + {__pyx_k_NO_SOURCE_not_reading_binary, sizeof(__pyx_k_NO_SOURCE_not_reading_binary), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_NO_SOURCE_not_reading_binary */ + {__pyx_k_Note_that_Cython_is_deliberately, sizeof(__pyx_k_Note_that_Cython_is_deliberately), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Note_that_Cython_is_deliberately */ + {__pyx_k_RETURN, sizeof(__pyx_k_RETURN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_RETURN */ + {__pyx_k_SITE_PACKAGES_PATHS, sizeof(__pyx_k_SITE_PACKAGES_PATHS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SITE_PACKAGES_PATHS */ + {__pyx_k_SYS_PREFIX_PATHS, sizeof(__pyx_k_SYS_PREFIX_PATHS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SYS_PREFIX_PATHS */ + {__pyx_k_TokenError, sizeof(__pyx_k_TokenError), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TokenError */ + {__pyx_k_UNSET, sizeof(__pyx_k_UNSET), 0, 1, 1}, /* PyObject cname: __pyx_n_u_UNSET */ + {__pyx_k__2, sizeof(__pyx_k__2), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__2 */ + {__pyx_k__3, sizeof(__pyx_k__3), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__3 */ + {__pyx_k__4, sizeof(__pyx_k__4), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__4 */ + {__pyx_k_add_note, sizeof(__pyx_k_add_note), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_add_note */ + {__pyx_k_all, sizeof(__pyx_k_all), 0, 1, 1}, /* PyObject cname: __pyx_n_u_all */ + {__pyx_k_amount, sizeof(__pyx_k_amount), 0, 1, 1}, /* PyObject cname: __pyx_n_u_amount */ + {__pyx_k_arg, sizeof(__pyx_k_arg), 0, 1, 1}, /* PyObject cname: __pyx_n_u_arg */ + {__pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 1, 1}, /* PyObject cname: __pyx_n_u_asyncio_coroutines */ + {__pyx_k_basename, sizeof(__pyx_k_basename), 0, 1, 1}, /* PyObject cname: __pyx_n_u_basename */ + {__pyx_k_builtin, sizeof(__pyx_k_builtin), 0, 1, 1}, /* PyObject cname: __pyx_n_u_builtin */ + {__pyx_k_call, sizeof(__pyx_k_call), 0, 1, 1}, /* PyObject cname: __pyx_n_u_call */ + {__pyx_k_calls, sizeof(__pyx_k_calls), 0, 1, 1}, /* PyObject cname: __pyx_n_u_calls */ + {__pyx_k_candidate, sizeof(__pyx_k_candidate), 0, 1, 1}, /* PyObject cname: __pyx_n_u_candidate */ + {__pyx_k_class, sizeof(__pyx_k_class), 0, 1, 1}, /* PyObject cname: __pyx_n_u_class */ + {__pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 1, 1}, /* PyObject cname: __pyx_n_u_cline_in_traceback */ + {__pyx_k_clone, sizeof(__pyx_k_clone), 0, 1, 1}, /* PyObject cname: __pyx_n_u_clone */ + {__pyx_k_close, sizeof(__pyx_k_close), 0, 1, 1}, /* PyObject cname: __pyx_n_u_close */ + {__pyx_k_code, sizeof(__pyx_k_code), 0, 1, 1}, /* PyObject cname: __pyx_n_u_code */ + {__pyx_k_code_2, sizeof(__pyx_k_code_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_code_2 */ + {__pyx_k_code_getter, sizeof(__pyx_k_code_getter), 0, 1, 1}, /* PyObject cname: __pyx_n_u_code_getter */ + {__pyx_k_collector, sizeof(__pyx_k_collector), 0, 1, 1}, /* PyObject cname: __pyx_n_u_collector */ + {__pyx_k_const, sizeof(__pyx_k_const), 0, 1, 1}, /* PyObject cname: __pyx_n_u_const */ + {__pyx_k_current_thread, sizeof(__pyx_k_current_thread), 0, 1, 1}, /* PyObject cname: __pyx_n_u_current_thread */ + {__pyx_k_dedent, sizeof(__pyx_k_dedent), 0, 1, 1}, /* PyObject cname: __pyx_n_u_dedent */ + {__pyx_k_def, sizeof(__pyx_k_def), 0, 1, 1}, /* PyObject cname: __pyx_n_u_def */ + {__pyx_k_depth, sizeof(__pyx_k_depth), 0, 1, 1}, /* PyObject cname: __pyx_n_u_depth */ + {__pyx_k_detach, sizeof(__pyx_k_detach), 0, 1, 1}, /* PyObject cname: __pyx_n_u_detach */ + {__pyx_k_detached, sizeof(__pyx_k_detached), 0, 1, 1}, /* PyObject cname: __pyx_n_u_detached */ + {__pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_disable */ + {__pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_enable */ + {__pyx_k_endswith, sizeof(__pyx_k_endswith), 0, 1, 1}, /* PyObject cname: __pyx_n_u_endswith */ + {__pyx_k_eq, sizeof(__pyx_k_eq), 0, 1, 1}, /* PyObject cname: __pyx_n_u_eq */ + {__pyx_k_exception, sizeof(__pyx_k_exception), 0, 1, 1}, /* PyObject cname: __pyx_n_u_exception */ + {__pyx_k_exists, sizeof(__pyx_k_exists), 0, 1, 1}, /* PyObject cname: __pyx_n_u_exists */ + {__pyx_k_f_globals, sizeof(__pyx_k_f_globals), 0, 1, 1}, /* PyObject cname: __pyx_n_u_f_globals */ + {__pyx_k_fast_clone, sizeof(__pyx_k_fast_clone), 0, 1, 1}, /* PyObject cname: __pyx_n_u_fast_clone */ + {__pyx_k_fast_detach, sizeof(__pyx_k_fast_detach), 0, 1, 1}, /* PyObject cname: __pyx_n_u_fast_detach */ + {__pyx_k_file, sizeof(__pyx_k_file), 0, 1, 1}, /* PyObject cname: __pyx_n_u_file */ + {__pyx_k_file_2, sizeof(__pyx_k_file_2), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_file_2 */ + {__pyx_k_filename, sizeof(__pyx_k_filename), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_filename */ + {__pyx_k_filename_2, sizeof(__pyx_k_filename_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_filename_2 */ + {__pyx_k_filename_3, sizeof(__pyx_k_filename_3), 0, 1, 1}, /* PyObject cname: __pyx_n_u_filename_3 */ + {__pyx_k_filename_getter, sizeof(__pyx_k_filename_getter), 0, 1, 1}, /* PyObject cname: __pyx_n_u_filename_getter */ + {__pyx_k_findall, sizeof(__pyx_k_findall), 0, 1, 1}, /* PyObject cname: __pyx_n_u_findall */ + {__pyx_k_first_arg, sizeof(__pyx_k_first_arg), 0, 1, 1}, /* PyObject cname: __pyx_n_u_first_arg */ + {__pyx_k_frame, sizeof(__pyx_k_frame), 0, 1, 1}, /* PyObject cname: __pyx_n_u_frame */ + {__pyx_k_fullsource, sizeof(__pyx_k_fullsource), 0, 1, 1}, /* PyObject cname: __pyx_n_u_fullsource */ + {__pyx_k_fullsource_getter, sizeof(__pyx_k_fullsource_getter), 0, 1, 1}, /* PyObject cname: __pyx_n_u_fullsource_getter */ + {__pyx_k_func, sizeof(__pyx_k_func), 0, 1, 1}, /* PyObject cname: __pyx_n_u_func */ + {__pyx_k_func_2, sizeof(__pyx_k_func_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_func_2 */ + {__pyx_k_function, sizeof(__pyx_k_function), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_function */ + {__pyx_k_function_2, sizeof(__pyx_k_function_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_function_2 */ + {__pyx_k_function_3, sizeof(__pyx_k_function_3), 0, 1, 1}, /* PyObject cname: __pyx_n_u_function_3 */ + {__pyx_k_function_getter, sizeof(__pyx_k_function_getter), 0, 1, 1}, /* PyObject cname: __pyx_n_u_function_getter */ + {__pyx_k_function_object, sizeof(__pyx_k_function_object), 0, 1, 1}, /* PyObject cname: __pyx_n_u_function_object */ + {__pyx_k_functools, sizeof(__pyx_k_functools), 0, 1, 1}, /* PyObject cname: __pyx_n_u_functools */ + {__pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_gc */ + {__pyx_k_generate_tokens, sizeof(__pyx_k_generate_tokens), 0, 1, 1}, /* PyObject cname: __pyx_n_u_generate_tokens */ + {__pyx_k_get, sizeof(__pyx_k_get), 0, 1, 1}, /* PyObject cname: __pyx_n_u_get */ + {__pyx_k_get_2, sizeof(__pyx_k_get_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_get_2 */ + {__pyx_k_get_func_in_mro, sizeof(__pyx_k_get_func_in_mro), 0, 1, 1}, /* PyObject cname: __pyx_n_u_get_func_in_mro */ + {__pyx_k_get_main_thread, sizeof(__pyx_k_get_main_thread), 0, 1, 1}, /* PyObject cname: __pyx_n_u_get_main_thread */ + {__pyx_k_getitem, sizeof(__pyx_k_getitem), 0, 1, 1}, /* PyObject cname: __pyx_n_u_getitem */ + {__pyx_k_getline, sizeof(__pyx_k_getline), 0, 1, 1}, /* PyObject cname: __pyx_n_u_getline */ + {__pyx_k_getlines, sizeof(__pyx_k_getlines), 0, 1, 1}, /* PyObject cname: __pyx_n_u_getlines */ + {__pyx_k_globals, sizeof(__pyx_k_globals), 0, 1, 1}, /* PyObject cname: __pyx_n_u_globals */ + {__pyx_k_globals_2, sizeof(__pyx_k_globals_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_globals_2 */ + {__pyx_k_globals_getter, sizeof(__pyx_k_globals_getter), 0, 1, 1}, /* PyObject cname: __pyx_n_u_globals_getter */ + {__pyx_k_hunter__event, sizeof(__pyx_k_hunter__event), 0, 1, 1}, /* PyObject cname: __pyx_n_u_hunter__event */ + {__pyx_k_ident, sizeof(__pyx_k_ident), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ident */ + {__pyx_k_if_same_code, sizeof(__pyx_k_if_same_code), 0, 1, 1}, /* PyObject cname: __pyx_n_u_if_same_code */ + {__pyx_k_init, sizeof(__pyx_k_init), 0, 1, 1}, /* PyObject cname: __pyx_n_u_init */ + {__pyx_k_instruction, sizeof(__pyx_k_instruction), 0, 1, 1}, /* PyObject cname: __pyx_n_u_instruction */ + {__pyx_k_instruction_getter, sizeof(__pyx_k_instruction_getter), 0, 1, 1}, /* PyObject cname: __pyx_n_u_instruction_getter */ + {__pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 1, 1}, /* PyObject cname: __pyx_n_u_is_coroutine */ + {__pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_isenabled */ + {__pyx_k_item, sizeof(__pyx_k_item), 0, 1, 1}, /* PyObject cname: __pyx_n_u_item */ + {__pyx_k_items, sizeof(__pyx_k_items), 0, 1, 1}, /* PyObject cname: __pyx_n_u_items */ + {__pyx_k_kind, sizeof(__pyx_k_kind), 0, 1, 1}, /* PyObject cname: __pyx_n_u_kind */ + {__pyx_k_lambda, sizeof(__pyx_k_lambda), 0, 1, 1}, /* PyObject cname: __pyx_n_u_lambda */ + {__pyx_k_limit, sizeof(__pyx_k_limit), 0, 1, 1}, /* PyObject cname: __pyx_n_u_limit */ + {__pyx_k_line, sizeof(__pyx_k_line), 0, 1, 1}, /* PyObject cname: __pyx_n_u_line */ + {__pyx_k_linecache, sizeof(__pyx_k_linecache), 0, 1, 1}, /* PyObject cname: __pyx_n_u_linecache */ + {__pyx_k_lineno, sizeof(__pyx_k_lineno), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_lineno */ + {__pyx_k_lineno_2, sizeof(__pyx_k_lineno_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_lineno_2 */ + {__pyx_k_lineno_3, sizeof(__pyx_k_lineno_3), 0, 1, 1}, /* PyObject cname: __pyx_n_u_lineno_3 */ + {__pyx_k_lineno_getter, sizeof(__pyx_k_lineno_getter), 0, 1, 1}, /* PyObject cname: __pyx_n_u_lineno_getter */ + {__pyx_k_locals, sizeof(__pyx_k_locals), 0, 1, 1}, /* PyObject cname: __pyx_n_u_locals */ + {__pyx_k_locals_2, sizeof(__pyx_k_locals_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_locals_2 */ + {__pyx_k_locals_getter, sizeof(__pyx_k_locals_getter), 0, 1, 1}, /* PyObject cname: __pyx_n_u_locals_getter */ + {__pyx_k_main, sizeof(__pyx_k_main), 0, 1, 1}, /* PyObject cname: __pyx_n_u_main */ + {__pyx_k_module, sizeof(__pyx_k_module), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_module */ + {__pyx_k_module_2, sizeof(__pyx_k_module_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_module_2 */ + {__pyx_k_module_3, sizeof(__pyx_k_module_3), 0, 1, 1}, /* PyObject cname: __pyx_n_u_module_3 */ + {__pyx_k_module_4, sizeof(__pyx_k_module_4), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_module_4 */ + {__pyx_k_module_5, sizeof(__pyx_k_module_5), 0, 1, 1}, /* PyObject cname: __pyx_n_u_module_5 */ + {__pyx_k_module_getter, sizeof(__pyx_k_module_getter), 0, 1, 1}, /* PyObject cname: __pyx_n_u_module_getter */ + {__pyx_k_module_globals, sizeof(__pyx_k_module_globals), 0, 1, 1}, /* PyObject cname: __pyx_n_u_module_globals */ + {__pyx_k_name, sizeof(__pyx_k_name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_name */ + {__pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_name_2 */ + {__pyx_k_namedtuple, sizeof(__pyx_k_namedtuple), 0, 1, 1}, /* PyObject cname: __pyx_n_u_namedtuple */ + {__pyx_k_next, sizeof(__pyx_k_next), 0, 1, 1}, /* PyObject cname: __pyx_n_u_next */ + {__pyx_k_object, sizeof(__pyx_k_object), 0, 1, 1}, /* PyObject cname: __pyx_n_u_object */ + {__pyx_k_os_path, sizeof(__pyx_k_os_path), 0, 1, 1}, /* PyObject cname: __pyx_n_u_os_path */ + {__pyx_k_other, sizeof(__pyx_k_other), 0, 1, 1}, /* PyObject cname: __pyx_n_u_other */ + {__pyx_k_partial, sizeof(__pyx_k_partial), 0, 1, 1}, /* PyObject cname: __pyx_n_u_partial */ + {__pyx_k_pkg_resources, sizeof(__pyx_k_pkg_resources), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pkg_resources */ + {__pyx_k_pop, sizeof(__pyx_k_pop), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pop */ + {__pyx_k_py, sizeof(__pyx_k_py), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_py */ + {__pyx_k_pyc, sizeof(__pyx_k_pyc), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_pyc */ + {__pyx_k_pyd, sizeof(__pyx_k_pyd), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_pyd */ + {__pyx_k_pyo, sizeof(__pyx_k_pyo), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_pyo */ + {__pyx_k_pyx, sizeof(__pyx_k_pyx), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_pyx */ + {__pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pyx_vtable */ + {__pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 1, 1}, /* PyObject cname: __pyx_n_u_qualname */ + {__pyx_k_repr, sizeof(__pyx_k_repr), 0, 1, 1}, /* PyObject cname: __pyx_n_u_repr */ + {__pyx_k_return, sizeof(__pyx_k_return), 0, 1, 1}, /* PyObject cname: __pyx_n_u_return */ + {__pyx_k_self, sizeof(__pyx_k_self), 0, 1, 1}, /* PyObject cname: __pyx_n_u_self */ + {__pyx_k_send, sizeof(__pyx_k_send), 0, 1, 1}, /* PyObject cname: __pyx_n_u_send */ + {__pyx_k_set_name, sizeof(__pyx_k_set_name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_set_name */ + {__pyx_k_site, sizeof(__pyx_k_site), 0, 1, 1}, /* PyObject cname: __pyx_n_u_site */ + {__pyx_k_so, sizeof(__pyx_k_so), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_so */ + {__pyx_k_source, sizeof(__pyx_k_source), 0, 1, 1}, /* PyObject cname: __pyx_n_u_source */ + {__pyx_k_source_getter, sizeof(__pyx_k_source_getter), 0, 1, 1}, /* PyObject cname: __pyx_n_u_source_getter */ + {__pyx_k_split, sizeof(__pyx_k_split), 0, 1, 1}, /* PyObject cname: __pyx_n_u_split */ + {__pyx_k_splitext, sizeof(__pyx_k_splitext), 0, 1, 1}, /* PyObject cname: __pyx_n_u_splitext */ + {__pyx_k_src_hunter__event_pxd, sizeof(__pyx_k_src_hunter__event_pxd), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_src_hunter__event_pxd */ + {__pyx_k_src_hunter__event_pyx, sizeof(__pyx_k_src_hunter__event_pyx), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_src_hunter__event_pyx */ + {__pyx_k_start, sizeof(__pyx_k_start), 0, 1, 1}, /* PyObject cname: __pyx_n_u_start */ + {__pyx_k_startswith, sizeof(__pyx_k_startswith), 0, 1, 1}, /* PyObject cname: __pyx_n_u_startswith */ + {__pyx_k_stdlib, sizeof(__pyx_k_stdlib), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stdlib */ + {__pyx_k_stdlib_getter, sizeof(__pyx_k_stdlib_getter), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stdlib_getter */ + {__pyx_k_string, sizeof(__pyx_k_string), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_string */ + {__pyx_k_sub, sizeof(__pyx_k_sub), 0, 1, 1}, /* PyObject cname: __pyx_n_u_sub */ + {__pyx_k_test, sizeof(__pyx_k_test), 0, 1, 1}, /* PyObject cname: __pyx_n_u_test */ + {__pyx_k_thread, sizeof(__pyx_k_thread), 0, 1, 1}, /* PyObject cname: __pyx_n_u_thread */ + {__pyx_k_threadid_getter, sizeof(__pyx_k_threadid_getter), 0, 1, 1}, /* PyObject cname: __pyx_n_u_threadid_getter */ + {__pyx_k_threadidn, sizeof(__pyx_k_threadidn), 0, 1, 1}, /* PyObject cname: __pyx_n_u_threadidn */ + {__pyx_k_threading, sizeof(__pyx_k_threading), 0, 1, 1}, /* PyObject cname: __pyx_n_u_threading */ + {__pyx_k_threading_support, sizeof(__pyx_k_threading_support), 0, 1, 1}, /* PyObject cname: __pyx_n_u_threading_support */ + {__pyx_k_threadname, sizeof(__pyx_k_threadname), 0, 1, 1}, /* PyObject cname: __pyx_n_u_threadname */ + {__pyx_k_threadname_getter, sizeof(__pyx_k_threadname_getter), 0, 1, 1}, /* PyObject cname: __pyx_n_u_threadname_getter */ + {__pyx_k_throw, sizeof(__pyx_k_throw), 0, 1, 1}, /* PyObject cname: __pyx_n_u_throw */ + {__pyx_k_tokenize, sizeof(__pyx_k_tokenize), 0, 1, 1}, /* PyObject cname: __pyx_n_u_tokenize */ + {__pyx_k_util, sizeof(__pyx_k_util), 0, 1, 1}, /* PyObject cname: __pyx_n_u_util */ + {__pyx_k_v, sizeof(__pyx_k_v), 0, 1, 1}, /* PyObject cname: __pyx_n_u_v */ + {__pyx_k_value, sizeof(__pyx_k_value), 0, 1, 1}, /* PyObject cname: __pyx_n_u_value */ + {__pyx_k_value_filter, sizeof(__pyx_k_value_filter), 0, 1, 1}, /* PyObject cname: __pyx_n_u_value_filter */ + {__pyx_k_values, sizeof(__pyx_k_values), 0, 1, 1}, /* PyObject cname: __pyx_n_u_values */ + {__pyx_k_yield_lines, sizeof(__pyx_k_yield_lines), 0, 1, 1}, /* PyObject cname: __pyx_n_u_yield_lines */ + {0, 0, 0, 0, 0} +}; +/* InitStrings.proto */ +static int __Pyx_InitStrings(__Pyx_StringTabEntry const *t, PyObject **target, const char* const* encoding_names); + +/* #### Code section: cached_builtins ### */ + +static int __Pyx_InitCachedBuiltins(__pyx_mstatetype *__pyx_mstate) { + CYTHON_UNUSED_VAR(__pyx_mstate); + __pyx_builtin_object = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_object); if (!__pyx_builtin_object) __PYX_ERR(0, 27, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: cached_constants ### */ + +static int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "hunter/_event.pyx":214 + * module = self.arg.__module__ + * else: + * module = self.globals.get('__name__', '') # <<<<<<<<<<<<<< + * if module is None: + * module = '?' +*/ + __pyx_mstate_global->__pyx_tuple[0] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_n_u_name_2, __pyx_mstate_global->__pyx_kp_u__2); if (unlikely(!__pyx_mstate_global->__pyx_tuple[0])) __PYX_ERR(0, 214, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[0]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[0]); + + /* "hunter/_event.pyx":233 + * if not filename: + * filename = '?' + * elif filename.endswith(('.pyc', '.pyo')): # <<<<<<<<<<<<<< + * filename = filename[:-1] + * elif filename.endswith(('.so', '.pyd')): +*/ + __pyx_mstate_global->__pyx_tuple[1] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_kp_u_pyc, __pyx_mstate_global->__pyx_kp_u_pyo); if (unlikely(!__pyx_mstate_global->__pyx_tuple[1])) __PYX_ERR(0, 233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[1]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[1]); + + /* "hunter/_event.pyx":234 + * filename = '?' + * elif filename.endswith(('.pyc', '.pyo')): + * filename = filename[:-1] # <<<<<<<<<<<<<< + * elif filename.endswith(('.so', '.pyd')): + * cybasename = CYTHON_SUFFIX_RE.sub('', filename) +*/ + __pyx_mstate_global->__pyx_slice[0] = PySlice_New(Py_None, __pyx_mstate_global->__pyx_int_neg_1, Py_None); if (unlikely(!__pyx_mstate_global->__pyx_slice[0])) __PYX_ERR(0, 234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_slice[0]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_slice[0]); + + /* "hunter/_event.pyx":235 + * elif filename.endswith(('.pyc', '.pyo')): + * filename = filename[:-1] + * elif filename.endswith(('.so', '.pyd')): # <<<<<<<<<<<<<< + * cybasename = CYTHON_SUFFIX_RE.sub('', filename) + * for ext in ('.pyx', '.py'): +*/ + __pyx_mstate_global->__pyx_tuple[2] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_kp_u_so, __pyx_mstate_global->__pyx_kp_u_pyd); if (unlikely(!__pyx_mstate_global->__pyx_tuple[2])) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[2]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[2]); + + /* "hunter/_event.pyx":237 + * elif filename.endswith(('.so', '.pyd')): + * cybasename = CYTHON_SUFFIX_RE.sub('', filename) + * for ext in ('.pyx', '.py'): # <<<<<<<<<<<<<< + * cyfilename = cybasename + ext + * if exists(cyfilename): +*/ + __pyx_mstate_global->__pyx_tuple[3] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_kp_u_pyx, __pyx_mstate_global->__pyx_kp_u_py); if (unlikely(!__pyx_mstate_global->__pyx_tuple[3])) __PYX_ERR(0, 237, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[3]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[3]); + + /* "hunter/_event.pyx":25 + * from .util import if_same_code + * + * __all__ = 'Event', # <<<<<<<<<<<<<< + * + * cdef object UNSET = object() +*/ + __pyx_mstate_global->__pyx_tuple[4] = PyTuple_Pack(1, __pyx_mstate_global->__pyx_n_u_Event); if (unlikely(!__pyx_mstate_global->__pyx_tuple[4])) __PYX_ERR(0, 25, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[4]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[4]); + + /* "hunter/_event.pyx":93 + * return self is other + * + * def detach(self, value_filter=None): # <<<<<<<<<<<<<< + * return fast_detach(self, value_filter) + * +*/ + __pyx_mstate_global->__pyx_tuple[5] = PyTuple_Pack(1, Py_None); if (unlikely(!__pyx_mstate_global->__pyx_tuple[5])) __PYX_ERR(0, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[5]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[5]); + + /* "hunter/_event.pyx":347 + * + * + * def yield_lines(filename, module_globals, start, list collector, # <<<<<<<<<<<<<< + * limit=10): + * dedent = None +*/ + __pyx_mstate_global->__pyx_tuple[6] = PyTuple_Pack(1, ((PyObject*)__pyx_mstate_global->__pyx_int_10)); if (unlikely(!__pyx_mstate_global->__pyx_tuple[6])) __PYX_ERR(0, 347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[6]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[6]); + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} +/* #### Code section: init_constants ### */ + +static int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate) { + CYTHON_UNUSED_VAR(__pyx_mstate); + __pyx_mstate->__pyx_umethod_PyDict_Type_pop.type = (PyObject*)&PyDict_Type; + __pyx_mstate->__pyx_umethod_PyDict_Type_pop.method_name = &__pyx_mstate->__pyx_n_u_pop; + if (__Pyx_InitStrings(__pyx_string_tab, __pyx_mstate->__pyx_string_tab, __pyx_string_tab_encodings) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + __pyx_mstate->__pyx_int_1 = PyLong_FromLong(1); if (unlikely(!__pyx_mstate->__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_10 = PyLong_FromLong(10); if (unlikely(!__pyx_mstate->__pyx_int_10)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_neg_1 = PyLong_FromLong(-1); if (unlikely(!__pyx_mstate->__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: init_codeobjects ### */ +\ + typedef struct { + unsigned int argcount : 3; + unsigned int num_posonly_args : 1; + unsigned int num_kwonly_args : 1; + unsigned int nlocals : 5; + unsigned int flags : 10; + unsigned int first_line : 9; + unsigned int line_table_length : 13; + } __Pyx_PyCode_New_function_description; +/* NewCodeObj.proto */ +static PyObject* __Pyx_PyCode_New( + const __Pyx_PyCode_New_function_description descr, + PyObject * const *varnames, + PyObject *filename, + PyObject *funcname, + const char *line_table, + PyObject *tuple_dedup_map +); + + +static int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate) { + PyObject* tuple_dedup_map = PyDict_New(); + if (unlikely(!tuple_dedup_map)) return -1; + { + const __Pyx_PyCode_New_function_description descr = {7, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 59, 176}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_frame, __pyx_mstate->__pyx_n_u_kind, __pyx_mstate->__pyx_n_u_arg, __pyx_mstate->__pyx_n_u_depth, __pyx_mstate->__pyx_n_u_calls, __pyx_mstate->__pyx_n_u_threading_support}; + __pyx_mstate_global->__pyx_codeobj_tab[0] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_init, __pyx_k_A_G1_IQ_HF_AQ_IQ_IQ_L_KuBa_IQ_M, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[0])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 85, 28}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[1] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_repr, __pyx_k_A_q_t_d_4_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[1])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 90, 11}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_other}; + __pyx_mstate_global->__pyx_codeobj_tab[2] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_eq, __pyx_k_A_uCq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[2])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 93, 16}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_value_filter}; + __pyx_mstate_global->__pyx_codeobj_tab[3] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_detach, __pyx_k_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[3])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 96, 11}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[4] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_clone, __pyx_k_A_z, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[4])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 24, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 99, 86}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_frame, __pyx_mstate->__pyx_n_u_kind, __pyx_mstate->__pyx_n_u_arg, __pyx_mstate->__pyx_n_u_depth, __pyx_mstate->__pyx_n_u_calls, __pyx_mstate->__pyx_n_u_threading_support, __pyx_mstate->__pyx_n_u_detached, __pyx_mstate->__pyx_n_u_builtin, __pyx_mstate->__pyx_n_u_code, __pyx_mstate->__pyx_n_u_filename_3, __pyx_mstate->__pyx_n_u_fullsource, __pyx_mstate->__pyx_n_u_function_3, __pyx_mstate->__pyx_n_u_function_object, __pyx_mstate->__pyx_n_u_globals_2, __pyx_mstate->__pyx_n_u_lineno_3, __pyx_mstate->__pyx_n_u_locals_2, __pyx_mstate->__pyx_n_u_module_5, __pyx_mstate->__pyx_n_u_source, __pyx_mstate->__pyx_n_u_stdlib, __pyx_mstate->__pyx_n_u_thread, __pyx_mstate->__pyx_n_u_threadidn, __pyx_mstate->__pyx_n_u_threadname, __pyx_mstate->__pyx_n_u_instruction}; + __pyx_mstate_global->__pyx_codeobj_tab[5] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_instruction_getter, __pyx_k_A_4_S_at1_nAT_Q_xt3ay_a_G1A_A_t1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[5])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 111, 12}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[6] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_get_2, __pyx_k_A_t_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[6])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 24, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 115, 70}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_frame, __pyx_mstate->__pyx_n_u_kind, __pyx_mstate->__pyx_n_u_arg, __pyx_mstate->__pyx_n_u_depth, __pyx_mstate->__pyx_n_u_calls, __pyx_mstate->__pyx_n_u_threading_support, __pyx_mstate->__pyx_n_u_detached, __pyx_mstate->__pyx_n_u_builtin, __pyx_mstate->__pyx_n_u_code, __pyx_mstate->__pyx_n_u_filename_3, __pyx_mstate->__pyx_n_u_fullsource, __pyx_mstate->__pyx_n_u_function_3, __pyx_mstate->__pyx_n_u_function_object, __pyx_mstate->__pyx_n_u_globals_2, __pyx_mstate->__pyx_n_u_lineno_3, __pyx_mstate->__pyx_n_u_locals_2, __pyx_mstate->__pyx_n_u_module_5, __pyx_mstate->__pyx_n_u_source, __pyx_mstate->__pyx_n_u_stdlib, __pyx_mstate->__pyx_n_u_thread, __pyx_mstate->__pyx_n_u_threadidn, __pyx_mstate->__pyx_n_u_threadname, __pyx_mstate->__pyx_n_u_instruction}; + __pyx_mstate_global->__pyx_codeobj_tab[7] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_threadid_getter, __pyx_k_A_4_3a_q_uG5_HCt1_N_N_t1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[7])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 127, 12}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[8] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_get_2, __pyx_k_A_t_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[8])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 24, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 131, 51}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_frame, __pyx_mstate->__pyx_n_u_kind, __pyx_mstate->__pyx_n_u_arg, __pyx_mstate->__pyx_n_u_depth, __pyx_mstate->__pyx_n_u_calls, __pyx_mstate->__pyx_n_u_threading_support, __pyx_mstate->__pyx_n_u_detached, __pyx_mstate->__pyx_n_u_builtin, __pyx_mstate->__pyx_n_u_code, __pyx_mstate->__pyx_n_u_filename_3, __pyx_mstate->__pyx_n_u_fullsource, __pyx_mstate->__pyx_n_u_function_3, __pyx_mstate->__pyx_n_u_function_object, __pyx_mstate->__pyx_n_u_globals_2, __pyx_mstate->__pyx_n_u_lineno_3, __pyx_mstate->__pyx_n_u_locals_2, __pyx_mstate->__pyx_n_u_module_5, __pyx_mstate->__pyx_n_u_source, __pyx_mstate->__pyx_n_u_stdlib, __pyx_mstate->__pyx_n_u_thread, __pyx_mstate->__pyx_n_u_threadidn, __pyx_mstate->__pyx_n_u_threadname, __pyx_mstate->__pyx_n_u_instruction}; + __pyx_mstate_global->__pyx_codeobj_tab[9] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_threadname_getter, __pyx_k_A_4_Cq_t9Cq_K_Q_t81_t1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[9])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 138, 12}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[10] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_get_2, __pyx_k_A_t_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[10])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 24, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 142, 48}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_frame, __pyx_mstate->__pyx_n_u_kind, __pyx_mstate->__pyx_n_u_arg, __pyx_mstate->__pyx_n_u_depth, __pyx_mstate->__pyx_n_u_calls, __pyx_mstate->__pyx_n_u_threading_support, __pyx_mstate->__pyx_n_u_detached, __pyx_mstate->__pyx_n_u_builtin, __pyx_mstate->__pyx_n_u_code, __pyx_mstate->__pyx_n_u_filename_3, __pyx_mstate->__pyx_n_u_fullsource, __pyx_mstate->__pyx_n_u_function_3, __pyx_mstate->__pyx_n_u_function_object, __pyx_mstate->__pyx_n_u_globals_2, __pyx_mstate->__pyx_n_u_lineno_3, __pyx_mstate->__pyx_n_u_locals_2, __pyx_mstate->__pyx_n_u_module_5, __pyx_mstate->__pyx_n_u_source, __pyx_mstate->__pyx_n_u_stdlib, __pyx_mstate->__pyx_n_u_thread, __pyx_mstate->__pyx_n_u_threadidn, __pyx_mstate->__pyx_n_u_threadname, __pyx_mstate->__pyx_n_u_instruction}; + __pyx_mstate_global->__pyx_codeobj_tab[11] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_locals_getter, __pyx_k_A_4y_1_t1_Kq_K_7q_A_t1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[11])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 150, 11}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[12] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_get_2, __pyx_k_A_t, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[12])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 24, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 154, 48}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_frame, __pyx_mstate->__pyx_n_u_kind, __pyx_mstate->__pyx_n_u_arg, __pyx_mstate->__pyx_n_u_depth, __pyx_mstate->__pyx_n_u_calls, __pyx_mstate->__pyx_n_u_threading_support, __pyx_mstate->__pyx_n_u_detached, __pyx_mstate->__pyx_n_u_builtin, __pyx_mstate->__pyx_n_u_code, __pyx_mstate->__pyx_n_u_filename_3, __pyx_mstate->__pyx_n_u_fullsource, __pyx_mstate->__pyx_n_u_function_3, __pyx_mstate->__pyx_n_u_function_object, __pyx_mstate->__pyx_n_u_globals_2, __pyx_mstate->__pyx_n_u_lineno_3, __pyx_mstate->__pyx_n_u_locals_2, __pyx_mstate->__pyx_n_u_module_5, __pyx_mstate->__pyx_n_u_source, __pyx_mstate->__pyx_n_u_stdlib, __pyx_mstate->__pyx_n_u_thread, __pyx_mstate->__pyx_n_u_threadidn, __pyx_mstate->__pyx_n_u_threadname, __pyx_mstate->__pyx_n_u_instruction}; + __pyx_mstate_global->__pyx_codeobj_tab[13] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_globals_getter, __pyx_k_A_4z_A_t1_Kq_L_9_a_t1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[13])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 162, 11}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[14] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_get_2, __pyx_k_A_t_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[14])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 24, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 166, 51}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_frame, __pyx_mstate->__pyx_n_u_kind, __pyx_mstate->__pyx_n_u_arg, __pyx_mstate->__pyx_n_u_depth, __pyx_mstate->__pyx_n_u_calls, __pyx_mstate->__pyx_n_u_threading_support, __pyx_mstate->__pyx_n_u_detached, __pyx_mstate->__pyx_n_u_builtin, __pyx_mstate->__pyx_n_u_code, __pyx_mstate->__pyx_n_u_filename_3, __pyx_mstate->__pyx_n_u_fullsource, __pyx_mstate->__pyx_n_u_function_3, __pyx_mstate->__pyx_n_u_function_object, __pyx_mstate->__pyx_n_u_globals_2, __pyx_mstate->__pyx_n_u_lineno_3, __pyx_mstate->__pyx_n_u_locals_2, __pyx_mstate->__pyx_n_u_module_5, __pyx_mstate->__pyx_n_u_source, __pyx_mstate->__pyx_n_u_stdlib, __pyx_mstate->__pyx_n_u_thread, __pyx_mstate->__pyx_n_u_threadidn, __pyx_mstate->__pyx_n_u_threadname, __pyx_mstate->__pyx_n_u_instruction}; + __pyx_mstate_global->__pyx_codeobj_tab[15] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_function_getter, __pyx_k_A_4_Q_t1_M_T_M_1_t1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[15])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 174, 12}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[16] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_get_2, __pyx_k_A_t_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[16])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 6, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 178, 213}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_code_2, __pyx_mstate->__pyx_n_u_candidate, __pyx_mstate->__pyx_n_u_func_2, __pyx_mstate->__pyx_n_u_first_arg, __pyx_mstate->__pyx_n_u_v}; + __pyx_mstate_global->__pyx_codeobj_tab[17] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_get_2, __pyx_k_A_4q_4q_3a_4_1_t9Cq_q_HD_Zq_q_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[17])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 24, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 209, 72}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_frame, __pyx_mstate->__pyx_n_u_kind, __pyx_mstate->__pyx_n_u_arg, __pyx_mstate->__pyx_n_u_depth, __pyx_mstate->__pyx_n_u_calls, __pyx_mstate->__pyx_n_u_threading_support, __pyx_mstate->__pyx_n_u_detached, __pyx_mstate->__pyx_n_u_builtin, __pyx_mstate->__pyx_n_u_code, __pyx_mstate->__pyx_n_u_filename_3, __pyx_mstate->__pyx_n_u_fullsource, __pyx_mstate->__pyx_n_u_function_3, __pyx_mstate->__pyx_n_u_function_object, __pyx_mstate->__pyx_n_u_globals_2, __pyx_mstate->__pyx_n_u_lineno_3, __pyx_mstate->__pyx_n_u_locals_2, __pyx_mstate->__pyx_n_u_module_5, __pyx_mstate->__pyx_n_u_source, __pyx_mstate->__pyx_n_u_stdlib, __pyx_mstate->__pyx_n_u_thread, __pyx_mstate->__pyx_n_u_threadidn, __pyx_mstate->__pyx_n_u_threadname, __pyx_mstate->__pyx_n_u_instruction}; + __pyx_mstate_global->__pyx_codeobj_tab[18] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_module_getter, __pyx_k_A_4y_1_t1_T_XT_a_wc_1_t1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[18])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 220, 11}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[19] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_get_2, __pyx_k_A_t, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[19])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 24, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 224, 157}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_frame, __pyx_mstate->__pyx_n_u_kind, __pyx_mstate->__pyx_n_u_arg, __pyx_mstate->__pyx_n_u_depth, __pyx_mstate->__pyx_n_u_calls, __pyx_mstate->__pyx_n_u_threading_support, __pyx_mstate->__pyx_n_u_detached, __pyx_mstate->__pyx_n_u_builtin, __pyx_mstate->__pyx_n_u_code, __pyx_mstate->__pyx_n_u_filename_3, __pyx_mstate->__pyx_n_u_fullsource, __pyx_mstate->__pyx_n_u_function_3, __pyx_mstate->__pyx_n_u_function_object, __pyx_mstate->__pyx_n_u_globals_2, __pyx_mstate->__pyx_n_u_lineno_3, __pyx_mstate->__pyx_n_u_locals_2, __pyx_mstate->__pyx_n_u_module_5, __pyx_mstate->__pyx_n_u_source, __pyx_mstate->__pyx_n_u_stdlib, __pyx_mstate->__pyx_n_u_thread, __pyx_mstate->__pyx_n_u_threadidn, __pyx_mstate->__pyx_n_u_threadname, __pyx_mstate->__pyx_n_u_instruction}; + __pyx_mstate_global->__pyx_codeobj_tab[20] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_filename_getter, __pyx_k_A_4_Q_4_1_t1_t1_4xt1A_t1_1_HA_83, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[20])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 246, 12}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[21] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_get_2, __pyx_k_A_t_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[21])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 24, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 250, 34}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_frame, __pyx_mstate->__pyx_n_u_kind, __pyx_mstate->__pyx_n_u_arg, __pyx_mstate->__pyx_n_u_depth, __pyx_mstate->__pyx_n_u_calls, __pyx_mstate->__pyx_n_u_threading_support, __pyx_mstate->__pyx_n_u_detached, __pyx_mstate->__pyx_n_u_builtin, __pyx_mstate->__pyx_n_u_code, __pyx_mstate->__pyx_n_u_filename_3, __pyx_mstate->__pyx_n_u_fullsource, __pyx_mstate->__pyx_n_u_function_3, __pyx_mstate->__pyx_n_u_function_object, __pyx_mstate->__pyx_n_u_globals_2, __pyx_mstate->__pyx_n_u_lineno_3, __pyx_mstate->__pyx_n_u_locals_2, __pyx_mstate->__pyx_n_u_module_5, __pyx_mstate->__pyx_n_u_source, __pyx_mstate->__pyx_n_u_stdlib, __pyx_mstate->__pyx_n_u_thread, __pyx_mstate->__pyx_n_u_threadidn, __pyx_mstate->__pyx_n_u_threadname, __pyx_mstate->__pyx_n_u_instruction}; + __pyx_mstate_global->__pyx_codeobj_tab[22] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_lineno_getter, __pyx_k_A_4y_1_7q_A_t1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[22])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 255, 11}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[23] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_get_2, __pyx_k_A_t, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[23])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 24, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 259, 32}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_frame, __pyx_mstate->__pyx_n_u_kind, __pyx_mstate->__pyx_n_u_arg, __pyx_mstate->__pyx_n_u_depth, __pyx_mstate->__pyx_n_u_calls, __pyx_mstate->__pyx_n_u_threading_support, __pyx_mstate->__pyx_n_u_detached, __pyx_mstate->__pyx_n_u_builtin, __pyx_mstate->__pyx_n_u_code, __pyx_mstate->__pyx_n_u_filename_3, __pyx_mstate->__pyx_n_u_fullsource, __pyx_mstate->__pyx_n_u_function_3, __pyx_mstate->__pyx_n_u_function_object, __pyx_mstate->__pyx_n_u_globals_2, __pyx_mstate->__pyx_n_u_lineno_3, __pyx_mstate->__pyx_n_u_locals_2, __pyx_mstate->__pyx_n_u_module_5, __pyx_mstate->__pyx_n_u_source, __pyx_mstate->__pyx_n_u_stdlib, __pyx_mstate->__pyx_n_u_thread, __pyx_mstate->__pyx_n_u_threadidn, __pyx_mstate->__pyx_n_u_threadname, __pyx_mstate->__pyx_n_u_instruction}; + __pyx_mstate_global->__pyx_codeobj_tab[24] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_code_getter, __pyx_k_A_4wc_a_4q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[24])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 265, 11}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[25] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_get_2, __pyx_k_A_t_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[25])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 24, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 269, 136}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_frame, __pyx_mstate->__pyx_n_u_kind, __pyx_mstate->__pyx_n_u_arg, __pyx_mstate->__pyx_n_u_depth, __pyx_mstate->__pyx_n_u_calls, __pyx_mstate->__pyx_n_u_threading_support, __pyx_mstate->__pyx_n_u_detached, __pyx_mstate->__pyx_n_u_builtin, __pyx_mstate->__pyx_n_u_code, __pyx_mstate->__pyx_n_u_filename_3, __pyx_mstate->__pyx_n_u_fullsource, __pyx_mstate->__pyx_n_u_function_3, __pyx_mstate->__pyx_n_u_function_object, __pyx_mstate->__pyx_n_u_globals_2, __pyx_mstate->__pyx_n_u_lineno_3, __pyx_mstate->__pyx_n_u_locals_2, __pyx_mstate->__pyx_n_u_module_5, __pyx_mstate->__pyx_n_u_source, __pyx_mstate->__pyx_n_u_stdlib, __pyx_mstate->__pyx_n_u_thread, __pyx_mstate->__pyx_n_u_threadidn, __pyx_mstate->__pyx_n_u_threadname, __pyx_mstate->__pyx_n_u_instruction}; + __pyx_mstate_global->__pyx_codeobj_tab[26] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_stdlib_getter, __pyx_k_A_4y_1_4wfAQ_s_Kq_Zs_U_g_X___ggj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[26])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 287, 11}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[27] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_get_2, __pyx_k_A_t, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[27])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 24, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 291, 212}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_frame, __pyx_mstate->__pyx_n_u_kind, __pyx_mstate->__pyx_n_u_arg, __pyx_mstate->__pyx_n_u_depth, __pyx_mstate->__pyx_n_u_calls, __pyx_mstate->__pyx_n_u_threading_support, __pyx_mstate->__pyx_n_u_detached, __pyx_mstate->__pyx_n_u_builtin, __pyx_mstate->__pyx_n_u_code, __pyx_mstate->__pyx_n_u_filename_3, __pyx_mstate->__pyx_n_u_fullsource, __pyx_mstate->__pyx_n_u_function_3, __pyx_mstate->__pyx_n_u_function_object, __pyx_mstate->__pyx_n_u_globals_2, __pyx_mstate->__pyx_n_u_lineno_3, __pyx_mstate->__pyx_n_u_locals_2, __pyx_mstate->__pyx_n_u_module_5, __pyx_mstate->__pyx_n_u_source, __pyx_mstate->__pyx_n_u_stdlib, __pyx_mstate->__pyx_n_u_thread, __pyx_mstate->__pyx_n_u_threadidn, __pyx_mstate->__pyx_n_u_threadname, __pyx_mstate->__pyx_n_u_instruction}; + __pyx_mstate_global->__pyx_codeobj_tab[28] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_fullsource_getter, __pyx_k_A_4_Cq_O1_t_q_4vS_t4y_1_A_Cwc_E, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[28])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 324, 12}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[29] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_get_2, __pyx_k_A_t_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[29])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 24, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 328, 110}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_frame, __pyx_mstate->__pyx_n_u_kind, __pyx_mstate->__pyx_n_u_arg, __pyx_mstate->__pyx_n_u_depth, __pyx_mstate->__pyx_n_u_calls, __pyx_mstate->__pyx_n_u_threading_support, __pyx_mstate->__pyx_n_u_detached, __pyx_mstate->__pyx_n_u_builtin, __pyx_mstate->__pyx_n_u_code, __pyx_mstate->__pyx_n_u_filename_3, __pyx_mstate->__pyx_n_u_fullsource, __pyx_mstate->__pyx_n_u_function_3, __pyx_mstate->__pyx_n_u_function_object, __pyx_mstate->__pyx_n_u_globals_2, __pyx_mstate->__pyx_n_u_lineno_3, __pyx_mstate->__pyx_n_u_locals_2, __pyx_mstate->__pyx_n_u_module_5, __pyx_mstate->__pyx_n_u_source, __pyx_mstate->__pyx_n_u_stdlib, __pyx_mstate->__pyx_n_u_thread, __pyx_mstate->__pyx_n_u_threadidn, __pyx_mstate->__pyx_n_u_threadname, __pyx_mstate->__pyx_n_u_instruction}; + __pyx_mstate_global->__pyx_codeobj_tab[30] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_source_getter, __pyx_k_A_4y_1_t9IRwa_Kr_GxqPXXYY_hhiij, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[30])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 339, 11}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[31] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_get_2, __pyx_k_A_t, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[31])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 343, 13}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_item}; + __pyx_mstate_global->__pyx_codeobj_tab[32] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_getitem, __pyx_k_A_wavQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[32])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 42, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[33] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pxd, __pyx_mstate->__pyx_n_u_get_2, __pyx_k_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[33])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 43, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[34] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pxd, __pyx_mstate->__pyx_n_u_get_2, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[34])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 44, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[35] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pxd, __pyx_mstate->__pyx_n_u_get_2, __pyx_k__5, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[35])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 45, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[36] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pxd, __pyx_mstate->__pyx_n_u_get_2, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[36])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 46, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[37] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pxd, __pyx_mstate->__pyx_n_u_get_2, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[37])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 47, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[38] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pxd, __pyx_mstate->__pyx_n_u_get_2, __pyx_k_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[38])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 48, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[39] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pxd, __pyx_mstate->__pyx_n_u_get_2, __pyx_k_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[39])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 49, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[40] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pxd, __pyx_mstate->__pyx_n_u_get_2, __pyx_k__5, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[40])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_GENERATOR), 347, 5}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_filename_2, __pyx_mstate->__pyx_n_u_module_globals, __pyx_mstate->__pyx_n_u_start, __pyx_mstate->__pyx_n_u_collector, __pyx_mstate->__pyx_n_u_limit, __pyx_mstate->__pyx_n_u_dedent, __pyx_mstate->__pyx_n_u_amount, __pyx_mstate->__pyx_n_u_line}; + __pyx_mstate_global->__pyx_codeobj_tab[41] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_yield_lines, __pyx_k__6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[41])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 362, 311}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_value_filter, __pyx_mstate->__pyx_n_u_UNSET, __pyx_mstate->__pyx_n_u_CALL, __pyx_mstate->__pyx_n_u_EXCEPTION, __pyx_mstate->__pyx_n_u_LINE, __pyx_mstate->__pyx_n_u_RETURN, __pyx_mstate->__pyx_n_u_KIND_NAMES}; + __pyx_mstate_global->__pyx_codeobj_tab[42] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_fast_detach, __pyx_k_HE_l_d_a_T_d_D_a_D_a_D_a_D_a_t, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[42])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 396, 228}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_UNSET, __pyx_mstate->__pyx_n_u_CALL, __pyx_mstate->__pyx_n_u_EXCEPTION, __pyx_mstate->__pyx_n_u_LINE, __pyx_mstate->__pyx_n_u_RETURN, __pyx_mstate->__pyx_n_u_KIND_NAMES}; + __pyx_mstate_global->__pyx_codeobj_tab[43] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__event_pyx, __pyx_mstate->__pyx_n_u_fast_clone, __pyx_k_HE_A_D_a_a_Q_a_Q_d_a_d_A_T_d_T, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[43])) goto bad; + } + Py_DECREF(tuple_dedup_map); + return 0; + bad: + Py_DECREF(tuple_dedup_map); + return -1; +} +/* #### Code section: init_globals ### */ + +static int __Pyx_InitGlobals(void) { + /* PythonCompatibility.init */ + if (likely(__Pyx_init_co_variables() == 0)); else + +if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + /* CachedMethodType.init */ + #if CYTHON_COMPILING_IN_LIMITED_API +{ + PyObject *typesModule=NULL; + typesModule = PyImport_ImportModule("types"); + if (typesModule) { + __pyx_mstate_global->__Pyx_CachedMethodType = PyObject_GetAttrString(typesModule, "MethodType"); + Py_DECREF(typesModule); + } +} // error handling follows +#endif + +if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: cleanup_globals ### */ +/* #### Code section: cleanup_module ### */ +/* #### Code section: main_method ### */ +/* #### Code section: utility_code_pragmas ### */ +#ifdef _MSC_VER +#pragma warning( push ) +/* Warning 4127: conditional expression is constant + * Cython uses constant conditional expressions to allow in inline functions to be optimized at + * compile-time, so this warning is not useful + */ +#pragma warning( disable : 4127 ) +#endif + + + +/* #### Code section: utility_code_def ### */ + +/* --- 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(modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, "RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +/* PyErrExceptionMatches */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); + for (i=0; i= 0x030C00A6 + PyObject *current_exception = tstate->current_exception; + if (unlikely(!current_exception)) return 0; + exc_type = (PyObject*) Py_TYPE(current_exception); + if (exc_type == err) return 1; +#else + exc_type = tstate->curexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; +#endif + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(exc_type); + #endif + if (unlikely(PyTuple_Check(err))) { + result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + } else { + result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err); + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(exc_type); + #endif + return result; +} +#endif + +/* PyErrFetchRestore */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject *tmp_value; + assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value))); + if (value) { + #if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb)) + #endif + PyException_SetTraceback(value, tb); + } + tmp_value = tstate->current_exception; + tstate->current_exception = value; + Py_XDECREF(tmp_value); + Py_XDECREF(type); + Py_XDECREF(tb); +#else + 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); +#endif +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject* exc_value; + exc_value = tstate->current_exception; + tstate->current_exception = 0; + *value = exc_value; + *type = NULL; + *tb = NULL; + if (exc_value) { + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + #if CYTHON_COMPILING_IN_CPYTHON + *tb = ((PyBaseExceptionObject*) exc_value)->traceback; + Py_XINCREF(*tb); + #else + *tb = PyException_GetTraceback(exc_value); + #endif + } +#else + *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 +} +#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)); + return PyObject_GetAttr(obj, attr_name); +} +#endif + +/* PyObjectGetAttrStrNoError */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d0000 +static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + __Pyx_PyErr_Clear(); +} +#endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { + PyObject *result; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + (void) PyObject_GetOptionalAttr(obj, attr_name, &result); + return result; +#else +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { + return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); + } +#endif + result = __Pyx_PyObject_GetAttrStr(obj, attr_name); + if (unlikely(!result)) { + __Pyx_PyObject_GetAttrStr_ClearAttributeError(); + } + return result; +#endif +} + +/* GetBuiltinName */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_mstate_global->__pyx_b, name); + if (unlikely(!result) && !PyErr_Occurred()) { + PyErr_Format(PyExc_NameError, + "name '%U' is not defined", name); + } + return result; +} + +/* TupleAndListFromArray */ +#if !CYTHON_COMPILING_IN_CPYTHON && CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject * +__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + Py_ssize_t i; + if (n <= 0) { + return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_tuple); + } + res = PyTuple_New(n); + if (unlikely(res == NULL)) return NULL; + for (i = 0; i < n; i++) { + if (unlikely(__Pyx_PyTuple_SET_ITEM(res, i, src[i]) < 0)) { + Py_DECREF(res); + return NULL; + } + Py_INCREF(src[i]); + } + return res; +} +#elif CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) { + PyObject *v; + Py_ssize_t i; + for (i = 0; i < length; i++) { + v = dest[i] = src[i]; + Py_INCREF(v); + } +} +static CYTHON_INLINE PyObject * +__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_tuple); + } + res = PyTuple_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n); + return res; +} +static CYTHON_INLINE PyObject * +__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + return PyList_New(0); + } + res = PyList_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n); + return res; +} +#endif + +/* BytesEquals */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL ||\ + !(CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS) + return PyObject_RichCompareBool(s1, s2, equals); +#else + if (s1 == s2) { + return (equals == Py_EQ); + } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { + const char *ps1, *ps2; + Py_ssize_t length = PyBytes_GET_SIZE(s1); + if (length != PyBytes_GET_SIZE(s2)) + return (equals == Py_NE); + ps1 = PyBytes_AS_STRING(s1); + ps2 = PyBytes_AS_STRING(s2); + if (ps1[0] != ps2[0]) { + return (equals == Py_NE); + } else if (length == 1) { + return (equals == Py_EQ); + } else { + int result; +#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000) + Py_hash_t hash1, hash2; + hash1 = ((PyBytesObject*)s1)->ob_shash; + hash2 = ((PyBytesObject*)s2)->ob_shash; + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + return (equals == Py_NE); + } +#endif + result = memcmp(ps1, ps2, (size_t)length); + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { + return (equals == Py_NE); + } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { + return (equals == Py_NE); + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +#endif +} + +/* UnicodeEquals */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL + return PyObject_RichCompareBool(s1, s2, equals); +#else + int s1_is_unicode, s2_is_unicode; + if (s1 == s2) { + goto return_eq; + } + s1_is_unicode = PyUnicode_CheckExact(s1); + s2_is_unicode = PyUnicode_CheckExact(s2); + if (s1_is_unicode & s2_is_unicode) { + Py_ssize_t length, length2; + int kind; + void *data1, *data2; + #if !CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) + return -1; + #endif + length = __Pyx_PyUnicode_GET_LENGTH(s1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(length < 0)) return -1; + #endif + length2 = __Pyx_PyUnicode_GET_LENGTH(s2); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(length2 < 0)) return -1; + #endif + if (length != length2) { + goto return_ne; + } +#if CYTHON_USE_UNICODE_INTERNALS + { + Py_hash_t hash1, hash2; + hash1 = ((PyASCIIObject*)s1)->hash; + hash2 = ((PyASCIIObject*)s2)->hash; + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + goto return_ne; + } + } +#endif + kind = __Pyx_PyUnicode_KIND(s1); + if (kind != __Pyx_PyUnicode_KIND(s2)) { + goto return_ne; + } + data1 = __Pyx_PyUnicode_DATA(s1); + data2 = __Pyx_PyUnicode_DATA(s2); + if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { + goto return_ne; + } else if (length == 1) { + goto return_eq; + } else { + int result = memcmp(data1, data2, (size_t)(length * kind)); + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & s2_is_unicode) { + goto return_ne; + } else if ((s2 == Py_None) & s1_is_unicode) { + goto return_ne; + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +return_eq: + return (equals == Py_EQ); +return_ne: + return (equals == Py_NE); +#endif +} + +/* fastcall */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) +{ + Py_ssize_t i, n = __Pyx_PyTuple_GET_SIZE(kwnames); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(n == -1)) return NULL; + #endif + for (i = 0; i < n; i++) + { + PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!namei)) return NULL; + #endif + if (s == namei) return kwvalues[i]; + } + for (i = 0; i < n; i++) + { + PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!namei)) return NULL; + #endif + int eq = __Pyx_PyUnicode_Equals(s, namei, Py_EQ); + if (unlikely(eq != 0)) { + if (unlikely(eq < 0)) return NULL; + return kwvalues[i]; + } + } + return NULL; +} +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API +CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { + Py_ssize_t i, nkwargs; + PyObject *dict; +#if !CYTHON_ASSUME_SAFE_SIZE + nkwargs = PyTuple_Size(kwnames); + if (unlikely(nkwargs < 0)) return NULL; +#else + nkwargs = PyTuple_GET_SIZE(kwnames); +#endif + dict = PyDict_New(); + if (unlikely(!dict)) + return NULL; + for (i=0; irecursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; + return result; +} +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject *const *args, Py_ssize_t nargs, PyObject *kwargs) { + PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); + PyObject *globals = PyFunction_GET_GLOBALS(func); + PyObject *argdefs = PyFunction_GET_DEFAULTS(func); + PyObject *closure; + PyObject *kwdefs; + 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 (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) { + return NULL; + } + if ( + co->co_kwonlyargcount == 0 && + 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); + kwdefs = PyFunction_GET_KW_DEFAULTS(func); + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); + Py_XDECREF(kwtuple); +done: + Py_LeaveRecursiveCall(); + return result; +} +#endif + +/* PyObjectCall */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = Py_TYPE(func)->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall(" 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 = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); + self = __Pyx_CyOrPyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall(" 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 + +/* PyObjectFastCall */ +#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API +static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject * const*args, size_t nargs, PyObject *kwargs) { + PyObject *argstuple; + PyObject *result = 0; + size_t i; + argstuple = PyTuple_New((Py_ssize_t)nargs); + if (unlikely(!argstuple)) return NULL; + for (i = 0; i < nargs; i++) { + Py_INCREF(args[i]); + if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) != (0)) goto bad; + } + result = __Pyx_PyObject_Call(func, argstuple, kwargs); + bad: + Py_DECREF(argstuple); + return result; +} +#endif +#if CYTHON_VECTORCALL && !CYTHON_COMPILING_IN_LIMITED_API + #if PY_VERSION_HEX < 0x03090000 + #define __Pyx_PyVectorcall_Function(callable) _PyVectorcall_Function(callable) + #elif CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE vectorcallfunc __Pyx_PyVectorcall_Function(PyObject *callable) { + PyTypeObject *tp = Py_TYPE(callable); + #if defined(__Pyx_CyFunction_USED) + if (__Pyx_CyFunction_CheckExact(callable)) { + return __Pyx_CyFunction_func_vectorcall(callable); + } + #endif + if (!PyType_HasFeature(tp, Py_TPFLAGS_HAVE_VECTORCALL)) { + return NULL; + } + assert(PyCallable_Check(callable)); + Py_ssize_t offset = tp->tp_vectorcall_offset; + assert(offset > 0); + vectorcallfunc ptr; + memcpy(&ptr, (char *) callable + offset, sizeof(ptr)); + return ptr; +} + #else + #define __Pyx_PyVectorcall_Function(callable) PyVectorcall_Function(callable) + #endif +#endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject *const *args, size_t _nargs, PyObject *kwargs) { + Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs); +#if CYTHON_COMPILING_IN_CPYTHON + if (nargs == 0 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS)) + return __Pyx_PyObject_CallMethO(func, NULL); + } + else if (nargs == 1 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O)) + return __Pyx_PyObject_CallMethO(func, args[0]); + } +#endif + #if PY_VERSION_HEX < 0x030800B1 + #if CYTHON_FAST_PYCCALL + if (PyCFunction_Check(func)) { + if (kwargs) { + return _PyCFunction_FastCallDict(func, args, nargs, kwargs); + } else { + return _PyCFunction_FastCallKeywords(func, args, nargs, NULL); + } + } + if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) { + return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL); + } + #endif + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs); + } + #endif + #endif + if (kwargs == NULL) { + #if CYTHON_VECTORCALL && !CYTHON_COMPILING_IN_LIMITED_API + vectorcallfunc f = __Pyx_PyVectorcall_Function(func); + if (f) { + return f(func, args, _nargs, NULL); + } + #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL + if (__Pyx_CyFunction_CheckExact(func)) { + __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func); + if (f) return f(func, args, _nargs, NULL); + } + #elif CYTHON_COMPILING_IN_LIMITED_API && CYTHON_VECTORCALL + return PyObject_Vectorcall(func, args, _nargs, NULL); + #endif + } + if (nargs == 0) { + return __Pyx_PyObject_Call(func, __pyx_mstate_global->__pyx_empty_tuple, kwargs); + } + #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API + return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs); + #else + return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs); + #endif +} + +/* UnpackUnboundCMethod */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030C0000 +static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *args, PyObject *kwargs) { + PyObject *result; + PyObject *selfless_args = PyTuple_GetSlice(args, 1, PyTuple_Size(args)); + if (unlikely(!selfless_args)) return NULL; + result = PyObject_Call(method, selfless_args, kwargs); + Py_DECREF(selfless_args); + return result; +} +#elif CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03090000 +static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject **args, Py_ssize_t nargs, PyObject *kwnames) { + return _PyObject_Vectorcall + (method, args ? args+1 : NULL, nargs ? nargs-1 : 0, kwnames); +} +#else +static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) { + return +#if PY_VERSION_HEX < 0x03090000 + _PyObject_Vectorcall +#else + PyObject_Vectorcall +#endif + (method, args ? args+1 : NULL, nargs ? (size_t) nargs-1 : 0, kwnames); +} +#endif +static PyMethodDef __Pyx_UnboundCMethod_Def = { + "CythonUnboundCMethod", + __PYX_REINTERPRET_FUNCION(PyCFunction, __Pyx_SelflessCall), +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030C0000 + METH_VARARGS | METH_KEYWORDS, +#else + METH_FASTCALL | METH_KEYWORDS, +#endif + NULL +}; +static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) { + PyObject *method, *result=NULL; + method = __Pyx_PyObject_GetAttrStr(target->type, *target->method_name); + if (unlikely(!method)) + return -1; + result = method; +#if CYTHON_COMPILING_IN_CPYTHON + if (likely(__Pyx_TypeCheck(method, &PyMethodDescr_Type))) + { + PyMethodDescrObject *descr = (PyMethodDescrObject*) method; + target->func = descr->d_method->ml_meth; + target->flag = descr->d_method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_STACKLESS); + } else +#endif +#if CYTHON_COMPILING_IN_PYPY +#else + if (PyCFunction_Check(method)) +#endif + { + PyObject *self; + int self_found; +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + self = PyObject_GetAttrString(method, "__self__"); + if (!self) { + PyErr_Clear(); + } +#else + self = PyCFunction_GET_SELF(method); +#endif + self_found = (self && self != Py_None); +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + Py_XDECREF(self); +#endif + if (self_found) { + PyObject *unbound_method = PyCFunction_New(&__Pyx_UnboundCMethod_Def, method); + if (unlikely(!unbound_method)) return -1; + Py_DECREF(method); + result = unbound_method; + } + } +#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + if (unlikely(target->method)) { + Py_DECREF(result); + } else +#endif + target->method = result; + return 0; +} + +/* CallUnboundCMethod2 */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2) { + int was_initialized = __Pyx_CachedCFunction_GetAndSetInitializing(cfunc); + if (likely(was_initialized == 2 && cfunc->func)) { + PyObject *args[2] = {arg1, arg2}; + if (cfunc->flag == METH_FASTCALL) { + return __Pyx_CallCFunctionFast(cfunc, self, args, 2); + } + if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS)) + return __Pyx_CallCFunctionFastWithKeywords(cfunc, self, args, 2, NULL); + } +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + else if (unlikely(was_initialized == 1)) { + __Pyx_CachedCFunction tmp_cfunc = { +#ifndef __cplusplus + 0 +#endif + }; + tmp_cfunc.type = cfunc->type; + tmp_cfunc.method_name = cfunc->method_name; + return __Pyx__CallUnboundCMethod2(&tmp_cfunc, self, arg1, arg2); + } +#endif + PyObject *result = __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2); + __Pyx_CachedCFunction_SetFinishedInitializing(cfunc); + return result; +} +#endif +static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2){ + if (unlikely(!cfunc->func && !cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; +#if CYTHON_COMPILING_IN_CPYTHON + if (cfunc->func && (cfunc->flag & METH_VARARGS)) { + PyObject *result = NULL; + PyObject *args = PyTuple_New(2); + if (unlikely(!args)) return NULL; + Py_INCREF(arg1); + PyTuple_SET_ITEM(args, 0, arg1); + Py_INCREF(arg2); + PyTuple_SET_ITEM(args, 1, arg2); + if (cfunc->flag & METH_KEYWORDS) + result = __Pyx_CallCFunctionWithKeywords(cfunc, self, args, NULL); + else + result = __Pyx_CallCFunction(cfunc, self, args); + Py_DECREF(args); + return result; + } +#endif + { + PyObject *args[4] = {NULL, self, arg1, arg2}; + return __Pyx_PyObject_FastCall(cfunc->method, args+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); + } +} + +/* ParseKeywords */ +static int __Pyx_ValidateDuplicatePosArgs( + PyObject *kwds, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + const char* function_name) +{ + PyObject ** const *name = argnames; + while (name != first_kw_arg) { + PyObject *key = **name; + int found = PyDict_Contains(kwds, key); + if (unlikely(found)) { + if (found == 1) __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; + } + name++; + } + return 0; +bad: + return -1; +} +#if CYTHON_USE_UNICODE_INTERNALS +static CYTHON_INLINE int __Pyx_UnicodeKeywordsEqual(PyObject *s1, PyObject *s2) { + int kind; + Py_ssize_t len = PyUnicode_GET_LENGTH(s1); + if (len != PyUnicode_GET_LENGTH(s2)) return 0; + kind = PyUnicode_KIND(s1); + if (kind != PyUnicode_KIND(s2)) return 0; + const void *data1 = PyUnicode_DATA(s1); + const void *data2 = PyUnicode_DATA(s2); + return (memcmp(data1, data2, (size_t) len * (size_t) kind) == 0); +} +#endif +static int __Pyx_MatchKeywordArg_str( + PyObject *key, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + size_t *index_found, + const char *function_name) +{ + PyObject ** const *name; + #if CYTHON_USE_UNICODE_INTERNALS + Py_hash_t key_hash = ((PyASCIIObject*)key)->hash; + if (unlikely(key_hash == -1)) { + key_hash = PyObject_Hash(key); + if (unlikely(key_hash == -1)) + goto bad; + } + #endif + name = first_kw_arg; + while (*name) { + PyObject *name_str = **name; + #if CYTHON_USE_UNICODE_INTERNALS + if (key_hash == ((PyASCIIObject*)name_str)->hash && __Pyx_UnicodeKeywordsEqual(name_str, key)) { + *index_found = (size_t) (name - argnames); + return 1; + } + #else + #if CYTHON_ASSUME_SAFE_SIZE + if (PyUnicode_GET_LENGTH(name_str) == PyUnicode_GET_LENGTH(key)) + #endif + { + int cmp = PyUnicode_Compare(name_str, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + *index_found = (size_t) (name - argnames); + return 1; + } + } + #endif + name++; + } + name = argnames; + while (name != first_kw_arg) { + PyObject *name_str = **name; + #if CYTHON_USE_UNICODE_INTERNALS + if (unlikely(key_hash == ((PyASCIIObject*)name_str)->hash)) { + if (__Pyx_UnicodeKeywordsEqual(name_str, key)) + goto arg_passed_twice; + } + #else + #if CYTHON_ASSUME_SAFE_SIZE + if (PyUnicode_GET_LENGTH(name_str) == PyUnicode_GET_LENGTH(key)) + #endif + { + if (unlikely(name_str == key)) goto arg_passed_twice; + int cmp = PyUnicode_Compare(name_str, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + } + #endif + name++; + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +bad: + return -1; +} +static int __Pyx_MatchKeywordArg_nostr( + PyObject *key, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + size_t *index_found, + const char *function_name) +{ + PyObject ** const *name; + if (unlikely(!PyUnicode_Check(key))) goto invalid_keyword_type; + name = first_kw_arg; + while (*name) { + int cmp = PyObject_RichCompareBool(**name, key, Py_EQ); + if (cmp == 1) { + *index_found = (size_t) (name - argnames); + return 1; + } + if (unlikely(cmp == -1)) goto bad; + name++; + } + name = argnames; + while (name != first_kw_arg) { + int cmp = PyObject_RichCompareBool(**name, key, Py_EQ); + if (unlikely(cmp != 0)) { + if (cmp == 1) goto arg_passed_twice; + else goto bad; + } + name++; + } + 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; +bad: + return -1; +} +static CYTHON_INLINE int __Pyx_MatchKeywordArg( + PyObject *key, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + size_t *index_found, + const char *function_name) +{ + return likely(PyUnicode_CheckExact(key)) ? + __Pyx_MatchKeywordArg_str(key, argnames, first_kw_arg, index_found, function_name) : + __Pyx_MatchKeywordArg_nostr(key, argnames, first_kw_arg, index_found, function_name); +} +static void __Pyx_RejectUnknownKeyword( + PyObject *kwds, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + const char *function_name) +{ + Py_ssize_t pos = 0; + PyObject *key = NULL; + __Pyx_BEGIN_CRITICAL_SECTION(kwds); + while (PyDict_Next(kwds, &pos, &key, NULL)) { + PyObject** const *name = first_kw_arg; + while (*name && (**name != key)) name++; + if (!*name) { + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(key); + #endif + size_t index_found = 0; + int cmp = __Pyx_MatchKeywordArg(key, argnames, first_kw_arg, &index_found, function_name); + if (cmp != 1) { + if (cmp == 0) { + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(key); + #endif + break; + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(key); + #endif + } + } + __Pyx_END_CRITICAL_SECTION(); + assert(PyErr_Occurred()); +} +static int __Pyx_ParseKeywordDict( + PyObject *kwds, + PyObject ** const argnames[], + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs) +{ + PyObject** const *name; + PyObject** const *first_kw_arg = argnames + num_pos_args; + Py_ssize_t extracted = 0; +#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) + if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return -1; +#endif + name = first_kw_arg; + while (*name && num_kwargs > extracted) { + PyObject * key = **name; + PyObject *value; + int found = 0; + #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + found = PyDict_GetItemRef(kwds, key, &value); + #else + value = PyDict_GetItemWithError(kwds, key); + if (value) { + Py_INCREF(value); + found = 1; + } else { + if (unlikely(PyErr_Occurred())) goto bad; + } + #endif + if (found) { + if (unlikely(found < 0)) goto bad; + values[name-argnames] = value; + extracted++; + } + name++; + } + if (num_kwargs > extracted) { + if (ignore_unknown_kwargs) { + if (unlikely(__Pyx_ValidateDuplicatePosArgs(kwds, argnames, first_kw_arg, function_name) == -1)) + goto bad; + } else { + __Pyx_RejectUnknownKeyword(kwds, argnames, first_kw_arg, function_name); + goto bad; + } + } + return 0; +bad: + return -1; +} +static int __Pyx_ParseKeywordDictToDict( + PyObject *kwds, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject** const *name; + PyObject** const *first_kw_arg = argnames + num_pos_args; + Py_ssize_t len; +#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) + if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return -1; +#endif + if (PyDict_Update(kwds2, kwds) < 0) goto bad; + name = first_kw_arg; + while (*name) { + PyObject *key = **name; + PyObject *value; +#if !CYTHON_COMPILING_IN_LIMITED_API && (PY_VERSION_HEX >= 0x030d00A2 || defined(PyDict_Pop)) + int found = PyDict_Pop(kwds2, key, &value); + if (found) { + if (unlikely(found < 0)) goto bad; + values[name-argnames] = value; + } +#elif __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + int found = PyDict_GetItemRef(kwds2, key, &value); + if (found) { + if (unlikely(found < 0)) goto bad; + values[name-argnames] = value; + if (unlikely(PyDict_DelItem(kwds2, key) < 0)) goto bad; + } +#else + #if CYTHON_COMPILING_IN_CPYTHON + value = _PyDict_Pop(kwds2, key, kwds2); + #else + value = __Pyx_CallUnboundCMethod2(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_pop, kwds2, key, kwds2); + #endif + if (value == kwds2) { + Py_DECREF(value); + } else { + if (unlikely(!value)) goto bad; + values[name-argnames] = value; + } +#endif + name++; + } + len = PyDict_Size(kwds2); + if (len > 0) { + return __Pyx_ValidateDuplicatePosArgs(kwds, argnames, first_kw_arg, function_name); + } else if (unlikely(len == -1)) { + goto bad; + } + return 0; +bad: + return -1; +} +static int __Pyx_ParseKeywordsTuple( + PyObject *kwds, + PyObject * const *kwvalues, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs) +{ + PyObject *key = NULL; + PyObject** const * name; + PyObject** const *first_kw_arg = argnames + num_pos_args; + for (Py_ssize_t pos = 0; pos < num_kwargs; pos++) { +#if CYTHON_AVOID_BORROWED_REFS + key = __Pyx_PySequence_ITEM(kwds, pos); +#else + key = __Pyx_PyTuple_GET_ITEM(kwds, pos); +#endif +#if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!key)) goto bad; +#endif + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + PyObject *value = kwvalues[pos]; + values[name-argnames] = __Pyx_NewRef(value); + } else { + size_t index_found = 0; + int cmp = __Pyx_MatchKeywordArg(key, argnames, first_kw_arg, &index_found, function_name); + if (cmp == 1) { + PyObject *value = kwvalues[pos]; + values[index_found] = __Pyx_NewRef(value); + } else { + if (unlikely(cmp == -1)) goto bad; + if (kwds2) { + PyObject *value = kwvalues[pos]; + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else if (!ignore_unknown_kwargs) { + goto invalid_keyword; + } + } + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(key); + key = NULL; + #endif + } + return 0; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + goto bad; +bad: + #if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(key); + #endif + return -1; +} +static int __Pyx_ParseKeywords( + PyObject *kwds, + PyObject * const *kwvalues, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs) +{ + if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds))) + return __Pyx_ParseKeywordsTuple(kwds, kwvalues, argnames, kwds2, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs); + else if (kwds2) + return __Pyx_ParseKeywordDictToDict(kwds, argnames, kwds2, values, num_pos_args, function_name); + else + return __Pyx_ParseKeywordDict(kwds, argnames, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs); +} + +/* 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); +} + +/* Profile */ +#if CYTHON_PROFILE || CYTHON_TRACE +#if CYTHON_TRACE && !CYTHON_USE_SYS_MONITORING +static int __Pyx_call_line_trace_func(PyThreadState *tstate, PyFrameObject *frame, int line) { + int ret; + PyObject *type, *value, *traceback; + __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); + __Pyx_PyFrame_SetLineNumber(frame, line); + __Pyx_EnterTracing(tstate); + ret = tstate->c_tracefunc(tstate->c_traceobj, frame, PyTrace_LINE, NULL); + __Pyx_LeaveTracing(tstate); + if (likely(!ret)) { + __Pyx_ErrRestoreInState(tstate, type, value, traceback); + } else { + Py_XDECREF(type); + Py_XDECREF(value); + Py_XDECREF(traceback); + } + return ret; +} +#endif +CYTHON_UNUSED static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno) { + PyCodeObject *py_code = PyCode_NewEmpty(srcfile, funcname, firstlineno); + if (likely(py_code)) { + py_code->co_flags |= CO_OPTIMIZED | CO_NEWLOCALS; + } + return py_code; +} +#if CYTHON_USE_SYS_MONITORING +CYTHON_UNUSED static int __Pyx__TraceStartFunc(PyMonitoringState *state_array, PyObject *code_obj, int offset, int skip_event) { + int ret; + __pyx_monitoring_version_type version = 0; + ret = PyMonitoring_EnterScope(state_array, &version, __Pyx_MonitoringEventTypes, __Pyx_MonitoringEventTypes_CyFunc_count); + if (unlikely(ret == -1)) return -1; + return skip_event ? 0 : PyMonitoring_FirePyStartEvent(&state_array[__Pyx_Monitoring_PY_START], code_obj, offset); +} +CYTHON_UNUSED static int __Pyx__TraceStartGen(PyMonitoringState *state_array, __pyx_monitoring_version_type *version, PyObject *code_obj, int offset) { + int ret; + ret = PyMonitoring_EnterScope(state_array, version, __Pyx_MonitoringEventTypes, __Pyx_MonitoringEventTypes_CyGen_count); + if (unlikely(ret == -1)) return -1; + return PyMonitoring_FirePyStartEvent(&state_array[__Pyx_Monitoring_PY_START], code_obj, offset); +} +CYTHON_UNUSED static int __Pyx__TraceResumeGen(PyMonitoringState *state_array, __pyx_monitoring_version_type *version, PyObject *code_obj, int offset) { + int ret; + ret = PyMonitoring_EnterScope(state_array, version, __Pyx_MonitoringEventTypes, __Pyx_MonitoringEventTypes_CyGen_count); + if (unlikely(ret == -1)) return -1; + return PyMonitoring_FirePyResumeEvent(&state_array[__Pyx_Monitoring_PY_RESUME], code_obj, offset); +} +CYTHON_UNUSED static void __Pyx__TraceException(PyMonitoringState *monitoring_state, PyObject *code_obj, int offset, int reraised) { + if (reraised) { + (void) PyMonitoring_FireReraiseEvent(monitoring_state, code_obj, offset); + } else { + (void) PyMonitoring_FireRaiseEvent(monitoring_state, code_obj, offset); + } +} +#if CYTHON_TRACE +CYTHON_UNUSED static int __Pyx__TraceLine(PyMonitoringState *monitoring_state, PyObject *code_obj, int line, int offset) { + int ret; + PyObject *exc = PyErr_GetRaisedException(); + ret = PyMonitoring_FireLineEvent(monitoring_state, code_obj, offset, line); + if (exc) PyErr_SetRaisedException(exc); + return ret; +} +#endif +#else +static int __Pyx_TraceSetupAndCall(PyCodeObject** code, + PyFrameObject** frame, + PyThreadState* tstate, + const char *funcname, + const char *srcfile, + int firstlineno, + int skip_event) { + if (*frame == NULL || !CYTHON_PROFILE_REUSE_FRAME) { + int needs_new_code_obj = (*code == NULL); + if (needs_new_code_obj) { + *code = __Pyx_createFrameCodeObject(funcname, srcfile, firstlineno); + if (*code == NULL) return 0; + } + *frame = PyFrame_New( + tstate, /*PyThreadState *tstate*/ + *code, /*PyCodeObject *code*/ + __pyx_mstate_global->__pyx_d, /*PyObject *globals*/ + 0 /*PyObject *locals*/ + ); + if (needs_new_code_obj && !CYTHON_PROFILE_REUSE_CODEOBJ) + Py_CLEAR(*code); // otherwise the reference is owned externally + if (*frame == NULL) return 0; + if (CYTHON_TRACE && (*frame)->f_trace == NULL) { + Py_INCREF(Py_None); + (*frame)->f_trace = Py_None; + } + } + if (!skip_event) { + PyObject *type, *value, *traceback; + int retval = 1; + __Pyx_PyFrame_SetLineNumber(*frame, firstlineno); + __Pyx_EnterTracing(tstate); + __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); + #if CYTHON_TRACE + if (tstate->c_tracefunc) + retval = tstate->c_tracefunc(tstate->c_traceobj, *frame, PyTrace_CALL, NULL) == 0; + if (retval && tstate->c_profilefunc) + #endif + retval = tstate->c_profilefunc(tstate->c_profileobj, *frame, PyTrace_CALL, NULL) == 0; + __Pyx_LeaveTracing(tstate); + if (unlikely(!retval)) { + Py_XDECREF(type); + Py_XDECREF(value); + Py_XDECREF(traceback); + return -1; + } + __Pyx_ErrRestoreInState(tstate, type, value, traceback); + } + return __Pyx_IsTracing(tstate, 0, 0); +} +#endif +#endif + +/* PyObjectFormatAndDecref */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f) { + if (unlikely(!s)) return NULL; + if (likely(PyUnicode_CheckExact(s))) return s; + return __Pyx_PyObject_FormatAndDecref(s, f); +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f) { + PyObject *result; + if (unlikely(!s)) return NULL; + result = PyObject_Format(s, f); + Py_DECREF(s); + return result; +} + +/* JoinPyUnicode */ +static PyObject* __Pyx_PyUnicode_Join(PyObject** values, Py_ssize_t value_count, Py_ssize_t result_ulength, + Py_UCS4 max_char) { +#if CYTHON_USE_UNICODE_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + PyObject *result_uval; + int result_ukind, kind_shift; + Py_ssize_t i, char_pos; + void *result_udata; + if (max_char > 1114111) max_char = 1114111; + result_uval = PyUnicode_New(result_ulength, max_char); + if (unlikely(!result_uval)) return NULL; + result_ukind = (max_char <= 255) ? PyUnicode_1BYTE_KIND : (max_char <= 65535) ? PyUnicode_2BYTE_KIND : PyUnicode_4BYTE_KIND; + kind_shift = (result_ukind == PyUnicode_4BYTE_KIND) ? 2 : result_ukind - 1; + result_udata = PyUnicode_DATA(result_uval); + assert(kind_shift == 2 || kind_shift == 1 || kind_shift == 0); + if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - result_ulength < 0)) + goto overflow; + char_pos = 0; + for (i=0; i < value_count; i++) { + int ukind; + Py_ssize_t ulength; + void *udata; + PyObject *uval = values[i]; + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_PyUnicode_READY(uval) == (-1)) + goto bad; + #endif + ulength = __Pyx_PyUnicode_GET_LENGTH(uval); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(ulength < 0)) goto bad; + #endif + if (unlikely(!ulength)) + continue; + if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - ulength < char_pos)) + goto overflow; + ukind = __Pyx_PyUnicode_KIND(uval); + udata = __Pyx_PyUnicode_DATA(uval); + if (ukind == result_ukind) { + memcpy((char *)result_udata + (char_pos << kind_shift), udata, (size_t) (ulength << kind_shift)); + } else { + #if PY_VERSION_HEX >= 0x030d0000 + if (unlikely(PyUnicode_CopyCharacters(result_uval, char_pos, uval, 0, ulength) < 0)) goto bad; + #elif CYTHON_COMPILING_IN_CPYTHON || defined(_PyUnicode_FastCopyCharacters) + _PyUnicode_FastCopyCharacters(result_uval, char_pos, uval, 0, ulength); + #else + Py_ssize_t j; + for (j=0; j < ulength; j++) { + Py_UCS4 uchar = __Pyx_PyUnicode_READ(ukind, udata, j); + __Pyx_PyUnicode_WRITE(result_ukind, result_udata, char_pos+j, uchar); + } + #endif + } + char_pos += ulength; + } + return result_uval; +overflow: + PyErr_SetString(PyExc_OverflowError, "join() result is too long for a Python string"); +bad: + Py_DECREF(result_uval); + return NULL; +#else + Py_ssize_t i; + PyObject *result = NULL; + PyObject *value_tuple = PyTuple_New(value_count); + if (unlikely(!value_tuple)) return NULL; + CYTHON_UNUSED_VAR(max_char); + CYTHON_UNUSED_VAR(result_ulength); + for (i=0; i__pyx_empty_unicode, value_tuple); +bad: + Py_DECREF(value_tuple); + return result; +#endif +} + +/* RejectKeywords */ +static void __Pyx_RejectKeywords(const char* function_name, PyObject *kwds) { + PyObject *key = NULL; + if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds))) { + key = __Pyx_PySequence_ITEM(kwds, 0); + } else { + Py_ssize_t pos = 0; +#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) + if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return; +#endif + PyDict_Next(kwds, &pos, &key, NULL); + Py_INCREF(key); + } + if (likely(key)) { + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + Py_DECREF(key); + } +} + +/* GetItemInt */ +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { + PyObject *r; + if (unlikely(!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_ASSUME_SAFE_SIZE && !CYTHON_AVOID_BORROWED_REFS && !CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyList_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { + PyObject *r = PyList_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyLong_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_ASSUME_SAFE_SIZE && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyTuple_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyLong_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_ASSUME_SAFE_SIZE && !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(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { + return __Pyx_PyList_GetItemRef(o, n); + } + } + else if (PyTuple_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } else { + PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping; + PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence; + if (mm && mm->mp_subscript) { + PyObject *r, *key = PyLong_FromSsize_t(i); + if (unlikely(!key)) return NULL; + r = mm->mp_subscript(o, key); + Py_DECREF(key); + return r; + } + if (likely(sm && sm->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) { + Py_ssize_t l = sm->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return NULL; + PyErr_Clear(); + } + } + return sm->sq_item(o, i); + } + } +#else + if (is_list || !PyMapping_Check(o)) { + return PySequence_GetItem(o, i); + } +#endif + return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i)); +} + +/* PyDictVersioning */ +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { + PyObject **dictptr = NULL; + Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; + if (offset) { +#if CYTHON_COMPILING_IN_CPYTHON + dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); +#else + dictptr = _PyObject_GetDictPtr(obj); +#endif + } + return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; +} +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) + return 0; + return obj_dict_version == __Pyx_get_object_dict_version(obj); +} #endif - return PyObject_GetAttr(obj, attr_name); + +/* GetModuleGlobalName */ +#if CYTHON_USE_DICT_VERSIONS +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) +#else +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) +#endif +{ + PyObject *result; +#if CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(!__pyx_m)) { + if (!PyErr_Occurred()) + PyErr_SetNone(PyExc_NameError); + return NULL; + } + result = PyObject_GetAttr(__pyx_m, name); + if (likely(result)) { + return result; + } + PyErr_Clear(); +#elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + if (unlikely(__Pyx_PyDict_GetItemRef(__pyx_mstate_global->__pyx_d, name, &result) == -1)) PyErr_Clear(); + __PYX_UPDATE_DICT_CACHE(__pyx_mstate_global->__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return result; + } +#else + result = _PyDict_GetItem_KnownHash(__pyx_mstate_global->__pyx_d, name, ((PyASCIIObject *) name)->hash); + __PYX_UPDATE_DICT_CACHE(__pyx_mstate_global->__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } + PyErr_Clear(); +#endif + return __Pyx_GetBuiltinName(name); +} + +/* PyObjectFastCallMethod */ +#if !CYTHON_VECTORCALL || PY_VERSION_HEX < 0x03090000 +static PyObject *__Pyx_PyObject_FastCallMethod(PyObject *name, PyObject *const *args, size_t nargsf) { + PyObject *result; + PyObject *attr = PyObject_GetAttr(args[0], name); + if (unlikely(!attr)) + return NULL; + result = __Pyx_PyObject_FastCall(attr, args+1, nargsf - 1); + Py_DECREF(attr); + return result; } #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); +/* IterFinish */ +static CYTHON_INLINE int __Pyx_IterFinish(void) { + PyObject* exc_type; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + exc_type = __Pyx_PyErr_CurrentExceptionType(); + if (unlikely(exc_type)) { + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) + return -1; + __Pyx_PyErr_Clear(); + return 0; + } + return 0; +} + +/* PyObjectCallNoArg */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { + PyObject *arg[2] = {NULL, NULL}; + return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} + +/* PyObjectCallOneArg */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *args[2] = {NULL, arg}; + return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} + +/* PyObjectGetMethod */ +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { + PyObject *attr; +#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP + __Pyx_TypeName type_name; + PyTypeObject *tp = Py_TYPE(obj); + PyObject *descr; + descrgetfunc f = NULL; + PyObject **dictptr, *dict; + int meth_found = 0; + assert (*method == NULL); + if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) { + attr = __Pyx_PyObject_GetAttrStr(obj, name); + goto try_unpack; + } + if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) { + return 0; + } + descr = _PyType_Lookup(tp, name); + if (likely(descr != NULL)) { + Py_INCREF(descr); +#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR + if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)) +#else + #ifdef __Pyx_CyFunction_USED + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) + #else + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type))) + #endif +#endif + { + meth_found = 1; + } else { + f = Py_TYPE(descr)->tp_descr_get; + if (f != NULL && PyDescr_IsData(descr)) { + attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); + Py_DECREF(descr); + goto try_unpack; + } + } + } + dictptr = _PyObject_GetDictPtr(obj); + if (dictptr != NULL && (dict = *dictptr) != NULL) { + Py_INCREF(dict); + attr = __Pyx_PyDict_GetItemStr(dict, name); + if (attr != NULL) { + Py_INCREF(attr); + Py_DECREF(dict); + Py_XDECREF(descr); + goto try_unpack; + } + Py_DECREF(dict); + } + if (meth_found) { + *method = descr; + return 1; + } + if (f != NULL) { + attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); + Py_DECREF(descr); + goto try_unpack; + } + if (likely(descr != NULL)) { + *method = descr; + return 0; + } + type_name = __Pyx_PyType_GetFullyQualifiedName(tp); + PyErr_Format(PyExc_AttributeError, + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, name); + __Pyx_DECREF_TypeName(type_name); + return 0; +#else + attr = __Pyx_PyObject_GetAttrStr(obj, name); + goto try_unpack; +#endif +try_unpack: +#if CYTHON_UNPACK_METHODS + if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) { + PyObject *function = PyMethod_GET_FUNCTION(attr); + Py_INCREF(function); + Py_DECREF(attr); + *method = function; + return 1; + } +#endif + *method = attr; + return 0; +} + +/* PyObjectCallMethod0 */ +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { +#if CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000)) + PyObject *args[1] = {obj}; + (void) __Pyx_PyObject_GetMethod; + (void) __Pyx_PyObject_CallOneArg; + (void) __Pyx_PyObject_CallNoArg; + return PyObject_VectorcallMethod(method_name, args, 1 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); +#else + PyObject *method = NULL, *result = NULL; + int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); + if (likely(is_method)) { + result = __Pyx_PyObject_CallOneArg(method, obj); + Py_DECREF(method); + return result; + } + if (unlikely(!method)) goto bad; + result = __Pyx_PyObject_CallNoArg(method); + Py_DECREF(method); +bad: + return result; +#endif +} + +/* 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; + } + return __Pyx_IterFinish(); +} + +/* 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 { + Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(t); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(size < 0)) return; + #endif + if (size < index) { + __Pyx_RaiseNeedMoreValuesError(size); + } else { + __Pyx_RaiseTooManyValuesError(index); + } + } +} + +/* UnpackTuple2 */ +static CYTHON_INLINE int __Pyx_unpack_tuple2( + PyObject* tuple, PyObject** value1, PyObject** value2, int is_tuple, int has_known_size, int decref_tuple) { + if (likely(is_tuple || PyTuple_Check(tuple))) { + Py_ssize_t size; + if (has_known_size) { + return __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple); + } + size = __Pyx_PyTuple_GET_SIZE(tuple); + if (likely(size == 2)) { + return __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple); + } + if (size >= 0) { + __Pyx_UnpackTupleError(tuple, 2); + } + return -1; + } else { + return __Pyx_unpack_tuple2_generic(tuple, value1, value2, has_known_size, decref_tuple); + } +} +static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( + PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int decref_tuple) { + PyObject *value1 = NULL, *value2 = NULL; +#if CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS + value1 = __Pyx_PySequence_ITEM(tuple, 0); if (unlikely(!value1)) goto bad; + value2 = __Pyx_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_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS +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 = __Pyx_PyObject_GetIterNextFunc(iter); + 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 */ +#if CYTHON_COMPILING_IN_PYPY +#include +#endif +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; #else - "name '%.200s' is not defined", PyString_AS_STRING(name)); + 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 } - return result; + *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); } - -/* 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 !CYTHON_COMPILING_IN_PYPY +static CYTHON_INLINE int __Pyx_dict_iter_next_source_is_dict( + PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos, + PyObject** pkey, PyObject** pvalue, PyObject** pitem) { + PyObject *key, *value; + if (unlikely(orig_length != PyDict_Size(iter_obj))) { + PyErr_SetString(PyExc_RuntimeError, "dictionary changed size during iteration"); + return -1; } - if (exact) { - more_or_less = "exactly"; + if (unlikely(!PyDict_Next(iter_obj, ppos, &key, &value))) { + return 0; } - 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); + if (pitem) { + PyObject* tuple = PyTuple_New(2); + if (unlikely(!tuple)) { + return -1; + } + Py_INCREF(key); + Py_INCREF(value); + #if CYTHON_ASSUME_SAFE_MACROS + PyTuple_SET_ITEM(tuple, 0, key); + PyTuple_SET_ITEM(tuple, 1, value); #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; + if (unlikely(PyTuple_SetItem(tuple, 0, key) < 0)) { + Py_DECREF(value); + Py_DECREF(tuple); + return -1; + } + if (unlikely(PyTuple_SetItem(tuple, 1, value) < 0)) { + Py_DECREF(tuple); + return -1; } - 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; + *pitem = tuple; + } else { + if (pkey) { + Py_INCREF(key); + *pkey = key; + } + if (pvalue) { + Py_INCREF(value); + *pvalue = value; } } - 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; + return 1; } - -/* ArgTypeTest */ -static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) -{ - if (unlikely(!type)) { - PyErr_SetString(PyExc_SystemError, "Missing type object"); - return 0; - } - else if (exact) { - #if PY_MAJOR_VERSION == 2 - if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; +#endif +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) { + int result; +#if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_BEGIN_CRITICAL_SECTION(iter_obj); +#endif + result = __Pyx_dict_iter_next_source_is_dict(iter_obj, orig_length, ppos, pkey, pvalue, pitem); +#if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_END_CRITICAL_SECTION(); +#endif + return result; + } else if (PyTuple_CheckExact(iter_obj)) { + Py_ssize_t pos = *ppos; + Py_ssize_t tuple_size = __Pyx_PyTuple_GET_SIZE(iter_obj); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(tuple_size < 0)) return -1; + #endif + if (unlikely(pos >= tuple_size)) return 0; + *ppos = pos + 1; + #if CYTHON_ASSUME_SAFE_MACROS + next_item = PyTuple_GET_ITEM(iter_obj, pos); + #else + next_item = PyTuple_GetItem(iter_obj, pos); + if (unlikely(!next_item)) return -1; + #endif + Py_INCREF(next_item); + } else if (PyList_CheckExact(iter_obj)) { + Py_ssize_t pos = *ppos; + Py_ssize_t list_size = __Pyx_PyList_GET_SIZE(iter_obj); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(list_size < 0)) return -1; + #endif + if (unlikely(pos >= list_size)) return 0; + *ppos = pos + 1; + #if CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + next_item = PyList_GetItemRef(iter_obj, pos); + if (unlikely(!next_item)) return -1; + #elif CYTHON_ASSUME_SAFE_MACROS + next_item = PyList_GET_ITEM(iter_obj, pos); + Py_INCREF(next_item); + #else + next_item = PyList_GetItem(iter_obj, pos); + if (unlikely(!next_item)) return -1; + Py_INCREF(next_item); #endif + } else +#endif + { + next_item = PyIter_Next(iter_obj); + if (unlikely(!next_item)) { + return __Pyx_IterFinish(); + } } - else { - if (likely(__Pyx_TypeCheck(obj, type))) return 1; + 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; } - PyErr_Format(PyExc_TypeError, - "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", - name, type->tp_name, Py_TYPE(obj)->tp_name); - return 0; + return 1; } -/* 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; -} +/* SliceObject */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj, + Py_ssize_t cstart, Py_ssize_t cstop, + PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice, + int has_cstart, int has_cstop, CYTHON_UNUSED int wraparound) { + __Pyx_TypeName obj_type_name; +#if CYTHON_USE_TYPE_SLOTS + PyMappingMethods* mp = Py_TYPE(obj)->tp_as_mapping; + if (likely(mp && mp->mp_subscript)) #endif - -/* Profile */ -#if CYTHON_PROFILE -static int __Pyx_TraceSetupAndCall(PyCodeObject** code, - PyFrameObject** frame, - PyThreadState* tstate, - const char *funcname, - const char *srcfile, - int firstlineno) { - PyObject *type, *value, *traceback; - int retval; - if (*frame == NULL || !CYTHON_PROFILE_REUSE_FRAME) { - if (*code == NULL) { - *code = __Pyx_createFrameCodeObject(funcname, srcfile, firstlineno); - if (*code == NULL) return 0; - } - *frame = PyFrame_New( - tstate, /*PyThreadState *tstate*/ - *code, /*PyCodeObject *code*/ - __pyx_d, /*PyObject *globals*/ - 0 /*PyObject *locals*/ - ); - if (*frame == NULL) return 0; - if (CYTHON_TRACE && (*frame)->f_trace == NULL) { - Py_INCREF(Py_None); - (*frame)->f_trace = Py_None; + { + PyObject* result; + PyObject *py_slice, *py_start, *py_stop; + if (_py_slice) { + py_slice = *_py_slice; + } else { + PyObject* owned_start = NULL; + PyObject* owned_stop = NULL; + if (_py_start) { + py_start = *_py_start; + } else { + if (has_cstart) { + owned_start = py_start = PyLong_FromSsize_t(cstart); + if (unlikely(!py_start)) goto bad; + } else + py_start = Py_None; + } + if (_py_stop) { + py_stop = *_py_stop; + } else { + if (has_cstop) { + owned_stop = py_stop = PyLong_FromSsize_t(cstop); + if (unlikely(!py_stop)) { + Py_XDECREF(owned_start); + goto bad; + } + } else + py_stop = Py_None; + } + py_slice = PySlice_New(py_start, py_stop, Py_None); + Py_XDECREF(owned_start); + Py_XDECREF(owned_stop); + if (unlikely(!py_slice)) goto bad; } -#if PY_VERSION_HEX < 0x030400B1 - } else { - (*frame)->f_tstate = tstate; +#if CYTHON_USE_TYPE_SLOTS + result = mp->mp_subscript(obj, py_slice); +#else + result = PyObject_GetItem(obj, py_slice); #endif + if (!_py_slice) { + Py_DECREF(py_slice); + } + return result; } - __Pyx_PyFrame_SetLineNumber(*frame, firstlineno); - retval = 1; - tstate->tracing++; - tstate->use_tracing = 0; - __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); - #if CYTHON_TRACE - if (tstate->c_tracefunc) - retval = tstate->c_tracefunc(tstate->c_traceobj, *frame, PyTrace_CALL, NULL) == 0; - if (retval && tstate->c_profilefunc) - #endif - retval = tstate->c_profilefunc(tstate->c_profileobj, *frame, PyTrace_CALL, NULL) == 0; - tstate->use_tracing = (tstate->c_profilefunc || - (CYTHON_TRACE && tstate->c_tracefunc)); - tstate->tracing--; - if (retval) { - __Pyx_ErrRestoreInState(tstate, type, value, traceback); - return tstate->use_tracing && retval; - } else { - Py_XDECREF(type); - Py_XDECREF(value); - Py_XDECREF(traceback); - return -1; - } -} -static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno) { - PyCodeObject *py_code = 0; -#if PY_MAJOR_VERSION >= 3 - py_code = PyCode_NewEmpty(srcfile, funcname, firstlineno); - if (likely(py_code)) { - py_code->co_flags |= CO_OPTIMIZED | CO_NEWLOCALS; - } -#else - PyObject *py_srcfile = 0; - PyObject *py_funcname = 0; - py_funcname = PyString_FromString(funcname); - if (unlikely(!py_funcname)) goto bad; - py_srcfile = PyString_FromString(srcfile); - if (unlikely(!py_srcfile)) goto bad; - py_code = PyCode_New( - 0, - 0, - 0, - CO_OPTIMIZED | CO_NEWLOCALS, - __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,*/ - firstlineno, - __pyx_empty_bytes /*PyObject *lnotab*/ - ); + obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, + "'" __Pyx_FMT_TYPENAME "' object is unsliceable", obj_type_name); + __Pyx_DECREF_TypeName(obj_type_name); bad: - Py_XDECREF(py_srcfile); - Py_XDECREF(py_funcname); -#endif - return py_code; + return NULL; } -#endif -/* 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; - } +/* ExtTypeTest */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + __Pyx_TypeName obj_type_name; + __Pyx_TypeName type_name; + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; } + if (likely(__Pyx_TypeCheck(obj, type))) + return 1; + obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); + type_name = __Pyx_PyType_GetFullyQualifiedName(type); + PyErr_Format(PyExc_TypeError, + "Cannot convert " __Pyx_FMT_TYPENAME " to " __Pyx_FMT_TYPENAME, + obj_type_name, type_name); + __Pyx_DECREF_TypeName(obj_type_name); + __Pyx_DECREF_TypeName(type_name); return 0; +} + +/* IterNextPlain */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 +static PyObject *__Pyx_GetBuiltinNext_LimitedAPI(void) { + if (unlikely(!__pyx_mstate_global->__Pyx_GetBuiltinNext_LimitedAPI_cache)) + __pyx_mstate_global->__Pyx_GetBuiltinNext_LimitedAPI_cache = __Pyx_GetBuiltinName(__pyx_mstate_global->__pyx_n_u_next); + return __pyx_mstate_global->__Pyx_GetBuiltinNext_LimitedAPI_cache; +} +#endif +static CYTHON_INLINE PyObject *__Pyx_PyIter_Next_Plain(PyObject *iterator) { +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + PyObject *result; + PyObject *next = __Pyx_GetBuiltinNext_LimitedAPI(); + if (unlikely(!next)) return NULL; + result = PyObject_CallFunctionObjArgs(next, iterator, NULL); + return result; #else - if (unlikely(PyErr_Occurred())) { - if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { - PyErr_Clear(); - return 0; - } else { - return -1; - } - } - return 0; + (void)__Pyx_GetBuiltinName; // only for early limited API + iternextfunc iternext = __Pyx_PyObject_GetIterNextFunc(iterator); + assert(iternext); + return iternext(iterator); #endif } -/* PyFunctionFastCall */ -#if CYTHON_FAST_PYCALL -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; +/* IterNext */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x03080000 +static PyObject *__Pyx_PyIter_Next2(PyObject *o, PyObject *defval) { 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 = __Pyx_PyFrame_GetLocalsplus(f); - 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; + PyObject *next = __Pyx_GetBuiltinNext_LimitedAPI(); + if (unlikely(!next)) return NULL; + result = PyObject_CallFunctionObjArgs(next, o, defval, NULL); return result; } -#if 1 || PY_VERSION_HEX < 0x030600B1 -static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t 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 +static PyObject *__Pyx_PyIter_Next2Default(PyObject* defval) { + PyObject* exc_type; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + exc_type = __Pyx_PyErr_CurrentExceptionType(); + if (unlikely(exc_type)) { + if (!defval || unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) + return NULL; + __Pyx_PyErr_Clear(); + Py_INCREF(defval); + return defval; } - else { - kwtuple = NULL; - k = NULL; + if (defval) { + Py_INCREF(defval); + return defval; } - closure = PyFunction_GET_CLOSURE(func); -#if PY_MAJOR_VERSION >= 3 - kwdefs = PyFunction_GET_KW_DEFAULTS(func); + __Pyx_PyErr_SetNone(PyExc_StopIteration); + return NULL; +} +static void __Pyx_PyIter_Next_ErrorNoIterator(PyObject *iterator) { + __Pyx_TypeName iterator_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(iterator)); + PyErr_Format(PyExc_TypeError, + __Pyx_FMT_TYPENAME " object is not an iterator", iterator_type_name); + __Pyx_DECREF_TypeName(iterator_type_name); +} +static CYTHON_INLINE PyObject *__Pyx_PyIter_Next2(PyObject* iterator, PyObject* defval) { + PyObject* next; +#if !CYTHON_COMPILING_IN_LIMITED_API + iternextfunc iternext = __Pyx_PyObject_TryGetSlot(iterator, tp_iternext, iternextfunc); + if (likely(iternext)) { + next = iternext(iterator); + if (likely(next)) + return next; + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 + if (unlikely(iternext == &_PyObject_NextNotImplemented)) + return NULL; + #endif + } else if (CYTHON_USE_TYPE_SLOTS) { + __Pyx_PyIter_Next_ErrorNoIterator(iterator); + return NULL; + } else #endif - if (argdefs != NULL) { - d = &PyTuple_GET_ITEM(argdefs, 0); - nd = Py_SIZE(argdefs); - } - else { - d = NULL; - nd = 0; + if (unlikely(!PyIter_Check(iterator))) { + __Pyx_PyIter_Next_ErrorNoIterator(iterator); + return NULL; + } else { + next = defval ? PyIter_Next(iterator) : __Pyx_PyIter_Next_Plain(iterator); + if (likely(next)) + return next; } -#if PY_MAJOR_VERSION >= 3 - result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, kwdefs, closure); -#else - result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, closure); -#endif - Py_XDECREF(kwtuple); -done: - Py_LeaveRecursiveCall(); - return result; + return __Pyx_PyIter_Next2Default(defval); } #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"); +/* PyLongBinop */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_Fallback___Pyx_PyLong_SubtractObjC(PyObject *op1, PyObject *op2, int inplace) { + return (inplace ? PyNumber_InPlaceSubtract : PyNumber_Subtract)(op1, op2); +} +#if CYTHON_USE_PYLONG_INTERNALS +static PyObject* __Pyx_Unpacked___Pyx_PyLong_SubtractObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) { + CYTHON_MAYBE_UNUSED_VAR(inplace); + CYTHON_UNUSED_VAR(zerodivision_check); + const long b = intval; + long a, x; +#ifdef HAVE_LONG_LONG + const PY_LONG_LONG llb = intval; + PY_LONG_LONG lla, llx; +#endif + if (unlikely(__Pyx_PyLong_IsZero(op1))) { + return PyLong_FromLong(-intval); + } + if (likely(__Pyx_PyLong_IsCompact(op1))) { + a = __Pyx_PyLong_CompactValue(op1); + } else { + const digit* digits = __Pyx_PyLong_Digits(op1); + const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(op1); + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + #ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + #endif + } + CYTHON_FALLTHROUGH; + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + #ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + #endif + } + CYTHON_FALLTHROUGH; + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + #ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + #endif + } + CYTHON_FALLTHROUGH; + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + #ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + #endif + } + CYTHON_FALLTHROUGH; + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + #ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + #endif + } + CYTHON_FALLTHROUGH; + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + #ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + #endif + } + CYTHON_FALLTHROUGH; + default: return PyLong_Type.tp_as_number->nb_subtract(op1, op2); + } } - return result; + x = a - b; + return PyLong_FromLong(x); +#ifdef HAVE_LONG_LONG + long_long: + llx = lla - llb; + return PyLong_FromLongLong(llx); +#endif + return __Pyx_Fallback___Pyx_PyLong_SubtractObjC(op1, op2, inplace); + + } #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"); +static PyObject* __Pyx_Float___Pyx_PyLong_SubtractObjC(PyObject *float_val, long intval, int zerodivision_check) { + CYTHON_UNUSED_VAR(zerodivision_check); + const long b = intval; + double a = __Pyx_PyFloat_AS_DOUBLE(float_val); + double result; + + result = ((double)a) - (double)b; + return PyFloat_FromDouble(result); +} +static CYTHON_INLINE PyObject* __Pyx_PyLong_SubtractObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) { + CYTHON_MAYBE_UNUSED_VAR(intval); + CYTHON_UNUSED_VAR(zerodivision_check); + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op1))) { + return __Pyx_Unpacked___Pyx_PyLong_SubtractObjC(op1, op2, intval, inplace, zerodivision_check); } - return result; + #endif + if (PyFloat_CheckExact(op1)) { + return __Pyx_Float___Pyx_PyLong_SubtractObjC(op1, intval, zerodivision_check); + } + return __Pyx_Fallback___Pyx_PyLong_SubtractObjC(op1, op2, inplace); } #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_CyFunction_Check(func))) -#else - if (likely(PyCFunction_Check(func))) -#endif +/* GetTopmostException */ +#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE +static _PyErr_StackItem * +__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) +{ + _PyErr_StackItem *exc_info = tstate->exc_info; + while ((exc_info->exc_value == NULL || exc_info->exc_value == Py_None) && + exc_info->previous_item != NULL) { - if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { - return __Pyx_PyObject_CallMethO(func, NULL); - } + exc_info = exc_info->previous_item; } - return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); + return exc_info; } #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 | METH_STACKLESS))); - 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)(void*)meth)) (self, args, nargs, NULL); +/* SaveResetException */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + PyObject *exc_value = exc_info->exc_value; + if (exc_value == NULL || exc_value == Py_None) { + *value = NULL; + *type = NULL; + *tb = NULL; } else { - return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); + *value = exc_value; + Py_INCREF(*value); + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + *tb = PyException_GetTraceback(exc_value); } + #elif CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + *type = exc_info->exc_type; + *value = exc_info->exc_value; + *tb = exc_info->exc_traceback; + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); + #else + *type = tstate->exc_type; + *value = tstate->exc_value; + *tb = tstate->exc_traceback; + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); + #endif +} +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = tstate->exc_info; + PyObject *tmp_value = exc_info->exc_value; + exc_info->exc_value = value; + Py_XDECREF(tmp_value); + Py_XDECREF(type); + Py_XDECREF(tb); + #else + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = type; + exc_info->exc_value = value; + exc_info->exc_traceback = tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = type; + tstate->exc_value = value; + tstate->exc_traceback = tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); + #endif } #endif -/* PyObjectCallOneArg */ +/* FastTypeChecks */ #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); +static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { + while (a) { + a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*); + if (a == b) + return 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 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__PyObject_CallOneArg(func, arg); + return __Pyx_InBases(a, b); } -#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; +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (cls == a || cls == b) return 1; + mro = cls->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + PyObject *base = PyTuple_GET_ITEM(mro, i); + if (base == (PyObject *)a || base == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b); } -#endif - -/* PyObjectGetMethod */ -static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { - PyObject *attr; -#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP - PyTypeObject *tp = Py_TYPE(obj); - PyObject *descr; - descrgetfunc f = NULL; - PyObject **dictptr, *dict; - int meth_found = 0; - assert (*method == NULL); - if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) { - attr = __Pyx_PyObject_GetAttrStr(obj, name); - goto try_unpack; +static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { + if (exc_type1) { + return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2); + } else { + return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } - if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) { - return 0; +} +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); + for (i=0; i= 3 - #ifdef __Pyx_CyFunction_USED - if (likely(PyFunction_Check(descr) || (Py_TYPE(descr) == &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) - #else - if (likely(PyFunction_Check(descr) || (Py_TYPE(descr) == &PyMethodDescr_Type))) - #endif -#else - #ifdef __Pyx_CyFunction_USED - if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr))) - #else - if (likely(PyFunction_Check(descr))) - #endif -#endif - { - meth_found = 1; + for (i=0; itp_descr_get; - if (f != NULL && PyDescr_IsData(descr)) { - attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); - Py_DECREF(descr); - goto try_unpack; - } } } - dictptr = _PyObject_GetDictPtr(obj); - if (dictptr != NULL && (dict = *dictptr) != NULL) { - Py_INCREF(dict); - attr = __Pyx_PyDict_GetItemStr(dict, name); - if (attr != NULL) { - Py_INCREF(attr); - Py_DECREF(dict); - Py_XDECREF(descr); - goto try_unpack; + return 0; +} +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject* exc_type) { + if (likely(err == exc_type)) return 1; + if (likely(PyExceptionClass_Check(err))) { + if (likely(PyExceptionClass_Check(exc_type))) { + return __Pyx_inner_PyErr_GivenExceptionMatches2(err, NULL, exc_type); + } else if (likely(PyTuple_Check(exc_type))) { + return __Pyx_PyErr_GivenExceptionMatchesTuple(err, exc_type); + } else { } - Py_DECREF(dict); } - if (meth_found) { - *method = descr; - return 1; + return PyErr_GivenExceptionMatches(err, exc_type); +} +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *exc_type1, PyObject *exc_type2) { + assert(PyExceptionClass_Check(exc_type1)); + assert(PyExceptionClass_Check(exc_type2)); + if (likely(err == exc_type1 || err == exc_type2)) return 1; + if (likely(PyExceptionClass_Check(err))) { + return __Pyx_inner_PyErr_GivenExceptionMatches2(err, exc_type1, exc_type2); } - if (f != NULL) { - attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); - Py_DECREF(descr); - goto try_unpack; + return (PyErr_GivenExceptionMatches(err, exc_type1) || PyErr_GivenExceptionMatches(err, exc_type2)); +} +#endif + +/* GetException */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) +#endif +{ + PyObject *local_type = NULL, *local_value, *local_tb = NULL; +#if CYTHON_FAST_THREAD_STATE + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if PY_VERSION_HEX >= 0x030C0000 + local_value = tstate->current_exception; + tstate->current_exception = 0; + #else + local_type = tstate->curexc_type; + local_value = tstate->curexc_value; + local_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; + #endif +#elif __PYX_LIMITED_VERSION_HEX > 0x030C0000 + local_value = PyErr_GetRaisedException(); +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); +#endif +#if __PYX_LIMITED_VERSION_HEX > 0x030C0000 + if (likely(local_value)) { + local_type = (PyObject*) Py_TYPE(local_value); + Py_INCREF(local_type); + local_tb = PyException_GetTraceback(local_value); + } +#else + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) +#else + if (unlikely(PyErr_Occurred())) +#endif + goto bad; + if (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; } - if (descr != NULL) { - *method = descr; - return 0; +#endif // __PYX_LIMITED_VERSION_HEX > 0x030C0000 + Py_XINCREF(local_tb); + Py_XINCREF(local_type); + Py_XINCREF(local_value); + *type = local_type; + *value = local_value; + *tb = local_tb; +#if CYTHON_FAST_THREAD_STATE + #if CYTHON_USE_EXC_INFO_STACK + { + _PyErr_StackItem *exc_info = tstate->exc_info; + #if PY_VERSION_HEX >= 0x030B00a4 + tmp_value = exc_info->exc_value; + exc_info->exc_value = local_value; + tmp_type = NULL; + tmp_tb = NULL; + Py_XDECREF(local_type); + Py_XDECREF(local_tb); + #else + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = local_type; + exc_info->exc_value = local_value; + exc_info->exc_traceback = local_tb; + #endif } - PyErr_Format(PyExc_AttributeError, -#if PY_MAJOR_VERSION >= 3 - "'%.50s' object has no attribute '%U'", - tp->tp_name, name); + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = local_type; + tstate->exc_value = local_value; + tstate->exc_traceback = local_tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#elif __PYX_LIMITED_VERSION_HEX >= 0x030b0000 + PyErr_SetHandledException(local_value); + Py_XDECREF(local_value); + Py_XDECREF(local_type); + Py_XDECREF(local_tb); #else - "'%.50s' object has no attribute '%.400s'", - tp->tp_name, PyString_AS_STRING(name)); + PyErr_SetExcInfo(local_type, local_value, local_tb); #endif return 0; -#else - attr = __Pyx_PyObject_GetAttrStr(obj, name); - goto try_unpack; -#endif -try_unpack: -#if CYTHON_UNPACK_METHODS - if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) { - PyObject *function = PyMethod_GET_FUNCTION(attr); - Py_INCREF(function); - Py_DECREF(attr); - *method = function; - return 1; - } +#if __PYX_LIMITED_VERSION_HEX <= 0x030C0000 +bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); + return -1; #endif - *method = attr; - return 0; } -/* PyObjectCallMethod0 */ -static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { - PyObject *method = NULL, *result = NULL; - int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); - if (likely(is_method)) { - result = __Pyx_PyObject_CallOneArg(method, obj); - Py_DECREF(method); - return result; +/* SwapException */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_value = exc_info->exc_value; + exc_info->exc_value = *value; + if (tmp_value == NULL || tmp_value == Py_None) { + Py_XDECREF(tmp_value); + tmp_value = NULL; + tmp_type = NULL; + tmp_tb = NULL; + } else { + tmp_type = (PyObject*) Py_TYPE(tmp_value); + Py_INCREF(tmp_type); + #if CYTHON_COMPILING_IN_CPYTHON + tmp_tb = ((PyBaseExceptionObject*) tmp_value)->traceback; + Py_XINCREF(tmp_tb); + #else + tmp_tb = PyException_GetTraceback(tmp_value); + #endif } - if (unlikely(!method)) goto bad; - result = __Pyx_PyObject_CallNoArg(method); - Py_DECREF(method); -bad: - return result; + #elif CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = *type; + exc_info->exc_value = *value; + exc_info->exc_traceback = *tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = *type; + tstate->exc_value = *value; + tstate->exc_traceback = *tb; + #endif + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; } - -/* 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"); +#else +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); + PyErr_SetExcInfo(*type, *value, *tb); + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; } +#endif -/* 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); +/* GetAttr */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { +#if CYTHON_USE_TYPE_SLOTS + if (likely(PyUnicode_Check(n))) + return __Pyx_PyObject_GetAttrStr(o, n); +#endif + return PyObject_GetAttr(o, n); } -/* 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(); +/* ArgTypeTest */ +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +{ + __Pyx_TypeName type_name; + __Pyx_TypeName obj_type_name; + PyObject *extra_info = __pyx_mstate_global->__pyx_empty_unicode; + int from_annotation_subclass = 0; + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + else if (!exact) { + if (likely(__Pyx_TypeCheck(obj, type))) return 1; + } else if (exact == 2) { + if (__Pyx_TypeCheck(obj, type)) { + from_annotation_subclass = 1; + extra_info = __pyx_mstate_global->__pyx_kp_u_Note_that_Cython_is_deliberately; + } + } + type_name = __Pyx_PyType_GetFullyQualifiedName(type); + obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME + ", got " __Pyx_FMT_TYPENAME ")" +#if __PYX_LIMITED_VERSION_HEX < 0x030C0000 + "%s%U" +#endif + , name, type_name, obj_type_name +#if __PYX_LIMITED_VERSION_HEX < 0x030C0000 + , (from_annotation_subclass ? ". " : ""), extra_info +#endif + ); +#if __PYX_LIMITED_VERSION_HEX >= 0x030C0000 + if (exact == 2 && from_annotation_subclass) { + PyObject *res; + PyObject *vargs[2]; + vargs[0] = PyErr_GetRaisedException(); + vargs[1] = extra_info; + res = PyObject_VectorcallMethod(__pyx_mstate_global->__pyx_kp_u_add_note, vargs, 2, NULL); + Py_XDECREF(res); + PyErr_SetRaisedException(vargs[0]); } +#endif + __Pyx_DECREF_TypeName(type_name); + __Pyx_DECREF_TypeName(obj_type_name); 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); +/* pep479 */ +static void __Pyx_Generator_Replace_StopIteration(int in_async_gen) { + PyObject *exc, *val, *tb, *cur_exc, *new_exc; + __Pyx_PyThreadState_declare + int is_async_stopiteration = 0; + CYTHON_MAYBE_UNUSED_VAR(in_async_gen); + __Pyx_PyThreadState_assign + cur_exc = __Pyx_PyErr_CurrentExceptionType(); + if (likely(!__Pyx_PyErr_GivenExceptionMatches(cur_exc, PyExc_StopIteration))) { + if (in_async_gen && unlikely(__Pyx_PyErr_GivenExceptionMatches(cur_exc, PyExc_StopAsyncIteration))) { + is_async_stopiteration = 1; + } else { + return; + } + } + __Pyx_GetException(&exc, &val, &tb); + Py_XDECREF(exc); + Py_XDECREF(tb); + new_exc = PyObject_CallFunction(PyExc_RuntimeError, "s", + is_async_stopiteration ? "async generator raised StopAsyncIteration" : + in_async_gen ? "async generator raised StopIteration" : + "generator raised StopIteration"); + if (!new_exc) { + Py_XDECREF(val); + return; } + PyException_SetCause(new_exc, val); // steals ref to val + PyErr_SetObject(PyExc_RuntimeError, new_exc); } -/* 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; +/* CallTypeTraverse */ +#if !CYTHON_USE_TYPE_SPECS || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x03090000) #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); +static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg) { + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x03090000 + if (__Pyx_get_runtime_version() < 0x03090000) return 0; + #endif + if (!always_call) { + PyTypeObject *base = __Pyx_PyObject_GetSlot(o, tp_base, PyTypeObject*); + unsigned long flags = PyType_GetFlags(base); + if (flags & Py_TPFLAGS_HEAPTYPE) { + return 0; + } } - *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; + Py_VISIT((PyObject*)Py_TYPE(o)); 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; } +#endif -/* 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; - } +/* TypeImport */ +#ifndef __PYX_HAVE_RT_ImportType_3_1_3 +#define __PYX_HAVE_RT_ImportType_3_1_3 +static PyTypeObject *__Pyx_ImportType_3_1_3(PyObject *module, const char *module_name, const char *class_name, + size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_1_3 check_size) +{ + PyObject *result = 0; + Py_ssize_t basicsize; + Py_ssize_t itemsize; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_basicsize; + PyObject *py_itemsize; +#endif + result = PyObject_GetAttrString(module, class_name); + if (!result) + goto bad; + if (!PyType_Check(result)) { + PyErr_Format(PyExc_TypeError, + "%.200s.%.200s is not a type object", + module_name, class_name); + goto bad; + } +#if !CYTHON_COMPILING_IN_LIMITED_API + basicsize = ((PyTypeObject *)result)->tp_basicsize; + itemsize = ((PyTypeObject *)result)->tp_itemsize; +#else + if (size == 0) { + return (PyTypeObject *)result; + } + py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); + if (!py_basicsize) + goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; + py_itemsize = PyObject_GetAttrString(result, "__itemsize__"); + if (!py_itemsize) + goto bad; + itemsize = PyLong_AsSsize_t(py_itemsize); + Py_DECREF(py_itemsize); + py_itemsize = 0; + if (itemsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; +#endif + if (itemsize) { + if (size % alignment) { + alignment = size % alignment; + } + if (itemsize < (Py_ssize_t)alignment) + itemsize = (Py_ssize_t)alignment; + } + if ((size_t)(basicsize + itemsize) < size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize+itemsize); + goto bad; + } + if (check_size == __Pyx_ImportType_CheckSize_Error_3_1_3 && + ((size_t)basicsize > size || (size_t)(basicsize + itemsize) < size)) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd-%zd from PyObject", + module_name, class_name, size, basicsize, basicsize+itemsize); + goto bad; + } + else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_1_3 && (size_t)basicsize > size) { + if (PyErr_WarnFormat(NULL, 0, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize) < 0) { + goto bad; } + } + return (PyTypeObject *)result; +bad: + Py_XDECREF(result); + return NULL; +} #endif + +/* LimitedApiGetTypeDict */ +#if CYTHON_COMPILING_IN_LIMITED_API +static Py_ssize_t __Pyx_GetTypeDictOffset(void) { + PyObject *tp_dictoffset_o; + Py_ssize_t tp_dictoffset; + tp_dictoffset_o = PyObject_GetAttrString((PyObject*)(&PyType_Type), "__dictoffset__"); + if (unlikely(!tp_dictoffset_o)) return -1; + tp_dictoffset = PyLong_AsSsize_t(tp_dictoffset_o); + Py_DECREF(tp_dictoffset_o); + if (unlikely(tp_dictoffset == 0)) { + PyErr_SetString( + PyExc_TypeError, + "'type' doesn't have a dictoffset"); + return -1; + } else if (unlikely(tp_dictoffset < 0)) { + PyErr_SetString( + PyExc_TypeError, + "'type' has an unexpected negative dictoffset. " + "Please report this as Cython bug"); + return -1; } - *p_orig_length = 0; - if (method_name) { - PyObject* iter; - iterable = __Pyx_PyObject_CallMethod0(iterable, method_name); - if (!iterable) + return tp_dictoffset; +} +static PyObject *__Pyx_GetTypeDict(PyTypeObject *tp) { + static Py_ssize_t tp_dictoffset = 0; + if (unlikely(tp_dictoffset == 0)) { + tp_dictoffset = __Pyx_GetTypeDictOffset(); + if (unlikely(tp_dictoffset == -1 && PyErr_Occurred())) { + tp_dictoffset = 0; // try again next time? 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); + return *(PyObject**)((char*)tp + tp_dictoffset); } -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(); + +/* SetItemOnTypeDict */ +static int __Pyx__SetItemOnTypeDict(PyTypeObject *tp, PyObject *k, PyObject *v) { + int result; + PyObject *tp_dict; +#if CYTHON_COMPILING_IN_LIMITED_API + tp_dict = __Pyx_GetTypeDict(tp); + if (unlikely(!tp_dict)) return -1; +#else + tp_dict = tp->tp_dict; +#endif + result = PyDict_SetItem(tp_dict, k, v); + if (likely(!result)) { + PyType_Modified(tp); + if (unlikely(PyObject_HasAttr(v, __pyx_mstate_global->__pyx_n_u_set_name))) { + PyObject *setNameResult = PyObject_CallMethodObjArgs(v, __pyx_mstate_global->__pyx_n_u_set_name, (PyObject *) tp, k, NULL); + if (!setNameResult) return -1; + Py_DECREF(setNameResult); } } - 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; + return result; } -/* PyObjectCall2Args */ -static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { - PyObject *args, *result = NULL; - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(function)) { - PyObject *args[2] = {arg1, arg2}; - return __Pyx_PyFunction_FastCall(function, args, 2); +/* FixUpExtensionType */ +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) { +#if __PYX_LIMITED_VERSION_HEX > 0x030900B1 + CYTHON_UNUSED_VAR(spec); + CYTHON_UNUSED_VAR(type); + CYTHON_UNUSED_VAR(__Pyx__SetItemOnTypeDict); +#else + const PyType_Slot *slot = spec->slots; + int changed = 0; +#if !CYTHON_COMPILING_IN_LIMITED_API + while (slot && slot->slot && slot->slot != Py_tp_members) + slot++; + if (slot && slot->slot == Py_tp_members) { +#if !CYTHON_COMPILING_IN_CPYTHON + const +#endif // !CYTHON_COMPILING_IN_CPYTHON) + PyMemberDef *memb = (PyMemberDef*) slot->pfunc; + while (memb && memb->name) { + if (memb->name[0] == '_' && memb->name[1] == '_') { + if (strcmp(memb->name, "__weaklistoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_weaklistoffset = memb->offset; + changed = 1; + } + else if (strcmp(memb->name, "__dictoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_dictoffset = memb->offset; + changed = 1; + } +#if CYTHON_METH_FASTCALL + else if (strcmp(memb->name, "__vectorcalloffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); +#if PY_VERSION_HEX >= 0x030800b4 + type->tp_vectorcall_offset = memb->offset; +#else + type->tp_print = (printfunc) memb->offset; +#endif + changed = 1; + } +#endif // CYTHON_METH_FASTCALL +#if !CYTHON_COMPILING_IN_PYPY + else if (strcmp(memb->name, "__module__") == 0) { + PyObject *descr; + assert(memb->type == T_OBJECT); + assert(memb->flags == 0 || memb->flags == READONLY); + descr = PyDescr_NewMember(type, memb); + if (unlikely(!descr)) + return -1; + int set_item_result = PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr); + Py_DECREF(descr); + if (unlikely(set_item_result < 0)) { + return -1; + } + changed = 1; + } +#endif // !CYTHON_COMPILING_IN_PYPY + } + memb++; + } } - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(function)) { - PyObject *args[2] = {arg1, arg2}; - return __Pyx_PyCFunction_FastCall(function, args, 2); +#endif // !CYTHON_COMPILING_IN_LIMITED_API +#if !CYTHON_COMPILING_IN_PYPY + slot = spec->slots; + while (slot && slot->slot && slot->slot != Py_tp_getset) + slot++; + if (slot && slot->slot == Py_tp_getset) { + PyGetSetDef *getset = (PyGetSetDef*) slot->pfunc; + while (getset && getset->name) { + if (getset->name[0] == '_' && getset->name[1] == '_' && strcmp(getset->name, "__module__") == 0) { + PyObject *descr = PyDescr_NewGetSet(type, getset); + if (unlikely(!descr)) + return -1; + #if CYTHON_COMPILING_IN_LIMITED_API + PyObject *pyname = PyUnicode_FromString(getset->name); + if (unlikely(!pyname)) { + Py_DECREF(descr); + return -1; + } + int set_item_result = __Pyx_SetItemOnTypeDict(type, pyname, descr); + Py_DECREF(pyname); + #else + CYTHON_UNUSED_VAR(__Pyx__SetItemOnTypeDict); + int set_item_result = PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr); + #endif + Py_DECREF(descr); + if (unlikely(set_item_result < 0)) { + return -1; + } + changed = 1; + } + ++getset; + } } - #endif - args = PyTuple_New(2); - if (unlikely(!args)) goto done; - Py_INCREF(arg1); - PyTuple_SET_ITEM(args, 0, arg1); - Py_INCREF(arg2); - PyTuple_SET_ITEM(args, 1, arg2); - Py_INCREF(function); - result = __Pyx_PyObject_Call(function, args, NULL); - Py_DECREF(args); - Py_DECREF(function); -done: - return result; +#endif // !CYTHON_COMPILING_IN_PYPY + if (changed) + PyType_Modified(type); +#endif // PY_VERSION_HEX > 0x030900B1 + return 0; } -/* PyDictVersioning */ -#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { - PyObject *dict = Py_TYPE(obj)->tp_dict; - return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; -} -static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { - PyObject **dictptr = NULL; - Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; - if (offset) { -#if CYTHON_COMPILING_IN_CPYTHON - dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); +/* ValidateBasesTuple */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) { + Py_ssize_t i, n; +#if CYTHON_ASSUME_SAFE_SIZE + n = PyTuple_GET_SIZE(bases); #else - dictptr = _PyObject_GetDictPtr(obj); + n = PyTuple_Size(bases); + if (unlikely(n < 0)) return -1; +#endif + for (i = 1; i < n; i++) + { + PyTypeObject *b; +#if CYTHON_AVOID_BORROWED_REFS + PyObject *b0 = PySequence_GetItem(bases, i); + if (!b0) return -1; +#elif CYTHON_ASSUME_SAFE_MACROS + PyObject *b0 = PyTuple_GET_ITEM(bases, i); +#else + PyObject *b0 = PyTuple_GetItem(bases, i); + if (!b0) return -1; +#endif + b = (PyTypeObject*) b0; + if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) + { + __Pyx_TypeName b_name = __Pyx_PyType_GetFullyQualifiedName(b); + PyErr_Format(PyExc_TypeError, + "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name); + __Pyx_DECREF_TypeName(b_name); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } + if (dictoffset == 0) + { + Py_ssize_t b_dictoffset = 0; +#if CYTHON_USE_TYPE_SLOTS + b_dictoffset = b->tp_dictoffset; +#else + PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__"); + if (!py_b_dictoffset) goto dictoffset_return; + b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset); + Py_DECREF(py_b_dictoffset); + if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return; +#endif + if (b_dictoffset) { + { + __Pyx_TypeName b_name = __Pyx_PyType_GetFullyQualifiedName(b); + PyErr_Format(PyExc_TypeError, + "extension type '%.200s' has no __dict__ slot, " + "but base type '" __Pyx_FMT_TYPENAME "' has: " + "either add 'cdef dict __dict__' to the extension type " + "or add '__slots__ = [...]' to the base type", + type_name, b_name); + __Pyx_DECREF_TypeName(b_name); + } +#if !CYTHON_USE_TYPE_SLOTS + dictoffset_return: +#endif +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } + } +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); #endif } - return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; -} -static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { - PyObject *dict = Py_TYPE(obj)->tp_dict; - if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) - return 0; - return obj_dict_version == __Pyx_get_object_dict_version(obj); + return 0; } #endif -/* GetModuleGlobalName */ -#if CYTHON_USE_DICT_VERSIONS -static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) -#else -static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) -#endif -{ - PyObject *result; -#if !CYTHON_AVOID_BORROWED_REFS -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 - result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } else if (unlikely(PyErr_Occurred())) { - return NULL; +/* PyType_Ready */ +CYTHON_UNUSED static int __Pyx_PyType_HasMultipleInheritance(PyTypeObject *t) { + while (t) { + PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); + if (bases) { + return 1; + } + t = __Pyx_PyType_GetSlot(t, tp_base, PyTypeObject*); } + return 0; +} +static int __Pyx_PyType_Ready(PyTypeObject *t) { +#if CYTHON_USE_TYPE_SPECS || !CYTHON_COMPILING_IN_CPYTHON || defined(PYSTON_MAJOR_VERSION) + (void)__Pyx_PyObject_CallMethod0; +#if CYTHON_USE_TYPE_SPECS + (void)__Pyx_validate_bases_tuple; +#endif + return PyType_Ready(t); #else - result = PyDict_GetItem(__pyx_d, name); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); + int r; + if (!__Pyx_PyType_HasMultipleInheritance(t)) { + return PyType_Ready(t); } + PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); + if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1)) + return -1; +#if !defined(PYSTON_MAJOR_VERSION) + { + int gc_was_enabled; + #if PY_VERSION_HEX >= 0x030A00b1 + gc_was_enabled = PyGC_Disable(); + (void)__Pyx_PyObject_CallMethod0; + #else + PyObject *ret, *py_status; + PyObject *gc = NULL; + #if (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) &&\ + !CYTHON_COMPILING_IN_GRAAL + gc = PyImport_GetModule(__pyx_mstate_global->__pyx_kp_u_gc); + #endif + if (unlikely(!gc)) gc = PyImport_Import(__pyx_mstate_global->__pyx_kp_u_gc); + if (unlikely(!gc)) return -1; + py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_isenabled); + if (unlikely(!py_status)) { + Py_DECREF(gc); + return -1; + } + gc_was_enabled = __Pyx_PyObject_IsTrue(py_status); + Py_DECREF(py_status); + if (gc_was_enabled > 0) { + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_disable); + if (unlikely(!ret)) { + Py_DECREF(gc); + return -1; + } + Py_DECREF(ret); + } else if (unlikely(gc_was_enabled == -1)) { + Py_DECREF(gc); + return -1; + } + #endif + t->tp_flags |= Py_TPFLAGS_HEAPTYPE; +#if PY_VERSION_HEX >= 0x030A0000 + t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE; #endif #else - result = PyObject_GetItem(__pyx_d, name); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); + (void)__Pyx_PyObject_CallMethod0; +#endif + r = PyType_Ready(t); +#if !defined(PYSTON_MAJOR_VERSION) + t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE; + #if PY_VERSION_HEX >= 0x030A00b1 + if (gc_was_enabled) + PyGC_Enable(); + #else + if (gc_was_enabled) { + PyObject *tp, *v, *tb; + PyErr_Fetch(&tp, &v, &tb); + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_enable); + if (likely(ret || r == -1)) { + Py_XDECREF(ret); + PyErr_Restore(tp, v, tb); + } else { + Py_XDECREF(tp); + Py_XDECREF(v); + Py_XDECREF(tb); + r = -1; + } + } + Py_DECREF(gc); + #endif } - PyErr_Clear(); #endif - return __Pyx_GetBuiltinName(name); -} - -/* 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; +#endif } -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(__Pyx_is_valid_index(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)); + +/* SetVTable */ +static int __Pyx_SetVtable(PyTypeObject *type, void *vtable) { + PyObject *ob = PyCapsule_New(vtable, 0, 0); + if (unlikely(!ob)) + goto bad; +#if CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(PyObject_SetAttr((PyObject *) type, __pyx_mstate_global->__pyx_n_u_pyx_vtable, ob) < 0)) #else - return PySequence_GetItem(o, i); + if (unlikely(PyDict_SetItem(type->tp_dict, __pyx_mstate_global->__pyx_n_u_pyx_vtable, ob) < 0)) #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(__Pyx_is_valid_index(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)); + goto bad; + Py_DECREF(ob); + return 0; +bad: + Py_XDECREF(ob); + return -1; +} + +/* GetVTable */ +static void* __Pyx_GetVtable(PyTypeObject *type) { + void* ptr; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *ob = PyObject_GetAttr((PyObject *)type, __pyx_mstate_global->__pyx_n_u_pyx_vtable); #else - return PySequence_GetItem(o, i); + PyObject *ob = PyObject_GetItem(type->tp_dict, __pyx_mstate_global->__pyx_n_u_pyx_vtable); #endif + if (!ob) + goto bad; + ptr = PyCapsule_GetPointer(ob, 0); + if (!ptr && !PyErr_Occurred()) + PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type"); + Py_DECREF(ob); + return ptr; +bad: + Py_XDECREF(ob); + return NULL; } -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(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { - PyObject *r = PyList_GET_ITEM(o, n); - Py_INCREF(r); - return r; + +/* MergeVTables */ +static int __Pyx_MergeVtables(PyTypeObject *type) { + int i=0; + Py_ssize_t size; + void** base_vtables; + __Pyx_TypeName tp_base_name = NULL; + __Pyx_TypeName base_name = NULL; + void* unknown = (void*)-1; + PyObject* bases = __Pyx_PyType_GetSlot(type, tp_bases, PyObject*); + int base_depth = 0; + { + PyTypeObject* base = __Pyx_PyType_GetSlot(type, tp_base, PyTypeObject*); + while (base) { + base_depth += 1; + base = __Pyx_PyType_GetSlot(base, tp_base, PyTypeObject*); } } - else if (PyTuple_CheckExact(o)) { - Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); - if ((!boundscheck) || likely(__Pyx_is_valid_index(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(); + base_vtables = (void**) PyMem_Malloc(sizeof(void*) * (size_t)(base_depth + 1)); + base_vtables[0] = unknown; +#if CYTHON_COMPILING_IN_LIMITED_API + size = PyTuple_Size(bases); + if (size < 0) goto other_failure; +#else + size = PyTuple_GET_SIZE(bases); +#endif + for (i = 1; i < size; i++) { + PyObject *basei; + void* base_vtable; +#if CYTHON_AVOID_BORROWED_REFS + basei = PySequence_GetItem(bases, i); + if (unlikely(!basei)) goto other_failure; +#elif !CYTHON_ASSUME_SAFE_MACROS + basei = PyTuple_GetItem(bases, i); + if (unlikely(!basei)) goto other_failure; +#else + basei = PyTuple_GET_ITEM(bases, i); +#endif + base_vtable = __Pyx_GetVtable((PyTypeObject*)basei); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(basei); +#endif + if (base_vtable != NULL) { + int j; + PyTypeObject* base = __Pyx_PyType_GetSlot(type, tp_base, PyTypeObject*); + for (j = 0; j < base_depth; j++) { + if (base_vtables[j] == unknown) { + base_vtables[j] = __Pyx_GetVtable(base); + base_vtables[j + 1] = unknown; + } + if (base_vtables[j] == base_vtable) { + break; + } else if (base_vtables[j] == NULL) { + goto bad; } + base = __Pyx_PyType_GetSlot(base, tp_base, PyTypeObject*); } - return m->sq_item(o, i); } } + PyErr_Clear(); + PyMem_Free(base_vtables); + return 0; +bad: + { + PyTypeObject* basei = NULL; + PyTypeObject* tp_base = __Pyx_PyType_GetSlot(type, tp_base, PyTypeObject*); + tp_base_name = __Pyx_PyType_GetFullyQualifiedName(tp_base); +#if CYTHON_AVOID_BORROWED_REFS + basei = (PyTypeObject*)PySequence_GetItem(bases, i); + if (unlikely(!basei)) goto really_bad; +#elif !CYTHON_ASSUME_SAFE_MACROS + basei = (PyTypeObject*)PyTuple_GetItem(bases, i); + if (unlikely(!basei)) goto really_bad; #else - if (is_list || PySequence_Check(o)) { - return PySequence_GetItem(o, i); + basei = (PyTypeObject*)PyTuple_GET_ITEM(bases, i); +#endif + base_name = __Pyx_PyType_GetFullyQualifiedName(basei); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(basei); +#endif } + PyErr_Format(PyExc_TypeError, + "multiple bases have vtable conflict: '" __Pyx_FMT_TYPENAME "' and '" __Pyx_FMT_TYPENAME "'", tp_base_name, base_name); +#if CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS +really_bad: // bad has failed! #endif - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); + __Pyx_DECREF_TypeName(tp_base_name); + __Pyx_DECREF_TypeName(base_name); +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS +other_failure: +#endif + PyMem_Free(base_vtables); + return -1; } -/* SliceObject */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj, - Py_ssize_t cstart, Py_ssize_t cstop, - PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice, - int has_cstart, int has_cstop, CYTHON_UNUSED int wraparound) { -#if CYTHON_USE_TYPE_SLOTS - PyMappingMethods* mp; -#if PY_MAJOR_VERSION < 3 - PySequenceMethods* ms = Py_TYPE(obj)->tp_as_sequence; - if (likely(ms && ms->sq_slice)) { - if (!has_cstart) { - if (_py_start && (*_py_start != Py_None)) { - cstart = __Pyx_PyIndex_AsSsize_t(*_py_start); - if ((cstart == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; - } else - cstart = 0; +/* ListPack */ +static PyObject *__Pyx_PyList_Pack(Py_ssize_t n, ...) { + va_list va; + PyObject *l = PyList_New(n); + va_start(va, n); + if (unlikely(!l)) goto end; + for (Py_ssize_t i=0; isq_length)) { - Py_ssize_t l = ms->sq_length(obj); - if (likely(l >= 0)) { - if (cstop < 0) { - cstop += l; - if (cstop < 0) cstop = 0; - } - if (cstart < 0) { - cstart += l; - if (cstart < 0) cstart = 0; - } - } else { - if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + } + end: + va_end(va); + return l; +} + +/* Import */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *module = 0; + PyObject *empty_dict = 0; + PyObject *empty_list = 0; + empty_dict = PyDict_New(); + if (unlikely(!empty_dict)) + goto bad; + if (level == -1) { + const char* package_sep = strchr(__Pyx_MODULE_NAME, '.'); + if (package_sep != (0)) { + module = PyImport_ImportModuleLevelObject( + name, __pyx_mstate_global->__pyx_d, empty_dict, from_list, 1); + if (unlikely(!module)) { + if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError))) goto bad; PyErr_Clear(); } } - return ms->sq_slice(obj, cstart, cstop); + level = 0; } -#endif - mp = Py_TYPE(obj)->tp_as_mapping; - if (likely(mp && mp->mp_subscript)) -#endif - { - PyObject* result; - PyObject *py_slice, *py_start, *py_stop; - if (_py_slice) { - py_slice = *_py_slice; - } else { - PyObject* owned_start = NULL; - PyObject* owned_stop = NULL; - if (_py_start) { - py_start = *_py_start; - } else { - if (has_cstart) { - owned_start = py_start = PyInt_FromSsize_t(cstart); - if (unlikely(!py_start)) goto bad; - } else - py_start = Py_None; - } - if (_py_stop) { - py_stop = *_py_stop; - } else { - if (has_cstop) { - owned_stop = py_stop = PyInt_FromSsize_t(cstop); - if (unlikely(!py_stop)) { - Py_XDECREF(owned_start); - goto bad; - } - } else - py_stop = Py_None; - } - py_slice = PySlice_New(py_start, py_stop, Py_None); - Py_XDECREF(owned_start); - Py_XDECREF(owned_stop); - if (unlikely(!py_slice)) goto bad; - } -#if CYTHON_USE_TYPE_SLOTS - result = mp->mp_subscript(obj, py_slice); -#else - result = PyObject_GetItem(obj, py_slice); -#endif - if (!_py_slice) { - Py_DECREF(py_slice); - } - return result; + if (!module) { + module = PyImport_ImportModuleLevelObject( + name, __pyx_mstate_global->__pyx_d, empty_dict, from_list, level); } - PyErr_Format(PyExc_TypeError, - "'%.200s' object is unsliceable", Py_TYPE(obj)->tp_name); bad: - return NULL; + Py_XDECREF(empty_dict); + Py_XDECREF(empty_list); + return module; } -/* BytesEquals */ -static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { -#if CYTHON_COMPILING_IN_PYPY - return PyObject_RichCompareBool(s1, s2, equals); -#else - if (s1 == s2) { - return (equals == Py_EQ); - } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { - const char *ps1, *ps2; - Py_ssize_t length = PyBytes_GET_SIZE(s1); - if (length != PyBytes_GET_SIZE(s2)) - return (equals == Py_NE); - ps1 = PyBytes_AS_STRING(s1); - ps2 = PyBytes_AS_STRING(s2); - if (ps1[0] != ps2[0]) { - return (equals == Py_NE); - } else if (length == 1) { - return (equals == Py_EQ); - } else { - int result; -#if CYTHON_USE_UNICODE_INTERNALS - Py_hash_t hash1, hash2; - hash1 = ((PyBytesObject*)s1)->ob_shash; - hash2 = ((PyBytesObject*)s2)->ob_shash; - if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { - return (equals == Py_NE); - } -#endif - result = memcmp(ps1, ps2, (size_t)length); - return (equals == Py_EQ) ? (result == 0) : (result != 0); +/* ImportFrom */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { + PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); + if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { + const char* module_name_str = 0; + PyObject* module_name = 0; + PyObject* module_dot = 0; + PyObject* full_name = 0; + PyErr_Clear(); + module_name_str = PyModule_GetName(module); + if (unlikely(!module_name_str)) { goto modbad; } + module_name = PyUnicode_FromString(module_name_str); + if (unlikely(!module_name)) { goto modbad; } + module_dot = PyUnicode_Concat(module_name, __pyx_mstate_global->__pyx_kp_u__4); + if (unlikely(!module_dot)) { goto modbad; } + full_name = PyUnicode_Concat(module_dot, name); + if (unlikely(!full_name)) { goto modbad; } + #if (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) ||\ + CYTHON_COMPILING_IN_GRAAL + { + PyObject *modules = PyImport_GetModuleDict(); + if (unlikely(!modules)) + goto modbad; + value = PyObject_GetItem(modules, full_name); } - } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { - return (equals == Py_NE); - } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { - return (equals == Py_NE); - } else { - int result; - PyObject* py_result = PyObject_RichCompare(s1, s2, equals); - if (!py_result) - return -1; - result = __Pyx_PyObject_IsTrue(py_result); - Py_DECREF(py_result); - return result; + #else + value = PyImport_GetModule(full_name); + #endif + modbad: + Py_XDECREF(full_name); + Py_XDECREF(module_dot); + Py_XDECREF(module_name); + } + if (unlikely(!value)) { + PyErr_Format(PyExc_ImportError, "cannot import name %S", name); } + return value; +} + +/* FetchSharedCythonModule */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void) { + return __Pyx_PyImport_AddModuleRef(__PYX_ABI_MODULE_NAME); +} + +/* dict_setdefault */ +static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value, + int is_safe_type) { + PyObject* value; + CYTHON_MAYBE_UNUSED_VAR(is_safe_type); +#if CYTHON_COMPILING_IN_LIMITED_API + value = PyObject_CallMethod(d, "setdefault", "OO", key, default_value); +#elif PY_VERSION_HEX >= 0x030d0000 + PyDict_SetDefaultRef(d, key, default_value, &value); +#else + value = PyDict_SetDefault(d, key, default_value); + if (unlikely(!value)) return NULL; + Py_INCREF(value); #endif + return value; } -/* UnicodeEquals */ -static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { -#if CYTHON_COMPILING_IN_PYPY - return PyObject_RichCompareBool(s1, s2, equals); +/* FetchCommonType */ +#if __PYX_LIMITED_VERSION_HEX < 0x030C0000 +static PyObject* __Pyx_PyType_FromMetaclass(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *result = __Pyx_PyType_FromModuleAndSpec(module, spec, bases); + if (result && metaclass) { + PyObject *old_tp = (PyObject*)Py_TYPE(result); + Py_INCREF((PyObject*)metaclass); +#if __PYX_LIMITED_VERSION_HEX >= 0x03090000 + Py_SET_TYPE(result, metaclass); #else -#if PY_MAJOR_VERSION < 3 - PyObject* owned_ref = NULL; + result->ob_type = metaclass; #endif - int s1_is_unicode, s2_is_unicode; - if (s1 == s2) { - goto return_eq; - } - s1_is_unicode = PyUnicode_CheckExact(s1); - s2_is_unicode = PyUnicode_CheckExact(s2); -#if PY_MAJOR_VERSION < 3 - if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { - owned_ref = PyUnicode_FromObject(s2); - if (unlikely(!owned_ref)) - return -1; - s2 = owned_ref; - s2_is_unicode = 1; - } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { - owned_ref = PyUnicode_FromObject(s1); - if (unlikely(!owned_ref)) - return -1; - s1 = owned_ref; - s1_is_unicode = 1; - } else if (((!s2_is_unicode) & (!s1_is_unicode))) { - return __Pyx_PyBytes_Equals(s1, s2, equals); + Py_DECREF(old_tp); } + return result; +} +#else +#define __Pyx_PyType_FromMetaclass(me, mo, s, b) PyType_FromMetaclass(me, mo, s, b) #endif - if (s1_is_unicode & s2_is_unicode) { - Py_ssize_t length; - int kind; - void *data1, *data2; - if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) - return -1; - length = __Pyx_PyUnicode_GET_LENGTH(s1); - if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { - goto return_ne; - } -#if CYTHON_USE_UNICODE_INTERNALS - { - Py_hash_t hash1, hash2; - #if CYTHON_PEP393_ENABLED - hash1 = ((PyASCIIObject*)s1)->hash; - hash2 = ((PyASCIIObject*)s2)->hash; - #else - hash1 = ((PyUnicodeObject*)s1)->hash; - hash2 = ((PyUnicodeObject*)s2)->hash; - #endif - if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { - goto return_ne; - } - } -#endif - kind = __Pyx_PyUnicode_KIND(s1); - if (kind != __Pyx_PyUnicode_KIND(s2)) { - goto return_ne; - } - data1 = __Pyx_PyUnicode_DATA(s1); - data2 = __Pyx_PyUnicode_DATA(s2); - if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { - goto return_ne; - } else if (length == 1) { - goto return_eq; - } else { - int result = memcmp(data1, data2, (size_t)(length * kind)); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - return (equals == Py_EQ) ? (result == 0) : (result != 0); - } - } else if ((s1 == Py_None) & s2_is_unicode) { - goto return_ne; - } else if ((s2 == Py_None) & s1_is_unicode) { - goto return_ne; - } else { - int result; - PyObject* py_result = PyObject_RichCompare(s1, s2, equals); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - if (!py_result) - return -1; - result = __Pyx_PyObject_IsTrue(py_result); - Py_DECREF(py_result); - return result; +static int __Pyx_VerifyCachedType(PyObject *cached_type, + const char *name, + Py_ssize_t expected_basicsize) { + Py_ssize_t basicsize; + if (!PyType_Check(cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", name); + return -1; } -return_eq: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - return (equals == Py_EQ); -return_ne: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - return (equals == Py_NE); + if (expected_basicsize == 0) { + return 0; // size is inherited, nothing useful to check + } +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_basicsize; + py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); + if (unlikely(!py_basicsize)) return -1; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = NULL; + if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) return -1; +#else + basicsize = ((PyTypeObject*) cached_type)->tp_basicsize; #endif + if (basicsize != expected_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + name); + return -1; + } + return 0; } - -/* IterNext */ -static PyObject *__Pyx_PyIter_Next2Default(PyObject* defval) { - PyObject* exc_type; - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - exc_type = __Pyx_PyErr_Occurred(); - if (unlikely(exc_type)) { - if (!defval || unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) - return NULL; - __Pyx_PyErr_Clear(); - Py_INCREF(defval); - return defval; +static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *abi_module = NULL, *cached_type = NULL, *abi_module_dict, *new_cached_type, *py_object_name; + int get_item_ref_result; + const char* object_name = strrchr(spec->name, '.'); + object_name = object_name ? object_name+1 : spec->name; + py_object_name = PyUnicode_FromString(object_name); + if (!py_object_name) return NULL; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) goto done; + abi_module_dict = PyModule_GetDict(abi_module); + if (!abi_module_dict) goto done; + get_item_ref_result = __Pyx_PyDict_GetItemRef(abi_module_dict, py_object_name, &cached_type); + if (get_item_ref_result == 1) { + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + spec->basicsize) < 0) { + goto bad; + } + goto done; + } else if (unlikely(get_item_ref_result == -1)) { + goto bad; } - if (defval) { - Py_INCREF(defval); - return defval; + CYTHON_UNUSED_VAR(module); + cached_type = __Pyx_PyType_FromMetaclass(metaclass, abi_module, spec, bases); + if (unlikely(!cached_type)) goto bad; + if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad; + new_cached_type = __Pyx_PyDict_SetDefault(abi_module_dict, py_object_name, cached_type, 1); + if (unlikely(new_cached_type != cached_type)) { + if (unlikely(!new_cached_type)) goto bad; + Py_DECREF(cached_type); + cached_type = new_cached_type; + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + spec->basicsize) < 0) { + goto bad; + } + goto done; + } else { + Py_DECREF(new_cached_type); } - __Pyx_PyErr_SetNone(PyExc_StopIteration); - return NULL; +done: + Py_XDECREF(abi_module); + Py_DECREF(py_object_name); + assert(cached_type == NULL || PyType_Check(cached_type)); + return (PyTypeObject *) cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; } -static void __Pyx_PyIter_Next_ErrorNoIterator(PyObject *iterator) { - PyErr_Format(PyExc_TypeError, - "%.200s object is not an iterator", Py_TYPE(iterator)->tp_name); + +/* CommonTypesMetaclass */ +static PyObject* __pyx_CommonTypesMetaclass_get_module(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED void* context) { + return PyUnicode_FromString(__PYX_ABI_MODULE_NAME); } -static CYTHON_INLINE PyObject *__Pyx_PyIter_Next2(PyObject* iterator, PyObject* defval) { - PyObject* next; - iternextfunc iternext = Py_TYPE(iterator)->tp_iternext; - if (likely(iternext)) { -#if CYTHON_USE_TYPE_SLOTS - next = iternext(iterator); - if (likely(next)) - return next; - #if PY_VERSION_HEX >= 0x02070000 - if (unlikely(iternext == &_PyObject_NextNotImplemented)) - return NULL; - #endif -#else - next = PyIter_Next(iterator); - if (likely(next)) - return next; +static PyGetSetDef __pyx_CommonTypesMetaclass_getset[] = { + {"__module__", __pyx_CommonTypesMetaclass_get_module, NULL, NULL, NULL}, + {0, 0, 0, 0, 0} +}; +static PyType_Slot __pyx_CommonTypesMetaclass_slots[] = { + {Py_tp_getset, (void *)__pyx_CommonTypesMetaclass_getset}, + {0, 0} +}; +static PyType_Spec __pyx_CommonTypesMetaclass_spec = { + __PYX_TYPE_MODULE_PREFIX "_common_types_metatype", + 0, + 0, +#if PY_VERSION_HEX >= 0x030A0000 + Py_TPFLAGS_IMMUTABLETYPE | + Py_TPFLAGS_DISALLOW_INSTANTIATION | #endif - } else if (CYTHON_USE_TYPE_SLOTS || unlikely(!PyIter_Check(iterator))) { - __Pyx_PyIter_Next_ErrorNoIterator(iterator); - return NULL; + Py_TPFLAGS_DEFAULT, + __pyx_CommonTypesMetaclass_slots +}; +static int __pyx_CommonTypesMetaclass_init(PyObject *module) { + __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module); + PyObject *bases = PyTuple_Pack(1, &PyType_Type); + if (unlikely(!bases)) { + return -1; } -#if !CYTHON_USE_TYPE_SLOTS - else { - next = PyIter_Next(iterator); - if (likely(next)) - return next; + mstate->__pyx_CommonTypesMetaclassType = __Pyx_FetchCommonTypeFromSpec(NULL, module, &__pyx_CommonTypesMetaclass_spec, bases); + if (unlikely(mstate->__pyx_CommonTypesMetaclassType == NULL)) { + return -1; } -#endif - return __Pyx_PyIter_Next2Default(defval); + return 0; } -/* PyIntBinop */ -#if !CYTHON_COMPILING_IN_PYPY -static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, int inplace, int zerodivision_check) { - (void)inplace; - (void)zerodivision_check; - #if PY_MAJOR_VERSION < 3 - if (likely(PyInt_CheckExact(op1))) { - const long b = intval; - long x; - long a = PyInt_AS_LONG(op1); - x = (long)((unsigned long)a - b); - if (likely((x^a) >= 0 || (x^~b) >= 0)) - return PyInt_FromLong(x); - return PyLong_Type.tp_as_number->nb_subtract(op1, op2); +/* PyMethodNew */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + PyObject *result; + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + #if __PYX_LIMITED_VERSION_HEX >= 0x030C0000 + { + PyObject *args[] = {func, self}; + result = PyObject_Vectorcall(__pyx_mstate_global->__Pyx_CachedMethodType, args, 2, NULL); } + #else + result = PyObject_CallFunctionObjArgs(__pyx_mstate_global->__Pyx_CachedMethodType, func, self, NULL); #endif - #if CYTHON_USE_PYLONG_INTERNALS - if (likely(PyLong_CheckExact(op1))) { - const long b = intval; - long a, x; -#ifdef HAVE_LONG_LONG - const PY_LONG_LONG llb = intval; - PY_LONG_LONG lla, llx; -#endif - const digit* digits = ((PyLongObject*)op1)->ob_digit; - const Py_ssize_t size = Py_SIZE(op1); - if (likely(__Pyx_sst_abs(size) <= 1)) { - a = likely(size) ? digits[0] : 0; - if (size == -1) a = -a; - } else { - switch (size) { - case -2: - if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; -#ifdef HAVE_LONG_LONG - } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { - lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; + return result; +} +#else +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + return PyMethod_New(func, self); +} #endif - } - CYTHON_FALLTHROUGH; - case 2: - if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; -#ifdef HAVE_LONG_LONG - } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { - lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; + +/* PyVectorcallFastCallDict */ +#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL) +static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) +{ + PyObject *res = NULL; + PyObject *kwnames; + PyObject **newargs; + PyObject **kwvalues; + Py_ssize_t i, pos; + size_t j; + PyObject *key, *value; + unsigned long keys_are_strings; + #if !CYTHON_ASSUME_SAFE_SIZE + Py_ssize_t nkw = PyDict_Size(kw); + if (unlikely(nkw == -1)) return NULL; + #else + Py_ssize_t nkw = PyDict_GET_SIZE(kw); + #endif + newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0])); + if (unlikely(newargs == NULL)) { + PyErr_NoMemory(); + return NULL; + } + for (j = 0; j < nargs; j++) newargs[j] = args[j]; + kwnames = PyTuple_New(nkw); + if (unlikely(kwnames == NULL)) { + PyMem_Free(newargs); + return NULL; + } + kwvalues = newargs + nargs; + pos = i = 0; + keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS; + while (PyDict_Next(kw, &pos, &key, &value)) { + keys_are_strings &= + #if CYTHON_COMPILING_IN_LIMITED_API + PyType_GetFlags(Py_TYPE(key)); + #else + Py_TYPE(key)->tp_flags; + #endif + Py_INCREF(key); + Py_INCREF(value); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(PyTuple_SetItem(kwnames, i, key) < 0)) goto cleanup; + #else + PyTuple_SET_ITEM(kwnames, i, key); + #endif + kwvalues[i] = value; + i++; + } + if (unlikely(!keys_are_strings)) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + goto cleanup; + } + res = vc(func, newargs, nargs, kwnames); +cleanup: + Py_DECREF(kwnames); + for (i = 0; i < nkw; i++) + Py_DECREF(kwvalues[i]); + PyMem_Free(newargs); + return res; +} +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) +{ + Py_ssize_t kw_size = + likely(kw == NULL) ? + 0 : +#if !CYTHON_ASSUME_SAFE_SIZE + PyDict_Size(kw); +#else + PyDict_GET_SIZE(kw); #endif - } - CYTHON_FALLTHROUGH; - case -3: - if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; -#ifdef HAVE_LONG_LONG - } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { - lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; + if (kw_size == 0) { + return vc(func, args, nargs, NULL); + } +#if !CYTHON_ASSUME_SAFE_SIZE + else if (unlikely(kw_size == -1)) { + return NULL; + } #endif - } - CYTHON_FALLTHROUGH; - case 3: - if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; -#ifdef HAVE_LONG_LONG - } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { - lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; + return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); +} #endif - } - CYTHON_FALLTHROUGH; - case -4: - if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; -#ifdef HAVE_LONG_LONG - } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { - lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; + +/* CythonFunctionShared */ +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunctionNoMethod(PyObject *func, void (*cfunc)(void)) { + if (__Pyx_CyFunction_Check(func)) { + return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc; + } else if (PyCFunction_Check(func)) { + return PyCFunction_GetFunction(func) == (PyCFunction) cfunc; + } + return 0; +} +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) { + if ((PyObject*)Py_TYPE(func) == __pyx_mstate_global->__Pyx_CachedMethodType) { + int result; + PyObject *newFunc = PyObject_GetAttr(func, __pyx_mstate_global->__pyx_n_u_func); + if (unlikely(!newFunc)) { + PyErr_Clear(); // It's only an optimization, so don't throw an error + return 0; + } + result = __Pyx__IsSameCyOrCFunctionNoMethod(newFunc, cfunc); + Py_DECREF(newFunc); + return result; + } + return __Pyx__IsSameCyOrCFunctionNoMethod(func, cfunc); +} +#else +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) { + if (PyMethod_Check(func)) { + func = PyMethod_GET_FUNCTION(func); + } + return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +} #endif - } - CYTHON_FALLTHROUGH; - case 4: - if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; -#ifdef HAVE_LONG_LONG - } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { - lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) { +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + __Pyx_Py_XDECREF_SET( + __Pyx_CyFunction_GetClassObj(f), + ((classobj) ? __Pyx_NewRef(classobj) : NULL)); +#else + __Pyx_Py_XDECREF_SET( + ((PyCMethodObject *) (f))->mm_class, + (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL)); #endif - } - CYTHON_FALLTHROUGH; - default: return PyLong_Type.tp_as_number->nb_subtract(op1, op2); - } +} +static PyObject * +__Pyx_CyFunction_get_doc_locked(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_doc == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_doc = PyObject_GetAttrString(op->func, "__doc__"); + if (unlikely(!op->func_doc)) return NULL; +#else + if (((PyCFunctionObject*)op)->m_ml->ml_doc) { + op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); + if (unlikely(op->func_doc == NULL)) + return NULL; + } else { + Py_INCREF(Py_None); + return Py_None; } - x = a - b; - return PyLong_FromLong(x); -#ifdef HAVE_LONG_LONG - long_long: - llx = lla - llb; - return PyLong_FromLongLong(llx); #endif - - } - #endif - if (PyFloat_CheckExact(op1)) { - const long b = intval; - double a = PyFloat_AS_DOUBLE(op1); - double result; - PyFPE_START_PROTECT("subtract", return NULL) - result = ((double)a) - (double)b; - PyFPE_END_PROTECT(result) - return PyFloat_FromDouble(result); + Py_INCREF(op->func_doc); + return op->func_doc; +} +static PyObject * +__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) { + PyObject *result; + CYTHON_UNUSED_VAR(closure); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_doc_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (value == NULL) { + value = Py_None; } - return (inplace ? PyNumber_InPlaceSubtract : PyNumber_Subtract)(op1, op2); + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_doc, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; } +static PyObject * +__Pyx_CyFunction_get_name_locked(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_name == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_name = PyObject_GetAttrString(op->func, "__name__"); +#else + op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); #endif - -/* StringJoin */ -#if !CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyBytes_Join(PyObject* sep, PyObject* values) { - return PyObject_CallMethodObjArgs(sep, __pyx_n_s_join, values, NULL); + if (unlikely(op->func_name == NULL)) + return NULL; + } + Py_INCREF(op->func_name); + return op->func_name; } -#endif - -/* GetTopmostException */ -#if CYTHON_USE_EXC_INFO_STACK -static _PyErr_StackItem * -__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) +static PyObject * +__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) { - _PyErr_StackItem *exc_info = tstate->exc_info; - while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && - exc_info->previous_item != NULL) - { - exc_info = exc_info->previous_item; + PyObject *result = NULL; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_name_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; } - return exc_info; + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_name, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; } -#endif - -/* SaveResetException */ -#if CYTHON_FAST_THREAD_STATE -static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { - #if CYTHON_USE_EXC_INFO_STACK - _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); - *type = exc_info->exc_type; - *value = exc_info->exc_value; - *tb = exc_info->exc_traceback; - #else - *type = tstate->exc_type; - *value = tstate->exc_value; - *tb = tstate->exc_traceback; - #endif - Py_XINCREF(*type); - Py_XINCREF(*value); - Py_XINCREF(*tb); +static PyObject * +__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + PyObject *result; + __Pyx_BEGIN_CRITICAL_SECTION(op); + Py_INCREF(op->func_qualname); + result = op->func_qualname; + __Pyx_END_CRITICAL_SECTION(); + return result; } -static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { - PyObject *tmp_type, *tmp_value, *tmp_tb; - #if CYTHON_USE_EXC_INFO_STACK - _PyErr_StackItem *exc_info = tstate->exc_info; - tmp_type = exc_info->exc_type; - tmp_value = exc_info->exc_value; - tmp_tb = exc_info->exc_traceback; - exc_info->exc_type = type; - exc_info->exc_value = value; - exc_info->exc_traceback = tb; +static int +__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_qualname, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_dict_locked(__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 PyObject * +__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + PyObject *result; + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_dict_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + 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; + } + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_dict, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + Py_INCREF(op->func_globals); + return op->func_globals; +} +static PyObject * +__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(op); + CYTHON_UNUSED_VAR(context); + Py_INCREF(Py_None); + return Py_None; +} +static PyObject * +__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context) +{ + PyObject* result = (op->func_code) ? op->func_code : Py_None; + CYTHON_UNUSED_VAR(context); + 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 - tmp_type = tstate->exc_type; - tmp_value = tstate->exc_value; - tmp_tb = tstate->exc_traceback; - tstate->exc_type = type; - tstate->exc_value = value; - tstate->exc_traceback = tb; + op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0); + if (unlikely(!op->defaults_tuple)) result = -1; + else { + op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1); + if (unlikely(!op->defaults_kwdict)) result = -1; + } #endif - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); + Py_DECREF(res); + return result; } -#endif - -/* 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; +static int +__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyTuple_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__defaults__ must be set to a tuple object"); + return -1; } - return b == &PyBaseObject_Type; + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->defaults_tuple, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; } -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; +static PyObject * +__Pyx_CyFunction_get_defaults_locked(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_tuple; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_tuple; + } else { + result = Py_None; } - return 0; } - return __Pyx_InBases(a, b); + Py_INCREF(result); + return result; } -#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; +static PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = NULL; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_defaults_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__kwdefaults__ must be set to a dict object"); + return -1; } - if (!res) { - res = PyObject_IsSubclass(err, exc_type2); - if (unlikely(res == -1)) { - PyErr_WriteUnraisable(err); - res = 0; + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults_locked(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_kwdict; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_kwdict; + } else { + result = Py_None; } } - __Pyx_ErrRestore(exception, value, tb); - return res; + Py_INCREF(result); + return result; } -#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); +static PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_kwdefaults_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value || value == Py_None) { + value = NULL; + } else if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__annotations__ must be set to a dict object"); + return -1; } - return res; + Py_XINCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_annotations, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; } -#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; ifunc_annotations; + if (unlikely(!result)) { + result = PyDict_New(); + if (unlikely(!result)) return NULL; + op->func_annotations = result; } + Py_INCREF(result); + return result; +} +static PyObject * +__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { + PyObject *result; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_annotations_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static PyObject * +__Pyx_CyFunction_get_is_coroutine_value(__pyx_CyFunctionObject *op) { + int is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; + if (is_coroutine) { + PyObject *is_coroutine_value, *module, *fromlist, *marker = __pyx_mstate_global->__pyx_n_u_is_coroutine; + fromlist = PyList_New(1); + if (unlikely(!fromlist)) return NULL; + Py_INCREF(marker); +#if CYTHON_ASSUME_SAFE_MACROS + PyList_SET_ITEM(fromlist, 0, marker); +#else + if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) { + Py_DECREF(marker); + Py_DECREF(fromlist); + return NULL; + } #endif - for (i=0; i__pyx_n_u_asyncio_coroutines, NULL, NULL, fromlist, 0); + Py_DECREF(fromlist); + if (unlikely(!module)) goto ignore; + is_coroutine_value = __Pyx_PyObject_GetAttrStr(module, marker); + Py_DECREF(module); + if (likely(is_coroutine_value)) { + return is_coroutine_value; } +ignore: + PyErr_Clear(); } - return 0; + return __Pyx_PyBool_FromLong(is_coroutine); } -static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject* exc_type) { - if (likely(err == exc_type)) return 1; - if (likely(PyExceptionClass_Check(err))) { - if (likely(PyExceptionClass_Check(exc_type))) { - return __Pyx_inner_PyErr_GivenExceptionMatches2(err, NULL, exc_type); - } else if (likely(PyTuple_Check(exc_type))) { - return __Pyx_PyErr_GivenExceptionMatchesTuple(err, exc_type); - } else { - } +static PyObject * +__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { + PyObject *result; + CYTHON_UNUSED_VAR(context); + if (op->func_is_coroutine) { + return __Pyx_NewRef(op->func_is_coroutine); } - return PyErr_GivenExceptionMatches(err, exc_type); -} -static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *exc_type1, PyObject *exc_type2) { - assert(PyExceptionClass_Check(exc_type1)); - assert(PyExceptionClass_Check(exc_type2)); - if (likely(err == exc_type1 || err == exc_type2)) return 1; - if (likely(PyExceptionClass_Check(err))) { - return __Pyx_inner_PyErr_GivenExceptionMatches2(err, exc_type1, exc_type2); + result = __Pyx_CyFunction_get_is_coroutine_value(op); + if (unlikely(!result)) + return NULL; + __Pyx_BEGIN_CRITICAL_SECTION(op); + if (op->func_is_coroutine) { + Py_DECREF(result); + result = __Pyx_NewRef(op->func_is_coroutine); + } else { + op->func_is_coroutine = __Pyx_NewRef(result); } - return (PyErr_GivenExceptionMatches(err, exc_type1) || PyErr_GivenExceptionMatches(err, exc_type2)); + __Pyx_END_CRITICAL_SECTION(); + return result; } +static void __Pyx_CyFunction_raise_argument_count_error(__pyx_CyFunctionObject *func, const char* message, Py_ssize_t size) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_name = __Pyx_CyFunction_get_name(func, NULL); + if (!py_name) return; + PyErr_Format(PyExc_TypeError, + "%.200S() %s (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, message, size); + Py_DECREF(py_name); +#else + const char* name = ((PyCFunctionObject*)func)->m_ml->ml_name; + PyErr_Format(PyExc_TypeError, + "%.200s() %s (%" CYTHON_FORMAT_SSIZE_T "d given)", + name, message, size); #endif - -/* PyErrExceptionMatches */ -#if CYTHON_FAST_THREAD_STATE -static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { - Py_ssize_t i, n; - n = PyTuple_GET_SIZE(tuple); -#if PY_MAJOR_VERSION >= 3 - for (i=0; im_ml->ml_name; + PyErr_Format(PyExc_TypeError, + "%.200s() %s", + name, message); #endif - for (i=0; icurexc_type; - if (exc_type == err) return 1; - if (unlikely(!exc_type)) return 0; - if (unlikely(PyTuple_Check(err))) - return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); - return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject * +__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_GetAttrString(op->func, "__module__"); } +static int +__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_SetAttrString(op->func, "__module__", value); +} +#endif +static PyGetSetDef __pyx_CyFunction_getsets[] = { + {"func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {"__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {"func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {"__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {"__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, + {"func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {"__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {"func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {"__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {"func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {"__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {"func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {"__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {"func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {"__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {"__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {"__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {"_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0}, +#if CYTHON_COMPILING_IN_LIMITED_API + {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0}, #endif - -/* GetException */ -#if CYTHON_FAST_THREAD_STATE -static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) + {0, 0, 0, 0, 0} +}; +static PyMemberDef __pyx_CyFunction_members[] = { +#if !CYTHON_COMPILING_IN_LIMITED_API + {"__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, +#endif + {"__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, +#if CYTHON_METH_FASTCALL +#if CYTHON_BACKPORT_VECTORCALL || CYTHON_COMPILING_IN_LIMITED_API + {"__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, #else -static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) + {"__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, #endif -{ - PyObject *local_type, *local_value, *local_tb; -#if CYTHON_FAST_THREAD_STATE - PyObject *tmp_type, *tmp_value, *tmp_tb; - local_type = tstate->curexc_type; - local_value = tstate->curexc_value; - local_tb = tstate->curexc_traceback; - tstate->curexc_type = 0; - tstate->curexc_value = 0; - tstate->curexc_traceback = 0; +#if CYTHON_COMPILING_IN_LIMITED_API + {"__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, #else - PyErr_Fetch(&local_type, &local_value, &local_tb); + {"__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, #endif - PyErr_NormalizeException(&local_type, &local_value, &local_tb); -#if CYTHON_FAST_THREAD_STATE - if (unlikely(tstate->curexc_type)) +#endif + {0, 0, 0, 0, 0} +}; +static PyObject * +__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args) +{ + PyObject *result = NULL; + CYTHON_UNUSED_VAR(args); + __Pyx_BEGIN_CRITICAL_SECTION(m); + Py_INCREF(m->func_qualname); + result = m->func_qualname; + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} +}; +#if CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) #else - if (unlikely(PyErr_Occurred())) +#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist) #endif - goto bad; - #if PY_MAJOR_VERSION >= 3 - if (local_tb) { - if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) - goto bad; - } - #endif - Py_XINCREF(local_tb); - Py_XINCREF(local_type); - Py_XINCREF(local_value); - *type = local_type; - *value = local_value; - *tb = local_tb; -#if CYTHON_FAST_THREAD_STATE - #if CYTHON_USE_EXC_INFO_STACK - { - _PyErr_StackItem *exc_info = tstate->exc_info; - tmp_type = exc_info->exc_type; - tmp_value = exc_info->exc_value; - tmp_tb = exc_info->exc_traceback; - exc_info->exc_type = local_type; - exc_info->exc_value = local_value; - exc_info->exc_traceback = local_tb; - } - #else - tmp_type = tstate->exc_type; - tmp_value = tstate->exc_value; - tmp_tb = tstate->exc_traceback; - tstate->exc_type = local_type; - tstate->exc_value = local_value; - tstate->exc_traceback = local_tb; - #endif - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { +#if !CYTHON_COMPILING_IN_LIMITED_API + PyCFunctionObject *cf = (PyCFunctionObject*) op; +#endif + if (unlikely(op == NULL)) + return NULL; +#if CYTHON_COMPILING_IN_LIMITED_API + op->func = PyCFunction_NewEx(ml, (PyObject*)op, module); + if (unlikely(!op->func)) return NULL; +#endif + op->flags = flags; + __Pyx_CyFunction_weakreflist(op) = NULL; +#if !CYTHON_COMPILING_IN_LIMITED_API + cf->m_ml = ml; + cf->m_self = (PyObject *) op; +#endif + Py_XINCREF(closure); + op->func_closure = closure; +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_XINCREF(module); + cf->m_module = module; +#endif + op->func_dict = NULL; + op->func_name = NULL; + Py_INCREF(qualname); + op->func_qualname = qualname; + op->func_doc = NULL; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + op->func_classobj = NULL; #else - PyErr_SetExcInfo(local_type, local_value, local_tb); + ((PyCMethodObject*)op)->mm_class = NULL; #endif - return 0; -bad: - *type = 0; - *value = 0; - *tb = 0; - Py_XDECREF(local_type); - Py_XDECREF(local_value); - Py_XDECREF(local_tb); - return -1; -} - -/* SwapException */ -#if CYTHON_FAST_THREAD_STATE -static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { - PyObject *tmp_type, *tmp_value, *tmp_tb; - #if CYTHON_USE_EXC_INFO_STACK - _PyErr_StackItem *exc_info = tstate->exc_info; - tmp_type = exc_info->exc_type; - tmp_value = exc_info->exc_value; - tmp_tb = exc_info->exc_traceback; - exc_info->exc_type = *type; - exc_info->exc_value = *value; - exc_info->exc_traceback = *tb; - #else - tmp_type = tstate->exc_type; - tmp_value = tstate->exc_value; - tmp_tb = tstate->exc_traceback; - tstate->exc_type = *type; - tstate->exc_value = *value; - tstate->exc_traceback = *tb; - #endif - *type = tmp_type; - *value = tmp_value; - *tb = tmp_tb; + op->func_globals = globals; + Py_INCREF(op->func_globals); + Py_XINCREF(code); + op->func_code = code; + op->defaults = NULL; + op->defaults_tuple = NULL; + op->defaults_kwdict = NULL; + op->defaults_getter = NULL; + op->func_annotations = NULL; + op->func_is_coroutine = NULL; +#if CYTHON_METH_FASTCALL + switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) { + case METH_NOARGS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS; + break; + case METH_O: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O; + break; + case METH_METHOD | METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD; + break; + case METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS; + break; + case METH_VARARGS | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = NULL; + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + Py_DECREF(op); + return NULL; + } +#endif + return (PyObject *) op; } +static int +__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) +{ + Py_CLEAR(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_CLEAR(m->func); #else -static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { - PyObject *tmp_type, *tmp_value, *tmp_tb; - PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); - PyErr_SetExcInfo(*type, *value, *tb); - *type = tmp_type; - *value = tmp_value; - *tb = tmp_tb; -} -#endif - -/* GetAttr */ -static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { -#if CYTHON_USE_TYPE_SLOTS -#if PY_MAJOR_VERSION >= 3 - if (likely(PyUnicode_Check(n))) + Py_CLEAR(((PyCFunctionObject*)m)->m_module); +#endif + 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); +#if !CYTHON_COMPILING_IN_LIMITED_API +#if PY_VERSION_HEX < 0x030900B1 + Py_CLEAR(__Pyx_CyFunction_GetClassObj(m)); #else - if (likely(PyString_Check(n))) + { + PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class; + ((PyCMethodObject *) (m))->mm_class = NULL; + Py_XDECREF(cls); + } #endif - return __Pyx_PyObject_GetAttrStr(o, n); #endif - return PyObject_GetAttr(o, n); + Py_CLEAR(m->defaults_tuple); + Py_CLEAR(m->defaults_kwdict); + Py_CLEAR(m->func_annotations); + Py_CLEAR(m->func_is_coroutine); + Py_CLEAR(m->defaults); + return 0; } - -/* GetAttr3 */ -static PyObject *__Pyx_GetAttr3Default(PyObject *d) { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) - return NULL; - __Pyx_PyErr_Clear(); - Py_INCREF(d); - return d; +static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + if (__Pyx_CyFunction_weakreflist(m) != NULL) + PyObject_ClearWeakRefs((PyObject *) m); + __Pyx_CyFunction_clear(m); + __Pyx_PyHeapTypeObject_GC_Del(m); } -static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { - PyObject *r = __Pyx_GetAttr(o, n); - return (likely(r)) ? r : __Pyx_GetAttr3Default(d); +static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + PyObject_GC_UnTrack(m); + __Pyx__CyFunction_dealloc(m); } - -/* 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; +static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) +{ { - #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, (PyObject *)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; -} - -/* ImportFrom */ -static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { - PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); - if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { - PyErr_Format(PyExc_ImportError, - #if PY_MAJOR_VERSION < 3 - "cannot import name %.230s", PyString_AS_STRING(name)); - #else - "cannot import name %S", name); - #endif + int e = __Pyx_call_type_traverse((PyObject*)m, 1, visit, arg); + if (e) return e; } - return value; + Py_VISIT(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(m->func); +#else + Py_VISIT(((PyCFunctionObject*)m)->m_module); +#endif + Py_VISIT(m->func_dict); + __Pyx_VISIT_CONST(m->func_name); + __Pyx_VISIT_CONST(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + __Pyx_VISIT_CONST(m->func_code); +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(__Pyx_CyFunction_GetClassObj(m)); +#endif + Py_VISIT(m->defaults_tuple); + Py_VISIT(m->defaults_kwdict); + Py_VISIT(m->func_is_coroutine); + Py_VISIT(m->defaults); + return 0; } - -/* 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; +static PyObject* +__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) +{ + PyObject *repr; + __Pyx_BEGIN_CRITICAL_SECTION(op); + repr = PyUnicode_FromFormat("", + op->func_qualname, (void *)op); + __Pyx_END_CRITICAL_SECTION(); + return repr; +} +static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *f = ((__pyx_CyFunctionObject*)func)->func; + PyCFunction meth; + int flags; + meth = PyCFunction_GetFunction(f); + if (unlikely(!meth)) return NULL; + flags = PyCFunction_GetFlags(f); + if (unlikely(flags < 0)) return NULL; +#else + PyCFunctionObject* f = (PyCFunctionObject*)func; + PyCFunction meth = f->m_ml->ml_meth; + int flags = f->m_ml->ml_flags; +#endif + Py_ssize_t size; + switch (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)(void(*)(void))meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_SIZE + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 0)) + return (*meth)(self, NULL); + __Pyx_CyFunction_raise_argument_count_error( + (__pyx_CyFunctionObject*)func, + "takes no arguments", size); + return NULL; } - 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; + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_SIZE + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 1)) { + PyObject *result, *arg0; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + arg0 = PyTuple_GET_ITEM(arg, 0); + #else + arg0 = __Pyx_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; + } + __Pyx_CyFunction_raise_argument_count_error( + (__pyx_CyFunctionObject*)func, + "takes exactly one argument", size); + return NULL; } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + return NULL; } - __Pyx_PyThreadState_assign - __Pyx_ErrRestore(type, value, tb); - return; -raise_error: - Py_XDECREF(value); - Py_XDECREF(type); - Py_XDECREF(tb); - return; + __Pyx_CyFunction_raise_type_error( + (__pyx_CyFunctionObject*)func, "takes no keyword arguments"); + return NULL; } +static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *self, *result; +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; #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; + self = ((PyCFunctionObject*)func)->m_self; +#endif + result = __Pyx_CyFunction_CallMethod(func, self, arg, kw); + return result; +} +static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { + PyObject *result; + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; +#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL) + __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); + if (vc) { +#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE + return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw); +#else + (void) &__Pyx_PyVectorcall_FastCallDict; + return PyVectorcall_Call(func, args, kw); +#endif } - 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; - } +#endif + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + Py_ssize_t argc; + PyObject *new_args; + PyObject *self; +#if CYTHON_ASSUME_SAFE_SIZE + argc = PyTuple_GET_SIZE(args); +#else + argc = PyTuple_Size(args); + if (unlikely(argc < 0)) return NULL; +#endif + 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); + PyErr_Format(PyExc_TypeError, + "unbound method %.200S() needs an argument", + cyfunc->func_qualname); + return NULL; } + result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); + Py_DECREF(new_args); } else { - PyErr_SetString(PyExc_TypeError, - "raise: exception class must be a subclass of BaseException"); - goto bad; + result = __Pyx_CyFunction_Call(func, args, kw); } - 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; + return result; +} +#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL) +static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames) +{ + int ret = 0; + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + if (unlikely(nargs < 1)) { + __Pyx_CyFunction_raise_type_error( + cyfunc, "needs an argument"); + return -1; } - PyException_SetCause(value, fixed_cause); + ret = 1; } - 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 + if (unlikely(kwnames) && unlikely(__Pyx_PyTuple_GET_SIZE(kwnames))) { + __Pyx_CyFunction_raise_type_error( + cyfunc, "takes no keyword arguments"); + return -1; } -bad: - Py_XDECREF(owned_instance); - return; + return ret; } +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); #endif - -/* ExtTypeTest */ -static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { - if (unlikely(!type)) { - PyErr_SetString(PyExc_SystemError, "Missing type object"); - return 0; - } - if (likely(__Pyx_TypeCheck(obj, type))) - return 1; - PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", - Py_TYPE(obj)->tp_name, type->tp_name); - return 0; -} - -/* HasAttr */ -static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { - PyObject *r; - if (unlikely(!__Pyx_PyBaseString_Check(n))) { - PyErr_SetString(PyExc_TypeError, - "hasattr(): attribute name must be string"); - return -1; + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif + break; + default: + return NULL; } - r = __Pyx_GetAttr(o, n); - if (unlikely(!r)) { - PyErr_Clear(); - return 0; - } else { - Py_DECREF(r); - return 1; + if (unlikely(nargs != 0)) { + __Pyx_CyFunction_raise_argument_count_error( + cyfunc, "takes no arguments", nargs); + return NULL; } + return meth(self, NULL); } - -/* PyObject_GenericGetAttrNoDict */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { - PyErr_Format(PyExc_AttributeError, -#if PY_MAJOR_VERSION >= 3 - "'%.50s' object has no attribute '%U'", - tp->tp_name, attr_name); +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; #else - "'%.50s' object has no attribute '%.400s'", - tp->tp_name, PyString_AS_STRING(attr_name)); + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); #endif - return NULL; -} -static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { - PyObject *descr; - PyTypeObject *tp = Py_TYPE(obj); - if (unlikely(!PyString_Check(attr_name))) { - return PyObject_GenericGetAttr(obj, attr_name); - } - assert(!tp->tp_dictoffset); - descr = _PyType_Lookup(tp, attr_name); - if (unlikely(!descr)) { - return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif + break; + default: + return NULL; } - Py_INCREF(descr); - #if PY_MAJOR_VERSION < 3 - if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) - #endif - { - descrgetfunc f = Py_TYPE(descr)->tp_descr_get; - if (unlikely(f)) { - PyObject *res = f(descr, obj, (PyObject *)tp); - Py_DECREF(descr); - return res; - } + if (unlikely(nargs != 1)) { + __Pyx_CyFunction_raise_argument_count_error( + cyfunc, "takes exactly one argument", nargs); + return NULL; } - return descr; + return meth(self, args[0]); } +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); #endif - -/* SetVTable */ -static int __Pyx_SetVtable(PyObject *dict, void *vtable) { -#if PY_VERSION_HEX >= 0x02070000 - PyObject *ob = PyCapsule_New(vtable, 0, 0); + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; #else - PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; #endif - if (!ob) - goto bad; - if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) - goto bad; - Py_DECREF(ob); - return 0; -bad: - Py_XDECREF(ob); - return -1; -} - -/* SetupReduce */ -static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { - int ret; - PyObject *name_attr; - name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name_2); - if (likely(name_attr)) { - ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); - } else { - ret = -1; - } - if (unlikely(ret < 0)) { - PyErr_Clear(); - ret = 0; - } - Py_XDECREF(name_attr); - return ret; -} -static int __Pyx_setup_reduce(PyObject* type_obj) { - int ret = 0; - PyObject *object_reduce = NULL; - PyObject *object_reduce_ex = NULL; - PyObject *reduce = NULL; - PyObject *reduce_ex = NULL; - PyObject *reduce_cython = NULL; - PyObject *setstate = NULL; - PyObject *setstate_cython = NULL; -#if CYTHON_USE_PYTYPE_LOOKUP - if (_PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate)) goto GOOD; -#else - if (PyObject_HasAttr(type_obj, __pyx_n_s_getstate)) goto GOOD; -#endif -#if CYTHON_USE_PYTYPE_LOOKUP - object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto BAD; -#else - object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto BAD; -#endif - reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto BAD; - if (reduce_ex == object_reduce_ex) { -#if CYTHON_USE_PYTYPE_LOOKUP - object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto BAD; -#else - object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto BAD; -#endif - reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto BAD; - if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { - reduce_cython = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_cython); if (unlikely(!reduce_cython)) goto BAD; - ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto BAD; - ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto BAD; - setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate); - if (!setstate) PyErr_Clear(); - if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { - setstate_cython = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate_cython); if (unlikely(!setstate_cython)) goto BAD; - ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto BAD; - ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto BAD; - } - PyType_Modified((PyTypeObject*)type_obj); - } - } - goto GOOD; -BAD: - if (!PyErr_Occurred()) - PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name); - ret = -1; -GOOD: -#if !CYTHON_USE_PYTYPE_LOOKUP - Py_XDECREF(object_reduce); - Py_XDECREF(object_reduce_ex); -#endif - Py_XDECREF(reduce); - Py_XDECREF(reduce_ex); - Py_XDECREF(reduce_cython); - Py_XDECREF(setstate); - Py_XDECREF(setstate_cython); - return ret; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif + break; + default: + return NULL; + } + return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))meth)(self, args, nargs, kwnames); } - -/* TypeImport */ -#ifndef __PYX_HAVE_RT_ImportType -#define __PYX_HAVE_RT_ImportType -static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, - size_t size, enum __Pyx_ImportType_CheckSize check_size) +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) { - PyObject *result = 0; - char warning[200]; - Py_ssize_t basicsize; -#ifdef Py_LIMITED_API - PyObject *py_basicsize; + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc); +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); #endif - result = PyObject_GetAttrString(module, class_name); - if (!result) - goto bad; - if (!PyType_Check(result)) { - PyErr_Format(PyExc_TypeError, - "%.200s.%.200s is not a type object", - module_name, class_name); - goto bad; - } -#ifndef Py_LIMITED_API - basicsize = ((PyTypeObject *)result)->tp_basicsize; + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; #else - py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); - if (!py_basicsize) - goto bad; - basicsize = PyLong_AsSsize_t(py_basicsize); - Py_DECREF(py_basicsize); - py_basicsize = 0; - if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) - goto bad; + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; #endif - if ((size_t)basicsize < size) { - PyErr_Format(PyExc_ValueError, - "%.200s.%.200s size changed, may indicate binary incompatibility. " - "Expected %zd from C header, got %zd from PyObject", - module_name, class_name, size, basicsize); - goto bad; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif + break; + default: + return NULL; } - if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) { - PyErr_Format(PyExc_ValueError, - "%.200s.%.200s size changed, may indicate binary incompatibility. " - "Expected %zd from C header, got %zd from PyObject", - module_name, class_name, size, basicsize); - goto bad; + return ((__Pyx_PyCMethod)(void(*)(void))meth)(self, cls, args, (size_t)nargs, kwnames); +} +#endif +static PyType_Slot __pyx_CyFunctionType_slots[] = { + {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc}, + {Py_tp_repr, (void *)__Pyx_CyFunction_repr}, + {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod}, + {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse}, + {Py_tp_clear, (void *)__Pyx_CyFunction_clear}, + {Py_tp_methods, (void *)__pyx_CyFunction_methods}, + {Py_tp_members, (void *)__pyx_CyFunction_members}, + {Py_tp_getset, (void *)__pyx_CyFunction_getsets}, + {Py_tp_descr_get, (void *)__Pyx_PyMethod_New}, + {0, 0}, +}; +static PyType_Spec __pyx_CyFunctionType_spec = { + __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, +#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR + Py_TPFLAGS_METHOD_DESCRIPTOR | +#endif +#if CYTHON_METH_FASTCALL +#if defined(Py_TPFLAGS_HAVE_VECTORCALL) + Py_TPFLAGS_HAVE_VECTORCALL | +#elif defined(_Py_TPFLAGS_HAVE_VECTORCALL) + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif +#endif // CYTHON_METH_FASTCALL +#if PY_VERSION_HEX >= 0x030A0000 + Py_TPFLAGS_IMMUTABLETYPE | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + __pyx_CyFunctionType_slots +}; +static int __pyx_CyFunction_init(PyObject *module) { + __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module); + mstate->__pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec( + mstate->__pyx_CommonTypesMetaclassType, module, &__pyx_CyFunctionType_spec, NULL); + if (unlikely(mstate->__pyx_CyFunctionType == NULL)) { + return -1; } - else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) { - PyOS_snprintf(warning, sizeof(warning), - "%s.%s size changed, may indicate binary incompatibility. " - "Expected %zd from C header, got %zd from PyObject", - module_name, class_name, size, basicsize); - if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; + return 0; +} +static CYTHON_INLINE PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func, PyTypeObject *defaults_type) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults = PyObject_CallObject((PyObject*)defaults_type, NULL); // _PyObject_New(defaults_type); + if (unlikely(!m->defaults)) + return NULL; + 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); +} + +/* CythonFunction */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + PyObject *op = __Pyx_CyFunction_Init( + PyObject_GC_New(__pyx_CyFunctionObject, __pyx_mstate_global->__pyx_CyFunctionType), + ml, flags, qualname, closure, module, globals, code + ); + if (likely(op)) { + PyObject_GC_Track(op); } - return (PyTypeObject *)result; -bad: - Py_XDECREF(result); - return NULL; + return op; } -#endif /* CLineInTraceback */ -#ifndef CYTHON_CLINE_IN_TRACEBACK +#if CYTHON_CLINE_IN_TRACEBACK && CYTHON_CLINE_IN_TRACEBACK_RUNTIME static int __Pyx_CLineForTraceback(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)) { + CYTHON_MAYBE_UNUSED_VAR(tstate); + if (unlikely(!__pyx_mstate_global->__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); + cython_runtime_dict = _PyObject_GetDictPtr(__pyx_mstate_global->__pyx_cython_runtime); if (likely(cython_runtime_dict)) { + __Pyx_BEGIN_CRITICAL_SECTION(*cython_runtime_dict); __PYX_PY_DICT_LOOKUP_IF_MODIFIED( use_cline, *cython_runtime_dict, - __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) + __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_mstate_global->__pyx_n_u_cline_in_traceback)) + Py_XINCREF(use_cline); + __Pyx_END_CRITICAL_SECTION(); } else #endif { - PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_mstate_global->__pyx_cython_runtime, __pyx_mstate_global->__pyx_n_u_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; + Py_INCREF(use_cline); Py_DECREF(use_cline_obj); } else { PyErr_Clear(); @@ -13192,11 +18936,12 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { } if (!use_cline) { c_line = 0; - PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); + (void) PyObject_SetAttr(__pyx_mstate_global->__pyx_cython_runtime, __pyx_mstate_global->__pyx_n_u_cline_in_traceback, Py_False); } else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { c_line = 0; } + Py_XDECREF(use_cline); __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); return c_line; } @@ -13224,117 +18969,195 @@ static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int co return mid + 1; } } -static PyCodeObject *__pyx_find_code_object(int code_line) { - PyCodeObject* code_object; +static __Pyx_CachedCodeObjectType *__pyx__find_code_object(struct __Pyx_CodeObjectCache *code_cache, int code_line) { + __Pyx_CachedCodeObjectType* code_object; int pos; - if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + if (unlikely(!code_line) || unlikely(!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)) { + pos = __pyx_bisect_code_objects(code_cache->entries, code_cache->count, code_line); + if (unlikely(pos >= code_cache->count) || unlikely(code_cache->entries[pos].code_line != code_line)) { return NULL; } - code_object = __pyx_code_cache.entries[pos].code_object; + code_object = 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) { +static __Pyx_CachedCodeObjectType *__pyx_find_code_object(int code_line) { +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && !CYTHON_ATOMICS + (void)__pyx__find_code_object; + return NULL; // Most implementation should have atomics. But otherwise, don't make it thread-safe, just miss. +#else + struct __Pyx_CodeObjectCache *code_cache = &__pyx_mstate_global->__pyx_code_cache; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_nonatomic_int_type old_count = __pyx_atomic_incr_acq_rel(&code_cache->accessor_count); + if (old_count < 0) { + __pyx_atomic_decr_acq_rel(&code_cache->accessor_count); + return NULL; + } +#endif + __Pyx_CachedCodeObjectType *result = __pyx__find_code_object(code_cache, code_line); +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_atomic_decr_acq_rel(&code_cache->accessor_count); +#endif + return result; +#endif +} +static void __pyx__insert_code_object(struct __Pyx_CodeObjectCache *code_cache, int code_line, __Pyx_CachedCodeObjectType* code_object) +{ int pos, i; - __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + __Pyx_CodeObjectCacheEntry* entries = 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; + code_cache->entries = entries; + code_cache->max_count = 64; + 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; + pos = __pyx_bisect_code_objects(code_cache->entries, code_cache->count, code_line); + if ((pos < code_cache->count) && unlikely(code_cache->entries[pos].code_line == code_line)) { + __Pyx_CachedCodeObjectType* tmp = entries[pos].code_object; entries[pos].code_object = code_object; + Py_INCREF(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; + if (code_cache->count == code_cache->max_count) { + int new_max = code_cache->max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( - __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); + 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; + code_cache->entries = entries; + code_cache->max_count = new_max; } - for (i=__pyx_code_cache.count; i>pos; i--) { + for (i=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++; + code_cache->count++; Py_INCREF(code_object); } +static void __pyx_insert_code_object(int code_line, __Pyx_CachedCodeObjectType* code_object) { +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && !CYTHON_ATOMICS + (void)__pyx__insert_code_object; + return; // Most implementation should have atomics. But otherwise, don't make it thread-safe, just fail. +#else + struct __Pyx_CodeObjectCache *code_cache = &__pyx_mstate_global->__pyx_code_cache; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_nonatomic_int_type expected = 0; + if (!__pyx_atomic_int_cmp_exchange(&code_cache->accessor_count, &expected, INT_MIN)) { + return; + } +#endif + __pyx__insert_code_object(code_cache, code_line, code_object); +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_atomic_sub(&code_cache->accessor_count, INT_MIN); +#endif +#endif +} /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API && !defined(PYPY_VERSION) + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict, + PyObject *firstlineno, PyObject *name) { + PyObject *replace = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL; + replace = PyObject_GetAttrString(code, "replace"); + if (likely(replace)) { + PyObject *result = PyObject_Call(replace, __pyx_mstate_global->__pyx_empty_tuple, scratch_dict); + Py_DECREF(replace); + return result; + } + PyErr_Clear(); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL; + PyObject *replace = NULL, *getframe = NULL, *frame = NULL; + PyObject *exc_type, *exc_value, *exc_traceback; + int success = 0; + if (c_line) { + (void) __pyx_cfilenm; + (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); + } + PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); + code_object = __pyx_find_code_object(c_line ? -c_line : py_line); + if (!code_object) { + code_object = Py_CompileString("_getframe()", filename, Py_eval_input); + if (unlikely(!code_object)) goto bad; + py_py_line = PyLong_FromLong(py_line); + if (unlikely(!py_py_line)) goto bad; + py_funcname = PyUnicode_FromString(funcname); + if (unlikely(!py_funcname)) goto bad; + dict = PyDict_New(); + if (unlikely(!dict)) goto bad; + { + PyObject *old_code_object = code_object; + code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname); + Py_DECREF(old_code_object); + } + if (unlikely(!code_object)) goto bad; + __pyx_insert_code_object(c_line ? -c_line : py_line, code_object); + } else { + dict = PyDict_New(); + } + getframe = PySys_GetObject("_getframe"); + if (unlikely(!getframe)) goto bad; + if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad; + frame = PyEval_EvalCode(code_object, dict, dict); + if (unlikely(!frame) || frame == Py_None) goto bad; + success = 1; + bad: + PyErr_Restore(exc_type, exc_value, exc_traceback); + Py_XDECREF(code_object); + Py_XDECREF(py_py_line); + Py_XDECREF(py_funcname); + Py_XDECREF(dict); + Py_XDECREF(replace); + if (success) { + PyTraceBack_Here( + (struct _frame*)frame); + } + Py_XDECREF(frame); +} +#else 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; + PyCodeObject *py_code = NULL; + PyObject *py_funcname = NULL; 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; + funcname = PyUnicode_AsUTF8(py_funcname); + if (!funcname) goto bad; } - 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); + py_code = PyCode_NewEmpty(filename, funcname, py_line); + Py_XDECREF(py_funcname); return py_code; bad: - Py_XDECREF(py_srcfile); Py_XDECREF(py_funcname); return NULL; } @@ -13343,20 +19166,30 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, PyCodeObject *py_code = 0; PyFrameObject *py_frame = 0; PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject *ptype, *pvalue, *ptraceback; 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) { + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); py_code = __Pyx_CreateCodeObjectForTraceback( funcname, c_line, py_line, filename); - if (!py_code) goto bad; + if (!py_code) { + /* If the code object creation fails, then we should clear the + fetched exception references and propagate the new exception */ + Py_XDECREF(ptype); + Py_XDECREF(pvalue); + Py_XDECREF(ptraceback); + goto bad; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); __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,*/ + __pyx_mstate_global->__pyx_d, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); if (!py_frame) goto bad; @@ -13366,37 +19199,7 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, Py_XDECREF(py_code); Py_XDECREF(py_frame); } - -/* CIntToPy */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { - const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; - const int is_unsigned = neg_one > const_zero; - if (is_unsigned) { - if (sizeof(int) < sizeof(long)) { - return PyInt_FromLong((long) value); - } else if (sizeof(int) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { - return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); -#endif - } - } else { - if (sizeof(int) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= 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(int), - little, !is_unsigned); - } -} /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ @@ -13420,214 +19223,248 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { return (target_type) value;\ } -/* CIntToPy */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { - const long neg_one = (long) ((long) 0 - (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); +/* CIntFromPy */ +static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" #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); + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop #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); - } -} - -/* CIntFromPy */ -static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { - const int neg_one = (int) ((int) 0 - (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 (unlikely(!PyLong_Check(x))) { + int val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (int) -1; + val = __Pyx_PyLong_As_int(tmp); + Py_DECREF(tmp); + return val; + } + 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]) + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { case 2: - if (8 * sizeof(int) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + 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) { + } 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) { + 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) { + } 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) { + 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) { + } 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; - } +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 + 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; - } + { + 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)) + 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)) + } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif - } - } else { + } + } 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]) + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { case -2: - if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + 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) { + } 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) { + 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) { + } 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) { + 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) { + } 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) { + 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) { + } 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) { + 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) { + } 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) { + 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) { + } 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)) + 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)) + } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif - } + } + } + { + int val; + int ret = -1; +#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } +#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (int) -1; + assert(PyLong_CheckExact(v)); } { -#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); + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { Py_DECREF(v); - if (likely(!ret)) - return val; + return (int) -1; } + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (int) -1; + } else { + stepval = v; + } + v = NULL; + val = (int) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((int) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((int) idigit) << bits; + } + if (!is_unsigned) { + if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); #endif + if (unlikely(ret)) 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: @@ -13640,183 +19477,461 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { return (int) -1; } -/* CIntFromPy */ -static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { - const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; +/* PyObjectVectorCallKwBuilder */ +#if CYTHON_VECTORCALL +static int __Pyx_VectorcallBuilder_AddArg(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n) { + (void)__Pyx_PyObject_FastCallDict; + if (__Pyx_PyTuple_SET_ITEM(builder, n, key) != (0)) return -1; + Py_INCREF(key); + args[n] = value; + return 0; +} +CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n) { + (void)__Pyx_VectorcallBuilder_AddArgStr; + if (unlikely(!PyUnicode_Check(key))) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + return -1; + } + return __Pyx_VectorcallBuilder_AddArg(key, value, builder, args, n); +} +static int __Pyx_VectorcallBuilder_AddArgStr(const char *key, PyObject *value, PyObject *builder, PyObject **args, int n) { + PyObject *pyKey = PyUnicode_FromString(key); + if (!pyKey) return -1; + return __Pyx_VectorcallBuilder_AddArg(pyKey, value, builder, args, n); +} +#else // CYTHON_VECTORCALL +CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, CYTHON_UNUSED PyObject **args, CYTHON_UNUSED int n) { + if (unlikely(!PyUnicode_Check(key))) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + return -1; + } + return PyDict_SetItem(builder, key, value); +} +#endif + +/* CIntToPy */ +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_int(int value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif 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)) + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyLong_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyLong_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 + if (is_unsigned) { + return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; + return PyLong_FromNativeBytes(bytes, sizeof(value), -1); + } +#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 + int one = 1; int little = (int)*(unsigned char *)&one; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); +#else + int one = 1; int little = (int)*(unsigned char *)&one; + PyObject *from_bytes, *result = NULL, *kwds = NULL; + PyObject *py_bytes = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + { + PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str }; + if (!is_unsigned) { + kwds = __Pyx_MakeVectorcallBuilderKwds(1); + if (!kwds) goto limited_bad; + if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad; } - return (long) val; + result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); } - } else + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif + } +} + +/* CIntToPy */ +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyLong_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY + } 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 PyLong_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); #endif - if (likely(PyLong_Check(x))) { + } + } + { + unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 if (is_unsigned) { + return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); + } else { + return PyLong_FromNativeBytes(bytes, sizeof(value), -1); + } +#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 + int one = 1; int little = (int)*(unsigned char *)&one; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); +#else + int one = 1; int little = (int)*(unsigned char *)&one; + PyObject *from_bytes, *result = NULL, *kwds = NULL; + PyObject *py_bytes = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + { + PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str }; + if (!is_unsigned) { + kwds = __Pyx_MakeVectorcallBuilderKwds(1); + if (!kwds) goto limited_bad; + if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad; + } + result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); + } + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif + } +} + +/* FormatTypeName */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 +static __Pyx_TypeName +__Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp) +{ + PyObject *module = NULL, *name = NULL, *result = NULL; + #if __PYX_LIMITED_VERSION_HEX < 0x030b0000 + name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_mstate_global->__pyx_n_u_qualname); + #else + name = PyType_GetQualName(tp); + #endif + if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) goto bad; + module = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_mstate_global->__pyx_n_u_module_3); + if (unlikely(module == NULL) || unlikely(!PyUnicode_Check(module))) goto bad; + if (PyUnicode_CompareWithASCIIString(module, "builtins") == 0) { + result = name; + name = NULL; + goto done; + } + result = PyUnicode_FromFormat("%U.%U", module, name); + if (unlikely(result == NULL)) goto bad; + done: + Py_XDECREF(name); + Py_XDECREF(module); + return result; + bad: + PyErr_Clear(); + if (name) { + result = name; + name = NULL; + } else { + result = __Pyx_NewRef(__pyx_mstate_global->__pyx_kp_u__3); + } + goto done; +} +#endif + +/* CIntFromPy */ +static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (unlikely(!PyLong_Check(x))) { + long val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (long) -1; + val = __Pyx_PyLong_As_long(tmp); + Py_DECREF(tmp); + return val; + } + 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]) + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { case 2: - if (8 * sizeof(long) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + 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) { + } 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) { + 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) { + } 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) { + 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) { + } 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; - } +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 + 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; - } + { + 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)) + 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)) + } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif - } - } else { + } + } 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]) + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { case -2: - if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + 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) { + } 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) { + 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) { + } 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) { + 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) { + } 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) { + 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) { + } 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) { + 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) { + } 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) { + 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) { + } 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)) + 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)) + } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif - } + } + } + { + long val; + int ret = -1; +#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } +#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (long) -1; + assert(PyLong_CheckExact(v)); } { -#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); + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { Py_DECREF(v); - if (likely(!ret)) - return val; + return (long) -1; } + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (long) -1; + } else { + stepval = v; + } + v = NULL; + val = (long) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((long) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((long) idigit) << bits; + } + if (!is_unsigned) { + if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); #endif + if (unlikely(ret)) 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: @@ -13829,52 +19944,136 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { return (long) -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); +/* RaiseException */ +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; } - 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; + 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 { - 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) + 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; - Py_INCREF(type); - cached_type = type; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyException_SetTraceback(value, tb); +#elif CYTHON_FAST_THREAD_STATE + 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); + } +#else + 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); +#endif } -done: - Py_DECREF(fake_module); - return cached_type; bad: - Py_XDECREF(cached_type); - cached_type = NULL; - goto done; + Py_XDECREF(owned_instance); + return; +} + +/* PyObjectCall2Args */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { + PyObject *args[3] = {NULL, arg1, arg2}; + return __Pyx_PyObject_FastCall(function, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); } /* PyObjectCallMethod1 */ +#if !(CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000))) static PyObject* __Pyx__PyObject_CallMethod1(PyObject* method, PyObject* arg) { PyObject *result = __Pyx_PyObject_CallOneArg(method, arg); Py_DECREF(method); return result; } +#endif static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) { +#if CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000)) + PyObject *args[2] = {obj, arg}; + (void) __Pyx_PyObject_GetMethod; + (void) __Pyx_PyObject_CallOneArg; + (void) __Pyx_PyObject_Call2Args; + return PyObject_VectorcallMethod(method_name, args, 2 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); +#else PyObject *method = NULL, *result; int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); if (likely(is_method)) { @@ -13884,15 +20083,84 @@ static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name } if (unlikely(!method)) return NULL; return __Pyx__PyObject_CallMethod1(method, arg); +#endif +} + +/* ReturnWithStopIteration */ +static void __Pyx__ReturnWithStopIteration(PyObject* value, int async); +static CYTHON_INLINE void __Pyx_ReturnWithStopIteration(PyObject* value, int async, int iternext) { + if (value == Py_None) { + if (async || !iternext) + PyErr_SetNone(async ? PyExc_StopAsyncIteration : PyExc_StopIteration); + return; + } + __Pyx__ReturnWithStopIteration(value, async); +} +static void __Pyx__ReturnWithStopIteration(PyObject* value, int async) { +#if CYTHON_COMPILING_IN_CPYTHON + __Pyx_PyThreadState_declare +#endif + PyObject *exc; + PyObject *exc_type = async ? PyExc_StopAsyncIteration : PyExc_StopIteration; +#if CYTHON_COMPILING_IN_CPYTHON + if ((PY_VERSION_HEX >= (0x030C00A6)) || unlikely(PyTuple_Check(value) || PyExceptionInstance_Check(value))) { + if (PY_VERSION_HEX >= (0x030e00A1)) { + exc = __Pyx_PyObject_CallOneArg(exc_type, value); + } else { + PyObject *args_tuple = PyTuple_New(1); + if (unlikely(!args_tuple)) return; + Py_INCREF(value); + PyTuple_SET_ITEM(args_tuple, 0, value); + exc = PyObject_Call(exc_type, args_tuple, NULL); + Py_DECREF(args_tuple); + } + if (unlikely(!exc)) return; + } else { + Py_INCREF(value); + exc = value; + } + #if CYTHON_FAST_THREAD_STATE + __Pyx_PyThreadState_assign + #if CYTHON_USE_EXC_INFO_STACK + if (!__pyx_tstate->exc_info->exc_value) + #else + if (!__pyx_tstate->exc_type) + #endif + { + Py_INCREF(exc_type); + __Pyx_ErrRestore(exc_type, exc, NULL); + return; + } + #endif +#else + exc = __Pyx_PyObject_CallOneArg(exc_type, value); + if (unlikely(!exc)) return; +#endif + PyErr_SetObject(exc_type, exc); + Py_DECREF(exc); } /* CoroutineBase */ -#include +#if !CYTHON_COMPILING_IN_LIMITED_API #include -#define __Pyx_Coroutine_Undelegate(gen) Py_CLEAR((gen)->yieldfrom) -static int __Pyx_PyGen__FetchStopIterationValue(CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject **pvalue) { +#if PY_VERSION_HEX >= 0x030b00a6 && !defined(PYPY_VERSION) + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif +#endif // CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE void +__Pyx_Coroutine_Undelegate(__pyx_CoroutineObject *gen) { +#if CYTHON_USE_AM_SEND + gen->yieldfrom_am_send = NULL; +#endif + Py_CLEAR(gen->yieldfrom); +} +static int __Pyx_PyGen__FetchStopIterationValue(PyThreadState *__pyx_tstate, PyObject **pvalue) { PyObject *et, *ev, *tb; PyObject *value = NULL; + CYTHON_UNUSED_VAR(__pyx_tstate); __Pyx_ErrFetch(&et, &ev, &tb); if (!et) { Py_XDECREF(tb); @@ -13906,20 +20174,35 @@ static int __Pyx_PyGen__FetchStopIterationValue(CYTHON_UNUSED PyThreadState *__p Py_INCREF(Py_None); value = Py_None; } -#if PY_VERSION_HEX >= 0x030300A0 - else if (Py_TYPE(ev) == (PyTypeObject*)PyExc_StopIteration) { + else if (likely(__Pyx_IS_TYPE(ev, (PyTypeObject*)PyExc_StopIteration))) { + #if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL + value = PyObject_GetAttr(ev, __pyx_mstate_global->__pyx_n_u_value); + if (unlikely(!value)) goto limited_api_failure; + #else value = ((PyStopIterationObject *)ev)->value; Py_INCREF(value); + #endif Py_DECREF(ev); } -#endif else if (unlikely(PyTuple_Check(ev))) { - if (PyTuple_GET_SIZE(ev) >= 1) { + Py_ssize_t tuple_size = __Pyx_PyTuple_GET_SIZE(ev); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(tuple_size < 0)) { + Py_XDECREF(tb); + Py_DECREF(ev); + Py_DECREF(et); + return -1; + } + #endif + if (tuple_size >= 1) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS value = PyTuple_GET_ITEM(ev, 0); Py_INCREF(value); -#else +#elif CYTHON_ASSUME_SAFE_MACROS value = PySequence_ITEM(ev, 0); +#else + value = PySequence_GetItem(ev, 0); + if (!value) goto limited_api_failure; #endif } else { Py_INCREF(Py_None); @@ -13947,30 +20230,41 @@ static int __Pyx_PyGen__FetchStopIterationValue(CYTHON_UNUSED PyThreadState *__p } Py_XDECREF(tb); Py_DECREF(et); -#if PY_VERSION_HEX >= 0x030300A0 +#if CYTHON_COMPILING_IN_LIMITED_API + value = PyObject_GetAttr(ev, __pyx_mstate_global->__pyx_n_u_value); +#else value = ((PyStopIterationObject *)ev)->value; Py_INCREF(value); +#endif Py_DECREF(ev); -#else - { - PyObject* args = __Pyx_PyObject_GetAttrStr(ev, __pyx_n_s_args); - Py_DECREF(ev); - if (likely(args)) { - value = PySequence_GetItem(args, 0); - Py_DECREF(args); - } - if (unlikely(!value)) { - __Pyx_ErrRestore(NULL, NULL, NULL); - Py_INCREF(Py_None); - value = Py_None; - } - } +#if CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(!value)) return -1; #endif *pvalue = value; return 0; +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL || !CYTHON_ASSUME_SAFE_MACROS + limited_api_failure: + Py_XDECREF(et); + Py_XDECREF(tb); + Py_XDECREF(ev); + return -1; +#endif +} +static CYTHON_INLINE +__Pyx_PySendResult __Pyx_Coroutine_status_from_result(PyObject **retval) { + if (*retval) { + return PYGEN_NEXT; + } else if (likely(__Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, retval) == 0)) { + return PYGEN_RETURN; + } else { + return PYGEN_ERROR; + } } static CYTHON_INLINE void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *exc_state) { +#if PY_VERSION_HEX >= 0x030B00a4 + Py_CLEAR(exc_state->exc_value); +#else PyObject *t, *v, *tb; t = exc_state->exc_type; v = exc_state->exc_value; @@ -13981,10 +20275,12 @@ void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *exc_state) { Py_XDECREF(t); Py_XDECREF(v); Py_XDECREF(tb); +#endif } #define __Pyx_Coroutine_AlreadyRunningError(gen) (__Pyx__Coroutine_AlreadyRunningError(gen), (PyObject*)NULL) -static void __Pyx__Coroutine_AlreadyRunningError(CYTHON_UNUSED __pyx_CoroutineObject *gen) { +static void __Pyx__Coroutine_AlreadyRunningError(__pyx_CoroutineObject *gen) { const char *msg; + CYTHON_MAYBE_UNUSED_VAR(gen); if ((0)) { #ifdef __Pyx_Coroutine_USED } else if (__Pyx_Coroutine_Check((PyObject*)gen)) { @@ -13999,25 +20295,9 @@ static void __Pyx__Coroutine_AlreadyRunningError(CYTHON_UNUSED __pyx_CoroutineOb } PyErr_SetString(PyExc_ValueError, msg); } -#define __Pyx_Coroutine_NotStartedError(gen) (__Pyx__Coroutine_NotStartedError(gen), (PyObject*)NULL) -static void __Pyx__Coroutine_NotStartedError(CYTHON_UNUSED PyObject *gen) { - const char *msg; - if ((0)) { - #ifdef __Pyx_Coroutine_USED - } else if (__Pyx_Coroutine_Check(gen)) { - msg = "can't send non-None value to a just-started coroutine"; - #endif - #ifdef __Pyx_AsyncGen_USED - } else if (__Pyx_AsyncGen_CheckExact(gen)) { - msg = "can't send non-None value to a just-started async generator"; - #endif - } else { - msg = "can't send non-None value to a just-started generator"; - } - PyErr_SetString(PyExc_TypeError, msg); -} -#define __Pyx_Coroutine_AlreadyTerminatedError(gen, value, closing) (__Pyx__Coroutine_AlreadyTerminatedError(gen, value, closing), (PyObject*)NULL) -static void __Pyx__Coroutine_AlreadyTerminatedError(CYTHON_UNUSED PyObject *gen, PyObject *value, CYTHON_UNUSED int closing) { +static void __Pyx_Coroutine_AlreadyTerminatedError(PyObject *gen, PyObject *value, int closing) { + CYTHON_MAYBE_UNUSED_VAR(gen); + CYTHON_MAYBE_UNUSED_VAR(closing); #ifdef __Pyx_Coroutine_USED if (!closing && __Pyx_Coroutine_Check(gen)) { PyErr_SetString(PyExc_RuntimeError, "cannot reuse already awaited coroutine"); @@ -14026,26 +20306,22 @@ static void __Pyx__Coroutine_AlreadyTerminatedError(CYTHON_UNUSED PyObject *gen, if (value) { #ifdef __Pyx_AsyncGen_USED if (__Pyx_AsyncGen_CheckExact(gen)) - PyErr_SetNone(__Pyx_PyExc_StopAsyncIteration); + PyErr_SetNone(PyExc_StopAsyncIteration); else #endif PyErr_SetNone(PyExc_StopIteration); } } static -PyObject *__Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value, int closing) { +__Pyx_PySendResult __Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value, PyObject **result, int closing) { __Pyx_PyThreadState_declare PyThreadState *tstate; __Pyx_ExcInfoStruct *exc_state; PyObject *retval; - assert(!self->is_running); - if (unlikely(self->resume_label == 0)) { - if (unlikely(value && value != Py_None)) { - return __Pyx_Coroutine_NotStartedError((PyObject*)self); - } - } + assert(__Pyx_Coroutine_get_is_running(self)); // Callers should ensure is_running if (unlikely(self->resume_label == -1)) { - return __Pyx_Coroutine_AlreadyTerminatedError((PyObject*)self, value, closing); + __Pyx_Coroutine_AlreadyTerminatedError((PyObject*)self, value, closing); + return PYGEN_ERROR; } #if CYTHON_FAST_THREAD_STATE __Pyx_PyThreadState_assign @@ -14054,15 +20330,30 @@ PyObject *__Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value, i tstate = __Pyx_PyThreadState_Current; #endif exc_state = &self->gi_exc_state; - if (exc_state->exc_type) { - #if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_PYSTON + if (exc_state->exc_value) { + #if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY #else - if (exc_state->exc_traceback) { - PyTracebackObject *tb = (PyTracebackObject *) exc_state->exc_traceback; + PyObject *exc_tb; + #if PY_VERSION_HEX >= 0x030B00a4 && !CYTHON_COMPILING_IN_CPYTHON + exc_tb = PyException_GetTraceback(exc_state->exc_value); + #elif PY_VERSION_HEX >= 0x030B00a4 + exc_tb = ((PyBaseExceptionObject*) exc_state->exc_value)->traceback; + #else + exc_tb = exc_state->exc_traceback; + #endif + if (exc_tb) { + PyTracebackObject *tb = (PyTracebackObject *) exc_tb; PyFrameObject *f = tb->tb_frame; - Py_XINCREF(tstate->frame); assert(f->f_back == NULL); + #if PY_VERSION_HEX >= 0x030B00A1 + f->f_back = PyThreadState_GetFrame(tstate); + #else + Py_XINCREF(tstate->frame); f->f_back = tstate->frame; + #endif + #if PY_VERSION_HEX >= 0x030B00a4 && !CYTHON_COMPILING_IN_CPYTHON + Py_DECREF(exc_tb); + #endif } #endif } @@ -14077,63 +20368,144 @@ PyObject *__Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value, i __Pyx_ExceptionSave(&exc_state->exc_type, &exc_state->exc_value, &exc_state->exc_traceback); } #endif - self->is_running = 1; - retval = self->body((PyObject *) self, tstate, value); - self->is_running = 0; + retval = self->body(self, tstate, value); #if CYTHON_USE_EXC_INFO_STACK exc_state = &self->gi_exc_state; tstate->exc_info = exc_state->previous_item; exc_state->previous_item = NULL; __Pyx_Coroutine_ResetFrameBackpointer(exc_state); #endif - return retval; + *result = retval; + if (self->resume_label == -1) { + return likely(retval) ? PYGEN_RETURN : PYGEN_ERROR; + } + return PYGEN_NEXT; } static CYTHON_INLINE void __Pyx_Coroutine_ResetFrameBackpointer(__Pyx_ExcInfoStruct *exc_state) { - PyObject *exc_tb = exc_state->exc_traceback; - if (likely(exc_tb)) { -#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_PYSTON +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API + CYTHON_UNUSED_VAR(exc_state); #else + PyObject *exc_tb; + #if PY_VERSION_HEX >= 0x030B00a4 + if (!exc_state->exc_value) return; + exc_tb = PyException_GetTraceback(exc_state->exc_value); + #else + exc_tb = exc_state->exc_traceback; + #endif + if (likely(exc_tb)) { PyTracebackObject *tb = (PyTracebackObject *) exc_tb; PyFrameObject *f = tb->tb_frame; Py_CLEAR(f->f_back); + #if PY_VERSION_HEX >= 0x030B00a4 + Py_DECREF(exc_tb); + #endif + } #endif +} +#define __Pyx_Coroutine_MethodReturnFromResult(gen, result, retval, iternext)\ + ((result) == PYGEN_NEXT ? (retval) : __Pyx__Coroutine_MethodReturnFromResult(gen, result, retval, iternext)) +static PyObject * +__Pyx__Coroutine_MethodReturnFromResult(PyObject* gen, __Pyx_PySendResult result, PyObject *retval, int iternext) { + CYTHON_MAYBE_UNUSED_VAR(gen); + if (likely(result == PYGEN_RETURN)) { + int is_async = 0; + #ifdef __Pyx_AsyncGen_USED + is_async = __Pyx_AsyncGen_CheckExact(gen); + #endif + __Pyx_ReturnWithStopIteration(retval, is_async, iternext); + Py_XDECREF(retval); } + return NULL; } +#if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE -PyObject *__Pyx_Coroutine_MethodReturn(CYTHON_UNUSED PyObject* gen, PyObject *retval) { - if (unlikely(!retval)) { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - if (!__Pyx_PyErr_Occurred()) { - PyObject *exc = PyExc_StopIteration; - #ifdef __Pyx_AsyncGen_USED - if (__Pyx_AsyncGen_CheckExact(gen)) - exc = __Pyx_PyExc_StopAsyncIteration; - #endif - __Pyx_PyErr_SetNone(exc); +PyObject *__Pyx_PyGen_Send(PyGenObject *gen, PyObject *arg) { +#if PY_VERSION_HEX <= 0x030A00A1 + return _PyGen_Send(gen, arg); +#else + PyObject *result; + if (PyIter_Send((PyObject*)gen, arg ? arg : Py_None, &result) == PYGEN_RETURN) { + if (PyAsyncGen_CheckExact(gen)) { + assert(result == Py_None); + PyErr_SetNone(PyExc_StopAsyncIteration); + } + else if (result == Py_None) { + PyErr_SetNone(PyExc_StopIteration); + } + else { +#if PY_VERSION_HEX < 0x030d00A1 + _PyGen_SetStopIterationValue(result); +#else + if (!PyTuple_Check(result) && !PyExceptionInstance_Check(result)) { + PyErr_SetObject(PyExc_StopIteration, result); + } else { + PyObject *exc = __Pyx_PyObject_CallOneArg(PyExc_StopIteration, result); + if (likely(exc != NULL)) { + PyErr_SetObject(PyExc_StopIteration, exc); + Py_DECREF(exc); + } + } +#endif } + Py_DECREF(result); + result = NULL; } - return retval; + return result; +#endif } -static CYTHON_INLINE -PyObject *__Pyx_Coroutine_FinishDelegation(__pyx_CoroutineObject *gen) { - PyObject *ret; +#endif +static CYTHON_INLINE __Pyx_PySendResult +__Pyx_Coroutine_FinishDelegation(__pyx_CoroutineObject *gen, PyObject** retval) { + __Pyx_PySendResult result; PyObject *val = NULL; + assert(__Pyx_Coroutine_get_is_running(gen)); __Pyx_Coroutine_Undelegate(gen); __Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, &val); - ret = __Pyx_Coroutine_SendEx(gen, val, 0); + result = __Pyx_Coroutine_SendEx(gen, val, retval, 0); Py_XDECREF(val); - return ret; + return result; +} +#if CYTHON_USE_AM_SEND +static __Pyx_PySendResult +__Pyx_Coroutine_SendToDelegate(__pyx_CoroutineObject *gen, __Pyx_pyiter_sendfunc gen_am_send, PyObject *value, PyObject **retval) { + PyObject *ret = NULL; + __Pyx_PySendResult delegate_result, result; + assert(__Pyx_Coroutine_get_is_running(gen)); + delegate_result = gen_am_send(gen->yieldfrom, value, &ret); + if (delegate_result == PYGEN_NEXT) { + assert (ret != NULL); + *retval = ret; + return PYGEN_NEXT; + } + assert (delegate_result != PYGEN_ERROR || ret == NULL); + __Pyx_Coroutine_Undelegate(gen); + result = __Pyx_Coroutine_SendEx(gen, ret, retval, 0); + Py_XDECREF(ret); + return result; } +#endif static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value) { - PyObject *retval; + PyObject *retval = NULL; + __Pyx_PySendResult result = __Pyx_Coroutine_AmSend(self, value, &retval); + return __Pyx_Coroutine_MethodReturnFromResult(self, result, retval, 0); +} +static __Pyx_PySendResult +__Pyx_Coroutine_AmSend(PyObject *self, PyObject *value, PyObject **retval) { + __Pyx_PySendResult result; __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; - PyObject *yf = gen->yieldfrom; - if (unlikely(gen->is_running)) - return __Pyx_Coroutine_AlreadyRunningError(gen); - if (yf) { + if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) { + *retval = __Pyx_Coroutine_AlreadyRunningError(gen); + return PYGEN_ERROR; + } + #if CYTHON_USE_AM_SEND + if (gen->yieldfrom_am_send) { + result = __Pyx_Coroutine_SendToDelegate(gen, gen->yieldfrom_am_send, value, retval); + } else + #endif + if (gen->yieldfrom) { + PyObject *yf = gen->yieldfrom; PyObject *ret; - gen->is_running = 1; + #if !CYTHON_USE_AM_SEND #ifdef __Pyx_Generator_USED if (__Pyx_Generator_CheckExact(yf)) { ret = __Pyx_Coroutine_Send(yf, value); @@ -14149,124 +20521,145 @@ static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value) { ret = __Pyx_async_gen_asend_send(yf, value); } else #endif - #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03030000 && (defined(__linux__) || PY_VERSION_HEX >= 0x030600B3) + #if CYTHON_COMPILING_IN_CPYTHON if (PyGen_CheckExact(yf)) { - ret = _PyGen_Send((PyGenObject*)yf, value == Py_None ? NULL : value); + ret = __Pyx_PyGen_Send((PyGenObject*)yf, value == Py_None ? NULL : value); } else - #endif - #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03050000 && defined(PyCoro_CheckExact) && (defined(__linux__) || PY_VERSION_HEX >= 0x030600B3) if (PyCoro_CheckExact(yf)) { - ret = _PyGen_Send((PyGenObject*)yf, value == Py_None ? NULL : value); + ret = __Pyx_PyGen_Send((PyGenObject*)yf, value == Py_None ? NULL : value); } else #endif + #endif { - if (value == Py_None) - ret = Py_TYPE(yf)->tp_iternext(yf); + #if !CYTHON_COMPILING_IN_LIMITED_API || __PYX_LIMITED_VERSION_HEX >= 0x03080000 + if (value == Py_None && PyIter_Check(yf)) + ret = __Pyx_PyIter_Next_Plain(yf); else - ret = __Pyx_PyObject_CallMethod1(yf, __pyx_n_s_send, value); + #endif + ret = __Pyx_PyObject_CallMethod1(yf, __pyx_mstate_global->__pyx_n_u_send, value); } - gen->is_running = 0; if (likely(ret)) { - return ret; + __Pyx_Coroutine_unset_is_running(gen); + *retval = ret; + return PYGEN_NEXT; } - retval = __Pyx_Coroutine_FinishDelegation(gen); + result = __Pyx_Coroutine_FinishDelegation(gen, retval); } else { - retval = __Pyx_Coroutine_SendEx(gen, value, 0); + result = __Pyx_Coroutine_SendEx(gen, value, retval, 0); } - return __Pyx_Coroutine_MethodReturn(self, retval); + __Pyx_Coroutine_unset_is_running(gen); + return result; } static int __Pyx_Coroutine_CloseIter(__pyx_CoroutineObject *gen, PyObject *yf) { + __Pyx_PySendResult result; PyObject *retval = NULL; - int err = 0; + CYTHON_UNUSED_VAR(gen); + assert(__Pyx_Coroutine_get_is_running(gen)); #ifdef __Pyx_Generator_USED if (__Pyx_Generator_CheckExact(yf)) { - retval = __Pyx_Coroutine_Close(yf); - if (!retval) - return -1; + result = __Pyx_Coroutine_Close(yf, &retval); } else #endif #ifdef __Pyx_Coroutine_USED if (__Pyx_Coroutine_Check(yf)) { - retval = __Pyx_Coroutine_Close(yf); - if (!retval) - return -1; + result = __Pyx_Coroutine_Close(yf, &retval); } else if (__Pyx_CoroutineAwait_CheckExact(yf)) { - retval = __Pyx_CoroutineAwait_Close((__pyx_CoroutineAwaitObject*)yf, NULL); - if (!retval) - return -1; + result = __Pyx_CoroutineAwait_Close((__pyx_CoroutineAwaitObject*)yf); } else #endif #ifdef __Pyx_AsyncGen_USED if (__pyx_PyAsyncGenASend_CheckExact(yf)) { retval = __Pyx_async_gen_asend_close(yf, NULL); + result = PYGEN_RETURN; } else if (__pyx_PyAsyncGenAThrow_CheckExact(yf)) { retval = __Pyx_async_gen_athrow_close(yf, NULL); + result = PYGEN_RETURN; } else #endif { PyObject *meth; - gen->is_running = 1; - meth = __Pyx_PyObject_GetAttrStr(yf, __pyx_n_s_close); + result = PYGEN_RETURN; + meth = __Pyx_PyObject_GetAttrStrNoError(yf, __pyx_mstate_global->__pyx_n_u_close); if (unlikely(!meth)) { - if (!PyErr_ExceptionMatches(PyExc_AttributeError)) { + if (unlikely(PyErr_Occurred())) { PyErr_WriteUnraisable(yf); } - PyErr_Clear(); } else { - retval = PyObject_CallFunction(meth, NULL); + retval = __Pyx_PyObject_CallNoArg(meth); Py_DECREF(meth); - if (!retval) - err = -1; + if (unlikely(!retval)) { + result = PYGEN_ERROR; + } } - gen->is_running = 0; } Py_XDECREF(retval); - return err; + return result == PYGEN_ERROR ? -1 : 0; } static PyObject *__Pyx_Generator_Next(PyObject *self) { + __Pyx_PySendResult result; + PyObject *retval = NULL; __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; - PyObject *yf = gen->yieldfrom; - if (unlikely(gen->is_running)) + if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) { return __Pyx_Coroutine_AlreadyRunningError(gen); - if (yf) { + } + #if CYTHON_USE_AM_SEND + if (gen->yieldfrom_am_send) { + result = __Pyx_Coroutine_SendToDelegate(gen, gen->yieldfrom_am_send, Py_None, &retval); + } else + #endif + if (gen->yieldfrom) { + PyObject *yf = gen->yieldfrom; PyObject *ret; - gen->is_running = 1; #ifdef __Pyx_Generator_USED if (__Pyx_Generator_CheckExact(yf)) { ret = __Pyx_Generator_Next(yf); } else #endif - #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03030000 && (defined(__linux__) || PY_VERSION_HEX >= 0x030600B3) - if (PyGen_CheckExact(yf)) { - ret = _PyGen_Send((PyGenObject*)yf, NULL); - } else - #endif #ifdef __Pyx_Coroutine_USED - if (__Pyx_Coroutine_Check(yf)) { + if (__Pyx_Coroutine_CheckExact(yf)) { ret = __Pyx_Coroutine_Send(yf, Py_None); } else #endif - ret = Py_TYPE(yf)->tp_iternext(yf); - gen->is_running = 0; + #if CYTHON_COMPILING_IN_CPYTHON && (PY_VERSION_HEX < 0x030A00A3 || !CYTHON_USE_AM_SEND) + if (PyGen_CheckExact(yf)) { + ret = __Pyx_PyGen_Send((PyGenObject*)yf, NULL); + } else + #endif + ret = __Pyx_PyIter_Next_Plain(yf); if (likely(ret)) { + __Pyx_Coroutine_unset_is_running(gen); return ret; } - return __Pyx_Coroutine_FinishDelegation(gen); + result = __Pyx_Coroutine_FinishDelegation(gen, &retval); + } else { + result = __Pyx_Coroutine_SendEx(gen, Py_None, &retval, 0); } - return __Pyx_Coroutine_SendEx(gen, Py_None, 0); + __Pyx_Coroutine_unset_is_running(gen); + return __Pyx_Coroutine_MethodReturnFromResult(self, result, retval, 1); } -static PyObject *__Pyx_Coroutine_Close_Method(PyObject *self, CYTHON_UNUSED PyObject *arg) { - return __Pyx_Coroutine_Close(self); +static PyObject *__Pyx_Coroutine_Close_Method(PyObject *self, PyObject *arg) { + PyObject *retval = NULL; + __Pyx_PySendResult result; + CYTHON_UNUSED_VAR(arg); + result = __Pyx_Coroutine_Close(self, &retval); + if (unlikely(result == PYGEN_ERROR)) + return NULL; + Py_XDECREF(retval); + Py_RETURN_NONE; } -static PyObject *__Pyx_Coroutine_Close(PyObject *self) { +static __Pyx_PySendResult +__Pyx_Coroutine_Close(PyObject *self, PyObject **retval) { __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; - PyObject *retval, *raised_exception; - PyObject *yf = gen->yieldfrom; + __Pyx_PySendResult result; + PyObject *yf; int err = 0; - if (unlikely(gen->is_running)) - return __Pyx_Coroutine_AlreadyRunningError(gen); + if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) { + *retval = __Pyx_Coroutine_AlreadyRunningError(gen); + return PYGEN_ERROR; + } + yf = gen->yieldfrom; if (yf) { Py_INCREF(yf); err = __Pyx_Coroutine_CloseIter(gen, yf); @@ -14275,10 +20668,25 @@ static PyObject *__Pyx_Coroutine_Close(PyObject *self) { } if (err == 0) PyErr_SetNone(PyExc_GeneratorExit); - retval = __Pyx_Coroutine_SendEx(gen, NULL, 1); - if (unlikely(retval)) { + result = __Pyx_Coroutine_SendEx(gen, NULL, retval, 1); + if (result == PYGEN_ERROR) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_Coroutine_unset_is_running(gen); + if (!__Pyx_PyErr_Occurred()) { + return PYGEN_RETURN; + } else if (likely(__Pyx_PyErr_ExceptionMatches2(PyExc_GeneratorExit, PyExc_StopIteration))) { + __Pyx_PyErr_Clear(); + return PYGEN_RETURN; + } + return PYGEN_ERROR; + } else if (likely(result == PYGEN_RETURN && *retval == Py_None)) { + __Pyx_Coroutine_unset_is_running(gen); + return PYGEN_RETURN; + } else { const char *msg; - Py_DECREF(retval); + Py_DECREF(*retval); + *retval = NULL; if ((0)) { #ifdef __Pyx_Coroutine_USED } else if (__Pyx_Coroutine_Check(self)) { @@ -14286,33 +20694,25 @@ static PyObject *__Pyx_Coroutine_Close(PyObject *self) { #endif #ifdef __Pyx_AsyncGen_USED } else if (__Pyx_AsyncGen_CheckExact(self)) { -#if PY_VERSION_HEX < 0x03060000 - msg = "async generator ignored GeneratorExit - might require Python 3.6+ finalisation (PEP 525)"; -#else msg = "async generator ignored GeneratorExit"; -#endif #endif } else { msg = "generator ignored GeneratorExit"; } PyErr_SetString(PyExc_RuntimeError, msg); - return NULL; - } - raised_exception = PyErr_Occurred(); - if (likely(!raised_exception || __Pyx_PyErr_GivenExceptionMatches2(raised_exception, PyExc_GeneratorExit, PyExc_StopIteration))) { - if (raised_exception) PyErr_Clear(); - Py_INCREF(Py_None); - return Py_None; + __Pyx_Coroutine_unset_is_running(gen); + return PYGEN_ERROR; } - return NULL; } static PyObject *__Pyx__Coroutine_Throw(PyObject *self, PyObject *typ, PyObject *val, PyObject *tb, PyObject *args, int close_on_genexit) { __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; - PyObject *yf = gen->yieldfrom; - if (unlikely(gen->is_running)) + PyObject *yf; + if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) return __Pyx_Coroutine_AlreadyRunningError(gen); + yf = gen->yieldfrom; if (yf) { + __Pyx_PySendResult result; PyObject *ret; Py_INCREF(yf); if (__Pyx_PyErr_GivenExceptionMatches(typ, PyExc_GeneratorExit) && close_on_genexit) { @@ -14320,10 +20720,9 @@ static PyObject *__Pyx__Coroutine_Throw(PyObject *self, PyObject *typ, PyObject Py_DECREF(yf); __Pyx_Coroutine_Undelegate(gen); if (err < 0) - return __Pyx_Coroutine_MethodReturn(self, __Pyx_Coroutine_SendEx(gen, NULL, 0)); + goto propagate_exception; goto throw_here; } - gen->is_running = 1; if (0 #ifdef __Pyx_Generator_USED || __Pyx_Generator_CheckExact(yf) @@ -14338,51 +20737,66 @@ static PyObject *__Pyx__Coroutine_Throw(PyObject *self, PyObject *typ, PyObject ret = __Pyx__Coroutine_Throw(((__pyx_CoroutineAwaitObject*)yf)->coroutine, typ, val, tb, args, close_on_genexit); #endif } else { - PyObject *meth = __Pyx_PyObject_GetAttrStr(yf, __pyx_n_s_throw); + PyObject *meth = __Pyx_PyObject_GetAttrStrNoError(yf, __pyx_mstate_global->__pyx_n_u_throw); if (unlikely(!meth)) { Py_DECREF(yf); - if (!PyErr_ExceptionMatches(PyExc_AttributeError)) { - gen->is_running = 0; + if (unlikely(PyErr_Occurred())) { + __Pyx_Coroutine_unset_is_running(gen); return NULL; } - PyErr_Clear(); __Pyx_Coroutine_Undelegate(gen); - gen->is_running = 0; goto throw_here; } if (likely(args)) { - ret = PyObject_CallObject(meth, args); + ret = __Pyx_PyObject_Call(meth, args, NULL); } else { - ret = PyObject_CallFunctionObjArgs(meth, typ, val, tb, NULL); + PyObject *cargs[4] = {NULL, typ, val, tb}; + ret = __Pyx_PyObject_FastCall(meth, cargs+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); } Py_DECREF(meth); } - gen->is_running = 0; Py_DECREF(yf); - if (!ret) { - ret = __Pyx_Coroutine_FinishDelegation(gen); + if (ret) { + __Pyx_Coroutine_unset_is_running(gen); + return ret; } - return __Pyx_Coroutine_MethodReturn(self, ret); + result = __Pyx_Coroutine_FinishDelegation(gen, &ret); + __Pyx_Coroutine_unset_is_running(gen); + return __Pyx_Coroutine_MethodReturnFromResult(self, result, ret, 0); } throw_here: __Pyx_Raise(typ, val, tb, NULL); - return __Pyx_Coroutine_MethodReturn(self, __Pyx_Coroutine_SendEx(gen, NULL, 0)); +propagate_exception: + { + PyObject *retval = NULL; + __Pyx_PySendResult result = __Pyx_Coroutine_SendEx(gen, NULL, &retval, 0); + __Pyx_Coroutine_unset_is_running(gen); + return __Pyx_Coroutine_MethodReturnFromResult(self, result, retval, 0); + } } static PyObject *__Pyx_Coroutine_Throw(PyObject *self, PyObject *args) { PyObject *typ; PyObject *val = NULL; PyObject *tb = NULL; - if (!PyArg_UnpackTuple(args, (char *)"throw", 1, 3, &typ, &val, &tb)) + if (unlikely(!PyArg_UnpackTuple(args, "throw", 1, 3, &typ, &val, &tb))) return NULL; return __Pyx__Coroutine_Throw(self, typ, val, tb, args, 1); } static CYTHON_INLINE int __Pyx_Coroutine_traverse_excstate(__Pyx_ExcInfoStruct *exc_state, visitproc visit, void *arg) { +#if PY_VERSION_HEX >= 0x030B00a4 + Py_VISIT(exc_state->exc_value); +#else Py_VISIT(exc_state->exc_type); Py_VISIT(exc_state->exc_value); Py_VISIT(exc_state->exc_traceback); +#endif return 0; } static int __Pyx_Coroutine_traverse(__pyx_CoroutineObject *gen, visitproc visit, void *arg) { + { + int e = __Pyx_call_type_traverse((PyObject*)gen, 1, visit, arg); + if (e) return e; + } Py_VISIT(gen->closure); Py_VISIT(gen->classobj); Py_VISIT(gen->yieldfrom); @@ -14392,7 +20806,7 @@ static int __Pyx_Coroutine_clear(PyObject *self) { __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; Py_CLEAR(gen->closure); Py_CLEAR(gen->classobj); - Py_CLEAR(gen->yieldfrom); + __Pyx_Coroutine_Undelegate(gen); __Pyx_Coroutine_ExceptionClear(&gen->gi_exc_state); #ifdef __Pyx_AsyncGen_USED if (__Pyx_AsyncGen_CheckExact(self)) { @@ -14400,6 +20814,7 @@ static int __Pyx_Coroutine_clear(PyObject *self) { } #endif Py_CLEAR(gen->gi_code); + Py_CLEAR(gen->gi_frame); Py_CLEAR(gen->gi_name); Py_CLEAR(gen->gi_qualname); Py_CLEAR(gen->gi_modulename); @@ -14412,11 +20827,14 @@ static void __Pyx_Coroutine_dealloc(PyObject *self) { PyObject_ClearWeakRefs(self); if (gen->resume_label >= 0) { PyObject_GC_Track(self); -#if PY_VERSION_HEX >= 0x030400a1 && CYTHON_USE_TP_FINALIZE - if (PyObject_CallFinalizerFromDealloc(self)) +#if CYTHON_USE_TP_FINALIZE + if (unlikely(PyObject_CallFinalizerFromDealloc(self))) #else - Py_TYPE(gen)->tp_del(self); - if (self->ob_refcnt > 0) + { + destructor del = __Pyx_PyObject_GetSlot(gen, tp_del, destructor); + if (del) del(self); + } + if (unlikely(Py_REFCNT(self) > 0)) #endif { return; @@ -14432,8 +20850,9 @@ static void __Pyx_Coroutine_dealloc(PyObject *self) { } #endif __Pyx_Coroutine_clear(self); - PyObject_GC_Del(gen); + __Pyx_PyHeapTypeObject_GC_Del(gen); } +#if CYTHON_USE_TP_FINALIZE static void __Pyx_Coroutine_del(PyObject *self) { PyObject *error_type, *error_value, *error_traceback; __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; @@ -14441,10 +20860,6 @@ static void __Pyx_Coroutine_del(PyObject *self) { if (gen->resume_label < 0) { return; } -#if !CYTHON_USE_TP_FINALIZE - assert(self->ob_refcnt == 0); - self->ob_refcnt = 1; -#endif __Pyx_PyThreadState_assign __Pyx_ErrFetch(&error_type, &error_value, &error_traceback); #ifdef __Pyx_AsyncGen_USED @@ -14470,122 +20885,116 @@ static void __Pyx_Coroutine_del(PyObject *self) { #endif { PyObject_GC_UnTrack(self); -#if PY_MAJOR_VERSION >= 3 || defined(PyErr_WarnFormat) if (unlikely(PyErr_WarnFormat(PyExc_RuntimeWarning, 1, "coroutine '%.50S' was never awaited", gen->gi_qualname) < 0)) PyErr_WriteUnraisable(self); -#else - {PyObject *msg; - char *cmsg; - #if CYTHON_COMPILING_IN_PYPY - msg = NULL; - cmsg = (char*) "coroutine was never awaited"; - #else - char *cname; - PyObject *qualname; - qualname = gen->gi_qualname; - cname = PyString_AS_STRING(qualname); - msg = PyString_FromFormat("coroutine '%.50s' was never awaited", cname); - if (unlikely(!msg)) { - PyErr_Clear(); - cmsg = (char*) "coroutine was never awaited"; - } else { - cmsg = PyString_AS_STRING(msg); - } - #endif - if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, cmsg, 1) < 0)) - PyErr_WriteUnraisable(self); - Py_XDECREF(msg);} -#endif PyObject_GC_Track(self); } #endif } else { - PyObject *res = __Pyx_Coroutine_Close(self); - if (unlikely(!res)) { - if (PyErr_Occurred()) - PyErr_WriteUnraisable(self); + PyObject *retval = NULL; + __Pyx_PySendResult result = __Pyx_Coroutine_Close(self, &retval); + if (result == PYGEN_ERROR) { + PyErr_WriteUnraisable(self); } else { - Py_DECREF(res); + Py_XDECREF(retval); } } __Pyx_ErrRestore(error_type, error_value, error_traceback); -#if !CYTHON_USE_TP_FINALIZE - assert(self->ob_refcnt > 0); - if (--self->ob_refcnt == 0) { - return; - } - { - Py_ssize_t refcnt = self->ob_refcnt; - _Py_NewReference(self); - self->ob_refcnt = refcnt; - } -#if CYTHON_COMPILING_IN_CPYTHON - assert(PyType_IS_GC(self->ob_type) && - _Py_AS_GC(self)->gc.gc_refs != _PyGC_REFS_UNTRACKED); - _Py_DEC_REFTOTAL; -#endif -#ifdef COUNT_ALLOCS - --Py_TYPE(self)->tp_frees; - --Py_TYPE(self)->tp_allocs; -#endif -#endif } +#endif static PyObject * -__Pyx_Coroutine_get_name(__pyx_CoroutineObject *self, CYTHON_UNUSED void *context) +__Pyx_Coroutine_get_name(__pyx_CoroutineObject *self, void *context) { PyObject *name = self->gi_name; + CYTHON_UNUSED_VAR(context); if (unlikely(!name)) name = Py_None; Py_INCREF(name); return name; } static int -__Pyx_Coroutine_set_name(__pyx_CoroutineObject *self, PyObject *value, CYTHON_UNUSED void *context) +__Pyx_Coroutine_set_name(__pyx_CoroutineObject *self, PyObject *value, void *context) { - PyObject *tmp; -#if PY_MAJOR_VERSION >= 3 - if (unlikely(value == NULL || !PyUnicode_Check(value))) -#else - if (unlikely(value == NULL || !PyString_Check(value))) -#endif - { + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { PyErr_SetString(PyExc_TypeError, "__name__ must be set to a string object"); return -1; } - tmp = self->gi_name; Py_INCREF(value); - self->gi_name = value; - Py_XDECREF(tmp); + __Pyx_Py_XDECREF_SET(self->gi_name, value); return 0; } static PyObject * -__Pyx_Coroutine_get_qualname(__pyx_CoroutineObject *self, CYTHON_UNUSED void *context) +__Pyx_Coroutine_get_qualname(__pyx_CoroutineObject *self, void *context) { PyObject *name = self->gi_qualname; + CYTHON_UNUSED_VAR(context); if (unlikely(!name)) name = Py_None; Py_INCREF(name); return name; } static int -__Pyx_Coroutine_set_qualname(__pyx_CoroutineObject *self, PyObject *value, CYTHON_UNUSED void *context) +__Pyx_Coroutine_set_qualname(__pyx_CoroutineObject *self, PyObject *value, void *context) { - PyObject *tmp; -#if PY_MAJOR_VERSION >= 3 - if (unlikely(value == NULL || !PyUnicode_Check(value))) -#else - if (unlikely(value == NULL || !PyString_Check(value))) -#endif - { + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { PyErr_SetString(PyExc_TypeError, "__qualname__ must be set to a string object"); return -1; } - tmp = self->gi_qualname; Py_INCREF(value); - self->gi_qualname = value; - Py_XDECREF(tmp); + __Pyx_Py_XDECREF_SET(self->gi_qualname, value); return 0; } +static PyObject * +__Pyx__Coroutine_get_frame(__pyx_CoroutineObject *self) +{ +#if !CYTHON_COMPILING_IN_LIMITED_API + PyObject *frame; + #if PY_VERSION_HEX >= 0x030d0000 + Py_BEGIN_CRITICAL_SECTION(self); + #endif + frame = self->gi_frame; + if (!frame) { + if (unlikely(!self->gi_code)) { + Py_RETURN_NONE; + } + PyObject *globals = PyDict_New(); + if (unlikely(!globals)) return NULL; + frame = (PyObject *) PyFrame_New( + PyThreadState_Get(), /*PyThreadState *tstate,*/ + (PyCodeObject*) self->gi_code, /*PyCodeObject *code,*/ + globals, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + Py_DECREF(globals); + if (unlikely(!frame)) + return NULL; + if (unlikely(self->gi_frame)) { + Py_DECREF(frame); + frame = self->gi_frame; + } else { + self->gi_frame = frame; + } + } + Py_INCREF(frame); + #if PY_VERSION_HEX >= 0x030d0000 + Py_END_CRITICAL_SECTION(); + #endif + return frame; +#else + CYTHON_UNUSED_VAR(self); + Py_RETURN_NONE; +#endif +} +static PyObject * +__Pyx_Coroutine_get_frame(__pyx_CoroutineObject *self, void *context) { + CYTHON_UNUSED_VAR(context); + PyObject *frame = self->gi_frame; + if (frame) + return __Pyx_NewRef(frame); + return __Pyx__Coroutine_get_frame(self); +} static __pyx_CoroutineObject *__Pyx__Coroutine_New( PyTypeObject* type, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, PyObject *name, PyObject *qualname, PyObject *module_name) { @@ -14604,9 +21013,14 @@ static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit( gen->resume_label = 0; gen->classobj = NULL; gen->yieldfrom = NULL; + gen->yieldfrom_am_send = NULL; + #if PY_VERSION_HEX >= 0x030B00a4 && !CYTHON_COMPILING_IN_LIMITED_API + gen->gi_exc_state.exc_value = NULL; + #else gen->gi_exc_state.exc_type = NULL; gen->gi_exc_state.exc_value = NULL; gen->gi_exc_state.exc_traceback = NULL; + #endif #if CYTHON_USE_EXC_INFO_STACK gen->gi_exc_state.previous_item = NULL; #endif @@ -14619,286 +21033,451 @@ static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit( gen->gi_modulename = module_name; Py_XINCREF(code); gen->gi_code = code; + gen->gi_frame = NULL; PyObject_GC_Track(gen); return gen; } - -/* PatchModuleWithCoroutine */ -static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code) { -#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) - int result; - PyObject *globals, *result_obj; - globals = PyDict_New(); if (unlikely(!globals)) goto ignore; - result = PyDict_SetItemString(globals, "_cython_coroutine_type", - #ifdef __Pyx_Coroutine_USED - (PyObject*)__pyx_CoroutineType); - #else - Py_None); +static char __Pyx_Coroutine_test_and_set_is_running(__pyx_CoroutineObject *gen) { + char result; + #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_BEGIN_CRITICAL_SECTION(gen); + #endif + result = gen->is_running; + gen->is_running = 1; + #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_END_CRITICAL_SECTION(); + #endif + return result; +} +static void __Pyx_Coroutine_unset_is_running(__pyx_CoroutineObject *gen) { + #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_BEGIN_CRITICAL_SECTION(gen); + #endif + assert(gen->is_running); + gen->is_running = 0; + #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_END_CRITICAL_SECTION(); + #endif +} +static char __Pyx_Coroutine_get_is_running(__pyx_CoroutineObject *gen) { + char result; + #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_BEGIN_CRITICAL_SECTION(gen); #endif - if (unlikely(result < 0)) goto ignore; - result = PyDict_SetItemString(globals, "_cython_generator_type", - #ifdef __Pyx_Generator_USED - (PyObject*)__pyx_GeneratorType); - #else - Py_None); + result = gen->is_running; + #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_END_CRITICAL_SECTION(); #endif - if (unlikely(result < 0)) goto ignore; - if (unlikely(PyDict_SetItemString(globals, "_module", module) < 0)) goto ignore; - if (unlikely(PyDict_SetItemString(globals, "__builtins__", __pyx_b) < 0)) goto ignore; - result_obj = PyRun_String(py_code, Py_file_input, globals, globals); - if (unlikely(!result_obj)) goto ignore; - Py_DECREF(result_obj); - Py_DECREF(globals); - return module; -ignore: - Py_XDECREF(globals); - PyErr_WriteUnraisable(module); - if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, "Cython module failed to patch module with custom type", 1) < 0)) { - Py_DECREF(module); - module = NULL; - } -#else - py_code++; -#endif - return module; + return result; } - -/* PatchGeneratorABC */ -#ifndef CYTHON_REGISTER_ABCS -#define CYTHON_REGISTER_ABCS 1 -#endif -#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) -static PyObject* __Pyx_patch_abc_module(PyObject *module); -static PyObject* __Pyx_patch_abc_module(PyObject *module) { - module = __Pyx_Coroutine_patch_module( - module, "" -"if _cython_generator_type is not None:\n" -" try: Generator = _module.Generator\n" -" except AttributeError: pass\n" -" else: Generator.register(_cython_generator_type)\n" -"if _cython_coroutine_type is not None:\n" -" try: Coroutine = _module.Coroutine\n" -" except AttributeError: pass\n" -" else: Coroutine.register(_cython_coroutine_type)\n" - ); - return module; +static PyObject *__Pyx_Coroutine_get_is_running_getter(PyObject *gen, void *closure) { + CYTHON_UNUSED_VAR(closure); + char result = __Pyx_Coroutine_get_is_running((__pyx_CoroutineObject*)gen); + if (result) Py_RETURN_TRUE; + else Py_RETURN_FALSE; } -#endif -static int __Pyx_patch_abc(void) { -#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) - static int abc_patched = 0; - if (CYTHON_REGISTER_ABCS && !abc_patched) { - PyObject *module; - module = PyImport_ImportModule((PY_MAJOR_VERSION >= 3) ? "collections.abc" : "collections"); - if (!module) { - PyErr_WriteUnraisable(NULL); - if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, - ((PY_MAJOR_VERSION >= 3) ? - "Cython module failed to register with collections.abc module" : - "Cython module failed to register with collections module"), 1) < 0)) { - return -1; - } - } else { - module = __Pyx_patch_abc_module(module); - abc_patched = 1; - if (unlikely(!module)) - return -1; - Py_DECREF(module); - } - module = PyImport_ImportModule("backports_abc"); - if (module) { - module = __Pyx_patch_abc_module(module); - Py_XDECREF(module); - } - if (!module) { - PyErr_Clear(); - } +#if __PYX_HAS_PY_AM_SEND == 2 +static void __Pyx_SetBackportTypeAmSend(PyTypeObject *type, __Pyx_PyAsyncMethodsStruct *static_amsend_methods, __Pyx_pyiter_sendfunc am_send) { + Py_ssize_t ptr_offset = (char*)(type->tp_as_async) - (char*)type; + if (ptr_offset < 0 || ptr_offset > type->tp_basicsize) { + return; } -#else - if ((0)) __Pyx_Coroutine_patch_module(NULL, NULL); + memcpy((void*)static_amsend_methods, (void*)(type->tp_as_async), sizeof(*type->tp_as_async)); + static_amsend_methods->am_send = am_send; + type->tp_as_async = __Pyx_SlotTpAsAsync(static_amsend_methods); +} #endif - return 0; +static PyObject *__Pyx_Coroutine_fail_reduce_ex(PyObject *self, PyObject *arg) { + CYTHON_UNUSED_VAR(arg); + __Pyx_TypeName self_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE((PyObject*)self)); + PyErr_Format(PyExc_TypeError, "cannot pickle '" __Pyx_FMT_TYPENAME "' object", + self_type_name); + __Pyx_DECREF_TypeName(self_type_name); + return NULL; } /* Generator */ static PyMethodDef __pyx_Generator_methods[] = { {"send", (PyCFunction) __Pyx_Coroutine_Send, METH_O, - (char*) PyDoc_STR("send(arg) -> send 'arg' into generator,\nreturn next yielded value or raise StopIteration.")}, + PyDoc_STR("send(arg) -> send 'arg' into generator,\nreturn next yielded value or raise StopIteration.")}, {"throw", (PyCFunction) __Pyx_Coroutine_Throw, METH_VARARGS, - (char*) PyDoc_STR("throw(typ[,val[,tb]]) -> raise exception in generator,\nreturn next yielded value or raise StopIteration.")}, + PyDoc_STR("throw(typ[,val[,tb]]) -> raise exception in generator,\nreturn next yielded value or raise StopIteration.")}, {"close", (PyCFunction) __Pyx_Coroutine_Close_Method, METH_NOARGS, - (char*) PyDoc_STR("close() -> raise GeneratorExit inside generator.")}, + PyDoc_STR("close() -> raise GeneratorExit inside generator.")}, + {"__reduce_ex__", (PyCFunction) __Pyx_Coroutine_fail_reduce_ex, METH_O, 0}, + {"__reduce__", (PyCFunction) __Pyx_Coroutine_fail_reduce_ex, METH_NOARGS, 0}, {0, 0, 0, 0} }; static PyMemberDef __pyx_Generator_memberlist[] = { - {(char *) "gi_running", T_BOOL, offsetof(__pyx_CoroutineObject, is_running), READONLY, NULL}, - {(char*) "gi_yieldfrom", T_OBJECT, offsetof(__pyx_CoroutineObject, yieldfrom), READONLY, - (char*) PyDoc_STR("object being iterated by 'yield from', or None")}, - {(char*) "gi_code", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_code), READONLY, NULL}, + {"gi_yieldfrom", T_OBJECT, offsetof(__pyx_CoroutineObject, yieldfrom), READONLY, + PyDoc_STR("object being iterated by 'yield from', or None")}, + {"gi_code", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_code), READONLY, NULL}, + {"__module__", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_modulename), 0, 0}, + {"__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CoroutineObject, gi_weakreflist), READONLY, 0}, {0, 0, 0, 0, 0} }; static PyGetSetDef __pyx_Generator_getsets[] = { - {(char *) "__name__", (getter)__Pyx_Coroutine_get_name, (setter)__Pyx_Coroutine_set_name, - (char*) PyDoc_STR("name of the generator"), 0}, - {(char *) "__qualname__", (getter)__Pyx_Coroutine_get_qualname, (setter)__Pyx_Coroutine_set_qualname, - (char*) PyDoc_STR("qualified name of the generator"), 0}, + {"__name__", (getter)__Pyx_Coroutine_get_name, (setter)__Pyx_Coroutine_set_name, + PyDoc_STR("name of the generator"), 0}, + {"__qualname__", (getter)__Pyx_Coroutine_get_qualname, (setter)__Pyx_Coroutine_set_qualname, + PyDoc_STR("qualified name of the generator"), 0}, + {"gi_frame", (getter)__Pyx_Coroutine_get_frame, NULL, + PyDoc_STR("Frame of the generator"), 0}, + {"gi_running", __Pyx_Coroutine_get_is_running_getter, NULL, NULL, NULL}, {0, 0, 0, 0, 0} }; -static PyTypeObject __pyx_GeneratorType_type = { - PyVarObject_HEAD_INIT(0, 0) - "generator", - sizeof(__pyx_CoroutineObject), - 0, - (destructor) __Pyx_Coroutine_dealloc, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE, - 0, - (traverseproc) __Pyx_Coroutine_traverse, - 0, - 0, - offsetof(__pyx_CoroutineObject, gi_weakreflist), - 0, - (iternextfunc) __Pyx_Generator_Next, - __pyx_Generator_methods, - __pyx_Generator_memberlist, - __pyx_Generator_getsets, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -#if CYTHON_USE_TP_FINALIZE - 0, -#else - __Pyx_Coroutine_del, -#endif - 0, +static PyType_Slot __pyx_GeneratorType_slots[] = { + {Py_tp_dealloc, (void *)__Pyx_Coroutine_dealloc}, + {Py_tp_traverse, (void *)__Pyx_Coroutine_traverse}, + {Py_tp_iter, (void *)PyObject_SelfIter}, + {Py_tp_iternext, (void *)__Pyx_Generator_Next}, + {Py_tp_methods, (void *)__pyx_Generator_methods}, + {Py_tp_members, (void *)__pyx_Generator_memberlist}, + {Py_tp_getset, (void *)__pyx_Generator_getsets}, + {Py_tp_getattro, (void *) PyObject_GenericGetAttr}, #if CYTHON_USE_TP_FINALIZE - __Pyx_Coroutine_del, -#elif PY_VERSION_HEX >= 0x030400a1 - 0, + {Py_tp_finalize, (void *)__Pyx_Coroutine_del}, #endif -#if PY_VERSION_HEX >= 0x030800b1 - 0, +#if __PYX_HAS_PY_AM_SEND == 1 + {Py_am_send, (void *)__Pyx_Coroutine_AmSend}, #endif -#if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + {0, 0}, +}; +static PyType_Spec __pyx_GeneratorType_spec = { + __PYX_TYPE_MODULE_PREFIX "generator", + sizeof(__pyx_CoroutineObject), 0, +#if PY_VERSION_HEX >= 0x030A0000 + Py_TPFLAGS_IMMUTABLETYPE | #endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE | __Pyx_TPFLAGS_HAVE_AM_SEND, + __pyx_GeneratorType_slots }; -static int __pyx_Generator_init(void) { - __pyx_GeneratorType_type.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; - __pyx_GeneratorType_type.tp_iter = PyObject_SelfIter; - __pyx_GeneratorType = __Pyx_FetchCommonType(&__pyx_GeneratorType_type); - if (unlikely(!__pyx_GeneratorType)) { +#if __PYX_HAS_PY_AM_SEND == 2 +static __Pyx_PyAsyncMethodsStruct __pyx_Generator_as_async; +#endif +static int __pyx_Generator_init(PyObject *module) { + __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module); + mstate->__pyx_GeneratorType = __Pyx_FetchCommonTypeFromSpec( + mstate->__pyx_CommonTypesMetaclassType, module, &__pyx_GeneratorType_spec, NULL); + if (unlikely(!mstate->__pyx_GeneratorType)) { return -1; } +#if __PYX_HAS_PY_AM_SEND == 2 + __Pyx_SetBackportTypeAmSend(mstate->__pyx_GeneratorType, &__pyx_Generator_as_async, &__Pyx_Coroutine_AmSend); +#endif return 0; } +static PyObject *__Pyx_Generator_GetInlinedResult(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; + PyObject *retval = NULL; + if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) { + return __Pyx_Coroutine_AlreadyRunningError(gen); + } + __Pyx_PySendResult result = __Pyx_Coroutine_SendEx(gen, Py_None, &retval, 0); + __Pyx_Coroutine_unset_is_running(gen); + (void) result; + assert (result == PYGEN_RETURN || result == PYGEN_ERROR); + assert ((result == PYGEN_RETURN && retval != NULL) || (result == PYGEN_ERROR && retval == NULL)); + return retval; +} + +/* GetRuntimeVersion */ +static unsigned long __Pyx_get_runtime_version(void) { +#if __PYX_LIMITED_VERSION_HEX >= 0x030b0000 + return Py_Version & ~0xFFUL; +#else + static unsigned long __Pyx_cached_runtime_version = 0; + if (__Pyx_cached_runtime_version == 0) { + const char* rt_version = Py_GetVersion(); + unsigned long version = 0; + unsigned long factor = 0x01000000UL; + unsigned int digit = 0; + int i = 0; + while (factor) { + while ('0' <= rt_version[i] && rt_version[i] <= '9') { + digit = digit * 10 + (unsigned int) (rt_version[i] - '0'); + ++i; + } + version += factor * digit; + if (rt_version[i] != '.') + break; + digit = 0; + factor >>= 8; + ++i; + } + __Pyx_cached_runtime_version = version; + } + return __Pyx_cached_runtime_version; +#endif +} /* CheckBinaryVersion */ -static int __Pyx_check_binary_version(void) { - char ctversion[4], rtversion[4]; - PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); - PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); - if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) { + const unsigned long MAJOR_MINOR = 0xFFFF0000UL; + if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR)) + return 0; + if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR))) + return 1; + { char message[200]; PyOS_snprintf(message, sizeof(message), - "compiletime version %s of module '%.100s' " - "does not match runtime version %s", - ctversion, __Pyx_MODULE_NAME, rtversion); + "compile time Python version %d.%d " + "of module '%.100s' " + "%s " + "runtime version %d.%d", + (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF), + __Pyx_MODULE_NAME, + (allow_newer) ? "was newer than" : "does not match", + (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF) + ); return PyErr_WarnEx(NULL, message, 1); } +} + +/* FunctionExport */ +static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig) { + PyObject *d = 0; + PyObject *cobj = 0; + union { + void (*fp)(void); + void *p; + } tmp; + d = PyObject_GetAttrString(__pyx_m, "__pyx_capi__"); + if (!d) { + PyErr_Clear(); + d = PyDict_New(); + if (!d) + goto bad; + Py_INCREF(d); + if (PyModule_AddObject(__pyx_m, "__pyx_capi__", d) < 0) + goto bad; + } + tmp.fp = f; + cobj = PyCapsule_New(tmp.p, sig, 0); + if (!cobj) + goto bad; + if (PyDict_SetItemString(d, name, cobj) < 0) + goto bad; + Py_DECREF(cobj); + Py_DECREF(d); return 0; +bad: + Py_XDECREF(cobj); + Py_XDECREF(d); + return -1; } -/* InitStrings */ -static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { - while (t->p) { - #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); +/* NewCodeObj */ +#if CYTHON_COMPILING_IN_LIMITED_API + static PyObject* __Pyx__PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyObject *exception_table = NULL; + PyObject *types_module=NULL, *code_type=NULL, *result=NULL; + #if __PYX_LIMITED_VERSION_HEX < 0x030b0000 + PyObject *version_info; + PyObject *py_minor_version = NULL; + #endif + long minor_version = 0; + PyObject *type, *value, *traceback; + PyErr_Fetch(&type, &value, &traceback); + #if __PYX_LIMITED_VERSION_HEX >= 0x030b0000 + minor_version = 11; + #else + if (!(version_info = PySys_GetObject("version_info"))) goto end; + if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; + minor_version = PyLong_AsLong(py_minor_version); + Py_DECREF(py_minor_version); + if (minor_version == -1 && PyErr_Occurred()) goto end; + #endif + if (!(types_module = PyImport_ImportModule("types"))) goto end; + if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; + if (minor_version <= 7) { + (void)p; + result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOOO", a, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else if (minor_version <= 10) { + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOOO", a,p, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); } else { - *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOOOO", a,p, k, l, s, f, code, + c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); } - #else - if (t->is_unicode | t->is_str) { + end: + Py_XDECREF(code_type); + Py_XDECREF(exception_table); + Py_XDECREF(types_module); + if (type) { + PyErr_Restore(type, value, traceback); + } + return result; + } +#elif PY_VERSION_HEX >= 0x030B0000 + static PyCodeObject* __Pyx__PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyCodeObject *result; + result = + #if PY_VERSION_HEX >= 0x030C0000 + PyUnstable_Code_NewWithPosOnlyArgs + #else + PyCode_NewWithPosOnlyArgs + #endif + (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, __pyx_mstate_global->__pyx_empty_bytes); + return result; + } +#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx__PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#else + #define __Pyx__PyCode_New(a, p, 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) +#endif +static PyObject* __Pyx_PyCode_New( + const __Pyx_PyCode_New_function_description descr, + PyObject * const *varnames, + PyObject *filename, + PyObject *funcname, + const char *line_table, + PyObject *tuple_dedup_map +) { + PyObject *code_obj = NULL, *varnames_tuple_dedup = NULL, *code_bytes = NULL, *line_table_bytes = NULL; + Py_ssize_t var_count = (Py_ssize_t) descr.nlocals; + PyObject *varnames_tuple = PyTuple_New(var_count); + if (unlikely(!varnames_tuple)) return NULL; + for (Py_ssize_t i=0; i < var_count; i++) { + Py_INCREF(varnames[i]); + if (__Pyx_PyTuple_SET_ITEM(varnames_tuple, i, varnames[i]) != (0)) goto done; + } + #if CYTHON_COMPILING_IN_LIMITED_API + varnames_tuple_dedup = PyDict_GetItem(tuple_dedup_map, varnames_tuple); + if (!varnames_tuple_dedup) { + if (unlikely(PyDict_SetItem(tuple_dedup_map, varnames_tuple, varnames_tuple) < 0)) goto done; + varnames_tuple_dedup = varnames_tuple; + } + #else + varnames_tuple_dedup = PyDict_SetDefault(tuple_dedup_map, varnames_tuple, varnames_tuple); + if (unlikely(!varnames_tuple_dedup)) goto done; + #endif + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(varnames_tuple_dedup); + #endif + if (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table != NULL + && !CYTHON_COMPILING_IN_GRAAL) { + line_table_bytes = PyBytes_FromStringAndSize(line_table, descr.line_table_length); + if (unlikely(!line_table_bytes)) goto done; + Py_ssize_t code_len = (descr.line_table_length * 2 + 4) & ~3; + code_bytes = PyBytes_FromStringAndSize(NULL, code_len); + if (unlikely(!code_bytes)) goto done; + char* c_code_bytes = PyBytes_AsString(code_bytes); + if (unlikely(!c_code_bytes)) goto done; + memset(c_code_bytes, 0, (size_t) code_len); + } + code_obj = (PyObject*) __Pyx__PyCode_New( + (int) descr.argcount, + (int) descr.num_posonly_args, + (int) descr.num_kwonly_args, + (int) descr.nlocals, + 0, + (int) descr.flags, + code_bytes ? code_bytes : __pyx_mstate_global->__pyx_empty_bytes, + __pyx_mstate_global->__pyx_empty_tuple, + __pyx_mstate_global->__pyx_empty_tuple, + varnames_tuple_dedup, + __pyx_mstate_global->__pyx_empty_tuple, + __pyx_mstate_global->__pyx_empty_tuple, + filename, + funcname, + (int) descr.first_line, + (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table_bytes) ? line_table_bytes : __pyx_mstate_global->__pyx_empty_bytes + ); +done: + Py_XDECREF(code_bytes); + Py_XDECREF(line_table_bytes); + #if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(varnames_tuple_dedup); + #endif + Py_DECREF(varnames_tuple); + return code_obj; +} + +/* InitStrings */ +static int __Pyx_InitStrings(__Pyx_StringTabEntry const *t, PyObject **target, const char* const* encoding_names) { + while (t->s) { + PyObject *str; + if (t->is_unicode) { if (t->intern) { - *t->p = PyUnicode_InternFromString(t->s); + str = PyUnicode_InternFromString(t->s); } else if (t->encoding) { - *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + str = PyUnicode_Decode(t->s, t->n - 1, encoding_names[t->encoding], NULL); } else { - *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + str = PyUnicode_FromStringAndSize(t->s, t->n - 1); } } else { - *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + str = PyBytes_FromStringAndSize(t->s, t->n - 1); } - #endif - if (!*t->p) + if (!str) return -1; - if (PyObject_Hash(*t->p) == -1) + *target = str; + if (PyObject_Hash(str) == -1) return -1; ++t; + ++target; } return 0; } +#include +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) { + size_t len = strlen(s); + if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) { + PyErr_SetString(PyExc_OverflowError, "byte string is too long"); + return -1; + } + return (Py_ssize_t) len; +} static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { - return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return __Pyx_PyUnicode_FromStringAndSize(c_str, len); +} +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) { + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return PyByteArray_FromStringAndSize(c_str, len); } 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 +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 +static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; +#if CYTHON_COMPILING_IN_LIMITED_API { - 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; - } + const char* result; + Py_ssize_t unicode_length; + CYTHON_MAYBE_UNUSED_VAR(unicode_length); // only for __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + #if __PYX_LIMITED_VERSION_HEX < 0x030A0000 + if (unlikely(PyArg_Parse(o, "s#", &result, length) < 0)) return NULL; + #else + result = PyUnicode_AsUTF8AndSize(o, length); + #endif + #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + unicode_length = PyUnicode_GetLength(o); + if (unlikely(unicode_length < 0)) return NULL; + if (unlikely(unicode_length != *length)) { + PyUnicode_AsASCIIString(o); + return NULL; } + #endif + return result; } -#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); @@ -14910,25 +21489,25 @@ static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py #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)) { +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 + if (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)) { +#if (CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS) || (CYTHON_COMPILING_IN_PYPY && (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))) *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); - } else +#else + *length = PyByteArray_Size(o); + if (*length == -1) return NULL; + return PyByteArray_AsString(o); #endif + } else { char* result; int r = PyBytes_AsStringAndSize(o, &result, length); @@ -14951,95 +21530,66 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { Py_DECREF(x); return retval; } -static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { -#if PY_MAJOR_VERSION >= 3 +static PyObject* __Pyx_PyNumber_LongWrongResultType(PyObject* result) { + __Pyx_TypeName result_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(result)); 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)) { + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME "). " + "The ability to return an instance of a strict subclass of int is deprecated, " + "and may be removed in a future version of Python.", + result_type_name)) { + __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } + __Pyx_DECREF_TypeName(result_type_name); return result; } -#endif PyErr_Format(PyExc_TypeError, - "__%.4s__ returned non-%.4s (type %.200s)", - type_name, type_name, Py_TYPE(result)->tp_name); + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ")", + result_type_name); + __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } -static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Long(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); + 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); + res = m->nb_int(x); } - #endif #else if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { - res = PyNumber_Int(x); + res = PyNumber_Long(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); - } + if (unlikely(!PyLong_CheckExact(res))) { + return __Pyx_PyNumber_LongWrongResultType(res); + } } else if (!PyErr_Occurred()) { - PyErr_SetString(PyExc_TypeError, - "an integer is required"); + 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(b); - } -#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; + if (likely(__Pyx_PyLong_IsCompact(b))) { + return __Pyx_PyLong_CompactValue(b); } else { + const digit* digits = __Pyx_PyLong_Digits(b); + const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b); switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { @@ -15078,16 +21628,356 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { } x = PyNumber_Index(b); if (!x) return -1; - ival = PyInt_AsSsize_t(x); + ival = PyLong_AsSsize_t(x); Py_DECREF(x); return ival; } +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { + if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { + return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o); + } else { + Py_ssize_t ival; + PyObject *x; + x = PyNumber_Index(o); + if (!x) return -1; + ival = PyLong_AsLong(x); + Py_DECREF(x); + return ival; + } +} +static CYTHON_INLINE PyObject *__Pyx_Owned_Py_None(int b) { + CYTHON_UNUSED_VAR(b); + return __Pyx_NewRef(Py_None); +} 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); +static CYTHON_INLINE PyObject * __Pyx_PyLong_FromSize_t(size_t ival) { + return PyLong_FromSize_t(ival); +} + + +/* MultiPhaseInitModuleState */ +#if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE +#ifndef CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +#if (CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX >= 0x030C0000) + #define CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE 1 +#else + #define CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE 0 +#endif +#endif +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE && !CYTHON_ATOMICS +#error "Module state with PEP489 requires atomics. Currently that's one of\ + C11, C++11, gcc atomic intrinsics or MSVC atomic intrinsics" +#endif +#if !CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +#define __Pyx_ModuleStateLookup_Lock() +#define __Pyx_ModuleStateLookup_Unlock() +#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d0000 +static PyMutex __Pyx_ModuleStateLookup_mutex = {0}; +#define __Pyx_ModuleStateLookup_Lock() PyMutex_Lock(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() PyMutex_Unlock(&__Pyx_ModuleStateLookup_mutex) +#elif defined(__cplusplus) && __cplusplus >= 201103L +#include +static std::mutex __Pyx_ModuleStateLookup_mutex; +#define __Pyx_ModuleStateLookup_Lock() __Pyx_ModuleStateLookup_mutex.lock() +#define __Pyx_ModuleStateLookup_Unlock() __Pyx_ModuleStateLookup_mutex.unlock() +#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ > 201112L) && !defined(__STDC_NO_THREADS__) +#include +static mtx_t __Pyx_ModuleStateLookup_mutex; +static once_flag __Pyx_ModuleStateLookup_mutex_once_flag = ONCE_FLAG_INIT; +static void __Pyx_ModuleStateLookup_initialize_mutex(void) { + mtx_init(&__Pyx_ModuleStateLookup_mutex, mtx_plain); +} +#define __Pyx_ModuleStateLookup_Lock()\ + call_once(&__Pyx_ModuleStateLookup_mutex_once_flag, __Pyx_ModuleStateLookup_initialize_mutex);\ + mtx_lock(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() mtx_unlock(&__Pyx_ModuleStateLookup_mutex) +#elif defined(HAVE_PTHREAD_H) +#include +static pthread_mutex_t __Pyx_ModuleStateLookup_mutex = PTHREAD_MUTEX_INITIALIZER; +#define __Pyx_ModuleStateLookup_Lock() pthread_mutex_lock(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() pthread_mutex_unlock(&__Pyx_ModuleStateLookup_mutex) +#elif defined(_WIN32) +#include // synchapi.h on its own doesn't work +static SRWLOCK __Pyx_ModuleStateLookup_mutex = SRWLOCK_INIT; +#define __Pyx_ModuleStateLookup_Lock() AcquireSRWLockExclusive(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() ReleaseSRWLockExclusive(&__Pyx_ModuleStateLookup_mutex) +#else +#error "No suitable lock available for CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE.\ + Requires C standard >= C11, or C++ standard >= C++11,\ + or pthreads, or the Windows 32 API, or Python >= 3.13." +#endif +typedef struct { + int64_t id; + PyObject *module; +} __Pyx_InterpreterIdAndModule; +typedef struct { + char interpreter_id_as_index; + Py_ssize_t count; + Py_ssize_t allocated; + __Pyx_InterpreterIdAndModule table[1]; +} __Pyx_ModuleStateLookupData; +#define __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE 32 +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +static __pyx_atomic_int_type __Pyx_ModuleStateLookup_read_counter = 0; +#endif +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +static __pyx_atomic_ptr_type __Pyx_ModuleStateLookup_data = 0; +#else +static __Pyx_ModuleStateLookupData* __Pyx_ModuleStateLookup_data = NULL; +#endif +static __Pyx_InterpreterIdAndModule* __Pyx_State_FindModuleStateLookupTableLowerBound( + __Pyx_InterpreterIdAndModule* table, + Py_ssize_t count, + int64_t interpreterId) { + __Pyx_InterpreterIdAndModule* begin = table; + __Pyx_InterpreterIdAndModule* end = begin + count; + if (begin->id == interpreterId) { + return begin; + } + while ((end - begin) > __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE) { + __Pyx_InterpreterIdAndModule* halfway = begin + (end - begin)/2; + if (halfway->id == interpreterId) { + return halfway; + } + if (halfway->id < interpreterId) { + begin = halfway; + } else { + end = halfway; + } + } + for (; begin < end; ++begin) { + if (begin->id >= interpreterId) return begin; + } + return begin; +} +static PyObject *__Pyx_State_FindModule(CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get()); + if (interpreter_id == -1) return NULL; +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData* data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data); + { + __pyx_atomic_incr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); + if (likely(data)) { + __Pyx_ModuleStateLookupData* new_data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_acquire(&__Pyx_ModuleStateLookup_data); + if (likely(data == new_data)) { + goto read_finished; + } + } + __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); + __Pyx_ModuleStateLookup_Lock(); + __pyx_atomic_incr_relaxed(&__Pyx_ModuleStateLookup_read_counter); + data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data); + __Pyx_ModuleStateLookup_Unlock(); + } + read_finished:; +#else + __Pyx_ModuleStateLookupData* data = __Pyx_ModuleStateLookup_data; +#endif + __Pyx_InterpreterIdAndModule* found = NULL; + if (unlikely(!data)) goto end; + if (data->interpreter_id_as_index) { + if (interpreter_id < data->count) { + found = data->table+interpreter_id; + } + } else { + found = __Pyx_State_FindModuleStateLookupTableLowerBound( + data->table, data->count, interpreter_id); + } + end: + { + PyObject *result=NULL; + if (found && found->id == interpreter_id) { + result = found->module; + } +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); +#endif + return result; + } +} +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +static void __Pyx_ModuleStateLookup_wait_until_no_readers(void) { + while (__pyx_atomic_load(&__Pyx_ModuleStateLookup_read_counter) != 0); +} +#else +#define __Pyx_ModuleStateLookup_wait_until_no_readers() +#endif +static int __Pyx_State_AddModuleInterpIdAsIndex(__Pyx_ModuleStateLookupData **old_data, PyObject* module, int64_t interpreter_id) { + Py_ssize_t to_allocate = (*old_data)->allocated; + while (to_allocate <= interpreter_id) { + if (to_allocate == 0) to_allocate = 1; + else to_allocate *= 2; + } + __Pyx_ModuleStateLookupData *new_data = *old_data; + if (to_allocate != (*old_data)->allocated) { + new_data = (__Pyx_ModuleStateLookupData *)realloc( + *old_data, + sizeof(__Pyx_ModuleStateLookupData)+(to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule)); + if (!new_data) { + PyErr_NoMemory(); + return -1; + } + for (Py_ssize_t i = new_data->allocated; i < to_allocate; ++i) { + new_data->table[i].id = i; + new_data->table[i].module = NULL; + } + new_data->allocated = to_allocate; + } + new_data->table[interpreter_id].module = module; + if (new_data->count < interpreter_id+1) { + new_data->count = interpreter_id+1; + } + *old_data = new_data; + return 0; +} +static void __Pyx_State_ConvertFromInterpIdAsIndex(__Pyx_ModuleStateLookupData *data) { + __Pyx_InterpreterIdAndModule *read = data->table; + __Pyx_InterpreterIdAndModule *write = data->table; + __Pyx_InterpreterIdAndModule *end = read + data->count; + for (; readmodule) { + write->id = read->id; + write->module = read->module; + ++write; + } + } + data->count = write - data->table; + for (; writeid = 0; + write->module = NULL; + } + data->interpreter_id_as_index = 0; +} +static int __Pyx_State_AddModule(PyObject* module, CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get()); + if (interpreter_id == -1) return -1; + int result = 0; + __Pyx_ModuleStateLookup_Lock(); +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData *old_data = (__Pyx_ModuleStateLookupData *) + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0); +#else + __Pyx_ModuleStateLookupData *old_data = __Pyx_ModuleStateLookup_data; +#endif + __Pyx_ModuleStateLookupData *new_data = old_data; + if (!new_data) { + new_data = (__Pyx_ModuleStateLookupData *)calloc(1, sizeof(__Pyx_ModuleStateLookupData)); + if (!new_data) { + result = -1; + PyErr_NoMemory(); + goto end; + } + new_data->allocated = 1; + new_data->interpreter_id_as_index = 1; + } + __Pyx_ModuleStateLookup_wait_until_no_readers(); + if (new_data->interpreter_id_as_index) { + if (interpreter_id < __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE) { + result = __Pyx_State_AddModuleInterpIdAsIndex(&new_data, module, interpreter_id); + goto end; + } + __Pyx_State_ConvertFromInterpIdAsIndex(new_data); + } + { + Py_ssize_t insert_at = 0; + { + __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound( + new_data->table, new_data->count, interpreter_id); + assert(lower_bound); + insert_at = lower_bound - new_data->table; + if (unlikely(insert_at < new_data->count && lower_bound->id == interpreter_id)) { + lower_bound->module = module; + goto end; // already in table, nothing more to do + } + } + if (new_data->count+1 >= new_data->allocated) { + Py_ssize_t to_allocate = (new_data->count+1)*2; + new_data = + (__Pyx_ModuleStateLookupData*)realloc( + new_data, + sizeof(__Pyx_ModuleStateLookupData) + + (to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule)); + if (!new_data) { + result = -1; + new_data = old_data; + PyErr_NoMemory(); + goto end; + } + new_data->allocated = to_allocate; + } + ++new_data->count; + int64_t last_id = interpreter_id; + PyObject *last_module = module; + for (Py_ssize_t i=insert_at; icount; ++i) { + int64_t current_id = new_data->table[i].id; + new_data->table[i].id = last_id; + last_id = current_id; + PyObject *current_module = new_data->table[i].module; + new_data->table[i].module = last_module; + last_module = current_module; + } + } + end: +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, new_data); +#else + __Pyx_ModuleStateLookup_data = new_data; +#endif + __Pyx_ModuleStateLookup_Unlock(); + return result; +} +static int __Pyx_State_RemoveModule(CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get()); + if (interpreter_id == -1) return -1; + __Pyx_ModuleStateLookup_Lock(); +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData *data = (__Pyx_ModuleStateLookupData *) + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0); +#else + __Pyx_ModuleStateLookupData *data = __Pyx_ModuleStateLookup_data; +#endif + if (data->interpreter_id_as_index) { + if (interpreter_id < data->count) { + data->table[interpreter_id].module = NULL; + } + goto done; + } + { + __Pyx_ModuleStateLookup_wait_until_no_readers(); + __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound( + data->table, data->count, interpreter_id); + if (!lower_bound) goto done; + if (lower_bound->id != interpreter_id) goto done; + __Pyx_InterpreterIdAndModule *end = data->table+data->count; + for (;lower_boundid = (lower_bound+1)->id; + lower_bound->module = (lower_bound+1)->module; + } + } + --data->count; + if (data->count == 0) { + free(data); + data = NULL; + } + done: +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, data); +#else + __Pyx_ModuleStateLookup_data = data; +#endif + __Pyx_ModuleStateLookup_Unlock(); + return 0; } +#endif + +/* #### Code section: utility_code_pragmas_end ### */ +#ifdef _MSC_VER +#pragma warning( pop ) +#endif + +/* #### Code section: end ### */ #endif /* Py_PYTHON_H */ diff --git a/src/hunter/_event.pxd b/src/hunter/_event.pxd index b8989e96..ed07b5de 100644 --- a/src/hunter/_event.pxd +++ b/src/hunter/_event.pxd @@ -1,11 +1,40 @@ -# cython: language_level=3str cimport cython -from ._tracer cimport * +ctypedef extern FrameType + +cdef extern from *: + ctypedef extern class types.CodeType[object PyCodeObject, check_size ignore]: + cdef object co_filename + cdef object co_name + cdef int co_argcount + +cdef extern from "vendor/_compat.h": + """ + static inline PyCodeObject* Hunter_PyFrame_GetCode(PyObject* frame) { + return PyFrame_GetCode((PyFrameObject*) frame); + } + static inline int Hunter_PyFrame_GetLasti(PyObject* frame) { + return PyFrame_GetLasti((PyFrameObject*) frame); + } + static inline int Hunter_PyFrame_GetLineNumber(PyObject* frame) { + return PyFrame_GetLineNumber((PyFrameObject*) frame); + } + static inline PyObject* Hunter_PyFrame_GetGlobals(PyObject* frame) { + return PyFrame_GetGlobals((PyFrameObject*) frame); + } + static inline PyObject* Hunter_PyFrame_GetLocals(PyObject* frame) { + return PyFrame_GetLocals((PyFrameObject*) frame); + } + """ + object PyCode_GetCode(CodeType) + object PyCode_GetVarnames(CodeType) + CodeType Hunter_PyFrame_GetCode(FrameType frame) + int Hunter_PyFrame_GetLasti(FrameType frame) + int Hunter_PyFrame_GetLineNumber(FrameType frame) + object Hunter_PyFrame_GetGlobals(FrameType frame) + object Hunter_PyFrame_GetLocals(FrameType frame) -cdef extern from "frameobject.h": - void PyFrame_FastToLocals(FrameType) @cython.final cdef class Event: @@ -17,6 +46,7 @@ cdef class Event: readonly int calls readonly bint threading_support readonly bint detached + readonly object builtin object _code object _filename @@ -32,5 +62,21 @@ cdef class Event: object _thread object _threadidn # slightly different name cause "_threadid" is a goddamn macro in Microsoft stddef.h object _threadname + object _instruction + + CodeType code_getter(self) + object filename_getter(self) + object fullsource_getter(self) + object function_getter(self) + object globals_getter(self) + object lineno_getter(self) + object locals_getter(self) + object module_getter(self) + object source_getter(self) + object stdlib_getter(self) + object threadid_getter(self) + object threadname_getter(self) + object instruction_getter(self) - Event clone(self) +cdef Event fast_clone(Event self) +cdef Event fast_detach(Event self, object value_filter) diff --git a/src/hunter/_event.pyx b/src/hunter/_event.pyx index 60fc24fe..99332762 100644 --- a/src/hunter/_event.pyx +++ b/src/hunter/_event.pyx @@ -1,4 +1,6 @@ -# cython: linetrace=True, language_level=3str +# cython: linetrace=True, language_level=3str, c_string_encoding=ascii, freethreading_compatible=True +cimport cython + from functools import partial from linecache import getline from linecache import getlines @@ -10,8 +12,7 @@ from tokenize import TokenError from tokenize import generate_tokens from cpython.pythread cimport PyThread_get_thread_ident - -from ._tracer cimport Tracer +from cpython.ref cimport PyObject from .const import SITE_PACKAGES_PATHS from .const import SYS_PREFIX_PATHS @@ -26,6 +27,23 @@ __all__ = 'Event', cdef object UNSET = object() +cdef str CALL = 'call' +cdef str EXCEPTION = 'exception' +cdef str LINE = 'line' +cdef str RETURN = 'return' + +cdef const PyObject** KIND_NAMES = [ + CALL, + EXCEPTION, + LINE, + RETURN, + CALL, + EXCEPTION, + RETURN, +] + + +@cython.auto_pickle(False) cdef class Event: """ A wrapper object for Frame objects. Instances of this are passed to your custom functions or predicates. @@ -37,17 +55,16 @@ cdef class Event: kind (str): A string like ``'call'``, ``'line'``, ``'return'`` or ``'exception'``. arg: A value that depends on ``kind``. Usually is ``None`` but for ``'return'`` or ``'exception'`` other values may be expected. - tracer (:class:`hunter.tracer.Tracer`): The :class:`~hunter.tracer.Tracer` instance that created the event. - Needed for the ``calls`` and ``depth`` fields. """ - def __init__(self, FrameType frame, str kind, object arg, Tracer tracer): + def __init__(self, FrameType frame, int kind, object arg, int depth, int calls, bint threading_support): self.arg = arg self.frame = frame - self.kind = kind - self.depth = tracer.depth - self.calls = tracer.calls - self.threading_support = tracer.threading_support + self.kind = KIND_NAMES[kind] + self.depth = depth + self.calls = calls + self.threading_support = threading_support self.detached = False + self.builtin = kind > 3 self._code = UNSET self._filename = UNSET @@ -63,66 +80,39 @@ cdef class Event: self._threadidn = UNSET self._threadname = UNSET self._thread = UNSET + self._instruction = UNSET + + def __repr__(self): + return '' % ( + self.kind, self.function, self.module, self.filename, self.lineno + ) + + def __eq__(self, other): + return self is other def detach(self, value_filter=None): - event = Event.__new__(Event) - - event._code = self.code - event._filename = self.filename - event._fullsource = self.fullsource - event._function_object = self._function_object - event._function = self.function - event._lineno = self.lineno - event._module = self.module - event._source = self.source - event._stdlib = self.stdlib - event._threadidn = self.threadid - event._threadname = self.threadname - - if value_filter: - event._globals = {key: value_filter(value) for key, value in self.globals.items()} - event._locals = {key: value_filter(value) for key, value in self.locals.items()} - event.arg = value_filter(self.arg) - else: - event._globals = {} - event._locals = {} - event.arg = None - - event.threading_support = self.threading_support - event.calls = self.calls - event.depth = self.depth - event.kind = self.kind - - event.detached = True - - return event - - cdef inline Event clone(self): - event = Event.__new__(Event) - event.arg = self.arg - event.frame = self.frame - event.kind = self.kind - event.depth = self.depth - event.calls = self.calls - event.threading_support = self.threading_support - event._code = self._code - event._filename = self._filename - event._fullsource = self._fullsource - event._function_object = self._function_object - event._function = self._function - event._globals = self._globals - event._lineno = self._lineno - event._locals = self._locals - event._module = self._module - event._source = self._source - event._stdlib = self._stdlib - event._threadidn = self._threadidn - event._threadname = self._threadname - event._thread = self._thread - return event + return fast_detach(self, value_filter) + + def clone(self): + return fast_clone(self) + + cdef inline instruction_getter(self): + cdef int position + + if self._instruction is UNSET: + position = Hunter_PyFrame_GetLasti(self.frame) + co_code = PyCode_GetCode(self.code_getter()) + if co_code and len(co_code) > position >= 0: + self._instruction = co_code[position] + else: + self._instruction = None + return self._instruction @property - def threadid(self): + def instruction(self): + return self.instruction_getter() + + cdef inline threadid_getter(self): cdef long current if self._threadidn is UNSET: @@ -135,7 +125,10 @@ cdef class Event: return self._threadidn @property - def threadname(self): + def threadid(self): + return self.threadid_getter() + + cdef inline threadname_getter(self): if self._threadname is UNSET: if self._thread is UNSET: self._thread = current_thread() @@ -143,28 +136,52 @@ cdef class Event: return self._threadname @property - def locals(self): + def threadname(self): + return self.threadname_getter() + + cdef inline locals_getter(self): if self._locals is UNSET: - PyFrame_FastToLocals(self.frame) - self._locals = self.frame.f_locals + if self.builtin: + self._locals = {} + else: + self._locals = Hunter_PyFrame_GetLocals(self.frame) return self._locals @property - def globals(self): + def locals(self): + return self.locals_getter() + + cdef inline globals_getter(self): if self._globals is UNSET: - self._globals = self.frame.f_globals + if self.builtin: + self._locals = {} + else: + self._globals = Hunter_PyFrame_GetGlobals(self.frame) return self._globals @property - def function(self): + def globals(self): + return self.globals_getter() + + cdef inline function_getter(self): if self._function is UNSET: - self._function = self.frame.f_code.co_name + if self.builtin: + self._function = self.arg.__name__ + else: + self._function = self.code_getter().co_name return self._function + @property + def function(self): + return self.function_getter() + @property def function_object(self): - if self._function_object is UNSET: - code = self.code + cdef CodeType code + if self.builtin: + return self.builtin + elif self._function_object is UNSET: + code = self.code_getter() if code.co_name is None: return None # First, try to find the function in globals @@ -175,7 +192,7 @@ cdef class Event: # methods, this should be the class (or an instance of the class) on which our # method is defined. if func is None and code.co_argcount >= 1: - first_arg = self.locals.get(code.co_varnames[0]) + first_arg = self.locals.get(PyCode_GetVarnames(code)[0]) func = get_func_in_mro(first_arg, code) # If we still can't find the function, as will be the case with static methods, # try looking at classes in global scope. @@ -189,30 +206,36 @@ cdef class Event: self._function_object = func return self._function_object - @property - def module(self): + cdef inline module_getter(self): if self._module is UNSET: - module = self.frame.f_globals.get('__name__', '') + if self.builtin: + module = self.arg.__module__ + else: + module = self.globals.get('__name__', '') if module is None: - module = '' - + module = '?' self._module = module return self._module @property - def filename(self): + def module(self): + return self.module_getter() + + cdef inline filename_getter(self): + cdef CodeType code if self._filename is UNSET: - filename = self.frame.f_code.co_filename + code = self.code_getter() + filename = code.co_filename if not filename: - filename = self.frame.f_globals.get('__file__') + filename = self.globals.get('__file__') if not filename: - filename = '' + filename = '?' elif filename.endswith(('.pyc', '.pyo')): filename = filename[:-1] elif filename.endswith(('.so', '.pyd')): - basename = CYTHON_SUFFIX_RE.sub('', filename) + cybasename = CYTHON_SUFFIX_RE.sub('', filename) for ext in ('.pyx', '.py'): - cyfilename = basename + ext + cyfilename = cybasename + ext if exists(cyfilename): filename = cyfilename break @@ -221,20 +244,29 @@ cdef class Event: return self._filename @property - def lineno(self): + def filename(self): + return self.filename_getter() + + cdef inline lineno_getter(self): if self._lineno is UNSET: - self._lineno = self.frame.f_lineno + self._lineno = Hunter_PyFrame_GetLineNumber(self.frame) return self._lineno @property - def code(self): + def lineno(self): + return self.lineno_getter() + + cdef inline CodeType code_getter(self): if self._code is UNSET: - return self.frame.f_code + return Hunter_PyFrame_GetCode(self.frame) else: return self._code @property - def stdlib(self): + def code(self): + return self.code_getter() + + cdef inline stdlib_getter(self): if self._stdlib is UNSET: module_parts = self.module.split('.') if 'pkg_resources' in module_parts: @@ -244,7 +276,7 @@ cdef class Event: # skip namedtuple exec garbage self._stdlib = True elif self.filename.startswith(SITE_PACKAGES_PATHS): - # if it's in site-packages then its definitely not stdlib + # if in site-packages then definitely not stdlib self._stdlib = False elif self.filename.startswith(SYS_PREFIX_PATHS): self._stdlib = True @@ -253,43 +285,61 @@ cdef class Event: return self._stdlib @property - def fullsource(self): + def stdlib(self): + return self.stdlib_getter() + + cdef inline fullsource_getter(self): cdef list lines + cdef CodeType code if self._fullsource is UNSET: try: self._fullsource = None - - if self.kind == 'call' and self.frame.f_code.co_name != "": + code = self.code_getter() + if self.kind == 'call' and code.co_name != '': lines = [] try: - for _, token, _, _, line in generate_tokens(partial( + for _, token, _, _, _ in generate_tokens( + partial( next, - yield_lines(self.filename, self.frame.f_globals, self.lineno - 1, lines) - )): - if token in ("def", "class", "lambda"): + yield_lines( + self.filename, + self.frame.f_globals, + self.lineno - 1, + lines, + ), + ) + ): + if token in ('def', 'class', 'lambda'): self._fullsource = ''.join(lines) break except TokenError: pass if self._fullsource is None: - self._fullsource = getline(self.filename, self.lineno, self.frame.f_globals) + self._fullsource = getline(self.filename, self.lineno, self.globals) except Exception as exc: - self._fullsource = "??? NO SOURCE: {!r}".format(exc) + self._fullsource = f'??? NO SOURCE: {exc!r}' return self._fullsource @property - def source(self): + def fullsource(self): + return self.fullsource_getter() + + cdef inline source_getter(self): if self._source is UNSET: if self.filename.endswith(('.so', '.pyd')): - self._source = "??? NO SOURCE: not reading {} file".format(splitext(basename(self.filename))[1]) + self._source = f'??? NO SOURCE: not reading binary {splitext(basename(self.filename))[1]} file' try: - self._source = getline(self.filename, self.lineno, self.frame.f_globals) + self._source = getline(self.filename, self.lineno, self.globals) except Exception as exc: - self._source = "??? NO SOURCE: {!r}".format(exc) + self._source = f'??? NO SOURCE: {exc!r}' return self._source + @property + def source(self): + return self.source_getter() + def __getitem__(self, item): return getattr(self, item) @@ -301,9 +351,71 @@ def yield_lines(filename, module_globals, start, list collector, for line in getlines(filename, module_globals)[start:start + limit]: if dedent is None: dedent = LEADING_WHITESPACE_RE.findall(line) - dedent = dedent[0] if dedent else "" + dedent = dedent[0] if dedent else '' amount = len(dedent) elif not line.startswith(dedent): break collector.append(line) yield line[amount:] + + +cdef inline Event fast_detach(Event self, object value_filter): + event = Event.__new__(Event) + + event._code = self.code_getter() + event._filename = self.filename_getter() + event._fullsource = self.fullsource_getter() + event._function_object = self._function_object + event._function = self.function_getter() + event._lineno = self.lineno_getter() + event._module = self.module_getter() + event._source = self.source_getter() + event._stdlib = self.stdlib_getter() + event._threadidn = self.threadid_getter() + event._threadname = self.threadname_getter() + event._instruction = self.instruction_getter() + + if value_filter: + event._globals = {key: value_filter(value) for key, value in self.globals.items()} + event._locals = {key: value_filter(value) for key, value in self.locals.items()} + event.arg = value_filter(self.arg) + else: + event._globals = {} + event._locals = {} + event.arg = None + + event.builtin = self.builtin + event.calls = self.calls + event.depth = self.depth + event.detached = True + event.kind = self.kind + event.threading_support = self.threading_support + + return event + +cdef inline Event fast_clone(Event self): + event = Event.__new__(Event) + event.arg = self.arg + event.builtin = self.builtin + event.calls = self.calls + event.depth = self.depth + event.detached = False + event.frame = self.frame + event.kind = self.kind + event.threading_support = self.threading_support + event._code = self._code + event._filename = self._filename + event._fullsource = self._fullsource + event._function_object = self._function_object + event._function = self._function + event._globals = self._globals + event._lineno = self._lineno + event._locals = self._locals + event._module = self._module + event._source = self._source + event._stdlib = self._stdlib + event._threadidn = self._threadidn + event._threadname = self._threadname + event._thread = self._thread + event._instruction = self._instruction + return event diff --git a/src/hunter/_predicates.c b/src/hunter/_predicates.c index 5cacc098..0b8944ad 100644 --- a/src/hunter/_predicates.c +++ b/src/hunter/_predicates.c @@ -1,20 +1,49 @@ -/* Generated by Cython 0.29.14 */ +/* Generated by Cython 3.1.3 */ +/* BEGIN: Cython Metadata +{ + "distutils": { + "depends": [ + "src/hunter/vendor/_compat.h" + ], + "extra_compile_args": [ + "-DCYTHON_USE_SYS_MONITORING=0" + ], + "include_dirs": [ + "src/hunter" + ], + "name": "hunter._predicates", + "sources": [ + "src/hunter/_predicates.pyx" + ] + }, + "module_name": "hunter._predicates" +} +END: Cython Metadata */ + +#ifndef PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN +#endif /* PY_SSIZE_T_CLEAN */ +/* InitLimitedAPI */ +#if defined(Py_LIMITED_API) && !defined(CYTHON_LIMITED_API) + #define CYTHON_LIMITED_API 1 +#endif + #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+. +#elif PY_VERSION_HEX < 0x03080000 + #error Cython requires Python 3.8+. #else -#define CYTHON_ABI "0_29_14" -#define CYTHON_HEX_VERSION 0x001D0EF0 +#define __PYX_ABI_VERSION "3_1_3" +#define CYTHON_HEX_VERSION 0x030103F0 #define CYTHON_FUTURE_DIVISION 1 +/* CModulePreamble */ #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif -#if !defined(WIN32) && !defined(MS_WINDOWS) +#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif @@ -33,9 +62,7 @@ #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG - #if PY_VERSION_HEX >= 0x02070000 - #define HAVE_LONG_LONG - #endif + #define HAVE_LONG_LONG #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG @@ -43,20 +70,21 @@ #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 __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX +#if defined(GRAALVM_PYTHON) + /* For very preliminary testing purposes. Most variables are set the same as PyPy. + The existence of this section does not imply that anything works or is even tested */ + #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 1 + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 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 @@ -67,95 +95,219 @@ #define CYTHON_USE_PYLONG_INTERNALS 0 #undef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1 #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 0 #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 -#elif defined(PYSTON_VERSION) - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 1 + #define CYTHON_USE_EXC_INFO_STACK 1 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(PYPY_VERSION) + #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_CPYTHON 0 - #ifndef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 1 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 #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_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_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #ifndef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 1 + #endif + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #if PY_VERSION_HEX < 0x03090000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PYPY_VERSION_NUM >= 0x07030C00) + #endif + #undef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_NUM >= 0x07031100) + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(CYTHON_LIMITED_API) + #ifdef Py_LIMITED_API + #undef __PYX_LIMITED_VERSION_HEX + #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API + #endif + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 1 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + #undef CYTHON_CLINE_IN_TRACEBACK + #define CYTHON_CLINE_IN_TRACEBACK 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 1 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #endif + #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 + #ifndef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0 #endif + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL (__PYX_LIMITED_VERSION_HEX >= 0x030C0000) #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 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif + #undef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #endif + #ifndef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND (__PYX_LIMITED_VERSION_HEX >= 0x030A0000) + #endif #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 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_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #ifdef Py_GIL_DISABLED + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 1 + #else + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + #endif + #if PY_VERSION_HEX < 0x030A0000 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #elif !defined(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 + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 #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 + #ifndef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif - #if PY_VERSION_HEX < 0x02070000 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #ifndef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 1 #endif - #ifndef CYTHON_USE_PYLIST_INTERNALS + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #elif !defined(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 + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING || PY_VERSION_HEX >= 0x030B00A2 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #elif !defined(CYTHON_USE_UNICODE_WRITER) @@ -164,36 +316,82 @@ #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1 + #elif !defined(CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS) + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0 + #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif + #ifndef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 1 + #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #elif !defined(CYTHON_FAST_GIL) + #define CYTHON_FAST_GIL (PY_VERSION_HEX < 0x030C00A6) + #endif + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 1 + #endif #ifndef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 1 #endif + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif + #ifndef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING (PY_VERSION_HEX >= 0x030d00B1) #endif #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) + #define CYTHON_USE_TP_FINALIZE 1 #endif - #ifndef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) + #ifndef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND 1 + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #elif !defined(CYTHON_USE_DICT_VERSIONS) + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5 && !CYTHON_USE_MODULE_STATE) #endif #ifndef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) + #define CYTHON_USE_EXC_INFO_STACK 1 + #endif + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS (!CYTHON_COMPILING_IN_CPYTHON_FREETHREADING) + #endif +#endif +#ifndef CYTHON_FAST_PYCCALL +#define CYTHON_FAST_PYCCALL CYTHON_FAST_PYCALL +#endif +#ifndef CYTHON_VECTORCALL +#if CYTHON_COMPILING_IN_LIMITED_API +#define CYTHON_VECTORCALL (__PYX_LIMITED_VERSION_HEX >= 0x030C0000) +#else +#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) #endif -#if !defined(CYTHON_FAST_PYCCALL) -#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif +#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) #if CYTHON_USE_PYLONG_INTERNALS - #include "longintrepr.h" #undef SHIFT #undef BASE #undef MASK @@ -201,6 +399,9 @@ enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; #endif #endif +#ifndef CYTHON_LOCK_AND_GIL_DEADLOCK_AVOIDANCE_TIME + #define CYTHON_LOCK_AND_GIL_DEADLOCK_AVOIDANCE_TIME 100 +#endif #ifndef __has_attribute #define __has_attribute(x) 0 #endif @@ -218,6 +419,17 @@ #define CYTHON_RESTRICT #endif #endif +#ifndef CYTHON_UNUSED + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(maybe_unused) + #define CYTHON_UNUSED [[maybe_unused]] + #endif + #endif + #endif +#endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) @@ -231,42 +443,76 @@ # define CYTHON_UNUSED # endif #endif -#ifndef CYTHON_MAYBE_UNUSED_VAR +#ifndef CYTHON_UNUSED_VAR # if defined(__cplusplus) - template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } + template void CYTHON_UNUSED_VAR( const T& ) { } # else -# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# define CYTHON_UNUSED_VAR(x) (void)(x) # endif #endif +#ifndef CYTHON_MAYBE_UNUSED_VAR + #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) +#endif #ifndef CYTHON_NCP_UNUSED -# if CYTHON_COMPILING_IN_CPYTHON +# if CYTHON_COMPILING_IN_CPYTHON && !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING # define CYTHON_NCP_UNUSED # else # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif +#ifndef CYTHON_USE_CPP_STD_MOVE + #if defined(__cplusplus) && (\ + __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) + #define CYTHON_USE_CPP_STD_MOVE 1 + #else + #define CYTHON_USE_CPP_STD_MOVE 0 + #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; + typedef unsigned char uint8_t; + typedef unsigned short uint16_t; + typedef unsigned int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; + #endif + #endif + #if _MSC_VER < 1300 + #ifdef _WIN64 + typedef unsigned long long __pyx_uintptr_t; + #else + typedef unsigned int __pyx_uintptr_t; + #endif + #else + #ifdef _WIN64 + typedef unsigned __int64 __pyx_uintptr_t; #else - typedef unsigned __int8 uint8_t; - typedef unsigned __int32 uint32_t; + typedef unsigned __int32 __pyx_uintptr_t; #endif #endif #else - #include + #include + typedef uintptr_t __pyx_uintptr_t; #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]] + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(fallthrough) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif #endif #endif #ifndef CYTHON_FALLTHROUGH @@ -276,14 +522,31 @@ #define CYTHON_FALLTHROUGH #endif #endif - #if defined(__clang__ ) && defined(__apple_build_version__) + #if defined(__clang__) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif +#ifndef Py_UNREACHABLE + #define Py_UNREACHABLE() assert(0); abort() +#endif +#ifdef __cplusplus + template + struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; + #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) +#else + #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) +#endif +#if CYTHON_COMPILING_IN_PYPY == 1 + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000) +#else + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000) +#endif +#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) +/* CInitCode */ #ifndef CYTHON_INLINE #if defined(__clang__) #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) @@ -298,26 +561,72 @@ #endif #endif -#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) - #define Py_OptimizeFlag 0 -#endif +/* PythonCompatibility */ #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" -#if PY_VERSION_HEX >= 0x030800A4 && PY_VERSION_HEX < 0x030800B2 - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_New(a, 0, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) -#else - #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_BUILTIN_MODULE_NAME "builtins" +#define __Pyx_DefaultClassType PyType_Type +#if CYTHON_COMPILING_IN_LIMITED_API + #ifndef CO_OPTIMIZED + static int CO_OPTIMIZED; + #endif + #ifndef CO_NEWLOCALS + static int CO_NEWLOCALS; + #endif + #ifndef CO_VARARGS + static int CO_VARARGS; + #endif + #ifndef CO_VARKEYWORDS + static int CO_VARKEYWORDS; + #endif + #ifndef CO_ASYNC_GENERATOR + static int CO_ASYNC_GENERATOR; + #endif + #ifndef CO_GENERATOR + static int CO_GENERATOR; + #endif + #ifndef CO_COROUTINE + static int CO_COROUTINE; + #endif +#else + #ifndef CO_COROUTINE + #define CO_COROUTINE 0x80 + #endif + #ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x200 + #endif #endif - #define __Pyx_DefaultClassType PyType_Type +static int __Pyx_init_co_variables(void); +#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE) + #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) +#else + #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) + #define __Pyx_Py_Is(x, y) Py_Is(x, y) +#else + #define __Pyx_Py_Is(x, y) ((x) == (y)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) + #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) +#else + #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) + #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) +#else + #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) + #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) +#else + #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) +#endif +#define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) +#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) +#else + #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 @@ -331,10 +640,16 @@ #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif +#ifndef Py_TPFLAGS_SEQUENCE + #define Py_TPFLAGS_SEQUENCE 0 +#endif +#ifndef Py_TPFLAGS_MAPPING + #define Py_TPFLAGS_MAPPING 0 +#endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif -#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) +#ifndef METH_FASTCALL #ifndef METH_FASTCALL #define METH_FASTCALL 0x80 #endif @@ -342,114 +657,208 @@ typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else - #define __Pyx_PyCFunctionFast _PyCFunctionFast - #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #if PY_VERSION_HEX >= 0x030d00A4 + # define __Pyx_PyCFunctionFast PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords + #else + # define __Pyx_PyCFunctionFast _PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #endif +#endif +#if CYTHON_METH_FASTCALL + #define __Pyx_METH_FASTCALL METH_FASTCALL + #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast + #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords +#else + #define __Pyx_METH_FASTCALL METH_VARARGS + #define __Pyx_PyCFunction_FastCall PyCFunction + #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords +#endif +#if CYTHON_VECTORCALL + #define __pyx_vectorcallfunc vectorcallfunc + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET + #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) +#elif CYTHON_BACKPORT_VECTORCALL + typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args, + size_t nargsf, PyObject *kwnames); + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)) +#else + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) +#endif +#if PY_VERSION_HEX >= 0x030900B1 +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) +#else +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) +#endif +#define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) +#elif !CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) +#endif +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) +static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { + return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; +} +#endif +static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void (*cfunc)(void)) { +#if CYTHON_COMPILING_IN_LIMITED_API + return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; +#else + return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; #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 | METH_STACKLESS))))) +} +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) +#if __PYX_LIMITED_VERSION_HEX < 0x03090000 + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) + typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); #else -#define __Pyx_PyFastCFunction_Check(func) 0 + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) + #define __Pyx_PyCMethod PyCMethod +#endif +#ifndef METH_METHOD + #define METH_METHOD 0x200 #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_CPYTHON && PY_VERSION_HEX < 0x030400A1 - #define PyMem_RawMalloc(n) PyMem_Malloc(n) - #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) - #define PyMem_RawFree(p) PyMem_Free(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) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) +#elif CYTHON_COMPILING_IN_GRAAL + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #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 +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyThreadState_Current PyThreadState_Get() +#elif !CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() #else - #define __Pyx_PyThreadState_Current _PyThreadState_Current + #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #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; -} -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); +#if CYTHON_USE_MODULE_STATE +static CYTHON_INLINE void *__Pyx__PyModule_GetState(PyObject *op) +{ + void *result; + result = PyModule_GetState(op); + if (!result) + Py_FatalError("Couldn't find the module state"); + return result; } +#define __Pyx_PyModule_GetState(o) (__pyx_mstatetype *)__Pyx__PyModule_GetState(o) +#else +#define __Pyx_PyModule_GetState(op) ((void)op,__pyx_mstate_global) +#endif +#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE((PyObject *) obj), name, func_ctype) +#define __Pyx_PyObject_TryGetSlot(obj, name, func_ctype) __Pyx_PyType_TryGetSlot(Py_TYPE(obj), name, func_ctype) +#define __Pyx_PyObject_GetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_GetSubSlot(Py_TYPE(obj), sub, name, func_ctype) +#define __Pyx_PyObject_TryGetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_TryGetSubSlot(Py_TYPE(obj), sub, name, func_ctype) +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) + #define __Pyx_PyType_TryGetSlot(type, name, func_ctype) __Pyx_PyType_GetSlot(type, name, func_ctype) + #define __Pyx_PyType_GetSubSlot(type, sub, name, func_ctype) (((type)->sub) ? ((type)->sub->name) : NULL) + #define __Pyx_PyType_TryGetSubSlot(type, sub, name, func_ctype) __Pyx_PyType_GetSubSlot(type, sub, name, func_ctype) +#else + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) + #define __Pyx_PyType_TryGetSlot(type, name, func_ctype)\ + ((__PYX_LIMITED_VERSION_HEX >= 0x030A0000 ||\ + (PyType_GetFlags(type) & Py_TPFLAGS_HEAPTYPE) || __Pyx_get_runtime_version() >= 0x030A0000) ?\ + __Pyx_PyType_GetSlot(type, name, func_ctype) : NULL) + #define __Pyx_PyType_GetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_GetSlot(obj, name, func_ctype) + #define __Pyx_PyType_TryGetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_TryGetSlot(obj, name, func_ctype) #endif #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) +#define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) +#define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { + PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); + if (res == NULL) PyErr_Clear(); + return res; +} +#elif !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000 +#define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#else +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { +#if CYTHON_COMPILING_IN_PYPY + return PyDict_GetItem(dict, name); +#else + PyDictEntry *ep; + PyDictObject *mp = (PyDictObject*) dict; + long hash = ((PyStringObject *) name)->ob_shash; + assert(hash != -1); + ep = (mp->ma_lookup)(mp, name, hash); + if (ep == NULL) { + return NULL; + } + return ep->me_value; +#endif +} +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#endif +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) + #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) #else - #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) - #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) + #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) + #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) #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) +#define __Pyx_PyObject_GetIterNextFunc(iterator) __Pyx_PyObject_GetSlot(iterator, tp_iternext, iternextfunc) +#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000 +#define __Pyx_PyHeapTypeObject_GC_Del(obj) {\ + PyTypeObject *type = Py_TYPE((PyObject*)obj);\ + assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\ + PyObject_GC_Del(obj);\ + Py_DECREF(type);\ +} #else -#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) +#define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) #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) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) + #define __Pyx_PyUnicode_DATA(u) ((void*)u) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) +#else + #if PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_READY(op) (0) + #else + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #endif #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_KIND(u) ((int)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)) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, (Py_UCS4) ch) + #if PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #else + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #endif + #endif #endif #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) @@ -459,106 +868,226 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #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) +#if CYTHON_COMPILING_IN_PYPY + #if !defined(PyUnicode_DecodeUnicodeEscape) + #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) + #endif + #if !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) + #endif + #if !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) + #endif + #if !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) + #endif #endif -#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) -#if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#if CYTHON_COMPILING_IN_CPYTHON + #define __Pyx_PySequence_ListKeepNew(obj)\ + (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj)) #else - #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) + #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) #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 +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type) #endif -#if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) - #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#if PY_VERSION_HEX >= 0x030900A4 + #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) #else - #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) - #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) + #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) +#endif +#if CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + #define __Pyx_PyList_GetItemRef(o, i) PyList_GetItemRef(o, i) + #elif CYTHON_COMPILING_IN_LIMITED_API || !CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PyList_GetItemRef(o, i) (likely((i) >= 0) ? PySequence_GetItem(o, i) : (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) + #else + #define __Pyx_PyList_GetItemRef(o, i) PySequence_ITEM(o, i) + #endif +#elif CYTHON_COMPILING_IN_LIMITED_API || !CYTHON_ASSUME_SAFE_MACROS + #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + #define __Pyx_PyList_GetItemRef(o, i) PyList_GetItemRef(o, i) + #else + #define __Pyx_PyList_GetItemRef(o, i) __Pyx_XNewRef(PyList_GetItem(o, i)) + #endif +#else + #define __Pyx_PyList_GetItemRef(o, i) __Pyx_NewRef(PyList_GET_ITEM(o, i)) +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 +#define __Pyx_PyDict_GetItemRef(dict, key, result) PyDict_GetItemRef(dict, key, result) +#elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS +static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key, PyObject **result) { + *result = PyObject_GetItem(dict, key); + if (*result == NULL) { + if (PyErr_ExceptionMatches(PyExc_KeyError)) { + PyErr_Clear(); + return 0; + } + return -1; + } + return 1; +} +#else +static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key, PyObject **result) { + *result = PyDict_GetItemWithError(dict, key); + if (*result == NULL) { + return PyErr_Occurred() ? -1 : 0; + } + Py_INCREF(*result); + return 1; +} #endif -#ifndef PySet_CheckExact - #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#if defined(CYTHON_DEBUG_VISIT_CONST) && CYTHON_DEBUG_VISIT_CONST + #define __Pyx_VISIT_CONST(obj) Py_VISIT(obj) +#else + #define __Pyx_VISIT_CONST(obj) #endif #if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i) #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyTuple_GET_ITEM(o, i) PyTuple_GET_ITEM(o, i) + #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyList_GET_ITEM(o, i) PyList_GET_ITEM(o, i) #else + #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) + #define __Pyx_PyTuple_GET_ITEM(o, i) PyTuple_GetItem(o, i) + #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) + #define __Pyx_PyList_GET_ITEM(o, i) PyList_GetItem(o, i) +#endif +#if CYTHON_ASSUME_SAFE_SIZE + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) + #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GET_LENGTH(o) +#else + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) + #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GetLength(o) +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) +#else + static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { + PyObject *module = PyImport_AddModule(name); + Py_XINCREF(module); + return module; + } #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 +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_InternFromString) + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) +#endif +#define __Pyx_PyLong_FromHash_t PyLong_FromSsize_t +#define __Pyx_PyLong_AsHash_t __Pyx_PyIndex_AsSsize_t +#if __PYX_LIMITED_VERSION_HEX >= 0x030A0000 + #define __Pyx_PySendResult PySendResult +#else + typedef enum { + PYGEN_RETURN = 0, + PYGEN_ERROR = -1, + PYGEN_NEXT = 1, + } __Pyx_PySendResult; +#endif +#if CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX < 0x030A00A3 + typedef __Pyx_PySendResult (*__Pyx_pyiter_sendfunc)(PyObject *iter, PyObject *value, PyObject **result); +#else + #define __Pyx_pyiter_sendfunc sendfunc +#endif +#if !CYTHON_USE_AM_SEND +#define __PYX_HAS_PY_AM_SEND 0 +#elif __PYX_LIMITED_VERSION_HEX >= 0x030A0000 +#define __PYX_HAS_PY_AM_SEND 1 #else - #define __Pyx_PyType_AsAsync(obj) NULL +#define __PYX_HAS_PY_AM_SEND 2 // our own backported implementation #endif -#ifndef __Pyx_PyAsyncMethodsStruct +#if __PYX_HAS_PY_AM_SEND < 2 + #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods +#else typedef struct { unaryfunc am_await; unaryfunc am_aiter; unaryfunc am_anext; + __Pyx_pyiter_sendfunc am_send; } __Pyx_PyAsyncMethodsStruct; + #define __Pyx_SlotTpAsAsync(s) ((PyAsyncMethods*)(s)) +#endif +#if CYTHON_USE_AM_SEND && PY_VERSION_HEX < 0x030A00F0 + #define __Pyx_TPFLAGS_HAVE_AM_SEND (1UL << 21) +#else + #define __Pyx_TPFLAGS_HAVE_AM_SEND (0) +#endif +#if PY_VERSION_HEX >= 0x03090000 +#define __Pyx_PyInterpreterState_Get() PyInterpreterState_Get() +#else +#define __Pyx_PyInterpreterState_Get() PyThreadState_Get()->interp +#endif +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030A0000 +#ifdef __cplusplus +extern "C" +#endif +PyAPI_FUNC(void *) PyMem_Calloc(size_t nelem, size_t elsize); +#endif +#if CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_init_co_variable(PyObject *inspect, const char* name, int *write_to) { + int value; + PyObject *py_value = PyObject_GetAttrString(inspect, name); + if (!py_value) return 0; + value = (int) PyLong_AsLong(py_value); + Py_DECREF(py_value); + *write_to = value; + return value != -1 || !PyErr_Occurred(); +} +static int __Pyx_init_co_variables(void) { + PyObject *inspect; + int result; + inspect = PyImport_ImportModule("inspect"); + result = +#if !defined(CO_OPTIMIZED) + __Pyx_init_co_variable(inspect, "CO_OPTIMIZED", &CO_OPTIMIZED) && +#endif +#if !defined(CO_NEWLOCALS) + __Pyx_init_co_variable(inspect, "CO_NEWLOCALS", &CO_NEWLOCALS) && +#endif +#if !defined(CO_VARARGS) + __Pyx_init_co_variable(inspect, "CO_VARARGS", &CO_VARARGS) && +#endif +#if !defined(CO_VARKEYWORDS) + __Pyx_init_co_variable(inspect, "CO_VARKEYWORDS", &CO_VARKEYWORDS) && +#endif +#if !defined(CO_ASYNC_GENERATOR) + __Pyx_init_co_variable(inspect, "CO_ASYNC_GENERATOR", &CO_ASYNC_GENERATOR) && +#endif +#if !defined(CO_GENERATOR) + __Pyx_init_co_variable(inspect, "CO_GENERATOR", &CO_GENERATOR) && +#endif +#if !defined(CO_COROUTINE) + __Pyx_init_co_variable(inspect, "CO_COROUTINE", &CO_COROUTINE) && +#endif + 1; + Py_DECREF(inspect); + return result ? 0 : -1; +} +#else +static int __Pyx_init_co_variables(void) { + return 0; // It's a limited API-only feature +} #endif -#if defined(WIN32) || defined(MS_WINDOWS) - #define _USE_MATH_DEFINES +/* MathInitCode */ +#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) + #ifndef _USE_MATH_DEFINES + #define _USE_MATH_DEFINES + #endif #endif #include #ifdef NAN @@ -576,14 +1105,31 @@ static CYTHON_INLINE float __PYX_NAN() { #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 +#ifndef CYTHON_CLINE_IN_TRACEBACK_RUNTIME +#define CYTHON_CLINE_IN_TRACEBACK_RUNTIME 0 +#endif +#ifndef CYTHON_CLINE_IN_TRACEBACK +#define CYTHON_CLINE_IN_TRACEBACK CYTHON_CLINE_IN_TRACEBACK_RUNTIME +#endif +#if CYTHON_CLINE_IN_TRACEBACK +#define __PYX_MARK_ERR_POS(f_index, lineno) { __pyx_filename = __pyx_f[f_index]; (void) __pyx_filename; __pyx_lineno = lineno; (void) __pyx_lineno; __pyx_clineno = __LINE__; (void) __pyx_clineno; } +#else +#define __PYX_MARK_ERR_POS(f_index, lineno) { __pyx_filename = __pyx_f[f_index]; (void) __pyx_filename; __pyx_lineno = lineno; (void) __pyx_lineno; (void) __pyx_clineno; } +#endif +#define __PYX_ERR(f_index, lineno, Ln_error) \ + { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } + +#ifdef CYTHON_EXTERN_C + #undef __PYX_EXTERN_C + #define __PYX_EXTERN_C CYTHON_EXTERN_C +#elif defined(__PYX_EXTERN_C) + #ifdef _MSC_VER + #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") + #else + #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. + #endif +#else + #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else #define __PYX_EXTERN_C extern @@ -593,9 +1139,26 @@ static CYTHON_INLINE float __PYX_NAN() { #define __PYX_HAVE__hunter___predicates #define __PYX_HAVE_API__hunter___predicates /* Early includes */ +#include "vendor/_compat.h" + + static inline PyCodeObject* Hunter_PyFrame_GetCode(PyObject* frame) { + return PyFrame_GetCode((PyFrameObject*) frame); + } + static inline int Hunter_PyFrame_GetLasti(PyObject* frame) { + return PyFrame_GetLasti((PyFrameObject*) frame); + } + static inline int Hunter_PyFrame_GetLineNumber(PyObject* frame) { + return PyFrame_GetLineNumber((PyFrameObject*) frame); + } + static inline PyObject* Hunter_PyFrame_GetGlobals(PyObject* frame) { + return PyFrame_GetGlobals((PyFrameObject*) frame); + } + static inline PyObject* Hunter_PyFrame_GetLocals(PyObject* frame) { + return PyFrame_GetLocals((PyFrameObject*) frame); + } + #include #include -#include "frameobject.h" #include "pystate.h" #ifdef _OPENMP #include @@ -605,12 +1168,8 @@ static CYTHON_INLINE float __PYX_NAN() { #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_UTF8 0 -#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize @@ -645,139 +1204,129 @@ static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s); 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)) +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*); #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)) +#if CYTHON_ASSUME_SAFE_MACROS + #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_PyByteArray_AsString(s) PyByteArray_AS_STRING(s) +#else + #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AsString(s)) + #define __Pyx_PyByteArray_AsString(s) PyByteArray_AsString(s) +#endif +#define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __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_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) #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_NewRef(PyObject *obj) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030a0000 || defined(Py_NewRef) + return Py_NewRef(obj); +#else + Py_INCREF(obj); + return obj; +#endif +} +static CYTHON_INLINE PyObject *__Pyx_XNewRef(PyObject *obj) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030a0000 || defined(Py_XNewRef) + return Py_XNewRef(obj); +#else + Py_XINCREF(obj); + return obj; +#endif +} +static CYTHON_INLINE PyObject *__Pyx_Owned_Py_None(int b); static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); -static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Long(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); +static CYTHON_INLINE PyObject * __Pyx_PyLong_FromSize_t(size_t); +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); #if CYTHON_ASSUME_SAFE_MACROS -#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#define __Pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#define __Pyx_PyFloat_AS_DOUBLE(x) PyFloat_AS_DOUBLE(x) #else -#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#define __Pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#define __Pyx_PyFloat_AS_DOUBLE(x) PyFloat_AsDouble(x) #endif -#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) -#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyFloat_AsFloat(x) ((float) __Pyx_PyFloat_AsDouble(x)) #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) + 1); - 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; -} +#if CYTHON_USE_PYLONG_INTERNALS + #if PY_VERSION_HEX >= 0x030C00A7 + #ifndef _PyLong_SIGN_MASK + #define _PyLong_SIGN_MASK 3 + #endif + #ifndef _PyLong_NON_SIZE_BITS + #define _PyLong_NON_SIZE_BITS 3 + #endif + #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK) + #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) + #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) + #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) + #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_SignedDigitCount(x)\ + ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) + #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) + #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) + #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) + #else + #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) + #endif + typedef Py_ssize_t __Pyx_compact_pylong; + typedef size_t __Pyx_compact_upylong; + #else + #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) + #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) + #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) + #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) + #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) + #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) + #define __Pyx_PyLong_CompactValue(x)\ + ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) + typedef sdigit __Pyx_compact_pylong; + typedef digit __Pyx_compact_upylong; + #endif + #if PY_VERSION_HEX >= 0x030C00A5 + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) + #else + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) + #endif #endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#elif __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeASCII(c_str, size, NULL) +#else + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #endif @@ -789,90 +1338,326 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #define likely(x) (x) #define unlikely(x) (x) #endif /* __GNUC__ */ +/* PretendToInitialize */ +#ifdef __cplusplus +#if __cplusplus > 201103L +#include +#endif +template +static void __Pyx_pretend_to_initialize(T* ptr) { +#if __cplusplus > 201103L + if ((std::is_trivially_default_constructible::value)) +#endif + *ptr = T(); + (void)ptr; +} +#else static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } +#endif + +#if !CYTHON_USE_MODULE_STATE 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; +#endif static int __pyx_lineno; static int __pyx_clineno = 0; -static const char * __pyx_cfilenm= __FILE__; +static const char * const __pyx_cfilenm = __FILE__; static const char *__pyx_filename; +/* #### Code section: filename_table ### */ -static const char *__pyx_f[] = { +static const char* const __pyx_f[] = { "src/hunter/_predicates.pyx", + "", "src/hunter/_predicates.pxd", - "stringsource", - ".tox/cythonize/lib/python3.8/site-packages/Cython/Includes/cpython/type.pxd", - "src/hunter/_tracer.pxd", "src/hunter/_event.pxd", + ".tox/cythonize/lib64/python3.13/site-packages/Cython/Includes/cpython/type.pxd", + "src/hunter/_tracer.pxd", }; +/* #### Code section: utility_code_proto_before_types ### */ +/* Atomics.proto */ +#include +#ifndef CYTHON_ATOMICS + #define CYTHON_ATOMICS 1 +#endif +#define __PYX_CYTHON_ATOMICS_ENABLED() CYTHON_ATOMICS +#define __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING() CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +#define __pyx_atomic_int_type int +#define __pyx_nonatomic_int_type int +#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\ + (__STDC_VERSION__ >= 201112L) &&\ + !defined(__STDC_NO_ATOMICS__)) + #include +#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\ + (__cplusplus >= 201103L) ||\ + (defined(_MSC_VER) && _MSC_VER >= 1700))) + #include +#endif +#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\ + (__STDC_VERSION__ >= 201112L) &&\ + !defined(__STDC_NO_ATOMICS__) &&\ + ATOMIC_INT_LOCK_FREE == 2) + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type atomic_int + #define __pyx_atomic_ptr_type atomic_uintptr_t + #define __pyx_nonatomic_ptr_type uintptr_t + #define __pyx_atomic_incr_relaxed(value) atomic_fetch_add_explicit(value, 1, memory_order_relaxed) + #define __pyx_atomic_incr_acq_rel(value) atomic_fetch_add_explicit(value, 1, memory_order_acq_rel) + #define __pyx_atomic_decr_acq_rel(value) atomic_fetch_sub_explicit(value, 1, memory_order_acq_rel) + #define __pyx_atomic_sub(value, arg) atomic_fetch_sub(value, arg) + #define __pyx_atomic_int_cmp_exchange(value, expected, desired) atomic_compare_exchange_strong(value, expected, desired) + #define __pyx_atomic_load(value) atomic_load(value) + #define __pyx_atomic_store(value, new_value) atomic_store(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) atomic_load_explicit(value, memory_order_relaxed) + #define __pyx_atomic_pointer_load_acquire(value) atomic_load_explicit(value, memory_order_acquire) + #define __pyx_atomic_pointer_exchange(value, new_value) atomic_exchange(value, (__pyx_nonatomic_ptr_type)new_value) + #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) + #pragma message ("Using standard C atomics") + #elif defined(__PYX_DEBUG_ATOMICS) + #warning "Using standard C atomics" + #endif +#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\ + (__cplusplus >= 201103L) ||\ +\ + (defined(_MSC_VER) && _MSC_VER >= 1700)) &&\ + ATOMIC_INT_LOCK_FREE == 2) + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type std::atomic_int + #define __pyx_atomic_ptr_type std::atomic_uintptr_t + #define __pyx_nonatomic_ptr_type uintptr_t + #define __pyx_atomic_incr_relaxed(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_relaxed) + #define __pyx_atomic_incr_acq_rel(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_acq_rel) + #define __pyx_atomic_decr_acq_rel(value) std::atomic_fetch_sub_explicit(value, 1, std::memory_order_acq_rel) + #define __pyx_atomic_sub(value, arg) std::atomic_fetch_sub(value, arg) + #define __pyx_atomic_int_cmp_exchange(value, expected, desired) std::atomic_compare_exchange_strong(value, expected, desired) + #define __pyx_atomic_load(value) std::atomic_load(value) + #define __pyx_atomic_store(value, new_value) std::atomic_store(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) std::atomic_load_explicit(value, std::memory_order_relaxed) + #define __pyx_atomic_pointer_load_acquire(value) std::atomic_load_explicit(value, std::memory_order_acquire) + #define __pyx_atomic_pointer_exchange(value, new_value) std::atomic_exchange(value, (__pyx_nonatomic_ptr_type)new_value) + #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) + #pragma message ("Using standard C++ atomics") + #elif defined(__PYX_DEBUG_ATOMICS) + #warning "Using standard C++ atomics" + #endif +#elif CYTHON_ATOMICS && (__GNUC__ >= 5 || (__GNUC__ == 4 &&\ + (__GNUC_MINOR__ > 1 ||\ + (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ >= 2)))) + #define __pyx_atomic_ptr_type void* + #define __pyx_atomic_incr_relaxed(value) __sync_fetch_and_add(value, 1) + #define __pyx_atomic_incr_acq_rel(value) __sync_fetch_and_add(value, 1) + #define __pyx_atomic_decr_acq_rel(value) __sync_fetch_and_sub(value, 1) + #define __pyx_atomic_sub(value, arg) __sync_fetch_and_sub(value, arg) + static CYTHON_INLINE int __pyx_atomic_int_cmp_exchange(__pyx_atomic_int_type* value, __pyx_nonatomic_int_type* expected, __pyx_nonatomic_int_type desired) { + __pyx_nonatomic_int_type old = __sync_val_compare_and_swap(value, *expected, desired); + int result = old == *expected; + *expected = old; + return result; + } + #define __pyx_atomic_load(value) __sync_fetch_and_add(value, 0) + #define __pyx_atomic_store(value, new_value) __sync_lock_test_and_set(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) __sync_fetch_and_add(value, 0) + #define __pyx_atomic_pointer_load_acquire(value) __sync_fetch_and_add(value, 0) + #define __pyx_atomic_pointer_exchange(value, new_value) __sync_lock_test_and_set(value, (__pyx_atomic_ptr_type)new_value) + #ifdef __PYX_DEBUG_ATOMICS + #warning "Using GNU atomics" + #endif +#elif CYTHON_ATOMICS && defined(_MSC_VER) + #include + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type long + #define __pyx_atomic_ptr_type void* + #undef __pyx_nonatomic_int_type + #define __pyx_nonatomic_int_type long + #pragma intrinsic (_InterlockedExchangeAdd, _InterlockedExchange, _InterlockedCompareExchange, _InterlockedCompareExchangePointer, _InterlockedExchangePointer) + #define __pyx_atomic_incr_relaxed(value) _InterlockedExchangeAdd(value, 1) + #define __pyx_atomic_incr_acq_rel(value) _InterlockedExchangeAdd(value, 1) + #define __pyx_atomic_decr_acq_rel(value) _InterlockedExchangeAdd(value, -1) + #define __pyx_atomic_sub(value, arg) _InterlockedExchangeAdd(value, -arg) + static CYTHON_INLINE int __pyx_atomic_int_cmp_exchange(__pyx_atomic_int_type* value, __pyx_nonatomic_int_type* expected, __pyx_nonatomic_int_type desired) { + __pyx_nonatomic_int_type old = _InterlockedCompareExchange(value, desired, *expected); + int result = old == *expected; + *expected = old; + return result; + } + #define __pyx_atomic_load(value) _InterlockedExchangeAdd(value, 0) + #define __pyx_atomic_store(value, new_value) _InterlockedExchange(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) *(void * volatile *)value + #define __pyx_atomic_pointer_load_acquire(value) _InterlockedCompareExchangePointer(value, 0, 0) + #define __pyx_atomic_pointer_exchange(value, new_value) _InterlockedExchangePointer(value, (__pyx_atomic_ptr_type)new_value) + #ifdef __PYX_DEBUG_ATOMICS + #pragma message ("Using MSVC atomics") + #endif +#else + #undef CYTHON_ATOMICS + #define CYTHON_ATOMICS 0 + #ifdef __PYX_DEBUG_ATOMICS + #warning "Not using atomics" + #endif +#endif +#if CYTHON_ATOMICS + #define __pyx_add_acquisition_count(memview)\ + __pyx_atomic_incr_relaxed(__pyx_get_slice_count_pointer(memview)) + #define __pyx_sub_acquisition_count(memview)\ + __pyx_atomic_decr_acq_rel(__pyx_get_slice_count_pointer(memview)) +#else + #define __pyx_add_acquisition_count(memview)\ + __pyx_add_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) + #define __pyx_sub_acquisition_count(memview)\ + __pyx_sub_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) +#endif + +/* Profile_config.proto */ +#ifndef CYTHON_PROFILE +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + #define CYTHON_PROFILE 0 +#else + #define CYTHON_PROFILE 1 +#endif +#endif +#ifndef CYTHON_TRACE_NOGIL + #define CYTHON_TRACE_NOGIL 0 +#else + #if CYTHON_TRACE_NOGIL && !defined(CYTHON_TRACE) + #define CYTHON_TRACE 1 + #endif +#endif +#ifndef CYTHON_TRACE + #define CYTHON_TRACE 0 +#endif +#if CYTHON_PROFILE || CYTHON_TRACE +#if CYTHON_USE_SYS_MONITORING + typedef enum { + __Pyx_Monitoring_PY_START = 0, + __Pyx_Monitoring_PY_RETURN, + __Pyx_Monitoring_PY_UNWIND, + __Pyx_Monitoring_LINE, + __Pyx_Monitoring_RAISE, + __Pyx_Monitoring_RERAISE, + __Pyx_Monitoring_EXCEPTION_HANDLED, + __Pyx_Monitoring_PY_RESUME, + __Pyx_Monitoring_PY_YIELD, + __Pyx_Monitoring_STOP_ITERATION, + } __Pyx_Monitoring_Event_Index; + static const unsigned char __Pyx_MonitoringEventTypes[] = { + PY_MONITORING_EVENT_PY_START, + PY_MONITORING_EVENT_PY_RETURN, + PY_MONITORING_EVENT_PY_UNWIND, + PY_MONITORING_EVENT_LINE, + PY_MONITORING_EVENT_RAISE, + PY_MONITORING_EVENT_RERAISE, + PY_MONITORING_EVENT_EXCEPTION_HANDLED, + PY_MONITORING_EVENT_PY_RESUME, + PY_MONITORING_EVENT_PY_YIELD, + PY_MONITORING_EVENT_STOP_ITERATION, + }; + #define __Pyx_MonitoringEventTypes_CyFunc_count (sizeof(__Pyx_MonitoringEventTypes) - 3) + #define __Pyx_MonitoringEventTypes_CyGen_count (sizeof(__Pyx_MonitoringEventTypes)) +#endif +#endif + +/* NoFastGil.proto */ +#define __Pyx_PyGILState_Ensure PyGILState_Ensure +#define __Pyx_PyGILState_Release PyGILState_Release +#define __Pyx_FastGIL_Remember() +#define __Pyx_FastGIL_Forget() +#define __Pyx_FastGilFuncInit() + +/* IncludeStructmemberH.proto */ +#include + +/* CriticalSections.proto */ +#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +#define __Pyx_PyCriticalSection void* +#define __Pyx_PyCriticalSection2 void* +#define __Pyx_PyCriticalSection_Begin1(cs, arg) (void)cs +#define __Pyx_PyCriticalSection_Begin2(cs, arg1, arg2) (void)cs +#define __Pyx_PyCriticalSection_End1(cs) +#define __Pyx_PyCriticalSection_End2(cs) +#else +#define __Pyx_PyCriticalSection PyCriticalSection +#define __Pyx_PyCriticalSection2 PyCriticalSection2 +#define __Pyx_PyCriticalSection_Begin1 PyCriticalSection_Begin +#define __Pyx_PyCriticalSection_Begin2 PyCriticalSection2_Begin +#define __Pyx_PyCriticalSection_End1 PyCriticalSection_End +#define __Pyx_PyCriticalSection_End2 PyCriticalSection2_End +#endif +#if PY_VERSION_HEX < 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_BEGIN_CRITICAL_SECTION(o) { +#define __Pyx_END_CRITICAL_SECTION() } +#else +#define __Pyx_BEGIN_CRITICAL_SECTION Py_BEGIN_CRITICAL_SECTION +#define __Pyx_END_CRITICAL_SECTION Py_END_CRITICAL_SECTION +#endif + +/* #### Code section: numeric_typedefs ### */ +/* #### Code section: complex_type_declarations ### */ +/* #### Code section: type_declarations ### */ /*--- Type declarations ---*/ -struct __pyx_obj_6hunter_7_tracer_Tracer; struct __pyx_obj_6hunter_6_event_Event; +struct __pyx_obj_6hunter_7_tracer_Tracer; struct __pyx_obj_6hunter_11_predicates_Query; struct __pyx_obj_6hunter_11_predicates_And; struct __pyx_obj_6hunter_11_predicates_Or; struct __pyx_obj_6hunter_11_predicates_Not; struct __pyx_obj_6hunter_11_predicates_When; struct __pyx_obj_6hunter_11_predicates_From; +struct __pyx_obj_6hunter_11_predicates_Backlog; +struct __pyx_obj_6hunter_11_predicates_QueryEntry; struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__; struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr; struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr; -struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3___repr__; +struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3_genexpr; struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr; -struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5___init__; -struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_6_genexpr; -struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_7___str__; -struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_8_genexpr; -struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_9___str__; -struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_10_genexpr; -struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_11___str__; -struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_12_genexpr; +struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5_genexpr; +struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event; -/* "_tracer.pxd":28 +/* "_event.pxd":4 * - * @cython.final - * cdef class Tracer: # <<<<<<<<<<<<<< - * cdef: - * readonly object handler - */ -struct __pyx_obj_6hunter_7_tracer_Tracer { - PyObject_HEAD - PyObject *handler; - PyObject *previous; - PyObject *threading_support; - int depth; - int calls; - PyObject *__weakref__; - PyObject *_threading_previous; - Py_tracefunc _previousfunc; -}; + * + * ctypedef extern FrameType # <<<<<<<<<<<<<< + * + * cdef extern from *: +*/ +typedef PyObject *FrameType; + +/* "_tracer.pxd":6 + * + * + * ctypedef extern FrameType # <<<<<<<<<<<<<< + * + * cdef extern from *: +*/ +typedef PyObject *FrameType; +/* "hunter/_predicates.pyx":37 + * ) + * + * ctypedef object (*Event_getter_typedef)(Event) # <<<<<<<<<<<<<< + * cdef inline Event_get_function(Event event): return event.function_getter() + * cdef inline Event_get_module(Event event): return event.module_getter() +*/ +typedef PyObject *(*__pyx_t_6hunter_11_predicates_Event_getter_typedef)(struct __pyx_obj_6hunter_6_event_Event *); -/* "_event.pxd":11 +/* "_event.pxd":39 * - * @cython.final - * cdef class Event: # <<<<<<<<<<<<<< + * + * @cython.final # <<<<<<<<<<<<<< + * cdef class Event: * cdef: - * readonly FrameType frame - */ +*/ struct __pyx_obj_6hunter_6_event_Event { PyObject_HEAD struct __pyx_vtabstruct_6hunter_6_event_Event *__pyx_vtab; - PyFrameObject *frame; + FrameType frame; PyObject *kind; PyObject *arg; int depth; int calls; int threading_support; int detached; + PyObject *builtin; PyObject *_code; PyObject *_filename; PyObject *_fullsource; @@ -887,16 +1672,38 @@ struct __pyx_obj_6hunter_6_event_Event { PyObject *_thread; PyObject *_threadidn; PyObject *_threadname; + PyObject *_instruction; }; -/* "hunter/_predicates.pxd":8 +/* "_tracer.pxd":25 * - * @cython.final - * cdef class Query: # <<<<<<<<<<<<<< + * + * @cython.final # <<<<<<<<<<<<<< + * cdef class Tracer: * cdef: - * readonly tuple query_contains - */ +*/ +struct __pyx_obj_6hunter_7_tracer_Tracer { + PyObject_HEAD + PyObject *handler; + PyObject *previous; + PyObject *threading_support; + int profiling_mode; + int depth; + int calls; + PyObject *__weakref__; + PyObject *_threading_previous; + Py_tracefunc _previousfunc; +}; + + +/* "hunter/_predicates.pxd":7 + * + * + * @cython.final # <<<<<<<<<<<<<< + * cdef class Query: + * cdef: +*/ struct __pyx_obj_6hunter_11_predicates_Query { PyObject_HEAD PyObject *query_contains; @@ -914,50 +1721,50 @@ struct __pyx_obj_6hunter_11_predicates_Query { /* "hunter/_predicates.pxd":22 * - * @cython.final - * cdef class And: # <<<<<<<<<<<<<< + * + * @cython.final # <<<<<<<<<<<<<< + * cdef class And: * cdef: - * readonly tuple predicates - */ +*/ struct __pyx_obj_6hunter_11_predicates_And { PyObject_HEAD PyObject *predicates; }; -/* "hunter/_predicates.pxd":27 +/* "hunter/_predicates.pxd":28 * - * @cython.final - * cdef class Or: # <<<<<<<<<<<<<< + * + * @cython.final # <<<<<<<<<<<<<< + * cdef class Or: * cdef: - * readonly tuple predicates - */ +*/ struct __pyx_obj_6hunter_11_predicates_Or { PyObject_HEAD PyObject *predicates; }; -/* "hunter/_predicates.pxd":32 +/* "hunter/_predicates.pxd":34 * - * @cython.final - * cdef class Not: # <<<<<<<<<<<<<< + * + * @cython.final # <<<<<<<<<<<<<< + * cdef class Not: * cdef: - * readonly object predicate - */ +*/ struct __pyx_obj_6hunter_11_predicates_Not { PyObject_HEAD PyObject *predicate; }; -/* "hunter/_predicates.pxd":37 +/* "hunter/_predicates.pxd":40 * - * @cython.final - * cdef class When: # <<<<<<<<<<<<<< + * + * @cython.final # <<<<<<<<<<<<<< + * cdef class When: * cdef: - * readonly object condition - */ +*/ struct __pyx_obj_6hunter_11_predicates_When { PyObject_HEAD PyObject *condition; @@ -965,13 +1772,13 @@ struct __pyx_obj_6hunter_11_predicates_When { }; -/* "hunter/_predicates.pxd":43 +/* "hunter/_predicates.pxd":47 * - * @cython.final - * cdef class From: # <<<<<<<<<<<<<< + * + * @cython.final # <<<<<<<<<<<<<< + * cdef class From: * cdef: - * readonly object condition - */ +*/ struct __pyx_obj_6hunter_11_predicates_From { PyObject_HEAD PyObject *condition; @@ -982,206 +1789,168 @@ struct __pyx_obj_6hunter_11_predicates_From { }; -/* "hunter/_predicates.pyx":137 +/* "hunter/_predicates.pxd":57 + * + * + * @cython.final # <<<<<<<<<<<<<< + * cdef class Backlog: + * cdef: +*/ +struct __pyx_obj_6hunter_11_predicates_Backlog { + PyObject_HEAD + PyObject *condition; + int size; + int stack; + int vars; + int strip; + PyObject *action; + PyObject *_try_repr; + PyObject *_filter; + PyObject *queue; +}; + + +/* "hunter/_predicates.pyx":77 + * + * + * @cython.final # <<<<<<<<<<<<<< + * cdef class QueryEntry: + * cdef Event_getter_typedef getter +*/ +struct __pyx_obj_6hunter_11_predicates_QueryEntry { + PyObject_HEAD + __pyx_t_6hunter_11_predicates_Event_getter_typedef getter; + int getter_index; + PyObject *value; +}; + + +/* "hunter/_predicates.pyx":199 * self.query_gte = tuple(sorted(query_gte.items())) * * def __str__(self): # <<<<<<<<<<<<<< * return 'Query(%s)' % ( - * ', '.join( - */ + * ', '.join([ +*/ struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__ { PyObject_HEAD - struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self; + PyObject *__pyx_8genexpr1__pyx_v_kind; }; -/* "hunter/_predicates.pyx":140 +/* "hunter/_predicates.pyx":202 * return 'Query(%s)' % ( - * ', '.join( - * ', '.join('%s%s=%r' % (key, kind, value) for key, value in mapping) # <<<<<<<<<<<<<< + * ', '.join([ + * ', '.join(f'{key}{kind}={value!r}' for key, value in mapping) # <<<<<<<<<<<<<< * for kind, mapping in [ * ('', self.query_eq), - */ +*/ struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr { PyObject_HEAD struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__ *__pyx_outer_scope; - PyObject *__pyx_v_genexpr; - PyObject *__pyx_v_kind; - PyObject *__pyx_v_mapping; - PyObject *__pyx_t_0; - Py_ssize_t __pyx_t_1; -}; - -struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr { - PyObject_HEAD - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr *__pyx_outer_scope; + PyObject *__pyx_genexpr_arg_0; PyObject *__pyx_v_key; PyObject *__pyx_v_value; - PyObject *__pyx_t_0; - Py_ssize_t __pyx_t_1; - PyObject *(*__pyx_t_2)(PyObject *); -}; - - -/* "hunter/_predicates.pyx":156 - * ) - * - * def __repr__(self): # <<<<<<<<<<<<<< - * return '' % ' '.join( - * fmt % (mapping,) for fmt, mapping in [ - */ -struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3___repr__ { - PyObject_HEAD - struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self; -}; - - -/* "hunter/_predicates.pyx":158 - * def __repr__(self): - * return '' % ' '.join( - * fmt % (mapping,) for fmt, mapping in [ # <<<<<<<<<<<<<< - * ('query_eq=%r', self.query_eq), - * ('query_in=%r', self.query_in), - */ -struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr { - PyObject_HEAD - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3___repr__ *__pyx_outer_scope; - PyObject *__pyx_v_fmt; - PyObject *__pyx_v_mapping; - PyObject *__pyx_t_0; - Py_ssize_t __pyx_t_1; -}; - - -/* "hunter/_predicates.pyx":268 - * """ - * - * def __init__(self, condition, *actions): # <<<<<<<<<<<<<< - * if not actions: - * raise TypeError('Must give at least one action.') - */ -struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5___init__ { - PyObject_HEAD - PyObject *__pyx_v_actions; }; -/* "hunter/_predicates.pyx":273 +/* "hunter/_predicates.pyx":322 * self.condition = condition * self.actions = tuple( - * action() if inspect.isclass(action) and issubclass(action, Action) else action # <<<<<<<<<<<<<< + * action() if isclass(action) and issubclass(action, Action) else action # <<<<<<<<<<<<<< * for action in actions) * - */ -struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_6_genexpr { +*/ +struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr { PyObject_HEAD - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5___init__ *__pyx_outer_scope; + PyObject *__pyx_genexpr_arg_0; PyObject *__pyx_v_action; PyObject *__pyx_t_0; Py_ssize_t __pyx_t_1; }; -/* "hunter/_predicates.pyx":276 - * for action in actions) - * - * def __str__(self): # <<<<<<<<<<<<<< - * return 'When(%s, %s)' % ( - * self.condition, - */ -struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_7___str__ { - PyObject_HEAD - struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self; -}; - - -/* "hunter/_predicates.pyx":279 +/* "hunter/_predicates.pyx":328 * return 'When(%s, %s)' % ( * self.condition, * ', '.join(repr(p) for p in self.actions) # <<<<<<<<<<<<<< * ) * - */ -struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_8_genexpr { +*/ +struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3_genexpr { PyObject_HEAD - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_7___str__ *__pyx_outer_scope; + PyObject *__pyx_genexpr_arg_0; PyObject *__pyx_v_p; - PyObject *__pyx_t_0; - Py_ssize_t __pyx_t_1; }; -/* "hunter/_predicates.pyx":401 - * self.predicates = predicates +/* "hunter/_predicates.pyx":446 * - * def __str__(self): # <<<<<<<<<<<<<< - * return 'And(%s)' % ', '.join(str(p) for p in self.predicates) + * def __str__(self): + * return 'And(%s)' % ', '.join(str(p) for p in self.predicates) # <<<<<<<<<<<<<< * - */ -struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_9___str__ { + * def __repr__(self): +*/ +struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr { PyObject_HEAD - struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self; + PyObject *__pyx_genexpr_arg_0; + PyObject *__pyx_v_p; }; -/* "hunter/_predicates.pyx":402 +/* "hunter/_predicates.pyx":496 * * def __str__(self): - * return 'And(%s)' % ', '.join(str(p) for p in self.predicates) # <<<<<<<<<<<<<< + * return 'Or(%s)' % ', '.join(str(p) for p in self.predicates) # <<<<<<<<<<<<<< * * def __repr__(self): - */ -struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_10_genexpr { +*/ +struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5_genexpr { PyObject_HEAD - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_9___str__ *__pyx_outer_scope; + PyObject *__pyx_genexpr_arg_0; PyObject *__pyx_v_p; - PyObject *__pyx_t_0; - Py_ssize_t __pyx_t_1; }; -/* "hunter/_predicates.pyx":454 - * self.predicates = predicates +/* "cfunc.to_py":65 * - * def __str__(self): # <<<<<<<<<<<<<< - * return 'Or(%s)' % ', '.join(str(p) for p in self.predicates) - * - */ -struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_11___str__ { - PyObject_HEAD - struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self; -}; - - -/* "hunter/_predicates.pyx":455 - * - * def __str__(self): - * return 'Or(%s)' % ', '.join(str(p) for p in self.predicates) # <<<<<<<<<<<<<< * - * def __repr__(self): - */ -struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_12_genexpr { + * @cname("__Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event") # <<<<<<<<<<<<<< + * cdef object __Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event(object (*f)(Event) ): + * def wrap(Event event): +*/ +struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event { PyObject_HEAD - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_11___str__ *__pyx_outer_scope; - PyObject *__pyx_v_p; - PyObject *__pyx_t_0; - Py_ssize_t __pyx_t_1; + PyObject *(*__pyx_v_f)(struct __pyx_obj_6hunter_6_event_Event *); }; -/* "_event.pxd":11 +/* "_event.pxd":39 * - * @cython.final - * cdef class Event: # <<<<<<<<<<<<<< + * + * @cython.final # <<<<<<<<<<<<<< + * cdef class Event: * cdef: - * readonly FrameType frame - */ +*/ struct __pyx_vtabstruct_6hunter_6_event_Event { - struct __pyx_obj_6hunter_6_event_Event *(*clone)(struct __pyx_obj_6hunter_6_event_Event *); + PyCodeObject *(*code_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*filename_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*fullsource_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*function_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*globals_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*lineno_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*locals_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*module_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*source_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*stdlib_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*threadid_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*threadname_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*instruction_getter)(struct __pyx_obj_6hunter_6_event_Event *); }; static struct __pyx_vtabstruct_6hunter_6_event_Event *__pyx_vtabptr_6hunter_6_event_Event; +/* #### Code section: utility_code_proto ### */ /* --- Runtime support code (head) --- */ /* Refnanny.proto */ @@ -1190,42 +1959,48 @@ static struct __pyx_vtabstruct_6hunter_6_event_Event *__pyx_vtabptr_6hunter_6_ev #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 (*INCREF)(void*, PyObject*, Py_ssize_t); + void (*DECREF)(void*, PyObject*, Py_ssize_t); + void (*GOTREF)(void*, PyObject*, Py_ssize_t); + void (*GIVEREF)(void*, PyObject*, Py_ssize_t); + void* (*SetupContext)(const char*, Py_ssize_t, 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__);\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ + } + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ + } + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ } -#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) + #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); else {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContextNogil() #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) @@ -1236,6 +2011,10 @@ static struct __pyx_vtabstruct_6hunter_6_event_Event *__pyx_vtabptr_6hunter_6_ev #define __Pyx_XGOTREF(r) #define __Pyx_XGIVEREF(r) #endif +#define __Pyx_Py_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; Py_XDECREF(tmp);\ + } while (0) #define __Pyx_XDECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_XDECREF(tmp);\ @@ -1247,32 +2026,30 @@ static struct __pyx_vtabstruct_6hunter_6_event_Event *__pyx_vtabptr_6hunter_6_ev #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); +/* PyErrExceptionMatches.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); #else -#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) #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); - -/* KeywordStringCheck.proto */ -static int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed); - /* 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 +#if PY_VERSION_HEX >= 0x030C00A6 +#define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL) +#else +#define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type) +#endif #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign -#define __Pyx_PyErr_Occurred() PyErr_Occurred() +#define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) +#define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() #endif /* PyErrFetchRestore.proto */ @@ -1284,7 +2061,7 @@ static int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name #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 +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6 #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) #else #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) @@ -1300,34 +2077,382 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif -/* Profile.proto */ -#ifndef CYTHON_PROFILE -#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_PYSTON - #define CYTHON_PROFILE 0 +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); #else - #define CYTHON_PROFILE 1 +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* PyObjectGetAttrStrNoError.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* TupleAndListFromArray.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); #endif +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); #endif -#ifndef CYTHON_TRACE_NOGIL - #define CYTHON_TRACE_NOGIL 0 + +/* IncludeStringH.proto */ +#include + +/* BytesEquals.proto */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); + +/* UnicodeEquals.proto */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); + +/* fastcall.proto */ +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_PySequence_ITEM(args, i) +#elif CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_NewRef(__Pyx_PyTuple_GET_ITEM(args, i)) #else - #if CYTHON_TRACE_NOGIL && !defined(CYTHON_TRACE) - #define CYTHON_TRACE 1 + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_XNewRef(PyTuple_GetItem(args, i)) +#endif +#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) +#define __Pyx_KwValues_VARARGS(args, nargs) NULL +#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) +#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) +#if CYTHON_METH_FASTCALL + #define __Pyx_ArgRef_FASTCALL(args, i) __Pyx_NewRef(args[i]) + #define __Pyx_NumKwargs_FASTCALL(kwds) __Pyx_PyTuple_GET_SIZE(kwds) + #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) + static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API + CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); + #else + #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) #endif +#else + #define __Pyx_ArgRef_FASTCALL __Pyx_ArgRef_VARARGS + #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS + #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS + #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS + #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS +#endif +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) +#if CYTHON_METH_FASTCALL || (CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(args + start, stop - start) +#else +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) #endif -#ifndef CYTHON_TRACE - #define CYTHON_TRACE 0 + +/* RaiseDoubleKeywords.proto */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +/* ParseKeywords.proto */ +static CYTHON_INLINE int __Pyx_ParseKeywords( + PyObject *kwds, PyObject *const *kwvalues, PyObject ** const argnames[], + PyObject *kwds2, PyObject *values[], + Py_ssize_t num_pos_args, Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs +); + +/* CallCFunction.proto */ +#define __Pyx_CallCFunction(cfunc, self, args)\ + ((PyCFunction)(void(*)(void))(cfunc)->func)(self, args) +#define __Pyx_CallCFunctionWithKeywords(cfunc, self, args, kwargs)\ + ((PyCFunctionWithKeywords)(void(*)(void))(cfunc)->func)(self, args, kwargs) +#define __Pyx_CallCFunctionFast(cfunc, self, args, nargs)\ + ((__Pyx_PyCFunctionFast)(void(*)(void))(PyCFunction)(cfunc)->func)(self, args, nargs) +#define __Pyx_CallCFunctionFastWithKeywords(cfunc, self, args, nargs, kwnames)\ + ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))(PyCFunction)(cfunc)->func)(self, args, nargs, kwnames) + +/* PyFunctionFastCall.proto */ +#if CYTHON_FAST_PYCALL +#if !CYTHON_VECTORCALL +#define __Pyx_PyFunction_FastCall(func, args, nargs)\ + __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject *const *args, Py_ssize_t nargs, PyObject *kwargs); +#endif +#define __Pyx_BUILD_ASSERT_EXPR(cond)\ + (sizeof(char [1 - 2*!(cond)]) - 1) +#ifndef Py_MEMBER_SIZE +#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) +#endif +#if !CYTHON_VECTORCALL +#if PY_VERSION_HEX >= 0x03080000 + #include "frameobject.h" + #define __Pxy_PyFrame_Initialize_Offsets() + #define __Pyx_PyFrame_GetLocalsplus(frame) ((frame)->f_localsplus) +#else + static size_t __pyx_pyframe_localsplus_offset = 0; + #include "frameobject.h" + #define __Pxy_PyFrame_Initialize_Offsets()\ + ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ + (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) + #define __Pyx_PyFrame_GetLocalsplus(frame)\ + (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) +#endif +#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 + +/* PyObjectFastCall.proto */ +#define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject * const*args, size_t nargs, PyObject *kwargs); + +/* UnpackUnboundCMethod.proto */ +typedef struct { + PyObject *type; + PyObject **method_name; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && CYTHON_ATOMICS + __pyx_atomic_int_type initialized; +#endif + PyCFunction func; + PyObject *method; + int flag; +} __Pyx_CachedCFunction; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +static CYTHON_INLINE int __Pyx_CachedCFunction_GetAndSetInitializing(__Pyx_CachedCFunction *cfunc) { +#if !CYTHON_ATOMICS + return 1; +#else + __pyx_nonatomic_int_type expected = 0; + if (__pyx_atomic_int_cmp_exchange(&cfunc->initialized, &expected, 1)) { + return 0; + } + return expected; +#endif +} +static CYTHON_INLINE void __Pyx_CachedCFunction_SetFinishedInitializing(__Pyx_CachedCFunction *cfunc) { +#if CYTHON_ATOMICS + __pyx_atomic_store(&cfunc->initialized, 2); +#endif +} +#else +#define __Pyx_CachedCFunction_GetAndSetInitializing(cfunc) 2 +#define __Pyx_CachedCFunction_SetFinishedInitializing(cfunc) +#endif + +/* CallUnboundCMethod2.proto */ +CYTHON_UNUSED +static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2); +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2); +#else +#define __Pyx_CallUnboundCMethod2(cfunc, self, arg1, arg2) __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2) #endif + +/* 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); + +/* ArgTypeTest.proto */ +#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ + ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\ + __Pyx__ArgTypeTest(obj, type, name, exact)) +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); + +/* Profile.proto */ #if CYTHON_TRACE #undef CYTHON_PROFILE_REUSE_FRAME #endif +#if CYTHON_USE_MODULE_STATE + #undef CYTHON_PROFILE_REUSE_CODEOBJ + #define CYTHON_PROFILE_REUSE_CODEOBJ 0 + #undef CYTHON_PROFILE_REUSE_FRAME +#endif +#ifndef CYTHON_PROFILE_REUSE_CODEOBJ + #define CYTHON_PROFILE_REUSE_CODEOBJ 1 +#endif #ifndef CYTHON_PROFILE_REUSE_FRAME #define CYTHON_PROFILE_REUSE_FRAME 0 #endif +#if CYTHON_USE_SYS_MONITORING && (CYTHON_PROFILE || CYTHON_TRACE) + #define __PYX_MONITORING_ABI_SUFFIX "_mon" +#else + #define __PYX_MONITORING_ABI_SUFFIX +#endif #if CYTHON_PROFILE || CYTHON_TRACE +#if CYTHON_USE_SYS_MONITORING + typedef uint64_t __pyx_monitoring_version_type; + #define __Pyx_TraceDeclarationsFunc\ + PyObject *__pyx_frame_code = NULL;\ + PyMonitoringState __pyx_pymonitoring_state[__Pyx_MonitoringEventTypes_CyFunc_count];\ + int __pyx_exception_already_reported = 0;\ + const int __pyx_sys_monitoring_disabled_in_parallel = 0; CYTHON_UNUSED_VAR(__pyx_sys_monitoring_disabled_in_parallel); + #define __Pyx_TraceDeclarationsGen\ + PyObject *__pyx_frame_code = Py_NewRef(__pyx_generator->gi_code);\ + PyMonitoringState* __pyx_pymonitoring_state = __pyx_generator->__pyx_pymonitoring_state;\ + __pyx_monitoring_version_type __pyx_pymonitoring_version = __pyx_generator->__pyx_pymonitoring_version;\ + int __pyx_exception_already_reported = 0;\ + const int __pyx_sys_monitoring_disabled_in_parallel = 0; CYTHON_UNUSED_VAR(__pyx_sys_monitoring_disabled_in_parallel); + #define __Pyx_IsTracing(event_id) ((!__pyx_sys_monitoring_disabled_in_parallel) && (__pyx_pymonitoring_state[event_id]).active) + #define __Pyx_TraceFrameInit(codeobj)\ + if (codeobj) __pyx_frame_code = codeobj; + #define __Pyx_TurnOffSysMonitoringInParallel\ + const int __pyx_sys_monitoring_disabled_in_parallel = 1;\ + CYTHON_UNUSED_VAR(__pyx_sys_monitoring_disabled_in_parallel); + CYTHON_UNUSED static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno); + CYTHON_UNUSED static int __Pyx__TraceStartFunc(PyMonitoringState *state_array, PyObject *code_obj, int offset, int skip_event); + CYTHON_UNUSED static int __Pyx__TraceStartGen(PyMonitoringState *state_array, __pyx_monitoring_version_type *version, PyObject *code_obj, int offset); + CYTHON_UNUSED static int __Pyx__TraceResumeGen(PyMonitoringState *state_array, __pyx_monitoring_version_type *version, PyObject *code_obj, int offset); + CYTHON_UNUSED static void __Pyx__TraceException(PyMonitoringState *monitoring_state, PyObject *code_obj, int offset, int reraised); + #define __Pyx_PyMonitoring_ExitScope(nogil)\ + if (nogil) {\ + (void) __pyx_exception_already_reported;\ + if (CYTHON_TRACE_NOGIL) {\ + PyGILState_STATE state = PyGILState_Ensure();\ + PyMonitoring_ExitScope();\ + Py_XDECREF(__pyx_frame_code);\ + PyGILState_Release(state);\ + }\ + } else {\ + PyMonitoring_ExitScope();\ + Py_XDECREF(__pyx_frame_code);\ + } + #define __Pyx_TraceStartFunc(funcname, srcfile, firstlineno, offset, nogil, skip_event, goto_error)\ + if ((0) ); else {\ + int ret = 0;\ + memset(__pyx_pymonitoring_state, 0, sizeof(__pyx_pymonitoring_state));\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + PyGILState_STATE state = PyGILState_Ensure();\ + if (!__Pyx_PyThreadState_Current->tracing) {\ + if (likely(__pyx_frame_code)) Py_INCREF(__pyx_frame_code);\ + else __pyx_frame_code = (PyObject*) __Pyx_createFrameCodeObject(funcname, srcfile, firstlineno);\ + if (unlikely(!__pyx_frame_code)) goto_error;\ + ret = __Pyx__TraceStartFunc(__pyx_pymonitoring_state, __pyx_frame_code, offset, skip_event);\ + }\ + PyGILState_Release(state);\ + }\ + } else {\ + if (!__Pyx_PyThreadState_Current->tracing) {\ + if (likely(__pyx_frame_code)) Py_INCREF(__pyx_frame_code);\ + else __pyx_frame_code = (PyObject*) __Pyx_createFrameCodeObject(funcname, srcfile, firstlineno);\ + if (unlikely(!__pyx_frame_code)) goto_error;\ + ret = __Pyx__TraceStartFunc(__pyx_pymonitoring_state, __pyx_frame_code, offset, skip_event);\ + }\ + }\ + if (unlikely(ret == -1)) goto_error;\ + } + #define __Pyx_TraceStartGen(funcname, srcfile, firstlineno, offset, nogil, skip_event, goto_error)\ + if ((0) ); else {\ + int ret = __Pyx__TraceStartGen(__pyx_pymonitoring_state, &__pyx_pymonitoring_version, __pyx_frame_code, offset);\ + if (unlikely(ret == -1)) goto_error;\ + } + #define __Pyx_TraceResumeGen(funcname, srcfile, firstlineno, offset, goto_error)\ + if ((0) ); else {\ + int ret = __Pyx__TraceResumeGen(__pyx_pymonitoring_state, &__pyx_pymonitoring_version, __pyx_frame_code, offset);\ + if (unlikely(ret == -1)) goto_error;\ + } + #define __Pyx_TraceYield(result, offset, goto_error)\ + if (!__Pyx_IsTracing(__Pyx_Monitoring_PY_YIELD)); else {\ + int ret = PyMonitoring_FirePyYieldEvent(&__pyx_pymonitoring_state[__Pyx_Monitoring_PY_RETURN], __pyx_frame_code, offset, result);\ + PyMonitoring_ExitScope();\ + if (unlikely(ret == -1)) goto_error;\ + } + #define __Pyx_TraceException(offset, reraised, fresh)\ + if (!__Pyx_IsTracing((reraised) ? __Pyx_Monitoring_RERAISE : __Pyx_Monitoring_RAISE)); else {\ + if (fresh || reraised || !__pyx_exception_already_reported) {\ + __Pyx__TraceException(&__pyx_pymonitoring_state[(reraised) ? __Pyx_Monitoring_RERAISE : __Pyx_Monitoring_RAISE], __pyx_frame_code, offset, reraised);\ + }\ + __pyx_exception_already_reported = 1;\ + } + #define __Pyx_TraceExceptionDone() __pyx_exception_already_reported = 0 + #define __Pyx_TraceExceptionHandled(offset)\ + if (!__Pyx_IsTracing(__Pyx_Monitoring_EXCEPTION_HANDLED)); else {\ + (void) PyMonitoring_FireExceptionHandledEvent(&__pyx_pymonitoring_state[__Pyx_Monitoring_EXCEPTION_HANDLED], __pyx_frame_code, offset);\ + __pyx_exception_already_reported = 0;\ + } + #define __Pyx_TraceReturnValue(result, offset, nogil, goto_error)\ + if (!__Pyx_IsTracing(__Pyx_Monitoring_PY_RETURN)); else {\ + int ret = 0;\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + PyGILState_STATE state = PyGILState_Ensure();\ + ret = PyMonitoring_FirePyReturnEvent(&__pyx_pymonitoring_state[__Pyx_Monitoring_PY_RETURN], __pyx_frame_code, offset, result);\ + PyGILState_Release(state);\ + }\ + } else {\ + ret = PyMonitoring_FirePyReturnEvent(&__pyx_pymonitoring_state[__Pyx_Monitoring_PY_RETURN], __pyx_frame_code, offset, result);\ + }\ + if (unlikely(ret == -1)) goto_error;\ + } + #define __Pyx_TraceReturnCValue(cresult, convert_function, offset, nogil, goto_error)\ + if (!__Pyx_IsTracing(__Pyx_Monitoring_PY_RETURN)); else {\ + int ret = 0;\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + PyGILState_STATE state = PyGILState_Ensure();\ + PyObject *pyvalue = convert_function(cresult);\ + if (unlikely(!pyvalue)) {\ + PyErr_Clear();\ + pyvalue = Py_None; Py_INCREF(Py_None);\ + }\ + ret = PyMonitoring_FirePyReturnEvent(&__pyx_pymonitoring_state[__Pyx_Monitoring_PY_RETURN], __pyx_frame_code, offset, pyvalue);\ + Py_DECREF(pyvalue);\ + PyGILState_Release(state);\ + }\ + } else {\ + PyObject *pyvalue = convert_function(cresult);\ + if (unlikely(!pyvalue)) {\ + PyErr_Clear();\ + pyvalue = Py_None; Py_INCREF(Py_None);\ + }\ + ret = PyMonitoring_FirePyReturnEvent(&__pyx_pymonitoring_state[__Pyx_Monitoring_PY_RETURN], __pyx_frame_code, offset, pyvalue);\ + Py_DECREF(pyvalue);\ + }\ + if (unlikely(ret == -1)) goto_error;\ + } + #define __Pyx_TraceExceptionUnwind(offset, nogil)\ + if (!__Pyx_IsTracing(__Pyx_Monitoring_PY_UNWIND)); else {\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + PyGILState_STATE state = PyGILState_Ensure();\ + (void) PyMonitoring_FirePyUnwindEvent(&__pyx_pymonitoring_state[__Pyx_Monitoring_PY_UNWIND], __pyx_frame_code, offset);\ + PyGILState_Release(state);\ + }\ + } else {\ + (void) PyMonitoring_FirePyUnwindEvent(&__pyx_pymonitoring_state[__Pyx_Monitoring_PY_UNWIND], __pyx_frame_code, offset);\ + }\ + } + #if CYTHON_TRACE + CYTHON_UNUSED static int __Pyx__TraceLine(PyMonitoringState *monitoring_state, PyObject *code_obj, int line, int offset); + #define __Pyx_TraceLine(line, offset, nogil, goto_error)\ + if (!__Pyx_IsTracing(__Pyx_Monitoring_LINE)); else {\ + int ret = 0;\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + PyGILState_STATE state = PyGILState_Ensure();\ + ret = __Pyx__TraceLine(&__pyx_pymonitoring_state[__Pyx_Monitoring_LINE], __pyx_frame_code, line, offset);\ + PyGILState_Release(state);\ + }\ + } else {\ + ret = __Pyx__TraceLine(&__pyx_pymonitoring_state[__Pyx_Monitoring_LINE], __pyx_frame_code, line, offset);\ + }\ + if (unlikely(ret == -1)) goto_error;\ + } + #endif +#else #include "compile.h" #include "frameobject.h" #include "traceback.h" +#if PY_VERSION_HEX >= 0x030b00a6 && !defined(PYPY_VERSION) + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif #if CYTHON_PROFILE_REUSE_FRAME #define CYTHON_FRAME_MODIFIER static #define CYTHON_FRAME_DEL(frame) @@ -1335,224 +2460,385 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #define CYTHON_FRAME_MODIFIER #define CYTHON_FRAME_DEL(frame) Py_CLEAR(frame) #endif - #define __Pyx_TraceDeclarations\ - static PyCodeObject *__pyx_frame_code = NULL;\ - CYTHON_FRAME_MODIFIER PyFrameObject *__pyx_frame = NULL;\ - int __Pyx_use_tracing = 0; + #if CYTHON_PROFILE_REUSE_CODEOBJ + #define CYTHON_CODEOBJ_MODIFIER static + #else + #define CYTHON_CODEOBJ_MODIFIER + #endif + #define __Pyx_TraceDeclarationsFunc\ + CYTHON_CODEOBJ_MODIFIER PyCodeObject *__pyx_frame_code = NULL;\ + CYTHON_FRAME_MODIFIER PyFrameObject *__pyx_frame = NULL;\ + int __Pyx_use_tracing = 0; + #define __Pyx_TraceDeclarationsGen\ + PyObject *__pyx_frame_code = __pyx_generator->gi_code;\ + CYTHON_FRAME_MODIFIER PyFrameObject *__pyx_frame = NULL;\ + int __Pyx_use_tracing = 0; #define __Pyx_TraceFrameInit(codeobj)\ - if (codeobj) __pyx_frame_code = (PyCodeObject*) codeobj; - #ifdef WITH_THREAD - #define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error)\ + if (codeobj) __pyx_frame_code = (PyCodeObject*) codeobj; + #define __Pyx_PyMonitoring_ExitScope(nogil) {} + #define __Pyx_TraceException(offset, reraised, fresh) {} + #define __Pyx_TraceExceptionHandled(offset) {} + #define __Pyx_TraceExceptionDone() {} + #define __Pyx_TurnOffSysMonitoringInParallel {} // Only needed for freethreading +#if PY_VERSION_HEX >= 0x030b00a2 + #if PY_VERSION_HEX >= 0x030C00b1 + #define __Pyx_IsTracing(tstate, check_tracing, check_funcs)\ + ((!(check_tracing) || !(tstate)->tracing) &&\ + (!(check_funcs) || (tstate)->c_profilefunc || (CYTHON_TRACE && (tstate)->c_tracefunc))) + #else + #define __Pyx_IsTracing(tstate, check_tracing, check_funcs)\ + (unlikely((tstate)->cframe->use_tracing) &&\ + (!(check_tracing) || !(tstate)->tracing) &&\ + (!(check_funcs) || (tstate)->c_profilefunc || (CYTHON_TRACE && (tstate)->c_tracefunc))) + #endif + #define __Pyx_EnterTracing(tstate) PyThreadState_EnterTracing(tstate) + #define __Pyx_LeaveTracing(tstate) PyThreadState_LeaveTracing(tstate) +#elif PY_VERSION_HEX >= 0x030a00b1 + #define __Pyx_IsTracing(tstate, check_tracing, check_funcs)\ + (unlikely((tstate)->cframe->use_tracing) &&\ + (!(check_tracing) || !(tstate)->tracing) &&\ + (!(check_funcs) || (tstate)->c_profilefunc || (CYTHON_TRACE && (tstate)->c_tracefunc))) + #define __Pyx_EnterTracing(tstate)\ + do { tstate->tracing++; tstate->cframe->use_tracing = 0; } while (0) + #define __Pyx_LeaveTracing(tstate)\ + do {\ + tstate->tracing--;\ + tstate->cframe->use_tracing = ((CYTHON_TRACE && tstate->c_tracefunc != NULL)\ + || tstate->c_profilefunc != NULL);\ + } while (0) +#else + #define __Pyx_IsTracing(tstate, check_tracing, check_funcs)\ + (unlikely((tstate)->use_tracing) &&\ + (!(check_tracing) || !(tstate)->tracing) &&\ + (!(check_funcs) || (tstate)->c_profilefunc || (CYTHON_TRACE && (tstate)->c_tracefunc))) + #define __Pyx_EnterTracing(tstate)\ + do { tstate->tracing++; tstate->use_tracing = 0; } while (0) + #define __Pyx_LeaveTracing(tstate)\ + do {\ + tstate->tracing--;\ + tstate->use_tracing = ((CYTHON_TRACE && tstate->c_tracefunc != NULL)\ + || tstate->c_profilefunc != NULL);\ + } while (0) +#endif + #define __Pyx_TraceStartFunc(funcname, srcfile, firstlineno, offset, nogil, skip_event, goto_error)\ if (nogil) {\ if (CYTHON_TRACE_NOGIL) {\ PyThreadState *tstate;\ PyGILState_STATE state = PyGILState_Ensure();\ tstate = __Pyx_PyThreadState_Current;\ - if (unlikely(tstate->use_tracing) && !tstate->tracing &&\ - (tstate->c_profilefunc || (CYTHON_TRACE && tstate->c_tracefunc))) {\ - __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ + if (__Pyx_IsTracing(tstate, 1, 1)) {\ + __Pyx_use_tracing = __Pyx_TraceSetupAndCall((PyCodeObject**)&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno, skip_event);\ }\ PyGILState_Release(state);\ if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ }\ } else {\ PyThreadState* tstate = PyThreadState_GET();\ - if (unlikely(tstate->use_tracing) && !tstate->tracing &&\ - (tstate->c_profilefunc || (CYTHON_TRACE && tstate->c_tracefunc))) {\ - __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ - if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ - }\ - } - #else - #define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error)\ - { PyThreadState* tstate = PyThreadState_GET();\ - if (unlikely(tstate->use_tracing) && !tstate->tracing &&\ - (tstate->c_profilefunc || (CYTHON_TRACE && tstate->c_tracefunc))) {\ - __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ + if (__Pyx_IsTracing(tstate, 1, 1)) {\ + __Pyx_use_tracing = __Pyx_TraceSetupAndCall((PyCodeObject**)&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno, skip_event);\ if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ }\ } - #endif - #define __Pyx_TraceException()\ + #define __Pyx_TraceStartGen __Pyx_TraceStartFunc + #define __Pyx_TraceYield(result, offset, goto_error)\ if (likely(!__Pyx_use_tracing)); else {\ PyThreadState* tstate = __Pyx_PyThreadState_Current;\ - if (tstate->use_tracing &&\ - (tstate->c_profilefunc || (CYTHON_TRACE && tstate->c_tracefunc))) {\ - tstate->tracing++;\ - tstate->use_tracing = 0;\ - PyObject *exc_info = __Pyx_GetExceptionTuple(tstate);\ - if (exc_info) {\ - if (CYTHON_TRACE && tstate->c_tracefunc)\ - tstate->c_tracefunc(\ - tstate->c_traceobj, __pyx_frame, PyTrace_EXCEPTION, exc_info);\ - tstate->c_profilefunc(\ - tstate->c_profileobj, __pyx_frame, PyTrace_EXCEPTION, exc_info);\ - Py_DECREF(exc_info);\ - }\ - tstate->use_tracing = 1;\ - tstate->tracing--;\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result, 0);\ }\ + if ((1)); else goto_error;\ } - static void __Pyx_call_return_trace_func(PyThreadState *tstate, PyFrameObject *frame, PyObject *result) { + #define __Pyx_TraceResumeGen(funcname, srcfile, firstlineno, offset, goto_error)\ + __Pyx_TraceStartFunc(funcname, srcfile, firstlineno, offset, 0, 0, goto_error) + CYTHON_UNUSED static void __Pyx_call_return_trace_func(PyThreadState *tstate, PyFrameObject *frame, PyObject *result, int delete_frame) { PyObject *type, *value, *traceback; __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); - tstate->tracing++; - tstate->use_tracing = 0; + __Pyx_EnterTracing(tstate); if (CYTHON_TRACE && tstate->c_tracefunc) tstate->c_tracefunc(tstate->c_traceobj, frame, PyTrace_RETURN, result); if (tstate->c_profilefunc) tstate->c_profilefunc(tstate->c_profileobj, frame, PyTrace_RETURN, result); - CYTHON_FRAME_DEL(frame); - tstate->use_tracing = 1; - tstate->tracing--; + if (delete_frame) { + CYTHON_FRAME_DEL(frame); + } + __Pyx_LeaveTracing(tstate); __Pyx_ErrRestoreInState(tstate, type, value, traceback); } - #ifdef WITH_THREAD - #define __Pyx_TraceReturn(result, nogil)\ + #define __Pyx_TraceReturnValue(result, offset, nogil, goto_error)\ if (likely(!__Pyx_use_tracing)); else {\ if (nogil) {\ if (CYTHON_TRACE_NOGIL) {\ PyThreadState *tstate;\ PyGILState_STATE state = PyGILState_Ensure();\ tstate = __Pyx_PyThreadState_Current;\ - if (tstate->use_tracing) {\ - __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result, 1);\ }\ PyGILState_Release(state);\ }\ } else {\ PyThreadState* tstate = __Pyx_PyThreadState_Current;\ - if (tstate->use_tracing) {\ - __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result, 1);\ }\ }\ + if ((1)); else goto_error;\ } - #else - #define __Pyx_TraceReturn(result, nogil)\ + #define __Pyx_TraceReturnCValue(cresult, convert_function, offset, nogil, goto_error)\ if (likely(!__Pyx_use_tracing)); else {\ - PyThreadState* tstate = __Pyx_PyThreadState_Current;\ - if (tstate->use_tracing) {\ - __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + PyThreadState *tstate;\ + PyGILState_STATE state = PyGILState_Ensure();\ + tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ + PyObject *pyvalue = convert_function(cresult);\ + if (unlikely(!pyvalue)) goto_error;\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, pyvalue, 1);\ + Py_DECREF(pyvalue);\ + }\ + PyGILState_Release(state);\ + }\ + } else {\ + PyThreadState* tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ + PyObject *pyvalue = convert_function(cresult);\ + if (unlikely(!pyvalue)) goto_error;\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, pyvalue, 1);\ + Py_DECREF(pyvalue);\ + }\ }\ } - #endif - static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno); - static int __Pyx_TraceSetupAndCall(PyCodeObject** code, PyFrameObject** frame, PyThreadState* tstate, const char *funcname, const char *srcfile, int firstlineno); -#else - #define __Pyx_TraceDeclarations - #define __Pyx_TraceFrameInit(codeobj) - #define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error) if ((1)); else goto_error; - #define __Pyx_TraceException() - #define __Pyx_TraceReturn(result, nogil) -#endif -#if CYTHON_TRACE - static int __Pyx_call_line_trace_func(PyThreadState *tstate, PyFrameObject *frame, int lineno) { - int ret; - PyObject *type, *value, *traceback; - __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); - __Pyx_PyFrame_SetLineNumber(frame, lineno); - tstate->tracing++; - tstate->use_tracing = 0; - ret = tstate->c_tracefunc(tstate->c_traceobj, frame, PyTrace_LINE, NULL); - tstate->use_tracing = 1; - tstate->tracing--; - if (likely(!ret)) { - __Pyx_ErrRestoreInState(tstate, type, value, traceback); - } else { - Py_XDECREF(type); - Py_XDECREF(value); - Py_XDECREF(traceback); - } - return ret; - } - #ifdef WITH_THREAD - #define __Pyx_TraceLine(lineno, nogil, goto_error)\ + #define __Pyx_TraceExceptionUnwind(offset, nogil)\ if (likely(!__Pyx_use_tracing)); else {\ if (nogil) {\ if (CYTHON_TRACE_NOGIL) {\ - int ret = 0;\ PyThreadState *tstate;\ PyGILState_STATE state = PyGILState_Ensure();\ tstate = __Pyx_PyThreadState_Current;\ - if (unlikely(tstate->use_tracing && tstate->c_tracefunc && __pyx_frame->f_trace)) {\ - ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, Py_None, 1);\ }\ PyGILState_Release(state);\ - if (unlikely(ret)) goto_error;\ }\ } else {\ PyThreadState* tstate = __Pyx_PyThreadState_Current;\ - if (unlikely(tstate->use_tracing && tstate->c_tracefunc && __pyx_frame->f_trace)) {\ - int ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ - if (unlikely(ret)) goto_error;\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, Py_None, 1);\ }\ }\ } - #else - #define __Pyx_TraceLine(lineno, nogil, goto_error)\ + static int __Pyx_TraceSetupAndCall(PyCodeObject** code, PyFrameObject** frame, PyThreadState* tstate, const char *funcname, const char *srcfile, int firstlineno, int skip_event); +#if CYTHON_TRACE + CYTHON_UNUSED static int __Pyx_call_line_trace_func(PyThreadState *tstate, PyFrameObject *frame, int line); + #define __Pyx_TraceLine(line, offset, nogil, goto_error)\ if (likely(!__Pyx_use_tracing)); else {\ - PyThreadState* tstate = __Pyx_PyThreadState_Current;\ - if (unlikely(tstate->use_tracing && tstate->c_tracefunc && __pyx_frame->f_trace)) {\ - int ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ - if (unlikely(ret)) goto_error;\ + int ret = 0;\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + PyThreadState *tstate;\ + PyGILState_STATE state = __Pyx_PyGILState_Ensure();\ + tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && __pyx_frame->f_trace) {\ + ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, line);\ + }\ + __Pyx_PyGILState_Release(state);\ + }\ + } else {\ + PyThreadState* tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && __pyx_frame->f_trace) {\ + ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, line);\ + }\ }\ + if (unlikely(ret)) goto_error;\ } - #endif -#else - #define __Pyx_TraceLine(lineno, nogil, goto_error) if ((1)); else goto_error; #endif +#endif +#else + #define __Pyx_TraceDeclarationsFunc + #define __Pyx_TraceDeclarationsGen + #define __Pyx_TraceExceptionDone() {} + #define __Pyx_TraceFrameInit(codeobj) {} + #define __Pyx_TurnOffSysMonitoringInParallel {} + #define __Pyx_PyMonitoring_ExitScope(nogil) {} + #define __Pyx_TraceException(offset, reraised, fresh) {} + #define __Pyx_TraceExceptionUnwind(offset, nogil) {} + #define __Pyx_TraceExceptionHandled(offset) {} + #define __Pyx_TraceStartFunc(funcname, srcfile, firstlineno, offset, nogil, skip_event, goto_error) if ((1)); else goto_error; + #define __Pyx_TraceStartGen __Pyx_TraceStartFunc + #define __Pyx_TraceResumeGen(funcname, srcfile, firstlineno, offset, goto_error) if ((1)); else goto_error; + #define __Pyx_TraceYield(result, offset, goto_error) if ((1)); else goto_error; + #define __Pyx_TraceReturnValue(result, offset, nogil, goto_error)\ + if ((1)); else goto_error; + #define __Pyx_TraceReturnCValue(cresult, convert_function, offset, nogil, goto_error)\ + if ((1)); else { (void) convert_function; goto_error } +#endif +#if !CYTHON_TRACE + #define __Pyx_TraceLine(line, offset, nogil, goto_error) if ((1)); else goto_error; +#endif + +/* LimitedApiGetTypeDict.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_GetTypeDict(PyTypeObject *tp); +#endif + +/* SetItemOnTypeDict.proto */ +static int __Pyx__SetItemOnTypeDict(PyTypeObject *tp, PyObject *k, PyObject *v); +#define __Pyx_SetItemOnTypeDict(tp, k, v) __Pyx__SetItemOnTypeDict((PyTypeObject*)tp, k, v) + +/* FixUpExtensionType.proto */ +static CYTHON_INLINE int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); + +/* FetchSharedCythonModule.proto */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void); + +/* dict_setdefault.proto */ +static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value, int is_safe_type); -/* IterFinish.proto */ -static CYTHON_INLINE int __Pyx_IterFinish(void); +/* FetchCommonType.proto */ +static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases); -/* 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, Py_ssize_t nargs, PyObject *kwargs); +/* CommonTypesMetaclass.proto */ +static int __pyx_CommonTypesMetaclass_init(PyObject *module); +#define __Pyx_CommonTypesMetaclass_USED + +/* CallTypeTraverse.proto */ +#if !CYTHON_USE_TYPE_SPECS || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x03090000) +#define __Pyx_call_type_traverse(o, always_call, visit, arg) 0 #else -#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) +static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg); #endif -#define __Pyx_BUILD_ASSERT_EXPR(cond)\ - (sizeof(char [1 - 2*!(cond)]) - 1) -#ifndef Py_MEMBER_SIZE -#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) -#endif - static size_t __pyx_pyframe_localsplus_offset = 0; - #include "frameobject.h" - #define __Pxy_PyFrame_Initialize_Offsets()\ - ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ - (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) - #define __Pyx_PyFrame_GetLocalsplus(frame)\ - (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) + +/* PyMethodNew.proto */ +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ); + +/* PyVectorcallFastCallDict.proto */ +#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL) +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw); #endif -/* PyObjectCall.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +/* CythonFunctionShared.proto */ +#define __Pyx_CyFunction_USED +#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 +#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 +#define __Pyx_CYFUNCTION_CCLASS 0x04 +#define __Pyx_CYFUNCTION_COROUTINE 0x08 +#define __Pyx_CyFunction_GetClosure(f)\ + (((__pyx_CyFunctionObject *) (f))->func_closure) +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_CyFunction_GetClassObj(f)\ + (((__pyx_CyFunctionObject *) (f))->func_classobj) #else -#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) + #define __Pyx_CyFunction_GetClassObj(f)\ + ((PyObject*) ((PyCMethodObject *) (f))->mm_class) +#endif +#define __Pyx_CyFunction_SetClassObj(f, classobj)\ + __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (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 { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject_HEAD + PyObject *func; +#elif PY_VERSION_HEX < 0x030900B1 + PyCFunctionObject func; +#else + PyCMethodObject func; +#endif +#if CYTHON_BACKPORT_VECTORCALL ||\ + (CYTHON_COMPILING_IN_LIMITED_API && CYTHON_METH_FASTCALL) + __pyx_vectorcallfunc func_vectorcall; +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + 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; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_classobj; +#endif + PyObject *defaults; + int flags; + PyObject *defaults_tuple; + PyObject *defaults_kwdict; + PyObject *(*defaults_getter)(PyObject *); + PyObject *func_annotations; + PyObject *func_is_coroutine; +} __pyx_CyFunctionObject; +#undef __Pyx_CyOrPyCFunction_Check +#define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_mstate_global->__pyx_CyFunctionType) +#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_mstate_global->__pyx_CyFunctionType, &PyCFunction_Type) +#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_mstate_global->__pyx_CyFunctionType) +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)); +#undef __Pyx_IsSameCFunction +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCyOrCFunction(func, cfunc) +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); +static CYTHON_INLINE PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func, + PyTypeObject *defaults_type); +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(PyObject *module); +#if CYTHON_METH_FASTCALL +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +#if CYTHON_BACKPORT_VECTORCALL || CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall) +#else +#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall) #endif - -/* PyObjectCallMethO.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif -/* PyObjectCallNoArg.proto */ +/* CythonFunction.proto */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); + +/* PyObjectCall2Args.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); + +/* CallUnboundCMethod1.proto */ +CYTHON_UNUSED +static PyObject* __Pyx__CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg); #if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); +static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg); #else -#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) +#define __Pyx_CallUnboundCMethod1(cfunc, self, arg) __Pyx__CallUnboundCMethod1(cfunc, self, arg) #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 +/* RejectKeywords.proto */ +static void __Pyx_RejectKeywords(const char* function_name, PyObject *kwds); + +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* KeywordStringCheck.proto */ +static CYTHON_INLINE int __Pyx_CheckKeywordStrings(const char* function_name, PyObject *kw); + +/* IterFinish.proto */ +static CYTHON_INLINE int __Pyx_IterFinish(void); + +/* PyObjectCallNoArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); /* PyObjectCallOneArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); @@ -1579,12 +2865,8 @@ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); 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( + PyObject* tuple, PyObject** value1, PyObject** value2, int is_tuple, int has_known_size, int 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( @@ -1596,8 +2878,12 @@ static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int 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); -/* PyObjectCall2Args.proto */ -static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); +/* PyObjectFastCallMethod.proto */ +#if CYTHON_VECTORCALL && PY_VERSION_HEX >= 0x03090000 +#define __Pyx_PyObject_FastCallMethod(name, args, nargsf) PyObject_VectorcallMethod(name, args, nargsf, NULL) +#else +static PyObject *__Pyx_PyObject_FastCallMethod(PyObject *name, PyObject *const *args, size_t nargsf); +#endif /* ListCompAppend.proto */ #if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS @@ -1606,8 +2892,12 @@ static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { Py_ssize_t len = Py_SIZE(list); if (likely(L->allocated > len)) { Py_INCREF(x); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 + L->ob_item[len] = x; + #else PyList_SET_ITEM(list, len, x); - Py_SIZE(list) = len+1; + #endif + __Pyx_SET_SIZE(list, len + 1); return 0; } return PyList_Append(list, x); @@ -1616,25 +2906,31 @@ static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { #define __Pyx_ListComp_Append(L,x) PyList_Append(L,x) #endif -/* RaiseException.proto */ -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); - -/* IncludeStringH.proto */ -#include - -/* BytesEquals.proto */ -static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); - -/* UnicodeEquals.proto */ -static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); +/* PyObjectFormatAndDecref.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f); +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f); -/* StrEquals.proto */ -#if PY_MAJOR_VERSION >= 3 -#define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals +/* PyObjectFormatSimple.proto */ +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + PyObject_Format(s, f)) +#elif CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + likely(PyLong_CheckExact(s)) ? PyLong_Type.tp_repr(s) :\ + likely(PyFloat_CheckExact(s)) ? PyFloat_Type.tp_repr(s) :\ + PyObject_Format(s, f)) #else -#define __Pyx_PyString_Equals __Pyx_PyBytes_Equals + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + PyObject_Format(s, f)) #endif +/* JoinPyUnicode.proto */ +static PyObject* __Pyx_PyUnicode_Join(PyObject** values, Py_ssize_t value_count, Py_ssize_t result_ulength, + Py_UCS4 max_char); + /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS #define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) @@ -1663,18 +2959,18 @@ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UIN /* GetModuleGlobalName.proto */ #if CYTHON_USE_DICT_VERSIONS -#define __Pyx_GetModuleGlobalName(var, name) {\ +#define __Pyx_GetModuleGlobalName(var, name) do {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ - (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ + (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_mstate_global->__pyx_d))) ?\ (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ -} -#define __Pyx_GetModuleGlobalNameUncached(var, name) {\ +} while(0) +#define __Pyx_GetModuleGlobalNameUncached(var, name) do {\ PY_UINT64_T __pyx_dict_version;\ PyObject *__pyx_dict_cached_value;\ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ -} +} while(0) static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); #else #define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) @@ -1691,116 +2987,76 @@ static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* s /* py_dict_items.proto */ static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d); -/* UnpackUnboundCMethod.proto */ -typedef struct { - PyObject *type; - PyObject **method_name; - PyCFunction func; - PyObject *method; - int flag; -} __Pyx_CachedCFunction; - /* CallUnboundCMethod0.proto */ +CYTHON_UNUSED static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self); #if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_CallUnboundCMethod0(cfunc, self)\ - (likely((cfunc)->func) ?\ - (likely((cfunc)->flag == METH_NOARGS) ? (*((cfunc)->func))(self, NULL) :\ - (PY_VERSION_HEX >= 0x030600B1 && likely((cfunc)->flag == METH_FASTCALL) ?\ - (PY_VERSION_HEX >= 0x030700A0 ?\ - (*(__Pyx_PyCFunctionFast)(void*)(PyCFunction)(cfunc)->func)(self, &__pyx_empty_tuple, 0) :\ - (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)(cfunc)->func)(self, &__pyx_empty_tuple, 0, NULL)) :\ - (PY_VERSION_HEX >= 0x030700A0 && (cfunc)->flag == (METH_FASTCALL | METH_KEYWORDS) ?\ - (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)(cfunc)->func)(self, &__pyx_empty_tuple, 0, NULL) :\ - (likely((cfunc)->flag == (METH_VARARGS | METH_KEYWORDS)) ? ((*(PyCFunctionWithKeywords)(void*)(PyCFunction)(cfunc)->func)(self, __pyx_empty_tuple, NULL)) :\ - ((cfunc)->flag == METH_VARARGS ? (*((cfunc)->func))(self, __pyx_empty_tuple) :\ - __Pyx__CallUnboundCMethod0(cfunc, self)))))) :\ - __Pyx__CallUnboundCMethod0(cfunc, self)) +static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self); #else #define __Pyx_CallUnboundCMethod0(cfunc, self) __Pyx__CallUnboundCMethod0(cfunc, self) #endif -/* None.proto */ -static CYTHON_INLINE void __Pyx_RaiseClosureNameError(const char *varname); - -/* StringJoin.proto */ -#if PY_MAJOR_VERSION < 3 -#define __Pyx_PyString_Join __Pyx_PyBytes_Join -#define __Pyx_PyBaseString_Join(s, v) (PyUnicode_CheckExact(s) ? PyUnicode_Join(s, v) : __Pyx_PyBytes_Join(s, v)) -#else -#define __Pyx_PyString_Join PyUnicode_Join -#define __Pyx_PyBaseString_Join PyUnicode_Join -#endif -#if CYTHON_COMPILING_IN_CPYTHON - #if PY_MAJOR_VERSION < 3 - #define __Pyx_PyBytes_Join _PyString_Join - #else - #define __Pyx_PyBytes_Join _PyBytes_Join - #endif -#else -static CYTHON_INLINE PyObject* __Pyx_PyBytes_Join(PyObject* sep, PyObject* values); -#endif - -/* 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); +/* RaiseUnboundLocalError.proto */ +static void __Pyx_RaiseUnboundLocalError(const char *varname); -/* ArgTypeTest.proto */ -#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ - ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ - __Pyx__ArgTypeTest(obj, type, name, exact)) -static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); +/* RaiseClosureNameError.proto */ +static void __Pyx_RaiseClosureNameError(const char *varname); -/* PyErrExceptionMatches.proto */ +/* GetException.proto */ #if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) -static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); +#define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #else -#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); #endif -/* GetAttr.proto */ -static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); +/* pep479.proto */ +static void __Pyx_Generator_Replace_StopIteration(int in_async_gen); /* GetAttr3.proto */ static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); -/* 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); +/* RaiseUnexpectedTypeError.proto */ +static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj); -/* ObjectGetItem.proto */ -#if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key); -#else -#define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key) +/* PyUnicodeContains.proto */ +static CYTHON_INLINE int __Pyx_PyUnicode_ContainsTF(PyObject* substring, PyObject* text, int eq) { + int result = PyUnicode_Contains(text, substring); + return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); +} + +/* unicode_tailmatch.proto */ +static int __Pyx_PyUnicode_Tailmatch( + PyObject* s, PyObject* substr, Py_ssize_t start, Py_ssize_t end, int direction); + +/* BuildPyUnicode.proto */ +static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, const char* chars, int clength, + int prepend_sign, char padding_char); + +/* COrdinalToPyUnicode.proto */ +static CYTHON_INLINE int __Pyx_CheckUnicodeValue(int value); +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromOrdinal_Padded(int value, Py_ssize_t width, char padding_char); + +/* GCCDiagnostics.proto */ +#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#define __Pyx_HAS_GCC_DIAGNOSTIC #endif +/* IncludeStdlibH.proto */ +#include + +/* CIntToPyUnicode.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char, char format_char); + +/* PyObject_Unicode.proto */ +#define __Pyx_PyObject_Unicode(obj)\ + (likely(PyUnicode_CheckExact(obj)) ? __Pyx_NewRef(obj) : PyObject_Str(obj)) + /* ListExtend.proto */ static CYTHON_INLINE int __Pyx_PyList_Extend(PyObject* L, PyObject* v) { -#if CYTHON_COMPILING_IN_CPYTHON +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00a2 + return PyList_Extend(L, v); +#elif CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 PyObject* none = _PyList_Extend((PyListObject*)L, v); if (unlikely(!none)) return -1; @@ -1818,8 +3074,12 @@ static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { Py_ssize_t len = Py_SIZE(list); if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { Py_INCREF(x); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 + L->ob_item[len] = x; + #else PyList_SET_ITEM(list, len, x); - Py_SIZE(list) = len+1; + #endif + __Pyx_SET_SIZE(list, len + 1); return 0; } return PyList_Append(list, x); @@ -1828,101 +3088,200 @@ static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { #define __Pyx_PyList_Append(L,x) PyList_Append(L,x) #endif +/* PyObjectVectorCallKwBuilder.proto */ +CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n); +#if CYTHON_VECTORCALL +#if PY_VERSION_HEX >= 0x03090000 +#define __Pyx_Object_Vectorcall_CallFromBuilder PyObject_Vectorcall +#else +#define __Pyx_Object_Vectorcall_CallFromBuilder _PyObject_Vectorcall +#endif +#define __Pyx_MakeVectorcallBuilderKwds(n) PyTuple_New(n) +static int __Pyx_VectorcallBuilder_AddArg(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n); +static int __Pyx_VectorcallBuilder_AddArgStr(const char *key, PyObject *value, PyObject *builder, PyObject **args, int n); +#else +#define __Pyx_Object_Vectorcall_CallFromBuilder __Pyx_PyObject_FastCallDict +#define __Pyx_MakeVectorcallBuilderKwds(n) __Pyx_PyDict_NewPresized(n) +#define __Pyx_VectorcallBuilder_AddArg(key, value, builder, args, n) PyDict_SetItem(builder, key, value) +#define __Pyx_VectorcallBuilder_AddArgStr(key, value, builder, args, n) PyDict_SetItemString(builder, key, value) +#endif + +/* ExtTypeTest.proto */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + +/* CBIntToPyUnicode.proto */ +#define __Pyx_PyUnicode_FromBInt_bint(value)\ + ((value) ? __Pyx_NewRef(__pyx_mstate_global->__pyx_n_u_True) : __Pyx_NewRef(__pyx_mstate_global->__pyx_n_u_False)) + /* Import.proto */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); /* ImportFrom.proto */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); +/* GetItemInt.proto */ +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil)\ + (__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, has_gil)\ + (__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, has_gil)\ + (__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); + +/* PyObjectCallMethod1.proto */ +static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg); + +/* append.proto */ +static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x); + /* HasAttr.proto */ +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 +#define __Pyx_HasAttr(o, n) PyObject_HasAttrWithError(o, n) +#else static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); +#endif -/* PyObject_GenericGetAttrNoDict.proto */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name); -#else -#define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr +/* ValidateBasesTuple.proto */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases); #endif +/* PyType_Ready.proto */ +CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t); + +/* DelItemOnTypeDict.proto */ +static int __Pyx__DelItemOnTypeDict(PyTypeObject *tp, PyObject *k); +#define __Pyx_DelItemOnTypeDict(tp, k) __Pyx__DelItemOnTypeDict((PyTypeObject*)tp, k) + /* SetupReduce.proto */ static int __Pyx_setup_reduce(PyObject* type_obj); /* TypeImport.proto */ -#ifndef __PYX_HAVE_RT_ImportType_proto -#define __PYX_HAVE_RT_ImportType_proto -enum __Pyx_ImportType_CheckSize { - __Pyx_ImportType_CheckSize_Error = 0, - __Pyx_ImportType_CheckSize_Warn = 1, - __Pyx_ImportType_CheckSize_Ignore = 2 +#ifndef __PYX_HAVE_RT_ImportType_proto_3_1_3 +#define __PYX_HAVE_RT_ImportType_proto_3_1_3 +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L +#include +#endif +#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L +#define __PYX_GET_STRUCT_ALIGNMENT_3_1_3(s) alignof(s) +#else +#define __PYX_GET_STRUCT_ALIGNMENT_3_1_3(s) sizeof(void*) +#endif +enum __Pyx_ImportType_CheckSize_3_1_3 { + __Pyx_ImportType_CheckSize_Error_3_1_3 = 0, + __Pyx_ImportType_CheckSize_Warn_3_1_3 = 1, + __Pyx_ImportType_CheckSize_Ignore_3_1_3 = 2 }; -static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size); +static PyTypeObject *__Pyx_ImportType_3_1_3(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_1_3 check_size); #endif /* GetVTable.proto */ -static void* __Pyx_GetVtable(PyObject *dict); +static void* __Pyx_GetVtable(PyTypeObject *type); -/* PatchModuleWithCoroutine.proto */ -static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code); - -/* PatchInspect.proto */ -static PyObject* __Pyx_patch_inspect(PyObject* module); +/* ListPack.proto */ +static PyObject *__Pyx_PyList_Pack(Py_ssize_t n, ...); /* CLineInTraceback.proto */ -#ifdef CYTHON_CLINE_IN_TRACEBACK -#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) -#else +#if CYTHON_CLINE_IN_TRACEBACK && CYTHON_CLINE_IN_TRACEBACK_RUNTIME static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); +#else +#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) #endif /* CodeObjectCache.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject __Pyx_CachedCodeObjectType; +#else +typedef PyCodeObject __Pyx_CachedCodeObjectType; +#endif typedef struct { - PyCodeObject* code_object; + __Pyx_CachedCodeObjectType* code_object; int code_line; } __Pyx_CodeObjectCacheEntry; struct __Pyx_CodeObjectCache { int count; int max_count; __Pyx_CodeObjectCacheEntry* entries; + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_atomic_int_type accessor_count; + #endif }; -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); +static __Pyx_CachedCodeObjectType *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, __Pyx_CachedCodeObjectType* 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_int(int value); - -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_int(int value); /* CIntFromPy.proto */ -static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); +static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *); /* CIntFromPy.proto */ -static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); +static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value); + +/* FormatTypeName.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%U" +#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 +#define __Pyx_PyType_GetFullyQualifiedName PyType_GetFullyQualifiedName +#else +static __Pyx_TypeName __Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp); +#endif +#else // !LIMITED_API +typedef const char *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%.200s" +#define __Pyx_PyType_GetFullyQualifiedName(tp) ((tp)->tp_name) +#define __Pyx_DECREF_TypeName(obj) +#endif /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, 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_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) #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)) +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2) { + return PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2); +} #endif +#define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) - -/* FetchCommonType.proto */ -static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); +#ifdef PyExceptionInstance_Check + #define __Pyx_PyBaseException_Check(obj) PyExceptionInstance_Check(obj) +#else + #define __Pyx_PyBaseException_Check(obj) __Pyx_TypeCheck(obj, PyExc_BaseException) +#endif /* GetTopmostException.proto */ -#if CYTHON_USE_EXC_INFO_STACK +#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); #endif @@ -1945,11 +3304,18 @@ static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject * static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); #endif -/* PyObjectCallMethod1.proto */ -static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg); +/* IterNextPlain.proto */ +static CYTHON_INLINE PyObject *__Pyx_PyIter_Next_Plain(PyObject *iterator); +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 +static PyObject *__Pyx_GetBuiltinNext_LimitedAPI(void); +#endif + +/* ReturnWithStopIteration.proto */ +static CYTHON_INLINE void __Pyx_ReturnWithStopIteration(PyObject* value, int async, int iternext); /* CoroutineBase.proto */ -typedef PyObject *(*__pyx_coroutine_body_t)(PyObject *, PyThreadState *, PyObject *); +struct __pyx_CoroutineObject; +typedef PyObject *(*__pyx_coroutine_body_t)(struct __pyx_CoroutineObject *, PyThreadState *, PyObject *); #if CYTHON_USE_EXC_INFO_STACK #define __Pyx_ExcInfoStruct _PyErr_StackItem #else @@ -1959,7 +3325,7 @@ typedef struct { PyObject *exc_traceback; } __Pyx_ExcInfoStruct; #endif -typedef struct { +typedef struct __pyx_CoroutineObject { PyObject_HEAD __pyx_coroutine_body_t body; PyObject *closure; @@ -1967,10 +3333,16 @@ typedef struct { PyObject *gi_weakreflist; PyObject *classobj; PyObject *yieldfrom; + __Pyx_pyiter_sendfunc yieldfrom_am_send; PyObject *gi_name; PyObject *gi_qualname; PyObject *gi_modulename; PyObject *gi_code; + PyObject *gi_frame; +#if CYTHON_USE_SYS_MONITORING && (CYTHON_PROFILE || CYTHON_TRACE) + PyMonitoringState __pyx_pymonitoring_state[__Pyx_MonitoringEventTypes_CyGen_count]; + uint64_t __pyx_pymonitoring_version; +#endif int resume_label; char is_running; } __pyx_CoroutineObject; @@ -1982,8 +3354,9 @@ static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit( PyObject *name, PyObject *qualname, PyObject *module_name); static CYTHON_INLINE void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *self); static int __Pyx_Coroutine_clear(PyObject *self); +static __Pyx_PySendResult __Pyx_Coroutine_AmSend(PyObject *self, PyObject *value, PyObject **retval); static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value); -static PyObject *__Pyx_Coroutine_Close(PyObject *self); +static __Pyx_PySendResult __Pyx_Coroutine_Close(PyObject *self, PyObject **retval); static PyObject *__Pyx_Coroutine_Throw(PyObject *gen, PyObject *args); #if CYTHON_USE_EXC_INFO_STACK #define __Pyx_Coroutine_SwapException(self) @@ -2007,390 +3380,564 @@ static PyObject *__Pyx_Coroutine_Throw(PyObject *gen, PyObject *args); #endif static int __Pyx_PyGen__FetchStopIterationValue(PyThreadState *tstate, PyObject **pvalue); static CYTHON_INLINE void __Pyx_Coroutine_ResetFrameBackpointer(__Pyx_ExcInfoStruct *exc_state); - -/* PatchGeneratorABC.proto */ -static int __Pyx_patch_abc(void); +static char __Pyx_Coroutine_test_and_set_is_running(__pyx_CoroutineObject *gen); +static void __Pyx_Coroutine_unset_is_running(__pyx_CoroutineObject *gen); +static char __Pyx_Coroutine_get_is_running(__pyx_CoroutineObject *gen); +static PyObject *__Pyx_Coroutine_get_is_running_getter(PyObject *gen, void *closure); +#if __PYX_HAS_PY_AM_SEND == 2 +static void __Pyx_SetBackportTypeAmSend(PyTypeObject *type, __Pyx_PyAsyncMethodsStruct *static_amsend_methods, __Pyx_pyiter_sendfunc am_send); +#endif +static PyObject *__Pyx_Coroutine_fail_reduce_ex(PyObject *self, PyObject *arg); /* Generator.proto */ #define __Pyx_Generator_USED -static PyTypeObject *__pyx_GeneratorType = 0; -#define __Pyx_Generator_CheckExact(obj) (Py_TYPE(obj) == __pyx_GeneratorType) +#define __Pyx_Generator_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_mstate_global->__pyx_GeneratorType) #define __Pyx_Generator_New(body, code, closure, name, qualname, module_name)\ - __Pyx__Coroutine_New(__pyx_GeneratorType, body, code, closure, name, qualname, module_name) + __Pyx__Coroutine_New(__pyx_mstate_global->__pyx_GeneratorType, body, code, closure, name, qualname, module_name) static PyObject *__Pyx_Generator_Next(PyObject *self); -static int __pyx_Generator_init(void); +static int __pyx_Generator_init(PyObject *module); +static CYTHON_INLINE PyObject *__Pyx_Generator_GetInlinedResult(PyObject *self); + +/* GetRuntimeVersion.proto */ +static unsigned long __Pyx_get_runtime_version(void); /* CheckBinaryVersion.proto */ -static int __Pyx_check_binary_version(void); +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); /* FunctionExport.proto */ static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig); -/* InitStrings.proto */ -static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); +/* FunctionImport.proto */ +static int __Pyx_ImportFunction_3_1_3(PyObject *module, const char *funcname, void (**f)(void), const char *sig); + +/* MultiPhaseInitModuleState.proto */ +#if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE +static PyObject *__Pyx_State_FindModule(void*); +static int __Pyx_State_AddModule(PyObject* module, void*); +static int __Pyx_State_RemoveModule(void*); +#elif CYTHON_USE_MODULE_STATE +#define __Pyx_State_FindModule PyState_FindModule +#define __Pyx_State_AddModule PyState_AddModule +#define __Pyx_State_RemoveModule PyState_RemoveModule +#endif + +/* #### Code section: module_declarations ### */ +/* CythonABIVersion.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API + #if CYTHON_METH_FASTCALL + #define __PYX_FASTCALL_ABI_SUFFIX "_fastcall" + #else + #define __PYX_FASTCALL_ABI_SUFFIX + #endif + #define __PYX_LIMITED_ABI_SUFFIX "limited" __PYX_FASTCALL_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX +#else + #define __PYX_LIMITED_ABI_SUFFIX +#endif +#if __PYX_HAS_PY_AM_SEND == 1 + #define __PYX_AM_SEND_ABI_SUFFIX +#elif __PYX_HAS_PY_AM_SEND == 2 + #define __PYX_AM_SEND_ABI_SUFFIX "amsendbackport" +#else + #define __PYX_AM_SEND_ABI_SUFFIX "noamsend" +#endif +#ifndef __PYX_MONITORING_ABI_SUFFIX + #define __PYX_MONITORING_ABI_SUFFIX +#endif +#if CYTHON_USE_TP_FINALIZE + #define __PYX_TP_FINALIZE_ABI_SUFFIX +#else + #define __PYX_TP_FINALIZE_ABI_SUFFIX "nofinalize" +#endif +#if CYTHON_USE_FREELISTS || !defined(__Pyx_AsyncGen_USED) + #define __PYX_FREELISTS_ABI_SUFFIX +#else + #define __PYX_FREELISTS_ABI_SUFFIX "nofreelists" +#endif +#define CYTHON_ABI __PYX_ABI_VERSION __PYX_LIMITED_ABI_SUFFIX __PYX_MONITORING_ABI_SUFFIX __PYX_TP_FINALIZE_ABI_SUFFIX __PYX_FREELISTS_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX +#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI +#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." + +/* Module declarations from "cython" */ -/* Module declarations from 'cython' */ +/* Module declarations from "types" */ -/* Module declarations from 'libc.string' */ +/* Module declarations from "hunter._event" */ +static struct __pyx_obj_6hunter_6_event_Event *(*__pyx_f_6hunter_6_event_fast_clone)(struct __pyx_obj_6hunter_6_event_Event *); /*proto*/ +static struct __pyx_obj_6hunter_6_event_Event *(*__pyx_f_6hunter_6_event_fast_detach)(struct __pyx_obj_6hunter_6_event_Event *, PyObject *); /*proto*/ -/* Module declarations from 'libc.stdio' */ +/* Module declarations from "libc.string" */ -/* Module declarations from '__builtin__' */ +/* Module declarations from "libc.stdio" */ -/* Module declarations from 'cpython.type' */ -static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; +/* Module declarations from "__builtin__" */ -/* Module declarations from 'cpython' */ +/* Module declarations from "cpython.type" */ -/* Module declarations from 'cpython.object' */ +/* Module declarations from "cpython" */ -/* Module declarations from 'cpython.pystate' */ +/* Module declarations from "cpython.object" */ -/* Module declarations from 'types' */ +/* Module declarations from "cpython.pystate" */ -/* Module declarations from 'hunter._tracer' */ -static PyTypeObject *__pyx_ptype_6hunter_7_tracer_CodeType = 0; -static PyTypeObject *__pyx_ptype_6hunter_7_tracer_FrameType = 0; -static PyTypeObject *__pyx_ptype_6hunter_7_tracer_Tracer = 0; +/* Module declarations from "cpython.ref" */ -/* Module declarations from 'hunter._event' */ -static PyTypeObject *__pyx_ptype_6hunter_6_event_Event = 0; +/* Module declarations from "types" */ -/* Module declarations from 'hunter._predicates' */ -static PyTypeObject *__pyx_ptype_6hunter_11_predicates_Query = 0; -static PyTypeObject *__pyx_ptype_6hunter_11_predicates_And = 0; -static PyTypeObject *__pyx_ptype_6hunter_11_predicates_Or = 0; -static PyTypeObject *__pyx_ptype_6hunter_11_predicates_Not = 0; -static PyTypeObject *__pyx_ptype_6hunter_11_predicates_When = 0; -static PyTypeObject *__pyx_ptype_6hunter_11_predicates_From = 0; -static PyTypeObject *__pyx_ptype_6hunter_11_predicates___pyx_scope_struct____str__ = 0; -static PyTypeObject *__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_1_genexpr = 0; -static PyTypeObject *__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_2_genexpr = 0; -static PyTypeObject *__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_3___repr__ = 0; -static PyTypeObject *__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_4_genexpr = 0; -static PyTypeObject *__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_5___init__ = 0; -static PyTypeObject *__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_6_genexpr = 0; -static PyTypeObject *__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_7___str__ = 0; -static PyTypeObject *__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_8_genexpr = 0; -static PyTypeObject *__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_9___str__ = 0; -static PyTypeObject *__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_10_genexpr = 0; -static PyTypeObject *__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_11___str__ = 0; -static PyTypeObject *__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_12_genexpr = 0; +/* Module declarations from "hunter._tracer" */ + +/* Module declarations from "hunter._predicates" */ static PyObject *__pyx_v_6hunter_11_predicates_ALLOWED_KEYS = 0; static PyObject *__pyx_v_6hunter_11_predicates_ALLOWED_OPERATORS = 0; +static __pyx_t_6hunter_11_predicates_Event_getter_typedef __pyx_v_6hunter_11_predicates_Event_getters[17]; static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_fast_And_call(struct __pyx_obj_6hunter_11_predicates_And *, struct __pyx_obj_6hunter_6_event_Event *); /*proto*/ static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_fast_From_call(struct __pyx_obj_6hunter_11_predicates_From *, struct __pyx_obj_6hunter_6_event_Event *); /*proto*/ static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_fast_Not_call(struct __pyx_obj_6hunter_11_predicates_Not *, struct __pyx_obj_6hunter_6_event_Event *); /*proto*/ static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_fast_Or_call(struct __pyx_obj_6hunter_11_predicates_Or *, struct __pyx_obj_6hunter_6_event_Event *); /*proto*/ -static PyObject *__pyx_f_6hunter_11_predicates_fast_Query_call(struct __pyx_obj_6hunter_11_predicates_Query *, struct __pyx_obj_6hunter_6_event_Event *); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_fast_Query_call(struct __pyx_obj_6hunter_11_predicates_Query *, struct __pyx_obj_6hunter_6_event_Event *); /*proto*/ static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_fast_When_call(struct __pyx_obj_6hunter_11_predicates_When *, struct __pyx_obj_6hunter_6_event_Event *); /*proto*/ static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_fast_call(PyObject *, struct __pyx_obj_6hunter_6_event_Event *); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_function(struct __pyx_obj_6hunter_6_event_Event *); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_module(struct __pyx_obj_6hunter_6_event_Event *); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_lineno(struct __pyx_obj_6hunter_6_event_Event *); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_globals(struct __pyx_obj_6hunter_6_event_Event *); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_stdlib(struct __pyx_obj_6hunter_6_event_Event *); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_arg(struct __pyx_obj_6hunter_6_event_Event *); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_locals(struct __pyx_obj_6hunter_6_event_Event *); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_kind(struct __pyx_obj_6hunter_6_event_Event *); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_filename(struct __pyx_obj_6hunter_6_event_Event *); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_source(struct __pyx_obj_6hunter_6_event_Event *); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_fullsource(struct __pyx_obj_6hunter_6_event_Event *); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_threadname(struct __pyx_obj_6hunter_6_event_Event *); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_threadid(struct __pyx_obj_6hunter_6_event_Event *); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_instruction(struct __pyx_obj_6hunter_6_event_Event *); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_depth(struct __pyx_obj_6hunter_6_event_Event *); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_calls(struct __pyx_obj_6hunter_6_event_Event *); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_builtin(struct __pyx_obj_6hunter_6_event_Event *); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_fast_Backlog_call(struct __pyx_obj_6hunter_11_predicates_Backlog *, struct __pyx_obj_6hunter_6_event_Event *); /*proto*/ static PyObject *__pyx_f_6hunter_11_predicates___pyx_unpickle_Query__set_state(struct __pyx_obj_6hunter_11_predicates_Query *, PyObject *); /*proto*/ static PyObject *__pyx_f_6hunter_11_predicates___pyx_unpickle_When__set_state(struct __pyx_obj_6hunter_11_predicates_When *, PyObject *); /*proto*/ static PyObject *__pyx_f_6hunter_11_predicates___pyx_unpickle_From__set_state(struct __pyx_obj_6hunter_11_predicates_From *, PyObject *); /*proto*/ static PyObject *__pyx_f_6hunter_11_predicates___pyx_unpickle_And__set_state(struct __pyx_obj_6hunter_11_predicates_And *, PyObject *); /*proto*/ static PyObject *__pyx_f_6hunter_11_predicates___pyx_unpickle_Or__set_state(struct __pyx_obj_6hunter_11_predicates_Or *, PyObject *); /*proto*/ static PyObject *__pyx_f_6hunter_11_predicates___pyx_unpickle_Not__set_state(struct __pyx_obj_6hunter_11_predicates_Not *, PyObject *); /*proto*/ +static PyObject *__pyx_f_6hunter_11_predicates___pyx_unpickle_Backlog__set_state(struct __pyx_obj_6hunter_11_predicates_Backlog *, PyObject *); /*proto*/ +static PyObject *__Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event(PyObject *(*)(struct __pyx_obj_6hunter_6_event_Event *)); /*proto*/ +/* #### Code section: typeinfo ### */ +/* #### Code section: before_global_var ### */ #define __Pyx_MODULE_NAME "hunter._predicates" extern int __pyx_module_is_main_hunter___predicates; int __pyx_module_is_main_hunter___predicates = 0; -/* Implementation of 'hunter._predicates' */ +/* Implementation of "hunter._predicates" */ +/* #### Code section: global_var ### */ static PyObject *__pyx_builtin_TypeError; static PyObject *__pyx_builtin_ValueError; +/* #### Code section: string_decls ### */ static const char __pyx_k_[] = "_"; +static const char __pyx_k_1[] = "\200\001\340\004\005\360\006\000\005\014\2101"; +static const char __pyx_k_6[] = "\200\001\330\004\"\240!\2406\250\021"; +static const char __pyx_k_A[] = "\210A"; +static const char __pyx_k_Q[] = "\320\000)\250\027\260\005\260Q"; +static const char __pyx_k_a[] = "\320\000*\250'\260\025\260a"; +static const char __pyx_k_f[] = "f"; +static const char __pyx_k_p[] = "p"; +static const char __pyx_k_q[] = "\220q"; +static const char __pyx_k_1F[] = "\200\001\330\004#\2401\240F\250!"; +static const char __pyx_k_4y[] = "\200\001\330\004\013\2104\210y\230\001\230\024\230\\\250\021"; +static const char __pyx_k_G5[] = "\320\000,\250G\2605\270\001"; static const char __pyx_k_Or[] = "Or"; -static const char __pyx_k__2[] = ""; -static const char __pyx_k__3[] = ", "; -static const char __pyx_k__4[] = " "; +static const char __pyx_k__2[] = "."; +static const char __pyx_k__3[] = "="; +static const char __pyx_k__4[] = ", "; +static const char __pyx_k__5[] = ""; +static const char __pyx_k__6[] = " "; +static const char __pyx_k__7[] = ")"; +static const char __pyx_k__8[] = ">"; +static const char __pyx_k__9[] = "?"; +static const char __pyx_k_eq[] = "__eq__"; static const char __pyx_k_ew[] = "ew"; +static const char __pyx_k_gc[] = "gc"; static const char __pyx_k_gt[] = "gt"; static const char __pyx_k_in[] = "in"; static const char __pyx_k_lt[] = "lt"; +static const char __pyx_k_or[] = "__or__"; static const char __pyx_k_re[] = "re"; static const char __pyx_k_rx[] = "rx"; static const char __pyx_k_sw[] = "sw"; +static const char __pyx_k_uA[] = "\320\000(\250\007\250u\260A"; +static const char __pyx_k_7_Q[] = "\320\000+\2507\260%\260~\300Q"; +static const char __pyx_k_A_D[] = "\200A\330\010\017\320\017<\270D\300\001"; +static const char __pyx_k_A_M[] = "\200A\330\010\014\210M\230\021"; +static const char __pyx_k_A_N[] = "\200A\330\010\014\210N\230!"; +static const char __pyx_k_A_q[] = "\200A\340\010\017\210q\220\001\220\021"; +static const char __pyx_k_A_r[] = "\200A\330\010\017\210r\220\021\220&\230\001"; static const char __pyx_k_And[] = "And"; static const char __pyx_k_Not[] = "Not"; +static const char __pyx_k_Q_2[] = "\200\001\330\004\n\210+\220Q"; +static const char __pyx_k_Q_3[] = "\220Q"; +static const char __pyx_k_QfA[] = "\200\001\330\004%\240Q\240f\250A"; +static const char __pyx_k__10[] = "\230!"; +static const char __pyx_k__11[] = "\230\001"; +static const char __pyx_k__12[] = "\250\001"; +static const char __pyx_k__13[] = "\200\001\330\004!\240\021\240&\250\001"; +static const char __pyx_k_a_2[] = "\220a"; static const char __pyx_k_all[] = "__all__"; +static const char __pyx_k_and[] = "__and__"; static const char __pyx_k_arg[] = "arg"; +static const char __pyx_k_fmt[] = "fmt"; +static const char __pyx_k_for[] = " for "; +static const char __pyx_k_get[] = "__get__"; static const char __pyx_k_gte[] = "gte"; static const char __pyx_k_has[] = "has"; +static const char __pyx_k_key[] = "key"; static const char __pyx_k_lte[] = "lte"; static const char __pyx_k_new[] = "__new__"; -static const char __pyx_k_From[] = "From"; +static const char __pyx_k_pop[] = "pop"; +static const char __pyx_k_q_2[] = "\240q"; +static const char __pyx_k_q_3[] = "\200\001\330\004 \240\001\240\026\240q"; +static const char __pyx_k_str[] = "__str__"; +static const char __pyx_k_A_1F[] = "\200A\330\010\017\210|\2301\230F\240!"; +static const char __pyx_k_A_4q[] = "\200A\330\010\017\320\017;\2704\270q"; +static const char __pyx_k_A_t1[] = "\200A\330\010\017\210t\2201"; +static const char __pyx_k_From[] = "From("; +static const char __pyx_k_G5_q[] = "\320\000,\250G\2605\270\017\300q"; static const char __pyx_k_Or_s[] = "Or(%s)"; -static const char __pyx_k_When[] = "When"; -static const char __pyx_k_args[] = "args"; -static const char __pyx_k_code[] = "code"; +static const char __pyx_k_True[] = "True"; +static const char __pyx_k_WE9I[] = "\320\000-\250W\260E\3209I\310\021"; +static const char __pyx_k_When[] = "When("; +static const char __pyx_k_call[] = "call"; static const char __pyx_k_dict[] = "__dict__"; +static const char __pyx_k_func[] = "__func__"; static const char __pyx_k_gt_2[] = "_gt"; static const char __pyx_k_in_2[] = "_in"; -static const char __pyx_k_join[] = "join"; +static const char __pyx_k_init[] = "__init__"; static const char __pyx_k_kind[] = "kind"; static const char __pyx_k_lt_2[] = "_lt"; static const char __pyx_k_main[] = "__main__"; -static const char __pyx_k_name[] = "__name__"; +static const char __pyx_k_name[] = "name"; +static const char __pyx_k_next[] = "next"; +static const char __pyx_k_repr[] = "__repr__"; +static const char __pyx_k_self[] = "self"; static const char __pyx_k_send[] = "send"; +static const char __pyx_k_size[] = "size"; static const char __pyx_k_test[] = "__test__"; +static const char __pyx_k_vars[] = "vars"; +static const char __pyx_k_wrap[] = "wrap"; +static const char __pyx_k_A_8_a[] = "\200A\330\010\017\320\0178\270\002\270$\270a"; +static const char __pyx_k_A_AV1[] = "\200A\330\010\017\210}\230A\230V\2401"; +static const char __pyx_k_A_QfA[] = "\200A\330\010\017\210~\230Q\230f\240A"; +static const char __pyx_k_A_avQ[] = "\200A\330\010\017\210\177\230a\230v\240Q"; +static const char __pyx_k_A_q_2[] = "\200A\330\010\017\320\017 \240\001\240\026\240q"; +static const char __pyx_k_A_q_U[] = "\200A\330\010\017\210q\330\014\020\220\001\330\014\020\220\005\220U\230!"; +static const char __pyx_k_A_s_1[] = "\200A\330\010\017\210s\220!\2201"; +static const char __pyx_k_A_s_6[] = "\200A\330\010\017\210s\220!\2206\230\021"; +static const char __pyx_k_A_t1D[] = "\200A\330\010\017\210t\2201\220D\230\001"; static const char __pyx_k_And_s[] = "And(%s)"; +static const char __pyx_k_False[] = "False"; static const char __pyx_k_Not_s[] = "Not(%s)"; static const char __pyx_k_Query[] = "Query"; +static const char __pyx_k_Value[] = "Value "; static const char __pyx_k_calls[] = "calls"; -static const char __pyx_k_chain[] = "chain"; +static const char __pyx_k_clear[] = "clear"; static const char __pyx_k_close[] = "close"; +static const char __pyx_k_count[] = "count"; static const char __pyx_k_depth[] = "depth"; +static const char __pyx_k_deque[] = "deque"; static const char __pyx_k_event[] = "event"; static const char __pyx_k_frame[] = "frame"; static const char __pyx_k_gte_2[] = "_gte"; +static const char __pyx_k_index[] = "index"; static const char __pyx_k_items[] = "items"; static const char __pyx_k_lte_2[] = "_lte"; static const char __pyx_k_match[] = "match"; +static const char __pyx_k_merge[] = "_merge"; +static const char __pyx_k_other[] = "other"; +static const char __pyx_k_parts[] = "parts"; +static const char __pyx_k_query[] = "query"; static const char __pyx_k_regex[] = "regex"; -static const char __pyx_k_s_s_r[] = "%s%s=%r"; static const char __pyx_k_split[] = "split"; +static const char __pyx_k_stack[] = "stack"; +static const char __pyx_k_state[] = "state"; +static const char __pyx_k_strip[] = "strip"; static const char __pyx_k_throw[] = "throw"; +static const char __pyx_k_value[] = "value"; +static const char __pyx_k_we_MQ[] = "\320\000/\250w\260e\320;M\310Q"; +static const char __pyx_k_0_u_Oq[] = "\320\0000\260\007\260u\320P\320P[\320[\\\320\\`\320`l\320lx\360\000\000y\001D\002\360\000\000D\002E\002\360\000\000E\002I\002\360\000\000I\002U\002\360\000\000U\002a\002\360\000\000a\002l\002\360\000\000l\002m\002\360\000\000m\002q\002\360\000\000q\002}\002\360\000\000}\002J\003\360\000\000J\003U\003\360\000\000U\003V\003\360\000\000V\003Z\003\360\000\000Z\003f\003\360\000\000f\003r\003\360\000\000r\003}\003\360\000\000}\003~\003\360\000\000~\003B\004\360\000\000B\004N\004\360\000\000N\004Z\004\360\000\000Z\004e\004\360\000\000e\004f\004\360\000\000f\004j\004\360\000\000j\004v\004\360\000\000v\004C\005\360\000\000C\005N\005\360\000\000N\005O\005\360\000\000O\005S\005\360\000\000S\005_\005\360\000\000_\005n\005\360\000\000n\005y\005\360\000\000y\005z\005\360\000\000z\005~\005\360\000\000~\005J\006\360\000\000J\006^\006\360\000\000^\006i\006\360\000\000i\006j\006\360\000\000j\006k\006\330\004\007\200s\210!\210=\230\002\230#\230T\240\027\250\001\250\036\260q\330\010\024\220I\230W\240A\240[\260\001\260\021"; +static const char __pyx_k_T_4_4y_L_HTXX__cckkooww_G1F_a_v[] = "\200\001\360\010\000\005\016\210T\220\032\2304\230|\2504\250y\270\004\270L\310\004\310H\320TX\320X_\320_c\320ck\320ko\320ow\320w{\320{|\330\004\014\210G\2201\220F\230,\240a\330\004\007\200v\210W\220A\330\010\022\220!\330\010\027\220q\340\010\027\220t\2309\240G\2505\260\003\2604\260{\300'\310\025\310c\320QU\320U]\320]d\320di\320il\320lp\320p{\360\000\000|\001C\002\360\000\000C\002H\002\360\000\000H\002K\002\360\000\000K\002O\002\360\000\000O\002V\002\360\000\000V\002]\002\360\000\000]\002^\002\330\004\007\200q\330\010\017\320\017(\250\004\250A\250W\260K\270w\300a\340\010\017\320\017(\250\004\250A\250W\260K\270q"; +static const char __pyx_k_T_7t_d_UYYeeiittx_y_D_D_H_H_T_T[] = "\200\001\360\010\000\005\016\210T\320\021\"\240$\320&7\260t\270;\300d\310+\320UY\320Ye\320ei\320it\320tx\360\000\000y\001D\002\360\000\000D\002H\002\360\000\000H\002T\002\360\000\000T\002X\002\360\000\000X\002f\002\360\000\000f\002j\002\360\000\000j\002k\002\330\004\014\210G\2201\220F\230,\240a\330\004\007\200v\210W\220A\330\010\022\220!\330\010\027\220q\340\010\027\220t\320\033+\2507\260%\260s\270$\320>N\310g\320UZ\320Z]\320]a\320ak\320kr\320rw\320wz\320z~\360\000\000\177\001I\002\360\000\000I\002P\002\360\000\000P\002U\002\360\000\000U\002X\002\360\000\000X\002\\\002\360\000\000\\\002g\002\360\000\000g\002n\002\360\000\000n\002s\002\360\000\000s\002v\002\360\000\000v\002z\002\360\000\000z\002D\003\360\000\000D\003K\003\360\000\000K\003P\003\360\000\000P\003S\003\360\000\000S\003W\003\360\000\000W\003a\003\360\000\000a\003h\003\360\000\000h\003m\003\360\000\000m\003p\003\360\000\000p\003t\003\360\000\000t\003\177\003\360\000\000\177\003F\004\360\000\000F\004K\004\360\000\000K\004N\004\360\000\000N\004R\004\360\000\000R\004_\004\360\000\000_\004f\004\360\000\000f\004k\004\360\000\000k\004n\004\360\000\000n\004r\004\360\000\000r\004D\005\360\000\000D\005K\005\360\000\000K\005L\005\330\004\007\200q\330\010\017\320\017&\240d\250!\2507\260+\270W\300A\340\010\017\320\017&\240d\250!\2507\260+\270Q"; +static const char __pyx_k_Ubbc_JfF_j_VW_4z_iq_1_ERt1_M_IU[] = "\320\004'\240{\260)\270=\310\r\320Ub\320bc\330\010\014\210J\220f\230F\240'\250\021\250(\260$\260j\300\001\300\030\310\035\320VW\330\010\013\2104\210z\230\021\230$\230i\240q\330\014\022\220)\2301\320\034E\300R\300t\3101\330\010\014\210M\230\021\330\010\014\210I\220U\230!\2307\240!\330\010\014\210H\220A\330\010\014\210I\220Q\330\010\014\210I\220Q\330\010\014\210H\220A\330\010\014\210M\230\024\230W\240M\260\024\260[\300\001\330\010\014\210K\220q"; +static const char __pyx_k_Yat_q_q_4q_xq_fAQ_Q_gRq_KvS_q_2[] = "\200\001\360\034\000\005\016\210Y\220a\220t\230<\240q\330\004\007\200q\330\010\013\2104\210q\330\014\020\220\007\220x\230q\340\014\032\230(\240$\240f\250A\250Q\330\014\032\230+\240Q\330\014!\240\025\240g\250R\250q\330\014\034\230K\240v\250S\260\001\330\014\037\230q\320 2\260#\260T\270\027\300\002\320BU\320UW\320WX\330\014\017\210q\330\020\023\220>\240\024\240[\260\007\260w\270a\330\024\"\240+\250V\2601\340\024\"\240+\250Q\330\020\023\220<\230w\240a\330\024#\2405\250\001\330\024\034\230A\330\024\"\240!\330\024\032\230&\240\004\240L\260\002\260!\330\030&\240e\2501\330\034\"\240'\250\025\250c\260\024\260Q\330\034.\250e\2601\330\034\"\240,\250b\260\014\270B\270c\300\027\310\001\340\030\033\2304\230t\2401\340\034'\240{\260!\330\034'\240|\2601\330\034'\240|\2601\330\030$\240K\250q\260\001\330\030 \240\005\240Q\330\030'\240q\330\024\030\230\017\240q\330\030\033\2304\230y\250\003\2505\260\003\2604\260x\270q\300\001\330\034 \240\007\240q\250\001\330\014\020\320\020!\240\024\240Q\330\020\023\2204\220y\240\003\2401\330\024\030\230\007\230q\240\001\330\025\036\230a\230t\240:\250X\260Q\330\024\030\230\007\230q\240\001\330\014\020\220\006\220f\230A\340\010\013\2104\210w\220d\230%\230w\240b\250\001\360\006\000\r\021\220\006\220f\230A\330\010\013\2104\210y\230\003\2305\240\003\2404\240x\250q\260\001\330\014\035\230[\250\001\250\027\260\004\260A\330\014\032\230)\2405\250\001\330\014\020\220\006\220g\230Q\230a\340\004\013\2101"; +static const char __pyx_k_Yd_M_waq_D_V1_1_Yd_M_waq_F_HM_q[] = "\200\001\330\004\010\210\005\210Y\220d\230!\330\010\034\230M\250\026\250w\260a\260q\330\010\013\320\013\034\230D\240\r\250V\2601\330\014\023\2201\330\004\010\210\005\210Y\220d\230!\330\010\034\230M\250\026\250w\260a\260q\330\010\014\210F\320\022$\240H\250M\270\026\270q\330\014\023\2201\330\004\010\210\005\210Y\220d\230!\330\010\034\230M\250\026\250w\260a\260q\330\010\014\210M\230\026\230w\240h\250f\260A\330\014\023\2201\330\004\010\210\005\210Y\220d\230!\330\010\034\230M\250\026\250w\260a\260q\330\010\013\2105\220\006\320\026'\240{\260\"\260M\300\026\300q\330\014\023\2201\330\004\010\210\005\210Y\220d\230!\330\010\034\230M\250\026\250w\260a\260q\330\010\013\2105\220\006\320\026'\240y\260\002\260-\270v\300Q\330\014\023\2201\330\004\010\210\005\210Y\220d\230!\330\010\034\230M\250\026\250w\260a\260q\330\010\013\2105\220\r\230V\2406\250\026\250q\260\001\330\014\023\2201\330\004\010\210\005\210Y\220d\230!\330\010\034\230M\250\026\250w\260a\260q\330\010\013\2104\320\017 \240\003\240=\260\006\260a\330\014\023\2201\330\004\010\210\005\210Y\220d\230!\330\010\034\230M\250\026\250w\260a\260q\330\010\013\2104\320\017 \240\004\240M\260\026\260q\330\014\023\2201\330\004\010\210\005\210Y\220d\230!\330\010\034\230M\250\026\250w\260a\260q\330\010\013\2104\320\017 \240\003\240=\260\006\260a\330\014\023\2201\330\004\010\210\005\210Y\220d\230!\330\010\034\230M\250\026\250w\260a\260q\330\010\013\2104\320\017 \240\004\240M\260\026\260q\330\014\023\2201\340\004\013\2101"; +static const char __pyx_k_hunter__predicates_And_predicat[] = ""; -static const char __pyx_k_hunter__predicates_Or_predicate[] = ""; -static const char __pyx_k_hunter__predicates_When_conditi[] = ""; -static const char __pyx_k_Incompatible_checksums_s_vs_0x1a[] = "Incompatible checksums (%s vs 0x1acd5f7 = (condition, origin_calls, origin_depth, predicate, watermark))"; -static const char __pyx_k_Incompatible_checksums_s_vs_0x4e[] = "Incompatible checksums (%s vs 0x4eca0a2 = (query_contains, query_endswith, query_eq, query_gt, query_gte, query_in, query_lt, query_lte, query_regex, query_startswith))"; -static const char __pyx_k_Incompatible_checksums_s_vs_0xaa[] = "Incompatible checksums (%s vs 0xaa8cbda = (predicates))"; -static const char __pyx_k_Incompatible_checksums_s_vs_0xb5[] = "Incompatible checksums (%s vs 0xb55b71c = (actions, condition))"; -static const char __pyx_k_Incompatible_checksums_s_vs_0xf6[] = "Incompatible checksums (%s vs 0xf670ef6 = (predicate))"; -static const char __pyx_k_Unexpected_argument_r_Must_be_on[] = "Unexpected argument %r. Must be one of %s with optional operators like: %s"; -static const char __pyx_k_Unexpected_operator_r_Must_be_on[] = "Unexpected operator %r. Must be one of %s."; -static const char __pyx_k_Value_r_for_r_is_invalid_Must_be[] = "Value %r for %r is invalid. Must be a string, list, tuple or set."; -static const char __pyx_k_Unexpected_argument_r_Must_be_on_2[] = "Unexpected argument %r. Must be one of %s."; -static PyObject *__pyx_n_s_; -static PyObject *__pyx_n_s_Action; -static PyObject *__pyx_n_s_And; -static PyObject *__pyx_kp_s_And_s; -static PyObject *__pyx_n_s_From; -static PyObject *__pyx_kp_s_From_s_s_watermark_s; -static PyObject *__pyx_kp_s_Incompatible_checksums_s_vs_0x1a; -static PyObject *__pyx_kp_s_Incompatible_checksums_s_vs_0x4e; -static PyObject *__pyx_kp_s_Incompatible_checksums_s_vs_0xaa; -static PyObject *__pyx_kp_s_Incompatible_checksums_s_vs_0xb5; -static PyObject *__pyx_kp_s_Incompatible_checksums_s_vs_0xf6; -static PyObject *__pyx_kp_s_Must_give_at_least_one_action; -static PyObject *__pyx_n_s_Not; -static PyObject *__pyx_kp_s_Not_s; -static PyObject *__pyx_n_s_Or; -static PyObject *__pyx_kp_s_Or_s; -static PyObject *__pyx_n_s_PickleError; -static PyObject *__pyx_n_s_Query; -static PyObject *__pyx_kp_s_Query_s; -static PyObject *__pyx_n_s_TypeError; -static PyObject *__pyx_kp_s_Unexpected_argument_r_Must_be_on; -static PyObject *__pyx_kp_s_Unexpected_argument_r_Must_be_on_2; -static PyObject *__pyx_kp_s_Unexpected_operator_r_Must_be_on; -static PyObject *__pyx_n_s_ValueError; -static PyObject *__pyx_kp_s_Value_r_for_r_is_invalid_Must_be; -static PyObject *__pyx_n_s_When; -static PyObject *__pyx_kp_s_When_s_s; -static PyObject *__pyx_kp_s__2; -static PyObject *__pyx_kp_s__3; -static PyObject *__pyx_kp_s__4; -static PyObject *__pyx_n_s_actions; -static PyObject *__pyx_n_s_all; -static PyObject *__pyx_n_s_arg; -static PyObject *__pyx_n_s_args; -static PyObject *__pyx_n_s_calls; -static PyObject *__pyx_n_s_chain; -static PyObject *__pyx_n_s_cline_in_traceback; -static PyObject *__pyx_n_s_close; -static PyObject *__pyx_n_s_code; -static PyObject *__pyx_n_s_compile; -static PyObject *__pyx_n_s_condition; -static PyObject *__pyx_n_s_contains; -static PyObject *__pyx_n_s_contains_2; -static PyObject *__pyx_n_s_depth; -static PyObject *__pyx_n_s_dict; -static PyObject *__pyx_n_s_endswith; -static PyObject *__pyx_n_s_endswith_2; -static PyObject *__pyx_n_s_event; -static PyObject *__pyx_n_s_ew; -static PyObject *__pyx_n_s_filename; -static PyObject *__pyx_n_s_frame; -static PyObject *__pyx_n_s_fullsource; -static PyObject *__pyx_n_s_function; -static PyObject *__pyx_n_s_genexpr; -static PyObject *__pyx_n_s_getstate; -static PyObject *__pyx_n_s_globals; -static PyObject *__pyx_n_s_gt; -static PyObject *__pyx_n_s_gt_2; -static PyObject *__pyx_n_s_gte; -static PyObject *__pyx_n_s_gte_2; -static PyObject *__pyx_n_s_has; -static PyObject *__pyx_n_s_hunter__predicates; -static PyObject *__pyx_kp_s_hunter__predicates_And_predicat; -static PyObject *__pyx_kp_s_hunter__predicates_From_conditi; -static PyObject *__pyx_kp_s_hunter__predicates_Not_predicat; -static PyObject *__pyx_kp_s_hunter__predicates_Or_predicate; -static PyObject *__pyx_kp_s_hunter__predicates_Query_s; -static PyObject *__pyx_kp_s_hunter__predicates_When_conditi; -static PyObject *__pyx_n_s_import; -static PyObject *__pyx_n_s_in; -static PyObject *__pyx_n_s_in_2; -static PyObject *__pyx_n_s_init___locals_genexpr; -static PyObject *__pyx_n_s_inspect; -static PyObject *__pyx_n_s_isclass; -static PyObject *__pyx_n_s_items; -static PyObject *__pyx_n_s_itertools; -static PyObject *__pyx_n_s_join; -static PyObject *__pyx_n_s_kind; -static PyObject *__pyx_n_s_lineno; -static PyObject *__pyx_n_s_locals; -static PyObject *__pyx_n_s_lt; -static PyObject *__pyx_n_s_lt_2; -static PyObject *__pyx_n_s_lte; -static PyObject *__pyx_n_s_lte_2; -static PyObject *__pyx_n_s_main; -static PyObject *__pyx_n_s_match; -static PyObject *__pyx_n_s_module; -static PyObject *__pyx_n_s_name; -static PyObject *__pyx_n_s_new; -static PyObject *__pyx_n_s_pickle; -static PyObject *__pyx_n_s_predicate; -static PyObject *__pyx_n_s_pyx_PickleError; -static PyObject *__pyx_n_s_pyx_checksum; -static PyObject *__pyx_n_s_pyx_result; -static PyObject *__pyx_n_s_pyx_state; -static PyObject *__pyx_n_s_pyx_type; -static PyObject *__pyx_n_s_pyx_unpickle_And; -static PyObject *__pyx_n_s_pyx_unpickle_From; -static PyObject *__pyx_n_s_pyx_unpickle_Not; -static PyObject *__pyx_n_s_pyx_unpickle_Or; -static PyObject *__pyx_n_s_pyx_unpickle_Query; -static PyObject *__pyx_n_s_pyx_unpickle_When; -static PyObject *__pyx_n_s_pyx_vtable; -static PyObject *__pyx_kp_s_query_contains_r; -static PyObject *__pyx_kp_s_query_endswith_r; -static PyObject *__pyx_kp_s_query_eq_r; -static PyObject *__pyx_kp_s_query_gt_r; -static PyObject *__pyx_kp_s_query_gte_r; -static PyObject *__pyx_kp_s_query_in_r; -static PyObject *__pyx_kp_s_query_lt_r; -static PyObject *__pyx_kp_s_query_lte_r; -static PyObject *__pyx_kp_s_query_regex_r; -static PyObject *__pyx_kp_s_query_startswith_r; -static PyObject *__pyx_n_s_re; -static PyObject *__pyx_n_s_reduce; -static PyObject *__pyx_n_s_reduce_cython; -static PyObject *__pyx_n_s_reduce_ex; -static PyObject *__pyx_n_s_regex; -static PyObject *__pyx_n_s_regex_2; -static PyObject *__pyx_n_s_repr___locals_genexpr; -static PyObject *__pyx_n_s_rx; -static PyObject *__pyx_kp_s_s_s_r; -static PyObject *__pyx_n_s_send; -static PyObject *__pyx_n_s_setstate; -static PyObject *__pyx_n_s_setstate_cython; -static PyObject *__pyx_n_s_source; -static PyObject *__pyx_n_s_split; -static PyObject *__pyx_n_s_startswith; -static PyObject *__pyx_n_s_startswith_2; -static PyObject *__pyx_n_s_stdlib; -static PyObject *__pyx_n_s_str___locals_genexpr; -static PyObject *__pyx_n_s_str___locals_genexpr_locals_ge; -static PyObject *__pyx_kp_s_stringsource; -static PyObject *__pyx_n_s_sw; -static PyObject *__pyx_n_s_test; -static PyObject *__pyx_n_s_threadid; -static PyObject *__pyx_n_s_threadname; -static PyObject *__pyx_n_s_throw; -static PyObject *__pyx_n_s_update; -static PyObject *__pyx_n_s_watermark; +static const char __pyx_k_hunter__predicates_Or_predicate[] = "\320>[\320[\\\340\020\032\230!\330\020\031\230\021\340\014\017\210w\220g\230Q\330\020\026\220i\230q\240\002\320\":\320:R\320RS\340\014\023\2201\220J\230j\250\001\250\027\260\001\340\010\014\210L\230\005\230W\240A\240X\250V\2601\330\010\014\320\014 \240\005\240W\250A\320-=\270V\3001\330\010\014\320\014\036\230e\2407\250!\250>\270\026\270q\330\010\014\210L\230\005\230W\240A\240X\250V\2601\330\010\014\320\014\036\230e\2407\250!\250>\270\026\270q\330\010\014\210O\2305\240\007\240q\250\013\2606\270\021\330\010\014\210L\230\005\230W\240A\240X\250V\2601\330\010\014\210M\230\025\230g\240Q\240i\250v\260Q\330\010\014\210L\230\005\230W\240A\240X\250V\2601\330\010\014\210M\230\025\230g\240Q\240i\250v\260Q"; +static const char __pyx_k_A_awa_Jd_d_D_a_Jd_D_a_M_XV1_Jd_K[] = "\200A\330\010\t\330\014\026\220a\220w\230a\330\014\020\220\004\220J\230d\240(\250&\260\001\330\014\020\220\004\320\024&\240d\250(\260&\270\001\330\014\020\220\004\320\024$\240D\250\010\260\006\260a\330\014\020\220\004\220J\230d\240(\250&\260\001\330\014\020\220\004\320\024$\240D\250\010\260\006\260a\330\014\020\220\004\220M\240\024\240X\250V\2601\330\014\020\220\004\220J\230d\240(\250&\260\001\330\014\020\220\004\220K\230t\2408\2506\260\021\330\014\020\220\004\220J\230d\240(\250&\260\001\330\014\020\220\004\220K\230t\2408\2506\260\021"; +static const char __pyx_k_Action_r_must_be_a_ColorStreamAc[] = "Action %r must be a ColorStreamAction."; +static const char __pyx_k_Incompatible_checksums_0x_x_vs_0[] = "Incompatible checksums (0x%x vs (0x5503a44, 0x9ea0a45, 0x4eca0a2) = (query_contains, query_endswith, query_eq, query_gt, query_gte, query_in, query_lt, query_lte, query_regex, query_startswith))"; +static const char __pyx_k_Note_that_Cython_is_deliberately[] = "Note that Cython is deliberately stricter than PEP-484 and rejects subclasses of builtin types. If you need to pass subclasses then set the 'annotation_typing' directive to False."; +static const char __pyx_k_Pyx_CFunc_6hunter_11_predicate_2[] = "__Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event"; +static const char __pyx_k_Incompatible_checksums_0x_x_vs_0_2[] = "Incompatible checksums (0x%x vs (0xe710366, 0x7718bb4, 0xb55b71c) = (actions, condition))"; +static const char __pyx_k_Incompatible_checksums_0x_x_vs_0_3[] = "Incompatible checksums (0x%x vs (0xcfd05cc, 0xd4c8954, 0x1acd5f7) = (condition, origin_calls, origin_depth, predicate, watermark))"; +static const char __pyx_k_Incompatible_checksums_0x_x_vs_0_4[] = "Incompatible checksums (0x%x vs (0x8e21672, 0xc8ea956, 0xaa8cbda) = (predicates))"; +static const char __pyx_k_Incompatible_checksums_0x_x_vs_0_5[] = "Incompatible checksums (0x%x vs (0x23761c9, 0x0444431, 0xf670ef6) = (predicate))"; +static const char __pyx_k_Incompatible_checksums_0x_x_vs_0_6[] = "Incompatible checksums (0x%x vs (0x1428ea1, 0xbd128e6, 0x4bbfdb4) = (_filter, _try_repr, action, condition, queue, size, stack, strip, vars))"; +/* #### Code section: decls ### */ +static PyObject *__pyx_pf_11cfunc_dot_to_py_74__Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event_wrap(PyObject *__pyx_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event); /* proto */ +static int __pyx_pf_6hunter_11_predicates_10QueryEntry___init__(struct __pyx_obj_6hunter_11_predicates_QueryEntry *__pyx_v_self, PyObject *__pyx_v_value, PyObject *__pyx_v_name); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_10QueryEntry_2__repr__(struct __pyx_obj_6hunter_11_predicates_QueryEntry *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_10QueryEntry_4__eq__(struct __pyx_obj_6hunter_11_predicates_QueryEntry *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_10QueryEntry_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6hunter_11_predicates_QueryEntry *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_10QueryEntry_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6hunter_11_predicates_QueryEntry *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static int __pyx_pf_6hunter_11_predicates_5Query___init__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self, PyObject *__pyx_v_query); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_7__str___7genexpr_genexpr(PyObject *__pyx_self); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_7__str___genexpr(PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_5Query_7__str___8genexpr1_genexpr(PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_5Query_2__str__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_8__repr___genexpr(PyObject *__pyx_self); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_5Query_4__repr__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_5Query_6__eq__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ -static Py_hash_t __pyx_pf_6hunter_11_predicates_5Query_8__hash__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_10__call__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_12__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_14__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_16__invert__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_5Query_8__call__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_5Query_10__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_5Query_12__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_5Query_14__invert__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_5Query_14query_contains___get__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_5Query_14query_endswith___get__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_5Query_8query_eq___get__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self); /* proto */ @@ -2401,20914 +3948,33680 @@ static PyObject *__pyx_pf_6hunter_11_predicates_5Query_8query_lt___get__(struct static PyObject *__pyx_pf_6hunter_11_predicates_5Query_9query_lte___get__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_5Query_11query_regex___get__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_5Query_16query_startswith___get__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_18__reduce_cython__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_20__setstate_cython__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_4When_8__init___genexpr(PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_5Query_16__reduce_cython__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_5Query_18__setstate_cython__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_4When_8__init___genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0); /* proto */ static int __pyx_pf_6hunter_11_predicates_4When___init__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self, PyObject *__pyx_v_condition, PyObject *__pyx_v_actions); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_4When_7__str___genexpr(PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_4When_7__str___genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_4When_2__str__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_4When_4__repr__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_4When_6__eq__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ -static Py_hash_t __pyx_pf_6hunter_11_predicates_4When_8__hash__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_4When_10__call__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_4When_12__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_4When_14__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_4When_16__invert__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_4When_8__call__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_4When_10__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_4When_12__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_4When_14__invert__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_4When_9condition___get__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_4When_7actions___get__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_4When_18__reduce_cython__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_4When_20__setstate_cython__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_4When_16__reduce_cython__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_4When_18__setstate_cython__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ static int __pyx_pf_6hunter_11_predicates_4From___init__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self, PyObject *__pyx_v_condition, PyObject *__pyx_v_predicate, PyObject *__pyx_v_watermark); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_4From_2__str__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_4From_4__repr__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_4From_6__eq__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ -static Py_hash_t __pyx_pf_6hunter_11_predicates_4From_8__hash__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_4From_10__call__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_4From_12__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_4From_14__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_4From_16__invert__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_4From_8__call__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_4From_10__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_4From_12__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_4From_14__invert__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_4From_9condition___get__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_4From_9predicate___get__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_4From_9watermark___get__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_4From_12origin_depth___get__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_4From_12origin_calls___get__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_4From_18__reduce_cython__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_4From_20__setstate_cython__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_4From_16__reduce_cython__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_4From_18__setstate_cython__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ static int __pyx_pf_6hunter_11_predicates_3And___init__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self, PyObject *__pyx_v_predicates); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_3And_7__str___genexpr(PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_3And_7__str___genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_3And_2__str__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_3And_4__repr__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_3And_6__eq__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ -static Py_hash_t __pyx_pf_6hunter_11_predicates_3And_8__hash__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_3And_10__call__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_3And_12__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_3And_14__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_3And_16__invert__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_3And_8__call__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_3And_10__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_3And_12__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_3And_14__invert__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_3And_10predicates___get__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_3And_18__reduce_cython__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_3And_20__setstate_cython__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_3And_16__reduce_cython__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_3And_18__setstate_cython__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ static int __pyx_pf_6hunter_11_predicates_2Or___init__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self, PyObject *__pyx_v_predicates); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_2Or_7__str___genexpr(PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_2Or_7__str___genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_2Or_2__str__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_2Or_4__repr__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_2Or_6__eq__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ -static Py_hash_t __pyx_pf_6hunter_11_predicates_2Or_8__hash__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_2Or_10__call__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_2Or_12__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_2Or_14__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_2Or_16__invert__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_2Or_8__call__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_2Or_10__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_2Or_12__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_2Or_14__invert__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_2Or_10predicates___get__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_2Or_18__reduce_cython__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_2Or_20__setstate_cython__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_2Or_16__reduce_cython__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_2Or_18__setstate_cython__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ static int __pyx_pf_6hunter_11_predicates_3Not___init__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self, PyObject *__pyx_v_predicate); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_3Not_2__str__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_3Not_4__repr__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_3Not_6__eq__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ -static Py_hash_t __pyx_pf_6hunter_11_predicates_3Not_8__hash__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_3Not_10__call__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_3Not_12__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_3Not_14__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_3Not_16__invert__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_3Not_8__call__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_3Not_10__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_3Not_12__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_3Not_14__invert__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_3Not_9predicate___get__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_3Not_18__reduce_cython__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_3Not_20__setstate_cython__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_3Not_16__reduce_cython__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_3Not_18__setstate_cython__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_6hunter_11_predicates_7Backlog___init__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self, PyObject *__pyx_v_condition, PyObject *__pyx_v_size, PyObject *__pyx_v_stack, PyObject *__pyx_v_vars, PyObject *__pyx_v_strip, PyObject *__pyx_v_action, PyObject *__pyx_v_filter); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_2__call__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self, PyObject *__pyx_v_event); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_4__str__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_6__repr__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_8__eq__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_10__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_12__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_14__invert__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_16filter(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self, PyObject *__pyx_v_predicates, PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_9condition___get__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_4size___get__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_5stack___get__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_4vars___get__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_5strip___get__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_6action___get__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_9_try_repr___get__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_7_filter___get__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_5queue___get__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_18__reduce_cython__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_20__setstate_cython__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates___pyx_unpickle_Query(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_2__pyx_unpickle_When(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_4__pyx_unpickle_From(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_6__pyx_unpickle_And(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_8__pyx_unpickle_Or(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_pf_6hunter_11_predicates_10__pyx_unpickle_Not(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_6hunter_11_predicates_12__pyx_unpickle_Backlog(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_tp_new_6hunter_11_predicates_Query(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_6hunter_11_predicates_And(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_6hunter_11_predicates_Or(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_6hunter_11_predicates_Not(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_6hunter_11_predicates_When(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_6hunter_11_predicates_From(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_6hunter_11_predicates_Backlog(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_6hunter_11_predicates_QueryEntry(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct____str__(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_1_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_2_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_3___repr__(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_3_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_4_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_5___init__(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_6_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_7___str__(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_8_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_9___str__(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_10_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_11___str__(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_12_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_items = {0, &__pyx_n_s_items, 0, 0, 0}; -static PyObject *__pyx_int_0; -static PyObject *__pyx_int_28104183; -static PyObject *__pyx_int_82616482; -static PyObject *__pyx_int_178834394; -static PyObject *__pyx_int_190166812; -static PyObject *__pyx_int_258412278; -static PyObject *__pyx_tuple__5; -static PyObject *__pyx_tuple__12; -static PyObject *__pyx_tuple__13; -static PyObject *__pyx_tuple__14; -static PyObject *__pyx_tuple__15; -static PyObject *__pyx_tuple__16; -static PyObject *__pyx_tuple__17; -static PyObject *__pyx_tuple__18; -static PyObject *__pyx_tuple__19; -static PyObject *__pyx_tuple__20; -static PyObject *__pyx_codeobj__6; -static PyObject *__pyx_codeobj__7; -static PyObject *__pyx_codeobj__8; -static PyObject *__pyx_codeobj__9; -static PyObject *__pyx_codeobj__10; -static PyObject *__pyx_codeobj__11; -/* Late includes */ - -/* "hunter/_predicates.pyx":44 - * See :class:`hunter.event.Event` for fields that can be filtered on. - * """ - * def __init__(self, **query): # <<<<<<<<<<<<<< - * """ - * Args: - */ - -/* Python wrapper */ -static int __pyx_pw_6hunter_11_predicates_5Query_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_6hunter_11_predicates_5Query___init__[] = "\n Args:\n query: criteria to match on.\n\n Accepted arguments:\n ``arg``,\n ``calls``,\n ``code``,\n ``depth``,\n ``filename``,\n ``frame``,\n ``fullsource``,\n ``function``,\n ``globals``,\n ``kind``,\n ``lineno``,\n ``locals``,\n ``module``,\n ``source``,\n ``stdlib``,\n ``threadid``,\n ``threadname``.\n "; -#if CYTHON_COMPILING_IN_CPYTHON -struct wrapperbase __pyx_wrapperbase_6hunter_11_predicates_5Query___init__; +static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_5_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +/* #### Code section: late_includes ### */ +/* #### Code section: module_state ### */ +/* SmallCodeConfig */ +#ifndef CYTHON_SMALL_CODE +#if defined(__clang__) + #define CYTHON_SMALL_CODE +#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) + #define CYTHON_SMALL_CODE __attribute__((cold)) +#else + #define CYTHON_SMALL_CODE #endif -static int __pyx_pw_6hunter_11_predicates_5Query_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v_query = 0; - int __pyx_r; +#endif + +typedef struct { + PyObject *__pyx_d; + PyObject *__pyx_b; + PyObject *__pyx_cython_runtime; + PyObject *__pyx_empty_tuple; + PyObject *__pyx_empty_bytes; + PyObject *__pyx_empty_unicode; + #ifdef __Pyx_CyFunction_USED + PyTypeObject *__pyx_CyFunctionType; + #endif + #ifdef __Pyx_FusedFunction_USED + PyTypeObject *__pyx_FusedFunctionType; + #endif + #ifdef __Pyx_Generator_USED + PyTypeObject *__pyx_GeneratorType; + #endif + #ifdef __Pyx_IterableCoroutine_USED + PyTypeObject *__pyx_IterableCoroutineType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineAwaitType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineType; + #endif + PyTypeObject *__pyx_ptype_6hunter_6_event_CodeType; + PyTypeObject *__pyx_ptype_6hunter_6_event_Event; + PyTypeObject *__pyx_ptype_7cpython_4type_type; + PyTypeObject *__pyx_ptype_6hunter_7_tracer_CodeType; + PyTypeObject *__pyx_ptype_6hunter_7_tracer_Tracer; + PyObject *__pyx_type_6hunter_11_predicates_Query; + PyObject *__pyx_type_6hunter_11_predicates_And; + PyObject *__pyx_type_6hunter_11_predicates_Or; + PyObject *__pyx_type_6hunter_11_predicates_Not; + PyObject *__pyx_type_6hunter_11_predicates_When; + PyObject *__pyx_type_6hunter_11_predicates_From; + PyObject *__pyx_type_6hunter_11_predicates_Backlog; + PyObject *__pyx_type_6hunter_11_predicates_QueryEntry; + PyObject *__pyx_type_6hunter_11_predicates___pyx_scope_struct____str__; + PyObject *__pyx_type_6hunter_11_predicates___pyx_scope_struct_1_genexpr; + PyObject *__pyx_type_6hunter_11_predicates___pyx_scope_struct_2_genexpr; + PyObject *__pyx_type_6hunter_11_predicates___pyx_scope_struct_3_genexpr; + PyObject *__pyx_type_6hunter_11_predicates___pyx_scope_struct_4_genexpr; + PyObject *__pyx_type_6hunter_11_predicates___pyx_scope_struct_5_genexpr; + PyObject *__pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event; + PyTypeObject *__pyx_ptype_6hunter_11_predicates_Query; + PyTypeObject *__pyx_ptype_6hunter_11_predicates_And; + PyTypeObject *__pyx_ptype_6hunter_11_predicates_Or; + PyTypeObject *__pyx_ptype_6hunter_11_predicates_Not; + PyTypeObject *__pyx_ptype_6hunter_11_predicates_When; + PyTypeObject *__pyx_ptype_6hunter_11_predicates_From; + PyTypeObject *__pyx_ptype_6hunter_11_predicates_Backlog; + PyTypeObject *__pyx_ptype_6hunter_11_predicates_QueryEntry; + PyTypeObject *__pyx_ptype_6hunter_11_predicates___pyx_scope_struct____str__; + PyTypeObject *__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_1_genexpr; + PyTypeObject *__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_2_genexpr; + PyTypeObject *__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_3_genexpr; + PyTypeObject *__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_4_genexpr; + PyTypeObject *__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_5_genexpr; + PyTypeObject *__pyx_ptype___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event; + __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_items; + __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_pop; + __Pyx_CachedCFunction __pyx_umethod_PyTuple_Type__index; + PyObject *__pyx_tuple[9]; + PyObject *__pyx_codeobj_tab[151]; + PyObject *__pyx_string_tab[292]; + PyObject *__pyx_int_0; + PyObject *__pyx_int_10; + PyObject *__pyx_int_100; + PyObject *__pyx_int_4473905; + PyObject *__pyx_int_21139105; + PyObject *__pyx_int_28104183; + PyObject *__pyx_int_37183945; + PyObject *__pyx_int_79429044; + PyObject *__pyx_int_82616482; + PyObject *__pyx_int_89143876; + PyObject *__pyx_int_124881844; + PyObject *__pyx_int_149034610; + PyObject *__pyx_int_166332997; + PyObject *__pyx_int_178834394; + PyObject *__pyx_int_190166812; + PyObject *__pyx_int_198256870; + PyObject *__pyx_int_210676054; + PyObject *__pyx_int_217908684; + PyObject *__pyx_int_223119700; + PyObject *__pyx_int_242287462; + PyObject *__pyx_int_258412278; + PyObject *__pyx_int_neg_1; +/* #### Code section: module_state_contents ### */ +/* CommonTypesMetaclass.module_state_decls */ +PyTypeObject *__pyx_CommonTypesMetaclassType; + +/* CachedMethodType.module_state_decls */ +#if CYTHON_COMPILING_IN_LIMITED_API +PyObject *__Pyx_CachedMethodType; +#endif + + +#if CYTHON_USE_FREELISTS +struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__ *__pyx_freelist_6hunter_11_predicates___pyx_scope_struct____str__[8]; +int __pyx_freecount_6hunter_11_predicates___pyx_scope_struct____str__; +#endif + +#if CYTHON_USE_FREELISTS +struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr *__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_1_genexpr[8]; +int __pyx_freecount_6hunter_11_predicates___pyx_scope_struct_1_genexpr; +#endif + +#if CYTHON_USE_FREELISTS +struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr *__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_2_genexpr[8]; +int __pyx_freecount_6hunter_11_predicates___pyx_scope_struct_2_genexpr; +#endif + +#if CYTHON_USE_FREELISTS +struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3_genexpr *__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_3_genexpr[8]; +int __pyx_freecount_6hunter_11_predicates___pyx_scope_struct_3_genexpr; +#endif + +#if CYTHON_USE_FREELISTS +struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr *__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_4_genexpr[8]; +int __pyx_freecount_6hunter_11_predicates___pyx_scope_struct_4_genexpr; +#endif + +#if CYTHON_USE_FREELISTS +struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5_genexpr *__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_5_genexpr[8]; +int __pyx_freecount_6hunter_11_predicates___pyx_scope_struct_5_genexpr; +#endif + +#if CYTHON_USE_FREELISTS +struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event *__pyx_freelist___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event[8]; +int __pyx_freecount___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event; +#endif +/* CodeObjectCache.module_state_decls */ +struct __Pyx_CodeObjectCache __pyx_code_cache; + +/* IterNextPlain.module_state_decls */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 +PyObject *__Pyx_GetBuiltinNext_LimitedAPI_cache; +#endif + +/* #### Code section: module_state_end ### */ +} __pyx_mstatetype; + +#if CYTHON_USE_MODULE_STATE +#ifdef __cplusplus +namespace { +extern struct PyModuleDef __pyx_moduledef; +} /* anonymous namespace */ +#else +static struct PyModuleDef __pyx_moduledef; +#endif + +#define __pyx_mstate_global (__Pyx_PyModule_GetState(__Pyx_State_FindModule(&__pyx_moduledef))) + +#define __pyx_m (__Pyx_State_FindModule(&__pyx_moduledef)) +#else +static __pyx_mstatetype __pyx_mstate_global_static = +#ifdef __cplusplus + {}; +#else + {0}; +#endif +static __pyx_mstatetype * const __pyx_mstate_global = &__pyx_mstate_global_static; +#endif +/* #### Code section: constant_name_defines ### */ +#define __pyx_n_u_ __pyx_string_tab[0] +#define __pyx_n_u_ALLOWED_KEYS __pyx_string_tab[1] +#define __pyx_n_u_ALLOWED_OPERATORS __pyx_string_tab[2] +#define __pyx_n_u_Action __pyx_string_tab[3] +#define __pyx_kp_u_Action_r_must_be_a_ColorStreamAc __pyx_string_tab[4] +#define __pyx_n_u_And __pyx_string_tab[5] +#define __pyx_n_u_And___reduce_cython __pyx_string_tab[6] +#define __pyx_n_u_And___setstate_cython __pyx_string_tab[7] +#define __pyx_kp_u_And_s __pyx_string_tab[8] +#define __pyx_kp_u_Backlog __pyx_string_tab[9] +#define __pyx_n_u_Backlog_2 __pyx_string_tab[10] +#define __pyx_n_u_Backlog___reduce_cython __pyx_string_tab[11] +#define __pyx_n_u_Backlog___setstate_cython __pyx_string_tab[12] +#define __pyx_n_u_Backlog_filter __pyx_string_tab[13] +#define __pyx_n_u_ColorStreamAction __pyx_string_tab[14] +#define __pyx_n_u_Event_get_arg __pyx_string_tab[15] +#define __pyx_n_u_Event_get_builtin __pyx_string_tab[16] +#define __pyx_n_u_Event_get_calls __pyx_string_tab[17] +#define __pyx_n_u_Event_get_depth __pyx_string_tab[18] +#define __pyx_n_u_Event_get_filename __pyx_string_tab[19] +#define __pyx_n_u_Event_get_fullsource __pyx_string_tab[20] +#define __pyx_n_u_Event_get_function __pyx_string_tab[21] +#define __pyx_n_u_Event_get_globals __pyx_string_tab[22] +#define __pyx_n_u_Event_get_instruction __pyx_string_tab[23] +#define __pyx_n_u_Event_get_kind __pyx_string_tab[24] +#define __pyx_n_u_Event_get_lineno __pyx_string_tab[25] +#define __pyx_n_u_Event_get_locals __pyx_string_tab[26] +#define __pyx_n_u_Event_get_module __pyx_string_tab[27] +#define __pyx_n_u_Event_get_source __pyx_string_tab[28] +#define __pyx_n_u_Event_get_stdlib __pyx_string_tab[29] +#define __pyx_n_u_Event_get_threadid __pyx_string_tab[30] +#define __pyx_n_u_Event_get_threadname __pyx_string_tab[31] +#define __pyx_n_u_Event_getters __pyx_string_tab[32] +#define __pyx_n_u_False __pyx_string_tab[33] +#define __pyx_kp_u_From __pyx_string_tab[34] +#define __pyx_n_u_From_2 __pyx_string_tab[35] +#define __pyx_n_u_From___reduce_cython __pyx_string_tab[36] +#define __pyx_n_u_From___setstate_cython __pyx_string_tab[37] +#define __pyx_kp_u_Incompatible_checksums_0x_x_vs_0 __pyx_string_tab[38] +#define __pyx_kp_u_Incompatible_checksums_0x_x_vs_0_2 __pyx_string_tab[39] +#define __pyx_kp_u_Incompatible_checksums_0x_x_vs_0_3 __pyx_string_tab[40] +#define __pyx_kp_u_Incompatible_checksums_0x_x_vs_0_4 __pyx_string_tab[41] +#define __pyx_kp_u_Incompatible_checksums_0x_x_vs_0_5 __pyx_string_tab[42] +#define __pyx_kp_u_Incompatible_checksums_0x_x_vs_0_6 __pyx_string_tab[43] +#define __pyx_kp_u_Must_be_one_of __pyx_string_tab[44] +#define __pyx_kp_u_Must_give_at_least_one_action __pyx_string_tab[45] +#define __pyx_n_u_Not __pyx_string_tab[46] +#define __pyx_n_u_Not___reduce_cython __pyx_string_tab[47] +#define __pyx_n_u_Not___setstate_cython __pyx_string_tab[48] +#define __pyx_kp_u_Not_s __pyx_string_tab[49] +#define __pyx_kp_u_Note_that_Cython_is_deliberately __pyx_string_tab[50] +#define __pyx_n_u_Or __pyx_string_tab[51] +#define __pyx_n_u_Or___reduce_cython __pyx_string_tab[52] +#define __pyx_n_u_Or___setstate_cython __pyx_string_tab[53] +#define __pyx_kp_u_Or_s __pyx_string_tab[54] +#define __pyx_n_u_PickleError __pyx_string_tab[55] +#define __pyx_n_u_Pyx_CFunc_6hunter_11_predicate __pyx_string_tab[56] +#define __pyx_n_u_Pyx_CFunc_6hunter_11_predicate_2 __pyx_string_tab[57] +#define __pyx_n_u_Query __pyx_string_tab[58] +#define __pyx_n_u_QueryEntry __pyx_string_tab[59] +#define __pyx_n_u_QueryEntry___reduce_cython __pyx_string_tab[60] +#define __pyx_n_u_QueryEntry___setstate_cython __pyx_string_tab[61] +#define __pyx_n_u_Query___reduce_cython __pyx_string_tab[62] +#define __pyx_n_u_Query___setstate_cython __pyx_string_tab[63] +#define __pyx_kp_u_Query_s __pyx_string_tab[64] +#define __pyx_n_u_True __pyx_string_tab[65] +#define __pyx_n_u_TypeError __pyx_string_tab[66] +#define __pyx_kp_u_Unexpected_argument __pyx_string_tab[67] +#define __pyx_kp_u_Unexpected_operator __pyx_string_tab[68] +#define __pyx_kp_u_Value __pyx_string_tab[69] +#define __pyx_n_u_ValueError __pyx_string_tab[70] +#define __pyx_kp_u_When __pyx_string_tab[71] +#define __pyx_n_u_When_2 __pyx_string_tab[72] +#define __pyx_n_u_When___reduce_cython __pyx_string_tab[73] +#define __pyx_n_u_When___setstate_cython __pyx_string_tab[74] +#define __pyx_kp_u__2 __pyx_string_tab[75] +#define __pyx_kp_u__3 __pyx_string_tab[76] +#define __pyx_kp_u__4 __pyx_string_tab[77] +#define __pyx_kp_u__5 __pyx_string_tab[78] +#define __pyx_kp_u__6 __pyx_string_tab[79] +#define __pyx_kp_u__7 __pyx_string_tab[80] +#define __pyx_kp_u__8 __pyx_string_tab[81] +#define __pyx_kp_u__9 __pyx_string_tab[82] +#define __pyx_n_u_action __pyx_string_tab[83] +#define __pyx_kp_u_action_2 __pyx_string_tab[84] +#define __pyx_kp_u_actions __pyx_string_tab[85] +#define __pyx_n_u_actions_2 __pyx_string_tab[86] +#define __pyx_kp_u_add_note __pyx_string_tab[87] +#define __pyx_n_u_all __pyx_string_tab[88] +#define __pyx_n_u_and __pyx_string_tab[89] +#define __pyx_n_u_append __pyx_string_tab[90] +#define __pyx_n_u_appendleft __pyx_string_tab[91] +#define __pyx_n_u_arg __pyx_string_tab[92] +#define __pyx_n_u_asyncio_coroutines __pyx_string_tab[93] +#define __pyx_n_u_builtin __pyx_string_tab[94] +#define __pyx_n_u_call __pyx_string_tab[95] +#define __pyx_n_u_call_2 __pyx_string_tab[96] +#define __pyx_n_u_callable __pyx_string_tab[97] +#define __pyx_n_u_calls __pyx_string_tab[98] +#define __pyx_n_u_cfunc_to_py __pyx_string_tab[99] +#define __pyx_n_u_cleanup __pyx_string_tab[100] +#define __pyx_n_u_clear __pyx_string_tab[101] +#define __pyx_n_u_cline_in_traceback __pyx_string_tab[102] +#define __pyx_n_u_close __pyx_string_tab[103] +#define __pyx_n_u_collections __pyx_string_tab[104] +#define __pyx_n_u_compile __pyx_string_tab[105] +#define __pyx_n_u_condition __pyx_string_tab[106] +#define __pyx_n_u_contains __pyx_string_tab[107] +#define __pyx_n_u_contains_2 __pyx_string_tab[108] +#define __pyx_n_u_count __pyx_string_tab[109] +#define __pyx_n_u_depth __pyx_string_tab[110] +#define __pyx_n_u_deque __pyx_string_tab[111] +#define __pyx_n_u_dict __pyx_string_tab[112] +#define __pyx_n_u_dict_2 __pyx_string_tab[113] +#define __pyx_kp_u_disable __pyx_string_tab[114] +#define __pyx_kp_u_enable __pyx_string_tab[115] +#define __pyx_n_u_endswith __pyx_string_tab[116] +#define __pyx_n_u_endswith_2 __pyx_string_tab[117] +#define __pyx_n_u_eq __pyx_string_tab[118] +#define __pyx_n_u_event __pyx_string_tab[119] +#define __pyx_n_u_ew __pyx_string_tab[120] +#define __pyx_n_u_f __pyx_string_tab[121] +#define __pyx_n_u_f_back __pyx_string_tab[122] +#define __pyx_n_u_fast_And_call __pyx_string_tab[123] +#define __pyx_n_u_fast_Backlog_call __pyx_string_tab[124] +#define __pyx_n_u_fast_From_call __pyx_string_tab[125] +#define __pyx_n_u_fast_Not_call __pyx_string_tab[126] +#define __pyx_n_u_fast_Or_call __pyx_string_tab[127] +#define __pyx_n_u_fast_Query_call __pyx_string_tab[128] +#define __pyx_n_u_fast_When_call __pyx_string_tab[129] +#define __pyx_n_u_fast_call __pyx_string_tab[130] +#define __pyx_n_u_filename __pyx_string_tab[131] +#define __pyx_n_u_filter __pyx_string_tab[132] +#define __pyx_kp_u_filter_2 __pyx_string_tab[133] +#define __pyx_n_u_fmt __pyx_string_tab[134] +#define __pyx_kp_u_for __pyx_string_tab[135] +#define __pyx_n_u_frame __pyx_string_tab[136] +#define __pyx_n_u_fullsource __pyx_string_tab[137] +#define __pyx_n_u_func __pyx_string_tab[138] +#define __pyx_n_u_function __pyx_string_tab[139] +#define __pyx_kp_u_gc __pyx_string_tab[140] +#define __pyx_n_u_genexpr __pyx_string_tab[141] +#define __pyx_n_u_get __pyx_string_tab[142] +#define __pyx_n_u_getstate __pyx_string_tab[143] +#define __pyx_n_u_globals __pyx_string_tab[144] +#define __pyx_n_u_gt __pyx_string_tab[145] +#define __pyx_n_u_gt_2 __pyx_string_tab[146] +#define __pyx_n_u_gte __pyx_string_tab[147] +#define __pyx_n_u_gte_2 __pyx_string_tab[148] +#define __pyx_n_u_has __pyx_string_tab[149] +#define __pyx_n_u_hunter __pyx_string_tab[150] +#define __pyx_n_u_hunter__predicates __pyx_string_tab[151] +#define __pyx_kp_u_hunter__predicates_And_predicat __pyx_string_tab[152] +#define __pyx_kp_u_hunter__predicates_From_conditi __pyx_string_tab[153] +#define __pyx_kp_u_hunter__predicates_Not_predicat __pyx_string_tab[154] +#define __pyx_kp_u_hunter__predicates_Or_predicate __pyx_string_tab[155] +#define __pyx_kp_u_hunter__predicates_When_conditi __pyx_string_tab[156] +#define __pyx_kp_u_hunter_predicates_Backlog_condi __pyx_string_tab[157] +#define __pyx_kp_u_hunter_predicates_Query_s __pyx_string_tab[158] +#define __pyx_n_u_in __pyx_string_tab[159] +#define __pyx_n_u_in_2 __pyx_string_tab[160] +#define __pyx_n_u_index __pyx_string_tab[161] +#define __pyx_n_u_init __pyx_string_tab[162] +#define __pyx_n_u_init___locals_genexpr __pyx_string_tab[163] +#define __pyx_n_u_inspect __pyx_string_tab[164] +#define __pyx_n_u_instruction __pyx_string_tab[165] +#define __pyx_n_u_invert __pyx_string_tab[166] +#define __pyx_n_u_is_coroutine __pyx_string_tab[167] +#define __pyx_kp_u_is_invalid_Must_be_a_string_lis __pyx_string_tab[168] +#define __pyx_n_u_isclass __pyx_string_tab[169] +#define __pyx_kp_u_isenabled __pyx_string_tab[170] +#define __pyx_n_u_items __pyx_string_tab[171] +#define __pyx_n_u_key __pyx_string_tab[172] +#define __pyx_n_u_kind __pyx_string_tab[173] +#define __pyx_n_u_kwargs __pyx_string_tab[174] +#define __pyx_n_u_lineno __pyx_string_tab[175] +#define __pyx_n_u_locals __pyx_string_tab[176] +#define __pyx_n_u_lt __pyx_string_tab[177] +#define __pyx_n_u_lt_2 __pyx_string_tab[178] +#define __pyx_n_u_lte __pyx_string_tab[179] +#define __pyx_n_u_lte_2 __pyx_string_tab[180] +#define __pyx_n_u_main __pyx_string_tab[181] +#define __pyx_n_u_mapping __pyx_string_tab[182] +#define __pyx_n_u_match __pyx_string_tab[183] +#define __pyx_n_u_maxlen __pyx_string_tab[184] +#define __pyx_n_u_merge __pyx_string_tab[185] +#define __pyx_n_u_module __pyx_string_tab[186] +#define __pyx_n_u_module_2 __pyx_string_tab[187] +#define __pyx_n_u_name __pyx_string_tab[188] +#define __pyx_n_u_name_2 __pyx_string_tab[189] +#define __pyx_n_u_new __pyx_string_tab[190] +#define __pyx_n_u_next __pyx_string_tab[191] +#define __pyx_n_u_operator __pyx_string_tab[192] +#define __pyx_n_u_or __pyx_string_tab[193] +#define __pyx_n_u_other __pyx_string_tab[194] +#define __pyx_n_u_p __pyx_string_tab[195] +#define __pyx_n_u_parts __pyx_string_tab[196] +#define __pyx_n_u_pickle __pyx_string_tab[197] +#define __pyx_n_u_pop __pyx_string_tab[198] +#define __pyx_n_u_predicate __pyx_string_tab[199] +#define __pyx_kp_u_predicate_2 __pyx_string_tab[200] +#define __pyx_n_u_predicates __pyx_string_tab[201] +#define __pyx_n_u_prefix __pyx_string_tab[202] +#define __pyx_n_u_pyx_PickleError __pyx_string_tab[203] +#define __pyx_n_u_pyx_checksum __pyx_string_tab[204] +#define __pyx_n_u_pyx_result __pyx_string_tab[205] +#define __pyx_n_u_pyx_state __pyx_string_tab[206] +#define __pyx_n_u_pyx_type __pyx_string_tab[207] +#define __pyx_n_u_pyx_unpickle_And __pyx_string_tab[208] +#define __pyx_n_u_pyx_unpickle_And__set_state __pyx_string_tab[209] +#define __pyx_n_u_pyx_unpickle_Backlog __pyx_string_tab[210] +#define __pyx_n_u_pyx_unpickle_Backlog__set_stat __pyx_string_tab[211] +#define __pyx_n_u_pyx_unpickle_From __pyx_string_tab[212] +#define __pyx_n_u_pyx_unpickle_From__set_state __pyx_string_tab[213] +#define __pyx_n_u_pyx_unpickle_Not __pyx_string_tab[214] +#define __pyx_n_u_pyx_unpickle_Not__set_state __pyx_string_tab[215] +#define __pyx_n_u_pyx_unpickle_Or __pyx_string_tab[216] +#define __pyx_n_u_pyx_unpickle_Or__set_state __pyx_string_tab[217] +#define __pyx_n_u_pyx_unpickle_Query __pyx_string_tab[218] +#define __pyx_n_u_pyx_unpickle_Query__set_state __pyx_string_tab[219] +#define __pyx_n_u_pyx_unpickle_When __pyx_string_tab[220] +#define __pyx_n_u_pyx_unpickle_When__set_state __pyx_string_tab[221] +#define __pyx_n_u_pyx_vtable __pyx_string_tab[222] +#define __pyx_n_u_qualname __pyx_string_tab[223] +#define __pyx_n_u_query __pyx_string_tab[224] +#define __pyx_n_u_query_contains __pyx_string_tab[225] +#define __pyx_kp_u_query_contains_r __pyx_string_tab[226] +#define __pyx_n_u_query_endswith __pyx_string_tab[227] +#define __pyx_kp_u_query_endswith_r __pyx_string_tab[228] +#define __pyx_n_u_query_eq __pyx_string_tab[229] +#define __pyx_kp_u_query_eq_r __pyx_string_tab[230] +#define __pyx_n_u_query_gt __pyx_string_tab[231] +#define __pyx_kp_u_query_gt_r __pyx_string_tab[232] +#define __pyx_n_u_query_gte __pyx_string_tab[233] +#define __pyx_kp_u_query_gte_r __pyx_string_tab[234] +#define __pyx_n_u_query_in __pyx_string_tab[235] +#define __pyx_kp_u_query_in_r __pyx_string_tab[236] +#define __pyx_n_u_query_lt __pyx_string_tab[237] +#define __pyx_kp_u_query_lt_r __pyx_string_tab[238] +#define __pyx_n_u_query_lte __pyx_string_tab[239] +#define __pyx_kp_u_query_lte_r __pyx_string_tab[240] +#define __pyx_n_u_query_regex __pyx_string_tab[241] +#define __pyx_kp_u_query_regex_r __pyx_string_tab[242] +#define __pyx_n_u_query_startswith __pyx_string_tab[243] +#define __pyx_kp_u_query_startswith_r __pyx_string_tab[244] +#define __pyx_n_u_re __pyx_string_tab[245] +#define __pyx_n_u_re_compile __pyx_string_tab[246] +#define __pyx_n_u_reduce __pyx_string_tab[247] +#define __pyx_n_u_reduce_cython __pyx_string_tab[248] +#define __pyx_n_u_reduce_ex __pyx_string_tab[249] +#define __pyx_n_u_regex __pyx_string_tab[250] +#define __pyx_n_u_regex_2 __pyx_string_tab[251] +#define __pyx_n_u_repr __pyx_string_tab[252] +#define __pyx_n_u_rx __pyx_string_tab[253] +#define __pyx_n_u_self __pyx_string_tab[254] +#define __pyx_kp_u_self_getter_cannot_be_converted __pyx_string_tab[255] +#define __pyx_n_u_send __pyx_string_tab[256] +#define __pyx_n_u_set_name __pyx_string_tab[257] +#define __pyx_n_u_setstate __pyx_string_tab[258] +#define __pyx_n_u_setstate_cython __pyx_string_tab[259] +#define __pyx_n_u_size __pyx_string_tab[260] +#define __pyx_kp_u_size_2 __pyx_string_tab[261] +#define __pyx_n_u_source __pyx_string_tab[262] +#define __pyx_n_u_split __pyx_string_tab[263] +#define __pyx_kp_u_src_hunter__predicates_pxd __pyx_string_tab[264] +#define __pyx_kp_u_src_hunter__predicates_pyx __pyx_string_tab[265] +#define __pyx_n_u_stack __pyx_string_tab[266] +#define __pyx_kp_u_stack_2 __pyx_string_tab[267] +#define __pyx_n_u_startswith __pyx_string_tab[268] +#define __pyx_n_u_startswith_2 __pyx_string_tab[269] +#define __pyx_n_u_state __pyx_string_tab[270] +#define __pyx_n_u_stdlib __pyx_string_tab[271] +#define __pyx_n_u_str __pyx_string_tab[272] +#define __pyx_n_u_str___locals_genexpr __pyx_string_tab[273] +#define __pyx_kp_u_stringsource __pyx_string_tab[274] +#define __pyx_n_u_strip __pyx_string_tab[275] +#define __pyx_n_u_sw __pyx_string_tab[276] +#define __pyx_n_u_test __pyx_string_tab[277] +#define __pyx_n_u_threadid __pyx_string_tab[278] +#define __pyx_n_u_threading_support __pyx_string_tab[279] +#define __pyx_n_u_threadname __pyx_string_tab[280] +#define __pyx_n_u_throw __pyx_string_tab[281] +#define __pyx_n_u_try_repr __pyx_string_tab[282] +#define __pyx_n_u_update __pyx_string_tab[283] +#define __pyx_n_u_use_setstate __pyx_string_tab[284] +#define __pyx_n_u_value __pyx_string_tab[285] +#define __pyx_n_u_vars __pyx_string_tab[286] +#define __pyx_kp_u_vars_2 __pyx_string_tab[287] +#define __pyx_n_u_watermark __pyx_string_tab[288] +#define __pyx_kp_u_watermark_2 __pyx_string_tab[289] +#define __pyx_kp_u_with_optional_operators_like __pyx_string_tab[290] +#define __pyx_n_u_wrap __pyx_string_tab[291] +/* #### Code section: module_state_clear ### */ +#if CYTHON_USE_MODULE_STATE +static CYTHON_SMALL_CODE int __pyx_m_clear(PyObject *m) { + __pyx_mstatetype *clear_module_state = __Pyx_PyModule_GetState(m); + if (!clear_module_state) return 0; + Py_CLEAR(clear_module_state->__pyx_d); + Py_CLEAR(clear_module_state->__pyx_b); + Py_CLEAR(clear_module_state->__pyx_cython_runtime); + Py_CLEAR(clear_module_state->__pyx_empty_tuple); + Py_CLEAR(clear_module_state->__pyx_empty_bytes); + Py_CLEAR(clear_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_CLEAR(clear_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_CLEAR(clear_module_state->__pyx_FusedFunctionType); + #endif + #if CYTHON_PEP489_MULTI_PHASE_INIT + __Pyx_State_RemoveModule(NULL); + #endif + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_6_event_CodeType); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_6_event_Event); + Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_4type_type); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_7_tracer_CodeType); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_7_tracer_Tracer); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_11_predicates_Query); + Py_CLEAR(clear_module_state->__pyx_type_6hunter_11_predicates_Query); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_11_predicates_And); + Py_CLEAR(clear_module_state->__pyx_type_6hunter_11_predicates_And); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_11_predicates_Or); + Py_CLEAR(clear_module_state->__pyx_type_6hunter_11_predicates_Or); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_11_predicates_Not); + Py_CLEAR(clear_module_state->__pyx_type_6hunter_11_predicates_Not); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_11_predicates_When); + Py_CLEAR(clear_module_state->__pyx_type_6hunter_11_predicates_When); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_11_predicates_From); + Py_CLEAR(clear_module_state->__pyx_type_6hunter_11_predicates_From); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_11_predicates_Backlog); + Py_CLEAR(clear_module_state->__pyx_type_6hunter_11_predicates_Backlog); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_11_predicates_QueryEntry); + Py_CLEAR(clear_module_state->__pyx_type_6hunter_11_predicates_QueryEntry); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct____str__); + Py_CLEAR(clear_module_state->__pyx_type_6hunter_11_predicates___pyx_scope_struct____str__); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_1_genexpr); + Py_CLEAR(clear_module_state->__pyx_type_6hunter_11_predicates___pyx_scope_struct_1_genexpr); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_2_genexpr); + Py_CLEAR(clear_module_state->__pyx_type_6hunter_11_predicates___pyx_scope_struct_2_genexpr); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_3_genexpr); + Py_CLEAR(clear_module_state->__pyx_type_6hunter_11_predicates___pyx_scope_struct_3_genexpr); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_4_genexpr); + Py_CLEAR(clear_module_state->__pyx_type_6hunter_11_predicates___pyx_scope_struct_4_genexpr); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_5_genexpr); + Py_CLEAR(clear_module_state->__pyx_type_6hunter_11_predicates___pyx_scope_struct_5_genexpr); + Py_CLEAR(clear_module_state->__pyx_ptype___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event); + Py_CLEAR(clear_module_state->__pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event); + for (int i=0; i<9; ++i) { Py_CLEAR(clear_module_state->__pyx_tuple[i]); } + for (int i=0; i<151; ++i) { Py_CLEAR(clear_module_state->__pyx_codeobj_tab[i]); } + for (int i=0; i<292; ++i) { Py_CLEAR(clear_module_state->__pyx_string_tab[i]); } + Py_CLEAR(clear_module_state->__pyx_int_0); + Py_CLEAR(clear_module_state->__pyx_int_10); + Py_CLEAR(clear_module_state->__pyx_int_100); + Py_CLEAR(clear_module_state->__pyx_int_4473905); + Py_CLEAR(clear_module_state->__pyx_int_21139105); + Py_CLEAR(clear_module_state->__pyx_int_28104183); + Py_CLEAR(clear_module_state->__pyx_int_37183945); + Py_CLEAR(clear_module_state->__pyx_int_79429044); + Py_CLEAR(clear_module_state->__pyx_int_82616482); + Py_CLEAR(clear_module_state->__pyx_int_89143876); + Py_CLEAR(clear_module_state->__pyx_int_124881844); + Py_CLEAR(clear_module_state->__pyx_int_149034610); + Py_CLEAR(clear_module_state->__pyx_int_166332997); + Py_CLEAR(clear_module_state->__pyx_int_178834394); + Py_CLEAR(clear_module_state->__pyx_int_190166812); + Py_CLEAR(clear_module_state->__pyx_int_198256870); + Py_CLEAR(clear_module_state->__pyx_int_210676054); + Py_CLEAR(clear_module_state->__pyx_int_217908684); + Py_CLEAR(clear_module_state->__pyx_int_223119700); + Py_CLEAR(clear_module_state->__pyx_int_242287462); + Py_CLEAR(clear_module_state->__pyx_int_258412278); + Py_CLEAR(clear_module_state->__pyx_int_neg_1); + return 0; +} +#endif +/* #### Code section: module_state_traverse ### */ +#if CYTHON_USE_MODULE_STATE +static CYTHON_SMALL_CODE int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { + __pyx_mstatetype *traverse_module_state = __Pyx_PyModule_GetState(m); + if (!traverse_module_state) return 0; + Py_VISIT(traverse_module_state->__pyx_d); + Py_VISIT(traverse_module_state->__pyx_b); + Py_VISIT(traverse_module_state->__pyx_cython_runtime); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_tuple); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_bytes); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_VISIT(traverse_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_VISIT(traverse_module_state->__pyx_FusedFunctionType); + #endif + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_6_event_CodeType); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_6_event_Event); + Py_VISIT(traverse_module_state->__pyx_ptype_7cpython_4type_type); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_7_tracer_CodeType); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_7_tracer_Tracer); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_11_predicates_Query); + Py_VISIT(traverse_module_state->__pyx_type_6hunter_11_predicates_Query); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_11_predicates_And); + Py_VISIT(traverse_module_state->__pyx_type_6hunter_11_predicates_And); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_11_predicates_Or); + Py_VISIT(traverse_module_state->__pyx_type_6hunter_11_predicates_Or); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_11_predicates_Not); + Py_VISIT(traverse_module_state->__pyx_type_6hunter_11_predicates_Not); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_11_predicates_When); + Py_VISIT(traverse_module_state->__pyx_type_6hunter_11_predicates_When); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_11_predicates_From); + Py_VISIT(traverse_module_state->__pyx_type_6hunter_11_predicates_From); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_11_predicates_Backlog); + Py_VISIT(traverse_module_state->__pyx_type_6hunter_11_predicates_Backlog); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_11_predicates_QueryEntry); + Py_VISIT(traverse_module_state->__pyx_type_6hunter_11_predicates_QueryEntry); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct____str__); + Py_VISIT(traverse_module_state->__pyx_type_6hunter_11_predicates___pyx_scope_struct____str__); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_1_genexpr); + Py_VISIT(traverse_module_state->__pyx_type_6hunter_11_predicates___pyx_scope_struct_1_genexpr); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_2_genexpr); + Py_VISIT(traverse_module_state->__pyx_type_6hunter_11_predicates___pyx_scope_struct_2_genexpr); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_3_genexpr); + Py_VISIT(traverse_module_state->__pyx_type_6hunter_11_predicates___pyx_scope_struct_3_genexpr); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_4_genexpr); + Py_VISIT(traverse_module_state->__pyx_type_6hunter_11_predicates___pyx_scope_struct_4_genexpr); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_5_genexpr); + Py_VISIT(traverse_module_state->__pyx_type_6hunter_11_predicates___pyx_scope_struct_5_genexpr); + Py_VISIT(traverse_module_state->__pyx_ptype___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event); + Py_VISIT(traverse_module_state->__pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event); + for (int i=0; i<9; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_tuple[i]); } + for (int i=0; i<151; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_codeobj_tab[i]); } + for (int i=0; i<292; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_string_tab[i]); } + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_0); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_10); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_100); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_4473905); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_21139105); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_28104183); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_37183945); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_79429044); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_82616482); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_89143876); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_124881844); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_149034610); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_166332997); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_178834394); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_190166812); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_198256870); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_210676054); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_217908684); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_223119700); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_242287462); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_258412278); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_neg_1); + return 0; +} +#endif +/* #### Code section: module_code ### */ + +/* "cfunc.to_py":67 + * @cname("__Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event") + * cdef object __Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event(object (*f)(Event) ): + * def wrap(Event event): # <<<<<<<<<<<<<< + * """wrap(event: 'Event')""" + * return f(event) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_11cfunc_dot_to_py_74__Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event_1wrap(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_11cfunc_dot_to_py_74__Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event_wrap, "wrap(event: 'Event')"); +static PyMethodDef __pyx_mdef_11cfunc_dot_to_py_74__Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event_1wrap = {"wrap", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_11cfunc_dot_to_py_74__Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event_1wrap, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_11cfunc_dot_to_py_74__Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event_wrap}; +static PyObject *__pyx_pw_11cfunc_dot_to_py_74__Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event_1wrap(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); - if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { - __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} - if (__pyx_kwds && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 1))) return -1; - __pyx_v_query = (__pyx_kwds) ? PyDict_Copy(__pyx_kwds) : PyDict_New(); if (unlikely(!__pyx_v_query)) return -1; - __Pyx_GOTREF(__pyx_v_query); - __pyx_r = __pyx_pf_6hunter_11_predicates_5Query___init__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self), __pyx_v_query); + __Pyx_RefNannySetupContext("wrap (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_event,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 67, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 67, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "wrap", 0) < 0) __PYX_ERR(1, 67, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("wrap", 1, 1, 1, i); __PYX_ERR(1, 67, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 67, __pyx_L3_error) + } + __pyx_v_event = ((struct __pyx_obj_6hunter_6_event_Event *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("wrap", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 67, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("cfunc.to_py.__Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event.wrap", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_event), __pyx_mstate_global->__pyx_ptype_6hunter_6_event_Event, 1, "event", 0))) __PYX_ERR(1, 67, __pyx_L1_error) + __pyx_r = __pyx_pf_11cfunc_dot_to_py_74__Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event_wrap(__pyx_self, __pyx_v_event); /* function exit code */ - __Pyx_XDECREF(__pyx_v_query); + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static int __pyx_pf_6hunter_11_predicates_5Query___init__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self, PyObject *__pyx_v_query) { - PyObject *__pyx_v_query_eq = NULL; - PyObject *__pyx_v_query_startswith = NULL; - PyObject *__pyx_v_query_endswith = NULL; - PyObject *__pyx_v_query_in = NULL; - PyObject *__pyx_v_query_contains = NULL; - PyObject *__pyx_v_query_regex = NULL; - PyObject *__pyx_v_query_lt = NULL; - PyObject *__pyx_v_query_lte = NULL; - PyObject *__pyx_v_query_gt = NULL; - PyObject *__pyx_v_query_gte = NULL; - PyObject *__pyx_v_key = NULL; - PyObject *__pyx_v_value = NULL; - PyObject *__pyx_v_parts = NULL; - Py_ssize_t __pyx_v_count; - PyObject *__pyx_v_prefix = NULL; - PyObject *__pyx_v_operator = NULL; - PyObject *__pyx_v_mapping = NULL; - PyObject *__pyx_7genexpr__pyx_v_p = NULL; - int __pyx_r; - __Pyx_TraceDeclarations +static PyObject *__pyx_pf_11cfunc_dot_to_py_74__Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event_wrap(PyObject *__pyx_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { + struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event *__pyx_cur_scope; + struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event *__pyx_outer_scope; + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - Py_ssize_t __pyx_t_2; - Py_ssize_t __pyx_t_3; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - int __pyx_t_7; - PyObject *__pyx_t_8 = NULL; - PyObject *__pyx_t_9 = NULL; - Py_ssize_t __pyx_t_10; - PyObject *(*__pyx_t_11)(PyObject *); - int __pyx_t_12; - int __pyx_t_13; - int __pyx_t_14; - int __pyx_t_15; - __Pyx_RefNannySetupContext("__init__", 0); - __Pyx_TraceCall("__init__", __pyx_f[0], 44, 0, __PYX_ERR(0, 44, __pyx_L1_error)); - - /* "hunter/_predicates.pyx":68 - * ``threadname``. - * """ - * query_eq = {} # <<<<<<<<<<<<<< - * query_startswith = {} - * query_endswith = {} - */ - __Pyx_TraceLine(68,0,__PYX_ERR(0, 68, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 68, __pyx_L1_error) + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[0])) + __Pyx_RefNannySetupContext("wrap", 0); + __pyx_outer_scope = (struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event *) __Pyx_CyFunction_GetClosure(__pyx_self); + __pyx_cur_scope = __pyx_outer_scope; + __Pyx_TraceStartFunc("wrap", __pyx_f[1], 67, 0, 0, 0, __PYX_ERR(1, 67, __pyx_L1_error)); + + /* "cfunc.to_py":69 + * def wrap(Event event): + * """wrap(event: 'Event')""" + * return f(event) # <<<<<<<<<<<<<< + * return wrap + * +*/ + __Pyx_TraceLine(69,1,0,__PYX_ERR(1, 69, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_cur_scope->__pyx_v_f(__pyx_v_event); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 69, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_v_query_eq = ((PyObject*)__pyx_t_1); + __pyx_r = __pyx_t_1; __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(1, 69, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":69 - * """ - * query_eq = {} - * query_startswith = {} # <<<<<<<<<<<<<< - * query_endswith = {} - * query_in = {} - */ - __Pyx_TraceLine(69,0,__PYX_ERR(0, 69, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 69, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v_query_startswith = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; + /* "cfunc.to_py":67 + * @cname("__Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event") + * cdef object __Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event(object (*f)(Event) ): + * def wrap(Event event): # <<<<<<<<<<<<<< + * """wrap(event: 'Event')""" + * return f(event) +*/ - /* "hunter/_predicates.pyx":70 - * query_eq = {} - * query_startswith = {} - * query_endswith = {} # <<<<<<<<<<<<<< - * query_in = {} - * query_contains = {} - */ - __Pyx_TraceLine(70,0,__PYX_ERR(0, 70, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 70, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v_query_endswith = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 67, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("cfunc.to_py.__Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event.wrap", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":71 - * query_startswith = {} - * query_endswith = {} - * query_in = {} # <<<<<<<<<<<<<< - * query_contains = {} - * query_regex = {} - */ - __Pyx_TraceLine(71,0,__PYX_ERR(0, 71, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 71, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v_query_in = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; +/* "cfunc.to_py":65 + * + * + * @cname("__Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event") # <<<<<<<<<<<<<< + * cdef object __Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event(object (*f)(Event) ): + * def wrap(Event event): +*/ - /* "hunter/_predicates.pyx":72 - * query_endswith = {} - * query_in = {} - * query_contains = {} # <<<<<<<<<<<<<< - * query_regex = {} - * query_lt = {} - */ - __Pyx_TraceLine(72,0,__PYX_ERR(0, 72, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 72, __pyx_L1_error) +static PyObject *__Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event(PyObject *(*__pyx_v_f)(struct __pyx_obj_6hunter_6_event_Event *)) { + struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event *__pyx_cur_scope; + PyObject *__pyx_v_wrap = 0; + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[1])) + __Pyx_RefNannySetupContext("__Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event", 0); + __pyx_cur_scope = (struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event *)__pyx_tp_new___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event(__pyx_mstate_global->__pyx_ptype___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event, __pyx_mstate_global->__pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(1, 65, __pyx_L1_error) + } else { + __Pyx_GOTREF((PyObject *)__pyx_cur_scope); + } + __Pyx_TraceStartFunc("__Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event", __pyx_f[1], 65, 0, 0, 0, __PYX_ERR(1, 65, __pyx_L1_error)); + __pyx_cur_scope->__pyx_v_f = __pyx_v_f; + + /* "cfunc.to_py":67 + * @cname("__Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event") + * cdef object __Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event(object (*f)(Event) ): + * def wrap(Event event): # <<<<<<<<<<<<<< + * """wrap(event: 'Event')""" + * return f(event) +*/ + __Pyx_TraceLine(67,1,0,__PYX_ERR(1, 67, __pyx_L1_error)) + __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_11cfunc_dot_to_py_74__Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event_1wrap, 0, __pyx_mstate_global->__pyx_n_u_Pyx_CFunc_6hunter_11_predicate, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_cfunc_to_py, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[0])); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 67, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_v_query_contains = ((PyObject*)__pyx_t_1); + __pyx_v_wrap = __pyx_t_1; __pyx_t_1 = 0; - /* "hunter/_predicates.pyx":73 - * query_in = {} - * query_contains = {} - * query_regex = {} # <<<<<<<<<<<<<< - * query_lt = {} - * query_lte = {} - */ - __Pyx_TraceLine(73,0,__PYX_ERR(0, 73, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 73, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v_query_regex = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; + /* "cfunc.to_py":70 + * """wrap(event: 'Event')""" + * return f(event) + * return wrap # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_TraceLine(70,2,0,__PYX_ERR(1, 70, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_wrap); + __pyx_r = __pyx_v_wrap; + __Pyx_TraceReturnValue(__pyx_r, 2, 0, __PYX_ERR(1, 70, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":74 - * query_contains = {} - * query_regex = {} - * query_lt = {} # <<<<<<<<<<<<<< - * query_lte = {} - * query_gt = {} - */ - __Pyx_TraceLine(74,0,__PYX_ERR(0, 74, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 74, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v_query_lt = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; + /* "cfunc.to_py":65 + * + * + * @cname("__Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event") # <<<<<<<<<<<<<< + * cdef object __Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event(object (*f)(Event) ): + * def wrap(Event event): +*/ - /* "hunter/_predicates.pyx":75 - * query_regex = {} - * query_lt = {} - * query_lte = {} # <<<<<<<<<<<<<< - * query_gt = {} - * query_gte = {} - */ - __Pyx_TraceLine(75,0,__PYX_ERR(0, 75, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 75, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v_query_lte = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 65, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("cfunc.to_py.__Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_wrap); + __Pyx_DECREF((PyObject *)__pyx_cur_scope); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":76 - * query_lt = {} - * query_lte = {} - * query_gt = {} # <<<<<<<<<<<<<< - * query_gte = {} +/* "hunter/_predicates.pyx":38 * - */ - __Pyx_TraceLine(76,0,__PYX_ERR(0, 76, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 76, __pyx_L1_error) + * ctypedef object (*Event_getter_typedef)(Event) + * cdef inline Event_get_function(Event event): return event.function_getter() # <<<<<<<<<<<<<< + * cdef inline Event_get_module(Event event): return event.module_getter() + * cdef inline Event_get_lineno(Event event): return event.lineno_getter() +*/ + +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_function(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[2])) + __Pyx_RefNannySetupContext("Event_get_function", 0); + __Pyx_TraceStartFunc("Event_get_function", __pyx_f[0], 38, 0, 0, 0, __PYX_ERR(0, 38, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((struct __pyx_vtabstruct_6hunter_6_event_Event *)__pyx_v_event->__pyx_vtab)->function_getter(__pyx_v_event); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 38, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_v_query_gt = ((PyObject*)__pyx_t_1); + __pyx_r = __pyx_t_1; __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 38, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":77 - * query_lte = {} - * query_gt = {} - * query_gte = {} # <<<<<<<<<<<<<< - * - * for key, value in query.items(): - */ - __Pyx_TraceLine(77,0,__PYX_ERR(0, 77, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error) + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 38, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Event_get_function", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/_predicates.pyx":39 + * ctypedef object (*Event_getter_typedef)(Event) + * cdef inline Event_get_function(Event event): return event.function_getter() + * cdef inline Event_get_module(Event event): return event.module_getter() # <<<<<<<<<<<<<< + * cdef inline Event_get_lineno(Event event): return event.lineno_getter() + * cdef inline Event_get_globals(Event event): return event.globals_getter() +*/ + +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_module(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[3])) + __Pyx_RefNannySetupContext("Event_get_module", 0); + __Pyx_TraceStartFunc("Event_get_module", __pyx_f[0], 39, 0, 0, 0, __PYX_ERR(0, 39, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((struct __pyx_vtabstruct_6hunter_6_event_Event *)__pyx_v_event->__pyx_vtab)->module_getter(__pyx_v_event); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 39, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_v_query_gte = ((PyObject*)__pyx_t_1); + __pyx_r = __pyx_t_1; __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 39, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":79 - * query_gte = {} - * - * for key, value in query.items(): # <<<<<<<<<<<<<< - * parts = [p for p in key.split('_') if p] - * count = len(parts) - */ - __Pyx_TraceLine(79,0,__PYX_ERR(0, 79, __pyx_L1_error)) - __pyx_t_2 = 0; - __pyx_t_5 = __Pyx_dict_iterator(__pyx_v_query, 1, __pyx_n_s_items, (&__pyx_t_3), (&__pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 79, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); + /* function exit code */ + __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __pyx_t_1 = __pyx_t_5; - __pyx_t_5 = 0; - while (1) { - __pyx_t_7 = __Pyx_dict_iter_next(__pyx_t_1, __pyx_t_3, &__pyx_t_2, &__pyx_t_5, &__pyx_t_6, NULL, __pyx_t_4); - if (unlikely(__pyx_t_7 == 0)) break; - if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 79, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GOTREF(__pyx_t_6); - __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_5); - __pyx_t_5 = 0; - __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_6); - __pyx_t_6 = 0; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 39, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Event_get_module", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":80 - * - * for key, value in query.items(): - * parts = [p for p in key.split('_') if p] # <<<<<<<<<<<<<< - * count = len(parts) - * if count > 2: - */ - __Pyx_TraceLine(80,0,__PYX_ERR(0, 80, __pyx_L1_error)) - { /* enter inner scope */ - __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 80, __pyx_L7_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_key, __pyx_n_s_split); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 80, __pyx_L7_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_9 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) { - __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); - if (likely(__pyx_t_9)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); - __Pyx_INCREF(__pyx_t_9); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_8, function); - } - } - __pyx_t_5 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_9, __pyx_n_s_) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_n_s_); - __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 80, __pyx_L7_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (likely(PyList_CheckExact(__pyx_t_5)) || PyTuple_CheckExact(__pyx_t_5)) { - __pyx_t_8 = __pyx_t_5; __Pyx_INCREF(__pyx_t_8); __pyx_t_10 = 0; - __pyx_t_11 = NULL; - } else { - __pyx_t_10 = -1; __pyx_t_8 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 80, __pyx_L7_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_11 = Py_TYPE(__pyx_t_8)->tp_iternext; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 80, __pyx_L7_error) - } - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - for (;;) { - if (likely(!__pyx_t_11)) { - if (likely(PyList_CheckExact(__pyx_t_8))) { - if (__pyx_t_10 >= PyList_GET_SIZE(__pyx_t_8)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_5 = PyList_GET_ITEM(__pyx_t_8, __pyx_t_10); __Pyx_INCREF(__pyx_t_5); __pyx_t_10++; if (unlikely(0 < 0)) __PYX_ERR(0, 80, __pyx_L7_error) - #else - __pyx_t_5 = PySequence_ITEM(__pyx_t_8, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 80, __pyx_L7_error) - __Pyx_GOTREF(__pyx_t_5); - #endif - } else { - if (__pyx_t_10 >= PyTuple_GET_SIZE(__pyx_t_8)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_8, __pyx_t_10); __Pyx_INCREF(__pyx_t_5); __pyx_t_10++; if (unlikely(0 < 0)) __PYX_ERR(0, 80, __pyx_L7_error) - #else - __pyx_t_5 = PySequence_ITEM(__pyx_t_8, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 80, __pyx_L7_error) - __Pyx_GOTREF(__pyx_t_5); - #endif - } - } else { - __pyx_t_5 = __pyx_t_11(__pyx_t_8); - if (unlikely(!__pyx_t_5)) { - PyObject* exc_type = PyErr_Occurred(); - if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(0, 80, __pyx_L7_error) - } - break; - } - __Pyx_GOTREF(__pyx_t_5); - } - __Pyx_XDECREF_SET(__pyx_7genexpr__pyx_v_p, __pyx_t_5); - __pyx_t_5 = 0; - __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_7genexpr__pyx_v_p); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 80, __pyx_L7_error) - if (__pyx_t_12) { - if (unlikely(__Pyx_ListComp_Append(__pyx_t_6, (PyObject*)__pyx_7genexpr__pyx_v_p))) __PYX_ERR(0, 80, __pyx_L7_error) - } - } - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_XDECREF(__pyx_7genexpr__pyx_v_p); __pyx_7genexpr__pyx_v_p = 0; - goto __pyx_L11_exit_scope; - __pyx_L7_error:; - __Pyx_XDECREF(__pyx_7genexpr__pyx_v_p); __pyx_7genexpr__pyx_v_p = 0; - goto __pyx_L1_error; - __pyx_L11_exit_scope:; - } /* exit inner scope */ - __Pyx_XDECREF_SET(__pyx_v_parts, ((PyObject*)__pyx_t_6)); - __pyx_t_6 = 0; +/* "hunter/_predicates.pyx":40 + * cdef inline Event_get_function(Event event): return event.function_getter() + * cdef inline Event_get_module(Event event): return event.module_getter() + * cdef inline Event_get_lineno(Event event): return event.lineno_getter() # <<<<<<<<<<<<<< + * cdef inline Event_get_globals(Event event): return event.globals_getter() + * cdef inline Event_get_stdlib(Event event): return event.stdlib_getter() +*/ - /* "hunter/_predicates.pyx":81 - * for key, value in query.items(): - * parts = [p for p in key.split('_') if p] - * count = len(parts) # <<<<<<<<<<<<<< - * if count > 2: - * raise TypeError('Unexpected argument %r. Must be one of %s with optional operators like: %s' % ( - */ - __Pyx_TraceLine(81,0,__PYX_ERR(0, 81, __pyx_L1_error)) - __pyx_t_10 = PyList_GET_SIZE(__pyx_v_parts); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(0, 81, __pyx_L1_error) - __pyx_v_count = __pyx_t_10; +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_lineno(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[4])) + __Pyx_RefNannySetupContext("Event_get_lineno", 0); + __Pyx_TraceStartFunc("Event_get_lineno", __pyx_f[0], 40, 0, 0, 0, __PYX_ERR(0, 40, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((struct __pyx_vtabstruct_6hunter_6_event_Event *)__pyx_v_event->__pyx_vtab)->lineno_getter(__pyx_v_event); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 40, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 40, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":82 - * parts = [p for p in key.split('_') if p] - * count = len(parts) - * if count > 2: # <<<<<<<<<<<<<< - * raise TypeError('Unexpected argument %r. Must be one of %s with optional operators like: %s' % ( - * key, ALLOWED_KEYS, ALLOWED_OPERATORS - */ - __Pyx_TraceLine(82,0,__PYX_ERR(0, 82, __pyx_L1_error)) - __pyx_t_12 = ((__pyx_v_count > 2) != 0); - if (unlikely(__pyx_t_12)) { + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 40, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Event_get_lineno", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":84 - * if count > 2: - * raise TypeError('Unexpected argument %r. Must be one of %s with optional operators like: %s' % ( - * key, ALLOWED_KEYS, ALLOWED_OPERATORS # <<<<<<<<<<<<<< - * )) - * elif count == 2: - */ - __Pyx_TraceLine(84,0,__PYX_ERR(0, 84, __pyx_L1_error)) - __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 84, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_INCREF(__pyx_v_key); - __Pyx_GIVEREF(__pyx_v_key); - PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_v_key); - __Pyx_INCREF(__pyx_v_6hunter_11_predicates_ALLOWED_KEYS); - __Pyx_GIVEREF(__pyx_v_6hunter_11_predicates_ALLOWED_KEYS); - PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_v_6hunter_11_predicates_ALLOWED_KEYS); - __Pyx_INCREF(__pyx_v_6hunter_11_predicates_ALLOWED_OPERATORS); - __Pyx_GIVEREF(__pyx_v_6hunter_11_predicates_ALLOWED_OPERATORS); - PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_v_6hunter_11_predicates_ALLOWED_OPERATORS); - - /* "hunter/_predicates.pyx":83 - * count = len(parts) - * if count > 2: - * raise TypeError('Unexpected argument %r. Must be one of %s with optional operators like: %s' % ( # <<<<<<<<<<<<<< - * key, ALLOWED_KEYS, ALLOWED_OPERATORS - * )) - */ - __Pyx_TraceLine(83,0,__PYX_ERR(0, 83, __pyx_L1_error)) - __pyx_t_8 = __Pyx_PyString_Format(__pyx_kp_s_Unexpected_argument_r_Must_be_on, __pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 83, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 83, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 83, __pyx_L1_error) +/* "hunter/_predicates.pyx":41 + * cdef inline Event_get_module(Event event): return event.module_getter() + * cdef inline Event_get_lineno(Event event): return event.lineno_getter() + * cdef inline Event_get_globals(Event event): return event.globals_getter() # <<<<<<<<<<<<<< + * cdef inline Event_get_stdlib(Event event): return event.stdlib_getter() + * cdef inline Event_get_arg(Event event): return event.arg +*/ - /* "hunter/_predicates.pyx":82 - * parts = [p for p in key.split('_') if p] - * count = len(parts) - * if count > 2: # <<<<<<<<<<<<<< - * raise TypeError('Unexpected argument %r. Must be one of %s with optional operators like: %s' % ( - * key, ALLOWED_KEYS, ALLOWED_OPERATORS - */ - } +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_globals(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[5])) + __Pyx_RefNannySetupContext("Event_get_globals", 0); + __Pyx_TraceStartFunc("Event_get_globals", __pyx_f[0], 41, 0, 0, 0, __PYX_ERR(0, 41, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((struct __pyx_vtabstruct_6hunter_6_event_Event *)__pyx_v_event->__pyx_vtab)->globals_getter(__pyx_v_event); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 41, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 41, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":86 - * key, ALLOWED_KEYS, ALLOWED_OPERATORS - * )) - * elif count == 2: # <<<<<<<<<<<<<< - * prefix, operator = parts - * if operator in ('startswith', 'sw'): - */ - __Pyx_TraceLine(86,0,__PYX_ERR(0, 86, __pyx_L1_error)) - __pyx_t_12 = ((__pyx_v_count == 2) != 0); - if (__pyx_t_12) { + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 41, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Event_get_globals", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":87 - * )) - * elif count == 2: - * prefix, operator = parts # <<<<<<<<<<<<<< - * if operator in ('startswith', 'sw'): - * if not isinstance(value, basestring): - */ - __Pyx_TraceLine(87,0,__PYX_ERR(0, 87, __pyx_L1_error)) - if (1) { - PyObject* sequence = __pyx_v_parts; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 87, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_6 = PyList_GET_ITEM(sequence, 0); - __pyx_t_8 = PyList_GET_ITEM(sequence, 1); - __Pyx_INCREF(__pyx_t_6); - __Pyx_INCREF(__pyx_t_8); - #else - __pyx_t_6 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - #endif - } - __Pyx_XDECREF_SET(__pyx_v_prefix, __pyx_t_6); - __pyx_t_6 = 0; - __Pyx_XDECREF_SET(__pyx_v_operator, __pyx_t_8); - __pyx_t_8 = 0; +/* "hunter/_predicates.pyx":42 + * cdef inline Event_get_lineno(Event event): return event.lineno_getter() + * cdef inline Event_get_globals(Event event): return event.globals_getter() + * cdef inline Event_get_stdlib(Event event): return event.stdlib_getter() # <<<<<<<<<<<<<< + * cdef inline Event_get_arg(Event event): return event.arg + * cdef inline Event_get_locals(Event event): return event.locals_getter() +*/ - /* "hunter/_predicates.pyx":88 - * elif count == 2: - * prefix, operator = parts - * if operator in ('startswith', 'sw'): # <<<<<<<<<<<<<< - * if not isinstance(value, basestring): - * if not isinstance(value, (list, set, tuple)): - */ - __Pyx_TraceLine(88,0,__PYX_ERR(0, 88, __pyx_L1_error)) - __Pyx_INCREF(__pyx_v_operator); - __pyx_t_8 = __pyx_v_operator; - __pyx_t_13 = (__Pyx_PyString_Equals(__pyx_t_8, __pyx_n_s_startswith, Py_EQ)); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 88, __pyx_L1_error) - if (!__pyx_t_13) { - } else { - __pyx_t_12 = __pyx_t_13; - goto __pyx_L14_bool_binop_done; - } - __pyx_t_13 = (__Pyx_PyString_Equals(__pyx_t_8, __pyx_n_s_sw, Py_EQ)); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 88, __pyx_L1_error) - __pyx_t_12 = __pyx_t_13; - __pyx_L14_bool_binop_done:; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_13 = (__pyx_t_12 != 0); - if (__pyx_t_13) { +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_stdlib(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[6])) + __Pyx_RefNannySetupContext("Event_get_stdlib", 0); + __Pyx_TraceStartFunc("Event_get_stdlib", __pyx_f[0], 42, 0, 0, 0, __PYX_ERR(0, 42, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((struct __pyx_vtabstruct_6hunter_6_event_Event *)__pyx_v_event->__pyx_vtab)->stdlib_getter(__pyx_v_event); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 42, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":89 - * prefix, operator = parts - * if operator in ('startswith', 'sw'): - * if not isinstance(value, basestring): # <<<<<<<<<<<<<< - * if not isinstance(value, (list, set, tuple)): - * raise ValueError('Value %r for %r is invalid. Must be a string, list, tuple or set.' % (value, key)) - */ - __Pyx_TraceLine(89,0,__PYX_ERR(0, 89, __pyx_L1_error)) - __pyx_t_13 = __Pyx_PyBaseString_Check(__pyx_v_value); - __pyx_t_12 = ((!(__pyx_t_13 != 0)) != 0); - if (__pyx_t_12) { + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 42, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Event_get_stdlib", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":90 - * if operator in ('startswith', 'sw'): - * if not isinstance(value, basestring): - * if not isinstance(value, (list, set, tuple)): # <<<<<<<<<<<<<< - * raise ValueError('Value %r for %r is invalid. Must be a string, list, tuple or set.' % (value, key)) - * value = tuple(value) - */ - __Pyx_TraceLine(90,0,__PYX_ERR(0, 90, __pyx_L1_error)) - __pyx_t_13 = PyList_Check(__pyx_v_value); - __pyx_t_14 = (__pyx_t_13 != 0); - if (!__pyx_t_14) { - } else { - __pyx_t_12 = __pyx_t_14; - goto __pyx_L18_bool_binop_done; - } - __pyx_t_14 = PySet_Check(__pyx_v_value); - __pyx_t_13 = (__pyx_t_14 != 0); - if (!__pyx_t_13) { - } else { - __pyx_t_12 = __pyx_t_13; - goto __pyx_L18_bool_binop_done; - } - __pyx_t_13 = PyTuple_Check(__pyx_v_value); - __pyx_t_14 = (__pyx_t_13 != 0); - __pyx_t_12 = __pyx_t_14; - __pyx_L18_bool_binop_done:; - __pyx_t_14 = ((!(__pyx_t_12 != 0)) != 0); - if (unlikely(__pyx_t_14)) { - - /* "hunter/_predicates.pyx":91 - * if not isinstance(value, basestring): - * if not isinstance(value, (list, set, tuple)): - * raise ValueError('Value %r for %r is invalid. Must be a string, list, tuple or set.' % (value, key)) # <<<<<<<<<<<<<< - * value = tuple(value) - * mapping = query_startswith - */ - __Pyx_TraceLine(91,0,__PYX_ERR(0, 91, __pyx_L1_error)) - __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 91, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_INCREF(__pyx_v_value); - __Pyx_GIVEREF(__pyx_v_value); - PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_value); - __Pyx_INCREF(__pyx_v_key); - __Pyx_GIVEREF(__pyx_v_key); - PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_v_key); - __pyx_t_6 = __Pyx_PyString_Format(__pyx_kp_s_Value_r_for_r_is_invalid_Must_be, __pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 91, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 91, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 91, __pyx_L1_error) +/* "hunter/_predicates.pyx":43 + * cdef inline Event_get_globals(Event event): return event.globals_getter() + * cdef inline Event_get_stdlib(Event event): return event.stdlib_getter() + * cdef inline Event_get_arg(Event event): return event.arg # <<<<<<<<<<<<<< + * cdef inline Event_get_locals(Event event): return event.locals_getter() + * cdef inline Event_get_kind(Event event): return event.kind +*/ - /* "hunter/_predicates.pyx":90 - * if operator in ('startswith', 'sw'): - * if not isinstance(value, basestring): - * if not isinstance(value, (list, set, tuple)): # <<<<<<<<<<<<<< - * raise ValueError('Value %r for %r is invalid. Must be a string, list, tuple or set.' % (value, key)) - * value = tuple(value) - */ - } +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_arg(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[7])) + __Pyx_RefNannySetupContext("Event_get_arg", 0); + __Pyx_TraceStartFunc("Event_get_arg", __pyx_f[0], 43, 0, 0, 0, __PYX_ERR(0, 43, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_event->arg); + __pyx_r = __pyx_v_event->arg; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 43, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":92 - * if not isinstance(value, (list, set, tuple)): - * raise ValueError('Value %r for %r is invalid. Must be a string, list, tuple or set.' % (value, key)) - * value = tuple(value) # <<<<<<<<<<<<<< - * mapping = query_startswith - * elif operator in ('endswith', 'ew'): - */ - __Pyx_TraceLine(92,0,__PYX_ERR(0, 92, __pyx_L1_error)) - __pyx_t_8 = __Pyx_PySequence_Tuple(__pyx_v_value); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 92, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_8); - __pyx_t_8 = 0; + /* function exit code */ + __pyx_L1_error:; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 43, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Event_get_arg", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":89 - * prefix, operator = parts - * if operator in ('startswith', 'sw'): - * if not isinstance(value, basestring): # <<<<<<<<<<<<<< - * if not isinstance(value, (list, set, tuple)): - * raise ValueError('Value %r for %r is invalid. Must be a string, list, tuple or set.' % (value, key)) - */ - } - - /* "hunter/_predicates.pyx":93 - * raise ValueError('Value %r for %r is invalid. Must be a string, list, tuple or set.' % (value, key)) - * value = tuple(value) - * mapping = query_startswith # <<<<<<<<<<<<<< - * elif operator in ('endswith', 'ew'): - * if not isinstance(value, basestring): - */ - __Pyx_TraceLine(93,0,__PYX_ERR(0, 93, __pyx_L1_error)) - __Pyx_INCREF(__pyx_v_query_startswith); - __Pyx_XDECREF_SET(__pyx_v_mapping, __pyx_v_query_startswith); +/* "hunter/_predicates.pyx":44 + * cdef inline Event_get_stdlib(Event event): return event.stdlib_getter() + * cdef inline Event_get_arg(Event event): return event.arg + * cdef inline Event_get_locals(Event event): return event.locals_getter() # <<<<<<<<<<<<<< + * cdef inline Event_get_kind(Event event): return event.kind + * cdef inline Event_get_filename(Event event): return event.filename_getter() +*/ + +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_locals(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[8])) + __Pyx_RefNannySetupContext("Event_get_locals", 0); + __Pyx_TraceStartFunc("Event_get_locals", __pyx_f[0], 44, 0, 0, 0, __PYX_ERR(0, 44, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((struct __pyx_vtabstruct_6hunter_6_event_Event *)__pyx_v_event->__pyx_vtab)->locals_getter(__pyx_v_event); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 44, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 44, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":88 - * elif count == 2: - * prefix, operator = parts - * if operator in ('startswith', 'sw'): # <<<<<<<<<<<<<< - * if not isinstance(value, basestring): - * if not isinstance(value, (list, set, tuple)): - */ - goto __pyx_L13; - } + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 44, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Event_get_locals", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":94 - * value = tuple(value) - * mapping = query_startswith - * elif operator in ('endswith', 'ew'): # <<<<<<<<<<<<<< - * if not isinstance(value, basestring): - * if not isinstance(value, (list, set, tuple)): - */ - __Pyx_TraceLine(94,0,__PYX_ERR(0, 94, __pyx_L1_error)) - __Pyx_INCREF(__pyx_v_operator); - __pyx_t_8 = __pyx_v_operator; - __pyx_t_12 = (__Pyx_PyString_Equals(__pyx_t_8, __pyx_n_s_endswith, Py_EQ)); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 94, __pyx_L1_error) - if (!__pyx_t_12) { - } else { - __pyx_t_14 = __pyx_t_12; - goto __pyx_L21_bool_binop_done; - } - __pyx_t_12 = (__Pyx_PyString_Equals(__pyx_t_8, __pyx_n_s_ew, Py_EQ)); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 94, __pyx_L1_error) - __pyx_t_14 = __pyx_t_12; - __pyx_L21_bool_binop_done:; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_12 = (__pyx_t_14 != 0); - if (__pyx_t_12) { +/* "hunter/_predicates.pyx":45 + * cdef inline Event_get_arg(Event event): return event.arg + * cdef inline Event_get_locals(Event event): return event.locals_getter() + * cdef inline Event_get_kind(Event event): return event.kind # <<<<<<<<<<<<<< + * cdef inline Event_get_filename(Event event): return event.filename_getter() + * cdef inline Event_get_source(Event event): return event.source_getter() +*/ - /* "hunter/_predicates.pyx":95 - * mapping = query_startswith - * elif operator in ('endswith', 'ew'): - * if not isinstance(value, basestring): # <<<<<<<<<<<<<< - * if not isinstance(value, (list, set, tuple)): - * raise ValueError('Value %r for %r is invalid. Must be a string, list, tuple or set.' % (value, key)) - */ - __Pyx_TraceLine(95,0,__PYX_ERR(0, 95, __pyx_L1_error)) - __pyx_t_12 = __Pyx_PyBaseString_Check(__pyx_v_value); - __pyx_t_14 = ((!(__pyx_t_12 != 0)) != 0); - if (__pyx_t_14) { +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_kind(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[9])) + __Pyx_RefNannySetupContext("Event_get_kind", 0); + __Pyx_TraceStartFunc("Event_get_kind", __pyx_f[0], 45, 0, 0, 0, __PYX_ERR(0, 45, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_event->kind); + __pyx_r = __pyx_v_event->kind; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 45, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":96 - * elif operator in ('endswith', 'ew'): - * if not isinstance(value, basestring): - * if not isinstance(value, (list, set, tuple)): # <<<<<<<<<<<<<< - * raise ValueError('Value %r for %r is invalid. Must be a string, list, tuple or set.' % (value, key)) - * value = tuple(value) - */ - __Pyx_TraceLine(96,0,__PYX_ERR(0, 96, __pyx_L1_error)) - __pyx_t_12 = PyList_Check(__pyx_v_value); - __pyx_t_13 = (__pyx_t_12 != 0); - if (!__pyx_t_13) { - } else { - __pyx_t_14 = __pyx_t_13; - goto __pyx_L25_bool_binop_done; - } - __pyx_t_13 = PySet_Check(__pyx_v_value); - __pyx_t_12 = (__pyx_t_13 != 0); - if (!__pyx_t_12) { - } else { - __pyx_t_14 = __pyx_t_12; - goto __pyx_L25_bool_binop_done; - } - __pyx_t_12 = PyTuple_Check(__pyx_v_value); - __pyx_t_13 = (__pyx_t_12 != 0); - __pyx_t_14 = __pyx_t_13; - __pyx_L25_bool_binop_done:; - __pyx_t_13 = ((!(__pyx_t_14 != 0)) != 0); - if (unlikely(__pyx_t_13)) { + /* function exit code */ + __pyx_L1_error:; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 45, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Event_get_kind", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":97 - * if not isinstance(value, basestring): - * if not isinstance(value, (list, set, tuple)): - * raise ValueError('Value %r for %r is invalid. Must be a string, list, tuple or set.' % (value, key)) # <<<<<<<<<<<<<< - * value = tuple(value) - * mapping = query_endswith - */ - __Pyx_TraceLine(97,0,__PYX_ERR(0, 97, __pyx_L1_error)) - __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 97, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_INCREF(__pyx_v_value); - __Pyx_GIVEREF(__pyx_v_value); - PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_value); - __Pyx_INCREF(__pyx_v_key); - __Pyx_GIVEREF(__pyx_v_key); - PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_v_key); - __pyx_t_6 = __Pyx_PyString_Format(__pyx_kp_s_Value_r_for_r_is_invalid_Must_be, __pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 97, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 97, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 97, __pyx_L1_error) +/* "hunter/_predicates.pyx":46 + * cdef inline Event_get_locals(Event event): return event.locals_getter() + * cdef inline Event_get_kind(Event event): return event.kind + * cdef inline Event_get_filename(Event event): return event.filename_getter() # <<<<<<<<<<<<<< + * cdef inline Event_get_source(Event event): return event.source_getter() + * cdef inline Event_get_fullsource(Event event): return event.fullsource_getter() +*/ - /* "hunter/_predicates.pyx":96 - * elif operator in ('endswith', 'ew'): - * if not isinstance(value, basestring): - * if not isinstance(value, (list, set, tuple)): # <<<<<<<<<<<<<< - * raise ValueError('Value %r for %r is invalid. Must be a string, list, tuple or set.' % (value, key)) - * value = tuple(value) - */ - } +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_filename(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[10])) + __Pyx_RefNannySetupContext("Event_get_filename", 0); + __Pyx_TraceStartFunc("Event_get_filename", __pyx_f[0], 46, 0, 0, 0, __PYX_ERR(0, 46, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((struct __pyx_vtabstruct_6hunter_6_event_Event *)__pyx_v_event->__pyx_vtab)->filename_getter(__pyx_v_event); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 46, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 46, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":98 - * if not isinstance(value, (list, set, tuple)): - * raise ValueError('Value %r for %r is invalid. Must be a string, list, tuple or set.' % (value, key)) - * value = tuple(value) # <<<<<<<<<<<<<< - * mapping = query_endswith - * elif operator == 'in': - */ - __Pyx_TraceLine(98,0,__PYX_ERR(0, 98, __pyx_L1_error)) - __pyx_t_8 = __Pyx_PySequence_Tuple(__pyx_v_value); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 98, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_8); - __pyx_t_8 = 0; + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 46, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Event_get_filename", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":95 - * mapping = query_startswith - * elif operator in ('endswith', 'ew'): - * if not isinstance(value, basestring): # <<<<<<<<<<<<<< - * if not isinstance(value, (list, set, tuple)): - * raise ValueError('Value %r for %r is invalid. Must be a string, list, tuple or set.' % (value, key)) - */ - } +/* "hunter/_predicates.pyx":47 + * cdef inline Event_get_kind(Event event): return event.kind + * cdef inline Event_get_filename(Event event): return event.filename_getter() + * cdef inline Event_get_source(Event event): return event.source_getter() # <<<<<<<<<<<<<< + * cdef inline Event_get_fullsource(Event event): return event.fullsource_getter() + * cdef inline Event_get_threadname(Event event): return event.threadname_getter() +*/ - /* "hunter/_predicates.pyx":99 - * raise ValueError('Value %r for %r is invalid. Must be a string, list, tuple or set.' % (value, key)) - * value = tuple(value) - * mapping = query_endswith # <<<<<<<<<<<<<< - * elif operator == 'in': - * mapping = query_in - */ - __Pyx_TraceLine(99,0,__PYX_ERR(0, 99, __pyx_L1_error)) - __Pyx_INCREF(__pyx_v_query_endswith); - __Pyx_XDECREF_SET(__pyx_v_mapping, __pyx_v_query_endswith); +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_source(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[11])) + __Pyx_RefNannySetupContext("Event_get_source", 0); + __Pyx_TraceStartFunc("Event_get_source", __pyx_f[0], 47, 0, 0, 0, __PYX_ERR(0, 47, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((struct __pyx_vtabstruct_6hunter_6_event_Event *)__pyx_v_event->__pyx_vtab)->source_getter(__pyx_v_event); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 47, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":94 - * value = tuple(value) - * mapping = query_startswith - * elif operator in ('endswith', 'ew'): # <<<<<<<<<<<<<< - * if not isinstance(value, basestring): - * if not isinstance(value, (list, set, tuple)): - */ - goto __pyx_L13; - } + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 47, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Event_get_source", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":100 - * value = tuple(value) - * mapping = query_endswith - * elif operator == 'in': # <<<<<<<<<<<<<< - * mapping = query_in - * elif operator in ('contains', 'has'): - */ - __Pyx_TraceLine(100,0,__PYX_ERR(0, 100, __pyx_L1_error)) - __pyx_t_13 = (__Pyx_PyString_Equals(__pyx_v_operator, __pyx_n_s_in, Py_EQ)); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 100, __pyx_L1_error) - if (__pyx_t_13) { +/* "hunter/_predicates.pyx":48 + * cdef inline Event_get_filename(Event event): return event.filename_getter() + * cdef inline Event_get_source(Event event): return event.source_getter() + * cdef inline Event_get_fullsource(Event event): return event.fullsource_getter() # <<<<<<<<<<<<<< + * cdef inline Event_get_threadname(Event event): return event.threadname_getter() + * cdef inline Event_get_threadid(Event event): return event.threadid_getter() +*/ - /* "hunter/_predicates.pyx":101 - * mapping = query_endswith - * elif operator == 'in': - * mapping = query_in # <<<<<<<<<<<<<< - * elif operator in ('contains', 'has'): - * mapping = query_contains - */ - __Pyx_TraceLine(101,0,__PYX_ERR(0, 101, __pyx_L1_error)) - __Pyx_INCREF(__pyx_v_query_in); - __Pyx_XDECREF_SET(__pyx_v_mapping, __pyx_v_query_in); +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_fullsource(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[12])) + __Pyx_RefNannySetupContext("Event_get_fullsource", 0); + __Pyx_TraceStartFunc("Event_get_fullsource", __pyx_f[0], 48, 0, 0, 0, __PYX_ERR(0, 48, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((struct __pyx_vtabstruct_6hunter_6_event_Event *)__pyx_v_event->__pyx_vtab)->fullsource_getter(__pyx_v_event); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 48, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":100 - * value = tuple(value) - * mapping = query_endswith - * elif operator == 'in': # <<<<<<<<<<<<<< - * mapping = query_in - * elif operator in ('contains', 'has'): - */ - goto __pyx_L13; - } + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 48, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Event_get_fullsource", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":102 - * elif operator == 'in': - * mapping = query_in - * elif operator in ('contains', 'has'): # <<<<<<<<<<<<<< - * mapping = query_contains - * elif operator in ('regex', 'rx'): - */ - __Pyx_TraceLine(102,0,__PYX_ERR(0, 102, __pyx_L1_error)) - __Pyx_INCREF(__pyx_v_operator); - __pyx_t_8 = __pyx_v_operator; - __pyx_t_14 = (__Pyx_PyString_Equals(__pyx_t_8, __pyx_n_s_contains, Py_EQ)); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 102, __pyx_L1_error) - if (!__pyx_t_14) { - } else { - __pyx_t_13 = __pyx_t_14; - goto __pyx_L28_bool_binop_done; - } - __pyx_t_14 = (__Pyx_PyString_Equals(__pyx_t_8, __pyx_n_s_has, Py_EQ)); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 102, __pyx_L1_error) - __pyx_t_13 = __pyx_t_14; - __pyx_L28_bool_binop_done:; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_14 = (__pyx_t_13 != 0); - if (__pyx_t_14) { +/* "hunter/_predicates.pyx":49 + * cdef inline Event_get_source(Event event): return event.source_getter() + * cdef inline Event_get_fullsource(Event event): return event.fullsource_getter() + * cdef inline Event_get_threadname(Event event): return event.threadname_getter() # <<<<<<<<<<<<<< + * cdef inline Event_get_threadid(Event event): return event.threadid_getter() + * cdef inline Event_get_instruction(Event event): return event.instruction_getter() +*/ - /* "hunter/_predicates.pyx":103 - * mapping = query_in - * elif operator in ('contains', 'has'): - * mapping = query_contains # <<<<<<<<<<<<<< - * elif operator in ('regex', 'rx'): - * value = re.compile(value) - */ - __Pyx_TraceLine(103,0,__PYX_ERR(0, 103, __pyx_L1_error)) - __Pyx_INCREF(__pyx_v_query_contains); - __Pyx_XDECREF_SET(__pyx_v_mapping, __pyx_v_query_contains); +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_threadname(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[13])) + __Pyx_RefNannySetupContext("Event_get_threadname", 0); + __Pyx_TraceStartFunc("Event_get_threadname", __pyx_f[0], 49, 0, 0, 0, __PYX_ERR(0, 49, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((struct __pyx_vtabstruct_6hunter_6_event_Event *)__pyx_v_event->__pyx_vtab)->threadname_getter(__pyx_v_event); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 49, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":102 - * elif operator == 'in': - * mapping = query_in - * elif operator in ('contains', 'has'): # <<<<<<<<<<<<<< - * mapping = query_contains - * elif operator in ('regex', 'rx'): - */ - goto __pyx_L13; - } + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 49, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Event_get_threadname", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":104 - * elif operator in ('contains', 'has'): - * mapping = query_contains - * elif operator in ('regex', 'rx'): # <<<<<<<<<<<<<< - * value = re.compile(value) - * mapping = query_regex - */ - __Pyx_TraceLine(104,0,__PYX_ERR(0, 104, __pyx_L1_error)) - __Pyx_INCREF(__pyx_v_operator); - __pyx_t_8 = __pyx_v_operator; - __pyx_t_13 = (__Pyx_PyString_Equals(__pyx_t_8, __pyx_n_s_regex, Py_EQ)); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 104, __pyx_L1_error) - if (!__pyx_t_13) { - } else { - __pyx_t_14 = __pyx_t_13; - goto __pyx_L30_bool_binop_done; - } - __pyx_t_13 = (__Pyx_PyString_Equals(__pyx_t_8, __pyx_n_s_rx, Py_EQ)); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 104, __pyx_L1_error) - __pyx_t_14 = __pyx_t_13; - __pyx_L30_bool_binop_done:; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_13 = (__pyx_t_14 != 0); - if (__pyx_t_13) { +/* "hunter/_predicates.pyx":50 + * cdef inline Event_get_fullsource(Event event): return event.fullsource_getter() + * cdef inline Event_get_threadname(Event event): return event.threadname_getter() + * cdef inline Event_get_threadid(Event event): return event.threadid_getter() # <<<<<<<<<<<<<< + * cdef inline Event_get_instruction(Event event): return event.instruction_getter() + * cdef inline Event_get_depth(Event event): return event.depth +*/ - /* "hunter/_predicates.pyx":105 - * mapping = query_contains - * elif operator in ('regex', 'rx'): - * value = re.compile(value) # <<<<<<<<<<<<<< - * mapping = query_regex - * elif operator == 'lt': - */ - __Pyx_TraceLine(105,0,__PYX_ERR(0, 105, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_re); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 105, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_compile); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 105, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_6)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_6); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - } - } - __pyx_t_8 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_value); - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 105, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_8); - __pyx_t_8 = 0; +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_threadid(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[14])) + __Pyx_RefNannySetupContext("Event_get_threadid", 0); + __Pyx_TraceStartFunc("Event_get_threadid", __pyx_f[0], 50, 0, 0, 0, __PYX_ERR(0, 50, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((struct __pyx_vtabstruct_6hunter_6_event_Event *)__pyx_v_event->__pyx_vtab)->threadid_getter(__pyx_v_event); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 50, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":106 - * elif operator in ('regex', 'rx'): - * value = re.compile(value) - * mapping = query_regex # <<<<<<<<<<<<<< - * elif operator == 'lt': - * mapping = query_lt - */ - __Pyx_TraceLine(106,0,__PYX_ERR(0, 106, __pyx_L1_error)) - __Pyx_INCREF(__pyx_v_query_regex); - __Pyx_XDECREF_SET(__pyx_v_mapping, __pyx_v_query_regex); + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 50, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Event_get_threadid", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":104 - * elif operator in ('contains', 'has'): - * mapping = query_contains - * elif operator in ('regex', 'rx'): # <<<<<<<<<<<<<< - * value = re.compile(value) - * mapping = query_regex - */ - goto __pyx_L13; - } +/* "hunter/_predicates.pyx":51 + * cdef inline Event_get_threadname(Event event): return event.threadname_getter() + * cdef inline Event_get_threadid(Event event): return event.threadid_getter() + * cdef inline Event_get_instruction(Event event): return event.instruction_getter() # <<<<<<<<<<<<<< + * cdef inline Event_get_depth(Event event): return event.depth + * cdef inline Event_get_calls(Event event): return event.calls +*/ - /* "hunter/_predicates.pyx":107 - * value = re.compile(value) - * mapping = query_regex - * elif operator == 'lt': # <<<<<<<<<<<<<< - * mapping = query_lt - * elif operator == 'lte': - */ - __Pyx_TraceLine(107,0,__PYX_ERR(0, 107, __pyx_L1_error)) - __pyx_t_13 = (__Pyx_PyString_Equals(__pyx_v_operator, __pyx_n_s_lt, Py_EQ)); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 107, __pyx_L1_error) - if (__pyx_t_13) { +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_instruction(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[15])) + __Pyx_RefNannySetupContext("Event_get_instruction", 0); + __Pyx_TraceStartFunc("Event_get_instruction", __pyx_f[0], 51, 0, 0, 0, __PYX_ERR(0, 51, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((struct __pyx_vtabstruct_6hunter_6_event_Event *)__pyx_v_event->__pyx_vtab)->instruction_getter(__pyx_v_event); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 51, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 51, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":108 - * mapping = query_regex - * elif operator == 'lt': - * mapping = query_lt # <<<<<<<<<<<<<< - * elif operator == 'lte': - * mapping = query_lte - */ - __Pyx_TraceLine(108,0,__PYX_ERR(0, 108, __pyx_L1_error)) - __Pyx_INCREF(__pyx_v_query_lt); - __Pyx_XDECREF_SET(__pyx_v_mapping, __pyx_v_query_lt); + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 51, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Event_get_instruction", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":107 - * value = re.compile(value) - * mapping = query_regex - * elif operator == 'lt': # <<<<<<<<<<<<<< - * mapping = query_lt - * elif operator == 'lte': - */ - goto __pyx_L13; - } +/* "hunter/_predicates.pyx":52 + * cdef inline Event_get_threadid(Event event): return event.threadid_getter() + * cdef inline Event_get_instruction(Event event): return event.instruction_getter() + * cdef inline Event_get_depth(Event event): return event.depth # <<<<<<<<<<<<<< + * cdef inline Event_get_calls(Event event): return event.calls + * cdef inline Event_get_builtin(Event event): return event.builtin +*/ - /* "hunter/_predicates.pyx":109 - * elif operator == 'lt': - * mapping = query_lt - * elif operator == 'lte': # <<<<<<<<<<<<<< - * mapping = query_lte - * elif operator == 'gt': - */ - __Pyx_TraceLine(109,0,__PYX_ERR(0, 109, __pyx_L1_error)) - __pyx_t_13 = (__Pyx_PyString_Equals(__pyx_v_operator, __pyx_n_s_lte, Py_EQ)); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 109, __pyx_L1_error) - if (__pyx_t_13) { +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_depth(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[16])) + __Pyx_RefNannySetupContext("Event_get_depth", 0); + __Pyx_TraceStartFunc("Event_get_depth", __pyx_f[0], 52, 0, 0, 0, __PYX_ERR(0, 52, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_event->depth); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 52, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":110 - * mapping = query_lt - * elif operator == 'lte': - * mapping = query_lte # <<<<<<<<<<<<<< - * elif operator == 'gt': - * mapping = query_gt - */ - __Pyx_TraceLine(110,0,__PYX_ERR(0, 110, __pyx_L1_error)) - __Pyx_INCREF(__pyx_v_query_lte); - __Pyx_XDECREF_SET(__pyx_v_mapping, __pyx_v_query_lte); + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 52, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Event_get_depth", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":109 - * elif operator == 'lt': - * mapping = query_lt - * elif operator == 'lte': # <<<<<<<<<<<<<< - * mapping = query_lte - * elif operator == 'gt': - */ - goto __pyx_L13; - } +/* "hunter/_predicates.pyx":53 + * cdef inline Event_get_instruction(Event event): return event.instruction_getter() + * cdef inline Event_get_depth(Event event): return event.depth + * cdef inline Event_get_calls(Event event): return event.calls # <<<<<<<<<<<<<< + * cdef inline Event_get_builtin(Event event): return event.builtin + * +*/ - /* "hunter/_predicates.pyx":111 - * elif operator == 'lte': - * mapping = query_lte - * elif operator == 'gt': # <<<<<<<<<<<<<< - * mapping = query_gt - * elif operator == 'gte': - */ - __Pyx_TraceLine(111,0,__PYX_ERR(0, 111, __pyx_L1_error)) - __pyx_t_13 = (__Pyx_PyString_Equals(__pyx_v_operator, __pyx_n_s_gt, Py_EQ)); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 111, __pyx_L1_error) - if (__pyx_t_13) { +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_calls(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[17])) + __Pyx_RefNannySetupContext("Event_get_calls", 0); + __Pyx_TraceStartFunc("Event_get_calls", __pyx_f[0], 53, 0, 0, 0, __PYX_ERR(0, 53, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_event->calls); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 53, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":112 - * mapping = query_lte - * elif operator == 'gt': - * mapping = query_gt # <<<<<<<<<<<<<< - * elif operator == 'gte': - * mapping = query_gte - */ - __Pyx_TraceLine(112,0,__PYX_ERR(0, 112, __pyx_L1_error)) - __Pyx_INCREF(__pyx_v_query_gt); - __Pyx_XDECREF_SET(__pyx_v_mapping, __pyx_v_query_gt); + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 53, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Event_get_calls", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":111 - * elif operator == 'lte': - * mapping = query_lte - * elif operator == 'gt': # <<<<<<<<<<<<<< - * mapping = query_gt - * elif operator == 'gte': - */ - goto __pyx_L13; - } +/* "hunter/_predicates.pyx":54 + * cdef inline Event_get_depth(Event event): return event.depth + * cdef inline Event_get_calls(Event event): return event.calls + * cdef inline Event_get_builtin(Event event): return event.builtin # <<<<<<<<<<<<<< + * + * cdef Event_getter_typedef[17] Event_getters = [ +*/ - /* "hunter/_predicates.pyx":113 - * elif operator == 'gt': - * mapping = query_gt - * elif operator == 'gte': # <<<<<<<<<<<<<< - * mapping = query_gte - * else: - */ - __Pyx_TraceLine(113,0,__PYX_ERR(0, 113, __pyx_L1_error)) - __pyx_t_13 = (__Pyx_PyString_Equals(__pyx_v_operator, __pyx_n_s_gte, Py_EQ)); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 113, __pyx_L1_error) - if (likely(__pyx_t_13)) { +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_Event_get_builtin(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[18])) + __Pyx_RefNannySetupContext("Event_get_builtin", 0); + __Pyx_TraceStartFunc("Event_get_builtin", __pyx_f[0], 54, 0, 0, 0, __PYX_ERR(0, 54, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_event->builtin); + __pyx_r = __pyx_v_event->builtin; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 54, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":114 - * mapping = query_gt - * elif operator == 'gte': - * mapping = query_gte # <<<<<<<<<<<<<< - * else: - * raise TypeError('Unexpected operator %r. Must be one of %s.' % (operator, ALLOWED_OPERATORS)) - */ - __Pyx_TraceLine(114,0,__PYX_ERR(0, 114, __pyx_L1_error)) - __Pyx_INCREF(__pyx_v_query_gte); - __Pyx_XDECREF_SET(__pyx_v_mapping, __pyx_v_query_gte); + /* function exit code */ + __pyx_L1_error:; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 54, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Event_get_builtin", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":113 - * elif operator == 'gt': - * mapping = query_gt - * elif operator == 'gte': # <<<<<<<<<<<<<< - * mapping = query_gte - * else: - */ - goto __pyx_L13; - } +/* "hunter/_predicates.pyx":83 + * cdef object value + * + * def __init__(self, object value, str name): # <<<<<<<<<<<<<< + * self.value = value + * self.getter_index = ALLOWED_KEYS.index(name) +*/ - /* "hunter/_predicates.pyx":116 - * mapping = query_gte - * else: - * raise TypeError('Unexpected operator %r. Must be one of %s.' % (operator, ALLOWED_OPERATORS)) # <<<<<<<<<<<<<< - * else: - * mapping = query_eq - */ - __Pyx_TraceLine(116,0,__PYX_ERR(0, 116, __pyx_L1_error)) - /*else*/ { - __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 116, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_INCREF(__pyx_v_operator); - __Pyx_GIVEREF(__pyx_v_operator); - PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_operator); - __Pyx_INCREF(__pyx_v_6hunter_11_predicates_ALLOWED_OPERATORS); - __Pyx_GIVEREF(__pyx_v_6hunter_11_predicates_ALLOWED_OPERATORS); - PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_v_6hunter_11_predicates_ALLOWED_OPERATORS); - __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Unexpected_operator_r_Must_be_on, __pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 116, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 116, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 116, __pyx_L1_error) +/* Python wrapper */ +static int __pyx_pw_6hunter_11_predicates_10QueryEntry_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_6hunter_11_predicates_10QueryEntry_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_value = 0; + PyObject *__pyx_v_name = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_value,&__pyx_mstate_global->__pyx_n_u_name,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 83, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 2: + values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 83, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 83, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; } - __pyx_L13:; - - /* "hunter/_predicates.pyx":86 - * key, ALLOWED_KEYS, ALLOWED_OPERATORS - * )) - * elif count == 2: # <<<<<<<<<<<<<< - * prefix, operator = parts - * if operator in ('startswith', 'sw'): - */ - goto __pyx_L12; + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__init__", 0) < 0) __PYX_ERR(0, 83, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, i); __PYX_ERR(0, 83, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 83, __pyx_L3_error) + values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 83, __pyx_L3_error) } + __pyx_v_value = values[0]; + __pyx_v_name = ((PyObject*)values[1]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 83, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("hunter._predicates.QueryEntry.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_name), (&PyUnicode_Type), 1, "name", 1))) __PYX_ERR(0, 83, __pyx_L1_error) + __pyx_r = __pyx_pf_6hunter_11_predicates_10QueryEntry___init__(((struct __pyx_obj_6hunter_11_predicates_QueryEntry *)__pyx_v_self), __pyx_v_value, __pyx_v_name); - /* "hunter/_predicates.pyx":118 - * raise TypeError('Unexpected operator %r. Must be one of %s.' % (operator, ALLOWED_OPERATORS)) - * else: - * mapping = query_eq # <<<<<<<<<<<<<< - * prefix = key - * - */ - __Pyx_TraceLine(118,0,__PYX_ERR(0, 118, __pyx_L1_error)) - /*else*/ { - __Pyx_INCREF(__pyx_v_query_eq); - __Pyx_XDECREF_SET(__pyx_v_mapping, __pyx_v_query_eq); + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":119 - * else: - * mapping = query_eq - * prefix = key # <<<<<<<<<<<<<< - * - * if prefix not in ALLOWED_KEYS: - */ - __Pyx_TraceLine(119,0,__PYX_ERR(0, 119, __pyx_L1_error)) - __Pyx_INCREF(__pyx_v_key); - __Pyx_XDECREF_SET(__pyx_v_prefix, __pyx_v_key); - } - __pyx_L12:; +static int __pyx_pf_6hunter_11_predicates_10QueryEntry___init__(struct __pyx_obj_6hunter_11_predicates_QueryEntry *__pyx_v_self, PyObject *__pyx_v_value, PyObject *__pyx_v_name) { + int __pyx_r; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[19])) + __Pyx_RefNannySetupContext("__init__", 0); + __Pyx_TraceStartFunc("__init__", __pyx_f[0], 83, 0, 0, 0, __PYX_ERR(0, 83, __pyx_L1_error)); + + /* "hunter/_predicates.pyx":84 + * + * def __init__(self, object value, str name): + * self.value = value # <<<<<<<<<<<<<< + * self.getter_index = ALLOWED_KEYS.index(name) + * self.getter = Event_getters[self.getter_index] +*/ + __Pyx_TraceLine(84,1,0,__PYX_ERR(0, 84, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->value); + __Pyx_DECREF(__pyx_v_self->value); + __pyx_v_self->value = __pyx_v_value; + + /* "hunter/_predicates.pyx":85 + * def __init__(self, object value, str name): + * self.value = value + * self.getter_index = ALLOWED_KEYS.index(name) # <<<<<<<<<<<<<< + * self.getter = Event_getters[self.getter_index] + * +*/ + __Pyx_TraceLine(85,8,0,__PYX_ERR(0, 85, __pyx_L1_error)) + __pyx_t_1 = __Pyx_CallUnboundCMethod1(&__pyx_mstate_global->__pyx_umethod_PyTuple_Type__index, __pyx_v_6hunter_11_predicates_ALLOWED_KEYS, __pyx_v_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_self->getter_index = __pyx_t_2; - /* "hunter/_predicates.pyx":121 - * prefix = key + /* "hunter/_predicates.pyx":86 + * self.value = value + * self.getter_index = ALLOWED_KEYS.index(name) + * self.getter = Event_getters[self.getter_index] # <<<<<<<<<<<<<< * - * if prefix not in ALLOWED_KEYS: # <<<<<<<<<<<<<< - * raise TypeError('Unexpected argument %r. Must be one of %s.' % (key, ALLOWED_KEYS)) - * - */ - __Pyx_TraceLine(121,0,__PYX_ERR(0, 121, __pyx_L1_error)) - __pyx_t_13 = (__Pyx_PySequence_ContainsTF(__pyx_v_prefix, __pyx_v_6hunter_11_predicates_ALLOWED_KEYS, Py_NE)); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 121, __pyx_L1_error) - __pyx_t_14 = (__pyx_t_13 != 0); - if (unlikely(__pyx_t_14)) { + * def __repr__(self): +*/ + __Pyx_TraceLine(86,10,0,__PYX_ERR(0, 86, __pyx_L1_error)) + __pyx_v_self->getter = (__pyx_v_6hunter_11_predicates_Event_getters[__pyx_v_self->getter_index]); - /* "hunter/_predicates.pyx":122 + /* "hunter/_predicates.pyx":83 + * cdef object value * - * if prefix not in ALLOWED_KEYS: - * raise TypeError('Unexpected argument %r. Must be one of %s.' % (key, ALLOWED_KEYS)) # <<<<<<<<<<<<<< - * - * mapping[prefix] = value - */ - __Pyx_TraceLine(122,0,__PYX_ERR(0, 122, __pyx_L1_error)) - __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 122, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_INCREF(__pyx_v_key); - __Pyx_GIVEREF(__pyx_v_key); - PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_key); - __Pyx_INCREF(__pyx_v_6hunter_11_predicates_ALLOWED_KEYS); - __Pyx_GIVEREF(__pyx_v_6hunter_11_predicates_ALLOWED_KEYS); - PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_v_6hunter_11_predicates_ALLOWED_KEYS); - __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Unexpected_argument_r_Must_be_on_2, __pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 122, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 122, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 122, __pyx_L1_error) + * def __init__(self, object value, str name): # <<<<<<<<<<<<<< + * self.value = value + * self.getter_index = ALLOWED_KEYS.index(name) +*/ - /* "hunter/_predicates.pyx":121 - * prefix = key + /* function exit code */ + __pyx_r = 0; + __Pyx_TraceReturnCValue(__pyx_r, __Pyx_Owned_Py_None, 0, 0, __PYX_ERR(0, 83, __pyx_L1_error)); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 83, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.QueryEntry.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/_predicates.pyx":88 + * self.getter = Event_getters[self.getter_index] * - * if prefix not in ALLOWED_KEYS: # <<<<<<<<<<<<<< - * raise TypeError('Unexpected argument %r. Must be one of %s.' % (key, ALLOWED_KEYS)) + * def __repr__(self): # <<<<<<<<<<<<<< + * return repr(self.value) * - */ - } +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_10QueryEntry_3__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_10QueryEntry_3__repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_10QueryEntry_2__repr__(((struct __pyx_obj_6hunter_11_predicates_QueryEntry *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_11_predicates_10QueryEntry_2__repr__(struct __pyx_obj_6hunter_11_predicates_QueryEntry *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[20])) + __Pyx_RefNannySetupContext("__repr__", 0); + __Pyx_TraceStartFunc("__repr__", __pyx_f[0], 88, 0, 0, 0, __PYX_ERR(0, 88, __pyx_L1_error)); - /* "hunter/_predicates.pyx":124 - * raise TypeError('Unexpected argument %r. Must be one of %s.' % (key, ALLOWED_KEYS)) + /* "hunter/_predicates.pyx":89 * - * mapping[prefix] = value # <<<<<<<<<<<<<< + * def __repr__(self): + * return repr(self.value) # <<<<<<<<<<<<<< * - * self.query_eq = tuple(sorted(query_eq.items())) - */ - __Pyx_TraceLine(124,0,__PYX_ERR(0, 124, __pyx_L1_error)) - if (unlikely(PyDict_SetItem(__pyx_v_mapping, __pyx_v_prefix, __pyx_v_value) < 0)) __PYX_ERR(0, 124, __pyx_L1_error) - } + * def __eq__(self, other): +*/ + __Pyx_TraceLine(89,1,0,__PYX_ERR(0, 89, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_v_self->value; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = PyObject_Repr(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 89, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":126 - * mapping[prefix] = value + /* "hunter/_predicates.pyx":88 + * self.getter = Event_getters[self.getter_index] * - * self.query_eq = tuple(sorted(query_eq.items())) # <<<<<<<<<<<<<< - * self.query_startswith = tuple(sorted(query_startswith.items())) - * self.query_endswith = tuple(sorted(query_endswith.items())) - */ - __Pyx_TraceLine(126,0,__PYX_ERR(0, 126, __pyx_L1_error)) - __pyx_t_8 = __Pyx_PyDict_Items(__pyx_v_query_eq); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 126, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_5 = PySequence_List(__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 126, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_1 = ((PyObject*)__pyx_t_5); - __pyx_t_5 = 0; - __pyx_t_15 = PyList_Sort(__pyx_t_1); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(0, 126, __pyx_L1_error) - if (unlikely(__pyx_t_1 == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(0, 126, __pyx_L1_error) - } - __pyx_t_5 = PyList_AsTuple(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 126, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_GIVEREF(__pyx_t_5); - __Pyx_GOTREF(__pyx_v_self->query_eq); - __Pyx_DECREF(__pyx_v_self->query_eq); - __pyx_v_self->query_eq = ((PyObject*)__pyx_t_5); - __pyx_t_5 = 0; + * def __repr__(self): # <<<<<<<<<<<<<< + * return repr(self.value) + * +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 88, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.QueryEntry.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":127 +/* "hunter/_predicates.pyx":91 + * return repr(self.value) * - * self.query_eq = tuple(sorted(query_eq.items())) - * self.query_startswith = tuple(sorted(query_startswith.items())) # <<<<<<<<<<<<<< - * self.query_endswith = tuple(sorted(query_endswith.items())) - * self.query_in = tuple(sorted(query_in.items())) - */ - __Pyx_TraceLine(127,0,__PYX_ERR(0, 127, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyDict_Items(__pyx_v_query_startswith); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 127, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_8 = PySequence_List(__pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 127, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_5 = ((PyObject*)__pyx_t_8); - __pyx_t_8 = 0; - __pyx_t_15 = PyList_Sort(__pyx_t_5); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(0, 127, __pyx_L1_error) - if (unlikely(__pyx_t_5 == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(0, 127, __pyx_L1_error) - } - __pyx_t_8 = PyList_AsTuple(__pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 127, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_GIVEREF(__pyx_t_8); - __Pyx_GOTREF(__pyx_v_self->query_startswith); - __Pyx_DECREF(__pyx_v_self->query_startswith); - __pyx_v_self->query_startswith = ((PyObject*)__pyx_t_8); - __pyx_t_8 = 0; + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return ( + * isinstance(other, QueryEntry) +*/ - /* "hunter/_predicates.pyx":128 - * self.query_eq = tuple(sorted(query_eq.items())) - * self.query_startswith = tuple(sorted(query_startswith.items())) - * self.query_endswith = tuple(sorted(query_endswith.items())) # <<<<<<<<<<<<<< - * self.query_in = tuple(sorted(query_in.items())) - * self.query_contains = tuple(sorted(query_contains.items())) - */ - __Pyx_TraceLine(128,0,__PYX_ERR(0, 128, __pyx_L1_error)) - __pyx_t_5 = __Pyx_PyDict_Items(__pyx_v_query_endswith); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 128, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_1 = PySequence_List(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 128, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_8 = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - __pyx_t_15 = PyList_Sort(__pyx_t_8); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(0, 128, __pyx_L1_error) - if (unlikely(__pyx_t_8 == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(0, 128, __pyx_L1_error) - } - __pyx_t_1 = PyList_AsTuple(__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 128, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v_self->query_endswith); - __Pyx_DECREF(__pyx_v_self->query_endswith); - __pyx_v_self->query_endswith = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_10QueryEntry_5__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_10QueryEntry_5__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_10QueryEntry_4__eq__(((struct __pyx_obj_6hunter_11_predicates_QueryEntry *)__pyx_v_self), ((PyObject *)__pyx_v_other)); - /* "hunter/_predicates.pyx":129 - * self.query_startswith = tuple(sorted(query_startswith.items())) - * self.query_endswith = tuple(sorted(query_endswith.items())) - * self.query_in = tuple(sorted(query_in.items())) # <<<<<<<<<<<<<< - * self.query_contains = tuple(sorted(query_contains.items())) - * self.query_regex = tuple(sorted(query_regex.items())) - */ - __Pyx_TraceLine(129,0,__PYX_ERR(0, 129, __pyx_L1_error)) - __pyx_t_8 = __Pyx_PyDict_Items(__pyx_v_query_in); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 129, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_5 = PySequence_List(__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 129, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_1 = ((PyObject*)__pyx_t_5); - __pyx_t_5 = 0; - __pyx_t_15 = PyList_Sort(__pyx_t_1); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(0, 129, __pyx_L1_error) - if (unlikely(__pyx_t_1 == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(0, 129, __pyx_L1_error) - } - __pyx_t_5 = PyList_AsTuple(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 129, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_GIVEREF(__pyx_t_5); - __Pyx_GOTREF(__pyx_v_self->query_in); - __Pyx_DECREF(__pyx_v_self->query_in); - __pyx_v_self->query_in = ((PyObject*)__pyx_t_5); - __pyx_t_5 = 0; + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":130 - * self.query_endswith = tuple(sorted(query_endswith.items())) - * self.query_in = tuple(sorted(query_in.items())) - * self.query_contains = tuple(sorted(query_contains.items())) # <<<<<<<<<<<<<< - * self.query_regex = tuple(sorted(query_regex.items())) - * self.query_lt = tuple(sorted(query_lt.items())) - */ - __Pyx_TraceLine(130,0,__PYX_ERR(0, 130, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyDict_Items(__pyx_v_query_contains); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 130, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_8 = PySequence_List(__pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 130, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_5 = ((PyObject*)__pyx_t_8); - __pyx_t_8 = 0; - __pyx_t_15 = PyList_Sort(__pyx_t_5); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(0, 130, __pyx_L1_error) - if (unlikely(__pyx_t_5 == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(0, 130, __pyx_L1_error) - } - __pyx_t_8 = PyList_AsTuple(__pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 130, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_GIVEREF(__pyx_t_8); - __Pyx_GOTREF(__pyx_v_self->query_contains); - __Pyx_DECREF(__pyx_v_self->query_contains); - __pyx_v_self->query_contains = ((PyObject*)__pyx_t_8); - __pyx_t_8 = 0; +static PyObject *__pyx_pf_6hunter_11_predicates_10QueryEntry_4__eq__(struct __pyx_obj_6hunter_11_predicates_QueryEntry *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[21])) + __Pyx_RefNannySetupContext("__eq__", 0); + __Pyx_TraceStartFunc("__eq__", __pyx_f[0], 91, 0, 0, 0, __PYX_ERR(0, 91, __pyx_L1_error)); - /* "hunter/_predicates.pyx":131 - * self.query_in = tuple(sorted(query_in.items())) - * self.query_contains = tuple(sorted(query_contains.items())) - * self.query_regex = tuple(sorted(query_regex.items())) # <<<<<<<<<<<<<< - * self.query_lt = tuple(sorted(query_lt.items())) - * self.query_lte = tuple(sorted(query_lte.items())) - */ - __Pyx_TraceLine(131,0,__PYX_ERR(0, 131, __pyx_L1_error)) - __pyx_t_5 = __Pyx_PyDict_Items(__pyx_v_query_regex); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 131, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_1 = PySequence_List(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 131, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_8 = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - __pyx_t_15 = PyList_Sort(__pyx_t_8); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(0, 131, __pyx_L1_error) - if (unlikely(__pyx_t_8 == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(0, 131, __pyx_L1_error) + /* "hunter/_predicates.pyx":92 + * + * def __eq__(self, other): + * return ( # <<<<<<<<<<<<<< + * isinstance(other, QueryEntry) + * and self.value == ( other).value +*/ + __Pyx_TraceLine(92,1,0,__PYX_ERR(0, 92, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + + /* "hunter/_predicates.pyx":93 + * def __eq__(self, other): + * return ( + * isinstance(other, QueryEntry) # <<<<<<<<<<<<<< + * and self.value == ( other).value + * and self.getter_index == ( other).getter_index +*/ + __Pyx_TraceLine(93,5,0,__PYX_ERR(0, 93, __pyx_L1_error)) + __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_other, __pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_QueryEntry); + if (__pyx_t_2) { + } else { + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L3_bool_binop_done; } - __pyx_t_1 = PyList_AsTuple(__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 131, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v_self->query_regex); - __Pyx_DECREF(__pyx_v_self->query_regex); - __pyx_v_self->query_regex = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - /* "hunter/_predicates.pyx":132 - * self.query_contains = tuple(sorted(query_contains.items())) - * self.query_regex = tuple(sorted(query_regex.items())) - * self.query_lt = tuple(sorted(query_lt.items())) # <<<<<<<<<<<<<< - * self.query_lte = tuple(sorted(query_lte.items())) - * self.query_gt = tuple(sorted(query_gt.items())) - */ - __Pyx_TraceLine(132,0,__PYX_ERR(0, 132, __pyx_L1_error)) - __pyx_t_8 = __Pyx_PyDict_Items(__pyx_v_query_lt); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 132, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_5 = PySequence_List(__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 132, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_1 = ((PyObject*)__pyx_t_5); - __pyx_t_5 = 0; - __pyx_t_15 = PyList_Sort(__pyx_t_1); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(0, 132, __pyx_L1_error) - if (unlikely(__pyx_t_1 == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(0, 132, __pyx_L1_error) + /* "hunter/_predicates.pyx":94 + * return ( + * isinstance(other, QueryEntry) + * and self.value == ( other).value # <<<<<<<<<<<<<< + * and self.getter_index == ( other).getter_index + * ) +*/ + __Pyx_TraceLine(94,12,0,__PYX_ERR(0, 94, __pyx_L1_error)) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->value, ((struct __pyx_obj_6hunter_11_predicates_QueryEntry *)__pyx_v_other)->value, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 94, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 94, __pyx_L1_error) + if (__pyx_t_2) { + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __Pyx_INCREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L3_bool_binop_done; } - __pyx_t_5 = PyList_AsTuple(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 132, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_GIVEREF(__pyx_t_5); - __Pyx_GOTREF(__pyx_v_self->query_lt); - __Pyx_DECREF(__pyx_v_self->query_lt); - __pyx_v_self->query_lt = ((PyObject*)__pyx_t_5); - __pyx_t_5 = 0; - /* "hunter/_predicates.pyx":133 - * self.query_regex = tuple(sorted(query_regex.items())) - * self.query_lt = tuple(sorted(query_lt.items())) - * self.query_lte = tuple(sorted(query_lte.items())) # <<<<<<<<<<<<<< - * self.query_gt = tuple(sorted(query_gt.items())) - * self.query_gte = tuple(sorted(query_gte.items())) - */ - __Pyx_TraceLine(133,0,__PYX_ERR(0, 133, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyDict_Items(__pyx_v_query_lte); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 133, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_8 = PySequence_List(__pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 133, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_5 = ((PyObject*)__pyx_t_8); - __pyx_t_8 = 0; - __pyx_t_15 = PyList_Sort(__pyx_t_5); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(0, 133, __pyx_L1_error) - if (unlikely(__pyx_t_5 == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(0, 133, __pyx_L1_error) - } - __pyx_t_8 = PyList_AsTuple(__pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 133, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_GIVEREF(__pyx_t_8); - __Pyx_GOTREF(__pyx_v_self->query_lte); - __Pyx_DECREF(__pyx_v_self->query_lte); - __pyx_v_self->query_lte = ((PyObject*)__pyx_t_8); - __pyx_t_8 = 0; - - /* "hunter/_predicates.pyx":134 - * self.query_lt = tuple(sorted(query_lt.items())) - * self.query_lte = tuple(sorted(query_lte.items())) - * self.query_gt = tuple(sorted(query_gt.items())) # <<<<<<<<<<<<<< - * self.query_gte = tuple(sorted(query_gte.items())) + /* "hunter/_predicates.pyx":95 + * isinstance(other, QueryEntry) + * and self.value == ( other).value + * and self.getter_index == ( other).getter_index # <<<<<<<<<<<<<< + * ) * - */ - __Pyx_TraceLine(134,0,__PYX_ERR(0, 134, __pyx_L1_error)) - __pyx_t_5 = __Pyx_PyDict_Items(__pyx_v_query_gt); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 134, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_1 = PySequence_List(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 134, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_8 = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - __pyx_t_15 = PyList_Sort(__pyx_t_8); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(0, 134, __pyx_L1_error) - if (unlikely(__pyx_t_8 == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(0, 134, __pyx_L1_error) - } - __pyx_t_1 = PyList_AsTuple(__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 134, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v_self->query_gt); - __Pyx_DECREF(__pyx_v_self->query_gt); - __pyx_v_self->query_gt = ((PyObject*)__pyx_t_1); +*/ + __Pyx_TraceLine(95,16,0,__PYX_ERR(0, 95, __pyx_L1_error)) + __pyx_t_2 = (__pyx_v_self->getter_index == ((struct __pyx_obj_6hunter_11_predicates_QueryEntry *)__pyx_v_other)->getter_index); + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 95, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = 0; + __pyx_L3_bool_binop_done:; + __pyx_r = __pyx_t_1; __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 92, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":135 - * self.query_lte = tuple(sorted(query_lte.items())) - * self.query_gt = tuple(sorted(query_gt.items())) - * self.query_gte = tuple(sorted(query_gte.items())) # <<<<<<<<<<<<<< + /* "hunter/_predicates.pyx":91 + * return repr(self.value) * - * def __str__(self): - */ - __Pyx_TraceLine(135,0,__PYX_ERR(0, 135, __pyx_L1_error)) - __pyx_t_8 = __Pyx_PyDict_Items(__pyx_v_query_gte); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 135, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_5 = PySequence_List(__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 135, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_1 = ((PyObject*)__pyx_t_5); - __pyx_t_5 = 0; - __pyx_t_15 = PyList_Sort(__pyx_t_1); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(0, 135, __pyx_L1_error) - if (unlikely(__pyx_t_1 == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(0, 135, __pyx_L1_error) - } - __pyx_t_5 = PyList_AsTuple(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 135, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_GIVEREF(__pyx_t_5); - __Pyx_GOTREF(__pyx_v_self->query_gte); - __Pyx_DECREF(__pyx_v_self->query_gte); - __pyx_v_self->query_gte = ((PyObject*)__pyx_t_5); - __pyx_t_5 = 0; - - /* "hunter/_predicates.pyx":44 - * See :class:`hunter.event.Event` for fields that can be filtered on. - * """ - * def __init__(self, **query): # <<<<<<<<<<<<<< - * """ - * Args: - */ + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return ( + * isinstance(other, QueryEntry) +*/ /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_XDECREF(__pyx_t_9); - __Pyx_AddTraceback("hunter._predicates.Query.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 91, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.QueryEntry.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF(__pyx_v_query_eq); - __Pyx_XDECREF(__pyx_v_query_startswith); - __Pyx_XDECREF(__pyx_v_query_endswith); - __Pyx_XDECREF(__pyx_v_query_in); - __Pyx_XDECREF(__pyx_v_query_contains); - __Pyx_XDECREF(__pyx_v_query_regex); - __Pyx_XDECREF(__pyx_v_query_lt); - __Pyx_XDECREF(__pyx_v_query_lte); - __Pyx_XDECREF(__pyx_v_query_gt); - __Pyx_XDECREF(__pyx_v_query_gte); - __Pyx_XDECREF(__pyx_v_key); - __Pyx_XDECREF(__pyx_v_value); - __Pyx_XDECREF(__pyx_v_parts); - __Pyx_XDECREF(__pyx_v_prefix); - __Pyx_XDECREF(__pyx_v_operator); - __Pyx_XDECREF(__pyx_v_mapping); - __Pyx_XDECREF(__pyx_7genexpr__pyx_v_p); - __Pyx_TraceReturn(Py_None, 0); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":137 - * self.query_gte = tuple(sorted(query_gte.items())) - * - * def __str__(self): # <<<<<<<<<<<<<< - * return 'Query(%s)' % ( - * ', '.join( - */ +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.getter cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_3__str__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_3__str__(PyObject *__pyx_v_self) { +static PyObject *__pyx_pw_6hunter_11_predicates_10QueryEntry_7__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_11_predicates_10QueryEntry_7__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_10QueryEntry_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_11_predicates_10QueryEntry_7__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_2__str__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_6hunter_11_predicates_10QueryEntry_6__reduce_cython__(((struct __pyx_obj_6hunter_11_predicates_QueryEntry *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_gb_6hunter_11_predicates_5Query_7__str___2generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ -static PyObject *__pyx_gb_6hunter_11_predicates_5Query_7__str___7genexpr_2generator1(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ - -/* "hunter/_predicates.pyx":140 - * return 'Query(%s)' % ( - * ', '.join( - * ', '.join('%s%s=%r' % (key, kind, value) for key, value in mapping) # <<<<<<<<<<<<<< - * for kind, mapping in [ - * ('', self.query_eq), - */ -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_7__str___7genexpr_genexpr(PyObject *__pyx_self) { - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr *__pyx_cur_scope; +static PyObject *__pyx_pf_6hunter_11_predicates_10QueryEntry_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6hunter_11_predicates_QueryEntry *__pyx_v_self) { PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("genexpr", 0); - __pyx_cur_scope = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr *)__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_2_genexpr(__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_2_genexpr, __pyx_empty_tuple, NULL); - if (unlikely(!__pyx_cur_scope)) { - __pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr *)Py_None); - __Pyx_INCREF(Py_None); - __PYX_ERR(0, 140, __pyx_L1_error) - } else { - __Pyx_GOTREF(__pyx_cur_scope); - } - __pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr *) __pyx_self; - __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_outer_scope)); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[22])) + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + __Pyx_TraceStartFunc("__reduce_cython__", __pyx_f[1], 1, 0, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "self.getter cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self.getter cannot be converted to a Python object for pickling" +*/ + __Pyx_TraceLine(2,2,0,__PYX_ERR(1, 2, __pyx_L1_error)) + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_self_getter_cannot_be_converted, 0, 0); + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.getter cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.QueryEntry.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.getter cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.getter cannot be converted to a Python object for pickling" +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_10QueryEntry_9__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_11_predicates_10QueryEntry_9__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_10QueryEntry_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_11_predicates_10QueryEntry_9__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_6hunter_11_predicates_5Query_7__str___7genexpr_2generator1, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_str___locals_genexpr_locals_ge, __pyx_n_s_hunter__predicates); if (unlikely(!gen)) __PYX_ERR(0, 140, __pyx_L1_error) - __Pyx_DECREF(__pyx_cur_scope); - __Pyx_RefNannyFinishContext(); - return (PyObject *) gen; + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 3, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 3, __pyx_L3_error) + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("hunter._predicates.QueryEntry.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6hunter_11_predicates_10QueryEntry_8__setstate_cython__(((struct __pyx_obj_6hunter_11_predicates_QueryEntry *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_11_predicates_10QueryEntry_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6hunter_11_predicates_QueryEntry *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[23])) + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + __Pyx_TraceStartFunc("__setstate_cython__", __pyx_f[1], 3, 0, 0, 0, __PYX_ERR(1, 3, __pyx_L1_error)); + + /* "(tree fragment)":4 + * raise TypeError, "self.getter cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self.getter cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< +*/ + __Pyx_TraceLine(4,2,0,__PYX_ERR(1, 4, __pyx_L1_error)) + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_self_getter_cannot_be_converted, 0, 0); + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.getter cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.getter cannot be converted to a Python object for pickling" +*/ /* function exit code */ __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.Query.__str__.genexpr.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 3, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.QueryEntry.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; - __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_gb_6hunter_11_predicates_5Query_7__str___7genexpr_2generator1(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ -{ - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr *__pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr *)__pyx_generator->closure); - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations +/* "hunter/_predicates.pyx":106 + * See :class:`hunter.event.Event` for fields that can be filtered on. + * """ + * def __init__(self, **query): # <<<<<<<<<<<<<< + * """ + * Args: +*/ + +/* Python wrapper */ +static int __pyx_pw_6hunter_11_predicates_5Query_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +PyDoc_STRVAR(__pyx_doc_6hunter_11_predicates_5Query___init__, "\n Args:\n query: criteria to match on.\n\n Accepted arguments:\n ``arg``,\n ``calls``,\n ``code``,\n ``depth``,\n ``filename``,\n ``frame``,\n ``fullsource``,\n ``function``,\n ``globals``,\n ``kind``,\n ``lineno``,\n ``locals``,\n ``module``,\n ``source``,\n ``stdlib``,\n ``threadid``,\n ``threadname``.\n "); +#if CYTHON_UPDATE_DESCRIPTOR_DOC +struct wrapperbase __pyx_wrapperbase_6hunter_11_predicates_5Query___init__; +#endif +static int __pyx_pw_6hunter_11_predicates_5Query_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_query = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, __pyx_nargs); return -1; } + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return -1; + if (__pyx_kwds_len > 0) { + if (unlikely(__Pyx_CheckKeywordStrings("__init__", __pyx_kwds) == -1)) return -1; + __pyx_v_query = __Pyx_KwargsAsDict_VARARGS(__pyx_kwds, __pyx_kwvalues); + if (unlikely(!__pyx_v_query)) return -1; + __Pyx_GOTREF(__pyx_v_query); + } else { + __pyx_v_query = PyDict_New(); + if (unlikely(!__pyx_v_query)) return -1; + __Pyx_GOTREF(__pyx_v_query); + } + __pyx_r = __pyx_pf_6hunter_11_predicates_5Query___init__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self), __pyx_v_query); + + /* function exit code */ + __Pyx_DECREF(__pyx_v_query); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6hunter_11_predicates_5Query___init__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self, PyObject *__pyx_v_query) { + PyObject *__pyx_v_query_eq = NULL; + PyObject *__pyx_v_query_startswith = NULL; + PyObject *__pyx_v_query_endswith = NULL; + PyObject *__pyx_v_query_in = NULL; + PyObject *__pyx_v_query_contains = NULL; + PyObject *__pyx_v_query_regex = NULL; + PyObject *__pyx_v_query_lt = NULL; + PyObject *__pyx_v_query_lte = NULL; + PyObject *__pyx_v_query_gt = NULL; + PyObject *__pyx_v_query_gte = NULL; + PyObject *__pyx_v_key = NULL; + PyObject *__pyx_v_value = NULL; + PyObject *__pyx_v_parts = NULL; + Py_ssize_t __pyx_v_count; + PyObject *__pyx_v_prefix = NULL; + PyObject *__pyx_v_operator = NULL; + PyObject *__pyx_v_mapping = NULL; + PyObject *__pyx_7genexpr__pyx_v_p = NULL; + int __pyx_r; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; - PyObject *(*__pyx_t_3)(PyObject *); - PyObject *__pyx_t_4 = NULL; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - PyObject *(*__pyx_t_8)(PyObject *); - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("genexpr", 0); - __Pyx_TraceCall("genexpr", __pyx_f[0], 140, 0, __PYX_ERR(0, 140, __pyx_L1_error)); - switch (__pyx_generator->resume_label) { - case 0: goto __pyx_L3_first_run; - case 1: goto __pyx_L8_resume_from_yield; - default: /* CPython raises the right error here */ - __Pyx_TraceReturn(Py_None, 0); - __Pyx_RefNannyFinishContext(); - return NULL; - } - __pyx_L3_first_run:; - if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 140, __pyx_L1_error) - if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_mapping)) { __Pyx_RaiseClosureNameError("mapping"); __PYX_ERR(0, 140, __pyx_L1_error) } - if (likely(PyList_CheckExact(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_mapping)) || PyTuple_CheckExact(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_mapping)) { - __pyx_t_1 = __pyx_cur_scope->__pyx_outer_scope->__pyx_v_mapping; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; - __pyx_t_3 = NULL; - } else { - __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_mapping); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 140, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 140, __pyx_L1_error) - } - for (;;) { - if (likely(!__pyx_t_3)) { - if (likely(PyList_CheckExact(__pyx_t_1))) { - if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 140, __pyx_L1_error) - #else - __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 140, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - #endif - } else { - if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 140, __pyx_L1_error) - #else - __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 140, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - #endif - } - } else { - __pyx_t_4 = __pyx_t_3(__pyx_t_1); - if (unlikely(!__pyx_t_4)) { - PyObject* exc_type = PyErr_Occurred(); - if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(0, 140, __pyx_L1_error) - } - break; - } - __Pyx_GOTREF(__pyx_t_4); - } - if ((likely(PyTuple_CheckExact(__pyx_t_4))) || (PyList_CheckExact(__pyx_t_4))) { - PyObject* sequence = __pyx_t_4; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 140, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_5 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1); - } else { - __pyx_t_5 = PyList_GET_ITEM(sequence, 0); - __pyx_t_6 = PyList_GET_ITEM(sequence, 1); - } - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(__pyx_t_6); - #else - __pyx_t_5 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 140, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 140, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - #endif - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - } else { - Py_ssize_t index = -1; - __pyx_t_7 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 140, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext; - index = 0; __pyx_t_5 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_5)) goto __pyx_L6_unpacking_failed; - __Pyx_GOTREF(__pyx_t_5); - index = 1; __pyx_t_6 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L6_unpacking_failed; - __Pyx_GOTREF(__pyx_t_6); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(0, 140, __pyx_L1_error) - __pyx_t_8 = NULL; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - goto __pyx_L7_unpacking_done; - __pyx_L6_unpacking_failed:; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_8 = NULL; - if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 140, __pyx_L1_error) - __pyx_L7_unpacking_done:; - } - __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_key); - __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_key, __pyx_t_5); - __Pyx_GIVEREF(__pyx_t_5); - __pyx_t_5 = 0; - __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_value); - __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_value, __pyx_t_6); - __Pyx_GIVEREF(__pyx_t_6); - __pyx_t_6 = 0; - if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_kind)) { __Pyx_RaiseClosureNameError("kind"); __PYX_ERR(0, 140, __pyx_L1_error) } - __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 140, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_INCREF(__pyx_cur_scope->__pyx_v_key); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_key); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_cur_scope->__pyx_v_key); - __Pyx_INCREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_kind); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_kind); - PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_kind); - __Pyx_INCREF(__pyx_cur_scope->__pyx_v_value); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_value); - PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_cur_scope->__pyx_v_value); - __pyx_t_6 = __Pyx_PyString_Format(__pyx_kp_s_s_s_r, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 140, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_r = __pyx_t_6; - __pyx_t_6 = 0; - __Pyx_XGIVEREF(__pyx_t_1); - __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; - __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; - __pyx_cur_scope->__pyx_t_2 = __pyx_t_3; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - __Pyx_Coroutine_ResetAndClearException(__pyx_generator); - /* return from generator, yielding value */ - __pyx_generator->resume_label = 1; - return __pyx_r; - __pyx_L8_resume_from_yield:; - __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; - __pyx_cur_scope->__pyx_t_0 = 0; - __Pyx_XGOTREF(__pyx_t_1); - __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; - __pyx_t_3 = __pyx_cur_scope->__pyx_t_2; - if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 140, __pyx_L1_error) - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + size_t __pyx_t_9; + Py_ssize_t __pyx_t_10; + PyObject *(*__pyx_t_11)(PyObject *); + int __pyx_t_12; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + PyObject *__pyx_t_15 = NULL; + PyObject *__pyx_t_16[6]; + PyObject *__pyx_t_17 = NULL; + int __pyx_t_18; + PyObject *__pyx_t_19[5]; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[24])) + __Pyx_RefNannySetupContext("__init__", 0); + __Pyx_TraceStartFunc("__init__", __pyx_f[0], 106, 0, 0, 0, __PYX_ERR(0, 106, __pyx_L1_error)); - /* function exit code */ - PyErr_SetNone(PyExc_StopIteration); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_L0:; - __Pyx_XDECREF(__pyx_r); __pyx_r = 0; - #if !CYTHON_USE_EXC_INFO_STACK - __Pyx_Coroutine_ResetAndClearException(__pyx_generator); - #endif - __pyx_generator->resume_label = -1; - __Pyx_Coroutine_clear((PyObject*)__pyx_generator); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":130 + * ``threadname``. + * """ + * query_eq = {} # <<<<<<<<<<<<<< + * query_startswith = {} + * query_endswith = {} +*/ + __Pyx_TraceLine(130,2,0,__PYX_ERR(0, 130, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 130, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_query_eq = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_7__str___genexpr(PyObject *__pyx_self) { - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr *__pyx_cur_scope; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("genexpr", 0); - __pyx_cur_scope = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr *)__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_1_genexpr(__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_1_genexpr, __pyx_empty_tuple, NULL); - if (unlikely(!__pyx_cur_scope)) { - __pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr *)Py_None); - __Pyx_INCREF(Py_None); - __PYX_ERR(0, 140, __pyx_L1_error) - } else { - __Pyx_GOTREF(__pyx_cur_scope); - } - __pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__ *) __pyx_self; - __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_outer_scope)); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope); - { - __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_6hunter_11_predicates_5Query_7__str___2generator, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_str___locals_genexpr, __pyx_n_s_hunter__predicates); if (unlikely(!gen)) __PYX_ERR(0, 140, __pyx_L1_error) - __Pyx_DECREF(__pyx_cur_scope); - __Pyx_RefNannyFinishContext(); - return (PyObject *) gen; - } + /* "hunter/_predicates.pyx":131 + * """ + * query_eq = {} + * query_startswith = {} # <<<<<<<<<<<<<< + * query_endswith = {} + * query_in = {} +*/ + __Pyx_TraceLine(131,4,0,__PYX_ERR(0, 131, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_query_startswith = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.Query.__str__.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":132 + * query_eq = {} + * query_startswith = {} + * query_endswith = {} # <<<<<<<<<<<<<< + * query_in = {} + * query_contains = {} +*/ + __Pyx_TraceLine(132,6,0,__PYX_ERR(0, 132, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_query_endswith = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; -static PyObject *__pyx_gb_6hunter_11_predicates_5Query_7__str___2generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ -{ - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr *__pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr *)__pyx_generator->closure); - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - PyObject *__pyx_t_9 = NULL; - PyObject *__pyx_t_10 = NULL; - PyObject *__pyx_t_11 = NULL; - Py_ssize_t __pyx_t_12; - int __pyx_t_13; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("genexpr", 0); - __Pyx_TraceCall("genexpr", __pyx_f[0], 140, 0, __PYX_ERR(0, 140, __pyx_L1_error)); - switch (__pyx_generator->resume_label) { - case 0: goto __pyx_L3_first_run; - case 1: goto __pyx_L7_resume_from_yield; - default: /* CPython raises the right error here */ - __Pyx_TraceReturn(Py_None, 0); - __Pyx_RefNannyFinishContext(); - return NULL; - } - __pyx_L3_first_run:; - if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 140, __pyx_L1_error) + /* "hunter/_predicates.pyx":133 + * query_startswith = {} + * query_endswith = {} + * query_in = {} # <<<<<<<<<<<<<< + * query_contains = {} + * query_regex = {} +*/ + __Pyx_TraceLine(133,8,0,__PYX_ERR(0, 133, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_query_in = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; - /* "hunter/_predicates.pyx":142 - * ', '.join('%s%s=%r' % (key, kind, value) for key, value in mapping) - * for kind, mapping in [ - * ('', self.query_eq), # <<<<<<<<<<<<<< - * ('_in', self.query_in), - * ('_contains', self.query_contains), - */ - __Pyx_TraceLine(142,0,__PYX_ERR(0, 142, __pyx_L1_error)) - if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 142, __pyx_L1_error) } - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 142, __pyx_L1_error) + /* "hunter/_predicates.pyx":134 + * query_endswith = {} + * query_in = {} + * query_contains = {} # <<<<<<<<<<<<<< + * query_regex = {} + * query_lt = {} +*/ + __Pyx_TraceLine(134,10,0,__PYX_ERR(0, 134, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 134, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_kp_s__2); - __Pyx_GIVEREF(__pyx_kp_s__2); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_s__2); - __Pyx_INCREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_eq); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_eq); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_eq); - - /* "hunter/_predicates.pyx":143 - * for kind, mapping in [ - * ('', self.query_eq), - * ('_in', self.query_in), # <<<<<<<<<<<<<< - * ('_contains', self.query_contains), - * ('_startswith', self.query_startswith), - */ - __Pyx_TraceLine(143,0,__PYX_ERR(0, 143, __pyx_L1_error)) - if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 143, __pyx_L1_error) } - __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 143, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_n_s_in_2); - __Pyx_GIVEREF(__pyx_n_s_in_2); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_in_2); - __Pyx_INCREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_in); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_in); - PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_in); - - /* "hunter/_predicates.pyx":144 - * ('', self.query_eq), - * ('_in', self.query_in), - * ('_contains', self.query_contains), # <<<<<<<<<<<<<< - * ('_startswith', self.query_startswith), - * ('_endswith', self.query_endswith), - */ - __Pyx_TraceLine(144,0,__PYX_ERR(0, 144, __pyx_L1_error)) - if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 144, __pyx_L1_error) } - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 144, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(__pyx_n_s_contains_2); - __Pyx_GIVEREF(__pyx_n_s_contains_2); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_contains_2); - __Pyx_INCREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_contains); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_contains); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_contains); - - /* "hunter/_predicates.pyx":145 - * ('_in', self.query_in), - * ('_contains', self.query_contains), - * ('_startswith', self.query_startswith), # <<<<<<<<<<<<<< - * ('_endswith', self.query_endswith), - * ('_regex', self.query_regex), - */ - __Pyx_TraceLine(145,0,__PYX_ERR(0, 145, __pyx_L1_error)) - if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 145, __pyx_L1_error) } - __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 145, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_INCREF(__pyx_n_s_startswith_2); - __Pyx_GIVEREF(__pyx_n_s_startswith_2); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_n_s_startswith_2); - __Pyx_INCREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_startswith); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_startswith); - PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_startswith); - - /* "hunter/_predicates.pyx":146 - * ('_contains', self.query_contains), - * ('_startswith', self.query_startswith), - * ('_endswith', self.query_endswith), # <<<<<<<<<<<<<< - * ('_regex', self.query_regex), - * ('_lt', self.query_lt), - */ - __Pyx_TraceLine(146,0,__PYX_ERR(0, 146, __pyx_L1_error)) - if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 146, __pyx_L1_error) } - __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 146, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_INCREF(__pyx_n_s_endswith_2); - __Pyx_GIVEREF(__pyx_n_s_endswith_2); - PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_n_s_endswith_2); - __Pyx_INCREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_endswith); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_endswith); - PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_endswith); - - /* "hunter/_predicates.pyx":147 - * ('_startswith', self.query_startswith), - * ('_endswith', self.query_endswith), - * ('_regex', self.query_regex), # <<<<<<<<<<<<<< - * ('_lt', self.query_lt), - * ('_lte', self.query_lte), - */ - __Pyx_TraceLine(147,0,__PYX_ERR(0, 147, __pyx_L1_error)) - if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 147, __pyx_L1_error) } - __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 147, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_INCREF(__pyx_n_s_regex_2); - __Pyx_GIVEREF(__pyx_n_s_regex_2); - PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_n_s_regex_2); - __Pyx_INCREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_regex); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_regex); - PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_regex); - - /* "hunter/_predicates.pyx":148 - * ('_endswith', self.query_endswith), - * ('_regex', self.query_regex), - * ('_lt', self.query_lt), # <<<<<<<<<<<<<< - * ('_lte', self.query_lte), - * ('_gt', self.query_gt), - */ - __Pyx_TraceLine(148,0,__PYX_ERR(0, 148, __pyx_L1_error)) - if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 148, __pyx_L1_error) } - __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 148, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_INCREF(__pyx_n_s_lt_2); - __Pyx_GIVEREF(__pyx_n_s_lt_2); - PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_n_s_lt_2); - __Pyx_INCREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_lt); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_lt); - PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_lt); - - /* "hunter/_predicates.pyx":149 - * ('_regex', self.query_regex), - * ('_lt', self.query_lt), - * ('_lte', self.query_lte), # <<<<<<<<<<<<<< - * ('_gt', self.query_gt), - * ('_gte', self.query_gte), - */ - __Pyx_TraceLine(149,0,__PYX_ERR(0, 149, __pyx_L1_error)) - if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 149, __pyx_L1_error) } - __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 149, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_INCREF(__pyx_n_s_lte_2); - __Pyx_GIVEREF(__pyx_n_s_lte_2); - PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_n_s_lte_2); - __Pyx_INCREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_lte); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_lte); - PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_lte); - - /* "hunter/_predicates.pyx":150 - * ('_lt', self.query_lt), - * ('_lte', self.query_lte), - * ('_gt', self.query_gt), # <<<<<<<<<<<<<< - * ('_gte', self.query_gte), - * ] if mapping - */ - __Pyx_TraceLine(150,0,__PYX_ERR(0, 150, __pyx_L1_error)) - if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 150, __pyx_L1_error) } - __pyx_t_9 = PyTuple_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 150, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_INCREF(__pyx_n_s_gt_2); - __Pyx_GIVEREF(__pyx_n_s_gt_2); - PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_n_s_gt_2); - __Pyx_INCREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_gt); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_gt); - PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_gt); - - /* "hunter/_predicates.pyx":151 - * ('_lte', self.query_lte), - * ('_gt', self.query_gt), - * ('_gte', self.query_gte), # <<<<<<<<<<<<<< - * ] if mapping - * ) - */ - __Pyx_TraceLine(151,0,__PYX_ERR(0, 151, __pyx_L1_error)) - if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 151, __pyx_L1_error) } - __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 151, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_10); - __Pyx_INCREF(__pyx_n_s_gte_2); - __Pyx_GIVEREF(__pyx_n_s_gte_2); - PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_n_s_gte_2); - __Pyx_INCREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_gte); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_gte); - PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_gte); - - /* "hunter/_predicates.pyx":141 - * ', '.join( - * ', '.join('%s%s=%r' % (key, kind, value) for key, value in mapping) - * for kind, mapping in [ # <<<<<<<<<<<<<< - * ('', self.query_eq), - * ('_in', self.query_in), - */ - __Pyx_TraceLine(141,0,__PYX_ERR(0, 141, __pyx_L1_error)) - __pyx_t_11 = PyTuple_New(10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 141, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_11); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_t_2); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_11, 2, __pyx_t_3); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_11, 3, __pyx_t_4); - __Pyx_GIVEREF(__pyx_t_5); - PyTuple_SET_ITEM(__pyx_t_11, 4, __pyx_t_5); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_11, 5, __pyx_t_6); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_11, 6, __pyx_t_7); - __Pyx_GIVEREF(__pyx_t_8); - PyTuple_SET_ITEM(__pyx_t_11, 7, __pyx_t_8); - __Pyx_GIVEREF(__pyx_t_9); - PyTuple_SET_ITEM(__pyx_t_11, 8, __pyx_t_9); - __Pyx_GIVEREF(__pyx_t_10); - PyTuple_SET_ITEM(__pyx_t_11, 9, __pyx_t_10); + __pyx_v_query_contains = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_2 = 0; - __pyx_t_3 = 0; - __pyx_t_4 = 0; - __pyx_t_5 = 0; - __pyx_t_6 = 0; - __pyx_t_7 = 0; - __pyx_t_8 = 0; - __pyx_t_9 = 0; - __pyx_t_10 = 0; - __pyx_t_10 = __pyx_t_11; __Pyx_INCREF(__pyx_t_10); __pyx_t_12 = 0; - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - for (;;) { - if (__pyx_t_12 >= 10) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_11 = PyTuple_GET_ITEM(__pyx_t_10, __pyx_t_12); __Pyx_INCREF(__pyx_t_11); __pyx_t_12++; if (unlikely(0 < 0)) __PYX_ERR(0, 141, __pyx_L1_error) - #else - __pyx_t_11 = PySequence_ITEM(__pyx_t_10, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 141, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_11); - #endif - if (likely(__pyx_t_11 != Py_None)) { - PyObject* sequence = __pyx_t_11; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 141, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_9 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_8 = PyTuple_GET_ITEM(sequence, 1); - __Pyx_INCREF(__pyx_t_9); - __Pyx_INCREF(__pyx_t_8); - #else - __pyx_t_9 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 141, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 141, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - #endif - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - } else { - __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(0, 141, __pyx_L1_error) - } - __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_kind); - __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_kind, __pyx_t_9); - __Pyx_GIVEREF(__pyx_t_9); - __pyx_t_9 = 0; - __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_mapping); - __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_mapping, __pyx_t_8); - __Pyx_GIVEREF(__pyx_t_8); - __pyx_t_8 = 0; - - /* "hunter/_predicates.pyx":152 - * ('_gt', self.query_gt), - * ('_gte', self.query_gte), - * ] if mapping # <<<<<<<<<<<<<< - * ) - * ) - */ - __Pyx_TraceLine(152,0,__PYX_ERR(0, 152, __pyx_L1_error)) - __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_mapping); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 152, __pyx_L1_error) - if (__pyx_t_13) { - - /* "hunter/_predicates.pyx":140 - * return 'Query(%s)' % ( - * ', '.join( - * ', '.join('%s%s=%r' % (key, kind, value) for key, value in mapping) # <<<<<<<<<<<<<< - * for kind, mapping in [ - * ('', self.query_eq), - */ - __Pyx_TraceLine(140,0,__PYX_ERR(0, 140, __pyx_L1_error)) - __pyx_t_11 = __pyx_pf_6hunter_11_predicates_5Query_7__str___7genexpr_genexpr(((PyObject*)__pyx_cur_scope)); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 140, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_11); - __pyx_t_8 = __Pyx_PyString_Join(__pyx_kp_s__3, __pyx_t_11); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 140, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __pyx_r = __pyx_t_8; - __pyx_t_8 = 0; - __Pyx_XGIVEREF(__pyx_t_10); - __pyx_cur_scope->__pyx_t_0 = __pyx_t_10; - __pyx_cur_scope->__pyx_t_1 = __pyx_t_12; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - __Pyx_Coroutine_ResetAndClearException(__pyx_generator); - /* return from generator, yielding value */ - __pyx_generator->resume_label = 1; - return __pyx_r; - __pyx_L7_resume_from_yield:; - __pyx_t_10 = __pyx_cur_scope->__pyx_t_0; - __pyx_cur_scope->__pyx_t_0 = 0; - __Pyx_XGOTREF(__pyx_t_10); - __pyx_t_12 = __pyx_cur_scope->__pyx_t_1; - if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 140, __pyx_L1_error) - - /* "hunter/_predicates.pyx":152 - * ('_gt', self.query_gt), - * ('_gte', self.query_gte), - * ] if mapping # <<<<<<<<<<<<<< - * ) - * ) - */ - } - - /* "hunter/_predicates.pyx":141 - * ', '.join( - * ', '.join('%s%s=%r' % (key, kind, value) for key, value in mapping) - * for kind, mapping in [ # <<<<<<<<<<<<<< - * ('', self.query_eq), - * ('_in', self.query_in), - */ - __Pyx_TraceLine(141,0,__PYX_ERR(0, 141, __pyx_L1_error)) - } - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); - - /* "hunter/_predicates.pyx":140 - * return 'Query(%s)' % ( - * ', '.join( - * ', '.join('%s%s=%r' % (key, kind, value) for key, value in mapping) # <<<<<<<<<<<<<< - * for kind, mapping in [ - * ('', self.query_eq), - */ - /* function exit code */ - PyErr_SetNone(PyExc_StopIteration); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_XDECREF(__pyx_t_9); - __Pyx_XDECREF(__pyx_t_10); - __Pyx_XDECREF(__pyx_t_11); - __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_L0:; - __Pyx_XDECREF(__pyx_r); __pyx_r = 0; - #if !CYTHON_USE_EXC_INFO_STACK - __Pyx_Coroutine_ResetAndClearException(__pyx_generator); - #endif - __pyx_generator->resume_label = -1; - __Pyx_Coroutine_clear((PyObject*)__pyx_generator); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":135 + * query_in = {} + * query_contains = {} + * query_regex = {} # <<<<<<<<<<<<<< + * query_lt = {} + * query_lte = {} +*/ + __Pyx_TraceLine(135,12,0,__PYX_ERR(0, 135, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_query_regex = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; -/* "hunter/_predicates.pyx":137 - * self.query_gte = tuple(sorted(query_gte.items())) - * - * def __str__(self): # <<<<<<<<<<<<<< - * return 'Query(%s)' % ( - * ', '.join( - */ + /* "hunter/_predicates.pyx":136 + * query_contains = {} + * query_regex = {} + * query_lt = {} # <<<<<<<<<<<<<< + * query_lte = {} + * query_gt = {} +*/ + __Pyx_TraceLine(136,14,0,__PYX_ERR(0, 136, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_query_lt = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_2__str__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self) { - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__ *__pyx_cur_scope; - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - __Pyx_RefNannySetupContext("__str__", 0); - __pyx_cur_scope = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__ *)__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct____str__(__pyx_ptype_6hunter_11_predicates___pyx_scope_struct____str__, __pyx_empty_tuple, NULL); - if (unlikely(!__pyx_cur_scope)) { - __pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__ *)Py_None); - __Pyx_INCREF(Py_None); - __PYX_ERR(0, 137, __pyx_L1_error) - } else { - __Pyx_GOTREF(__pyx_cur_scope); - } - __Pyx_TraceCall("__str__", __pyx_f[0], 137, 0, __PYX_ERR(0, 137, __pyx_L1_error)); - __pyx_cur_scope->__pyx_v_self = __pyx_v_self; - __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self); - __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self); + /* "hunter/_predicates.pyx":137 + * query_regex = {} + * query_lt = {} + * query_lte = {} # <<<<<<<<<<<<<< + * query_gt = {} + * query_gte = {} +*/ + __Pyx_TraceLine(137,16,0,__PYX_ERR(0, 137, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_query_lte = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; /* "hunter/_predicates.pyx":138 + * query_lt = {} + * query_lte = {} + * query_gt = {} # <<<<<<<<<<<<<< + * query_gte = {} * - * def __str__(self): - * return 'Query(%s)' % ( # <<<<<<<<<<<<<< - * ', '.join( - * ', '.join('%s%s=%r' % (key, kind, value) for key, value in mapping) - */ - __Pyx_TraceLine(138,0,__PYX_ERR(0, 138, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - - /* "hunter/_predicates.pyx":140 - * return 'Query(%s)' % ( - * ', '.join( - * ', '.join('%s%s=%r' % (key, kind, value) for key, value in mapping) # <<<<<<<<<<<<<< - * for kind, mapping in [ - * ('', self.query_eq), - */ - __Pyx_TraceLine(140,0,__PYX_ERR(0, 140, __pyx_L1_error)) - __pyx_t_1 = __pyx_pf_6hunter_11_predicates_5Query_7__str___genexpr(((PyObject*)__pyx_cur_scope)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 140, __pyx_L1_error) +*/ + __Pyx_TraceLine(138,18,0,__PYX_ERR(0, 138, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 138, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); + __pyx_v_query_gt = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; /* "hunter/_predicates.pyx":139 - * def __str__(self): - * return 'Query(%s)' % ( - * ', '.join( # <<<<<<<<<<<<<< - * ', '.join('%s%s=%r' % (key, kind, value) for key, value in mapping) - * for kind, mapping in [ - */ - __Pyx_TraceLine(139,0,__PYX_ERR(0, 139, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyString_Join(__pyx_kp_s__3, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 139, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "hunter/_predicates.pyx":138 + * query_lte = {} + * query_gt = {} + * query_gte = {} # <<<<<<<<<<<<<< * - * def __str__(self): - * return 'Query(%s)' % ( # <<<<<<<<<<<<<< - * ', '.join( - * ', '.join('%s%s=%r' % (key, kind, value) for key, value in mapping) - */ - __Pyx_TraceLine(138,0,__PYX_ERR(0, 138, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Query_s, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 138, __pyx_L1_error) + * for key, value in query.items(): +*/ + __Pyx_TraceLine(139,20,0,__PYX_ERR(0, 139, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 139, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_r = __pyx_t_1; + __pyx_v_query_gte = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - goto __pyx_L0; - /* "hunter/_predicates.pyx":137 - * self.query_gte = tuple(sorted(query_gte.items())) + /* "hunter/_predicates.pyx":141 + * query_gte = {} * - * def __str__(self): # <<<<<<<<<<<<<< - * return 'Query(%s)' % ( - * ', '.join( - */ - - /* function exit code */ - __pyx_L1_error:; + * for key, value in query.items(): # <<<<<<<<<<<<<< + * parts = [p for p in key.split('_') if p] + * count = len(parts) +*/ + __Pyx_TraceLine(141,21,0,__PYX_ERR(0, 141, __pyx_L1_error)) + __pyx_t_2 = 0; + __pyx_t_5 = __Pyx_dict_iterator(__pyx_v_query, 1, __pyx_mstate_global->__pyx_n_u_items, (&__pyx_t_3), (&__pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("hunter._predicates.Query.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + __pyx_t_1 = __pyx_t_5; + __pyx_t_5 = 0; + while (1) { + __pyx_t_7 = __Pyx_dict_iter_next(__pyx_t_1, __pyx_t_3, &__pyx_t_2, &__pyx_t_5, &__pyx_t_6, NULL, __pyx_t_4); + if (unlikely(__pyx_t_7 == 0)) break; + if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_5); + __pyx_t_5 = 0; + __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_6); + __pyx_t_6 = 0; -/* "hunter/_predicates.pyx":156 - * ) + /* "hunter/_predicates.pyx":142 * - * def __repr__(self): # <<<<<<<<<<<<<< - * return '' % ' '.join( - * fmt % (mapping,) for fmt, mapping in [ - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_5__repr__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_5__repr__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_4__repr__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} -static PyObject *__pyx_gb_6hunter_11_predicates_5Query_8__repr___2generator2(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ - -/* "hunter/_predicates.pyx":158 - * def __repr__(self): - * return '' % ' '.join( - * fmt % (mapping,) for fmt, mapping in [ # <<<<<<<<<<<<<< - * ('query_eq=%r', self.query_eq), - * ('query_in=%r', self.query_in), - */ - -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_8__repr___genexpr(PyObject *__pyx_self) { - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr *__pyx_cur_scope; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("genexpr", 0); - __pyx_cur_scope = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr *)__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_4_genexpr(__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_4_genexpr, __pyx_empty_tuple, NULL); - if (unlikely(!__pyx_cur_scope)) { - __pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr *)Py_None); - __Pyx_INCREF(Py_None); - __PYX_ERR(0, 158, __pyx_L1_error) - } else { - __Pyx_GOTREF(__pyx_cur_scope); - } - __pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3___repr__ *) __pyx_self; - __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_outer_scope)); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope); - { - __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_6hunter_11_predicates_5Query_8__repr___2generator2, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_repr___locals_genexpr, __pyx_n_s_hunter__predicates); if (unlikely(!gen)) __PYX_ERR(0, 158, __pyx_L1_error) - __Pyx_DECREF(__pyx_cur_scope); - __Pyx_RefNannyFinishContext(); - return (PyObject *) gen; - } - - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.Query.__repr__.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_gb_6hunter_11_predicates_5Query_8__repr___2generator2(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ -{ - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr *__pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr *)__pyx_generator->closure); - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - PyObject *__pyx_t_9 = NULL; - PyObject *__pyx_t_10 = NULL; - PyObject *__pyx_t_11 = NULL; - Py_ssize_t __pyx_t_12; - int __pyx_t_13; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("genexpr", 0); - __Pyx_TraceCall("genexpr", __pyx_f[0], 158, 0, __PYX_ERR(0, 158, __pyx_L1_error)); - switch (__pyx_generator->resume_label) { - case 0: goto __pyx_L3_first_run; - case 1: goto __pyx_L7_resume_from_yield; - default: /* CPython raises the right error here */ - __Pyx_TraceReturn(Py_None, 0); - __Pyx_RefNannyFinishContext(); - return NULL; - } - __pyx_L3_first_run:; - if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 158, __pyx_L1_error) - - /* "hunter/_predicates.pyx":159 - * return '' % ' '.join( - * fmt % (mapping,) for fmt, mapping in [ - * ('query_eq=%r', self.query_eq), # <<<<<<<<<<<<<< - * ('query_in=%r', self.query_in), - * ('query_contains=%r', self.query_contains), - */ - __Pyx_TraceLine(159,0,__PYX_ERR(0, 159, __pyx_L1_error)) - if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 159, __pyx_L1_error) } - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 159, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_kp_s_query_eq_r); - __Pyx_GIVEREF(__pyx_kp_s_query_eq_r); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_s_query_eq_r); - __Pyx_INCREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_eq); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_eq); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_eq); - - /* "hunter/_predicates.pyx":160 - * fmt % (mapping,) for fmt, mapping in [ - * ('query_eq=%r', self.query_eq), - * ('query_in=%r', self.query_in), # <<<<<<<<<<<<<< - * ('query_contains=%r', self.query_contains), - * ('query_startswith=%r', self.query_startswith), - */ - __Pyx_TraceLine(160,0,__PYX_ERR(0, 160, __pyx_L1_error)) - if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 160, __pyx_L1_error) } - __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 160, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_kp_s_query_in_r); - __Pyx_GIVEREF(__pyx_kp_s_query_in_r); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_s_query_in_r); - __Pyx_INCREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_in); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_in); - PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_in); - - /* "hunter/_predicates.pyx":161 - * ('query_eq=%r', self.query_eq), - * ('query_in=%r', self.query_in), - * ('query_contains=%r', self.query_contains), # <<<<<<<<<<<<<< - * ('query_startswith=%r', self.query_startswith), - * ('query_endswith=%r', self.query_endswith), - */ - __Pyx_TraceLine(161,0,__PYX_ERR(0, 161, __pyx_L1_error)) - if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 161, __pyx_L1_error) } - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 161, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(__pyx_kp_s_query_contains_r); - __Pyx_GIVEREF(__pyx_kp_s_query_contains_r); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_s_query_contains_r); - __Pyx_INCREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_contains); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_contains); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_contains); - - /* "hunter/_predicates.pyx":162 - * ('query_in=%r', self.query_in), - * ('query_contains=%r', self.query_contains), - * ('query_startswith=%r', self.query_startswith), # <<<<<<<<<<<<<< - * ('query_endswith=%r', self.query_endswith), - * ('query_regex=%r', self.query_regex), - */ - __Pyx_TraceLine(162,0,__PYX_ERR(0, 162, __pyx_L1_error)) - if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 162, __pyx_L1_error) } - __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 162, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_INCREF(__pyx_kp_s_query_startswith_r); - __Pyx_GIVEREF(__pyx_kp_s_query_startswith_r); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_kp_s_query_startswith_r); - __Pyx_INCREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_startswith); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_startswith); - PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_startswith); - - /* "hunter/_predicates.pyx":163 - * ('query_contains=%r', self.query_contains), - * ('query_startswith=%r', self.query_startswith), - * ('query_endswith=%r', self.query_endswith), # <<<<<<<<<<<<<< - * ('query_regex=%r', self.query_regex), - * ('query_lt=%r', self.query_lt), - */ - __Pyx_TraceLine(163,0,__PYX_ERR(0, 163, __pyx_L1_error)) - if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 163, __pyx_L1_error) } - __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 163, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_INCREF(__pyx_kp_s_query_endswith_r); - __Pyx_GIVEREF(__pyx_kp_s_query_endswith_r); - PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_kp_s_query_endswith_r); - __Pyx_INCREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_endswith); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_endswith); - PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_endswith); - - /* "hunter/_predicates.pyx":164 - * ('query_startswith=%r', self.query_startswith), - * ('query_endswith=%r', self.query_endswith), - * ('query_regex=%r', self.query_regex), # <<<<<<<<<<<<<< - * ('query_lt=%r', self.query_lt), - * ('query_lte=%r', self.query_lte), - */ - __Pyx_TraceLine(164,0,__PYX_ERR(0, 164, __pyx_L1_error)) - if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 164, __pyx_L1_error) } - __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 164, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_INCREF(__pyx_kp_s_query_regex_r); - __Pyx_GIVEREF(__pyx_kp_s_query_regex_r); - PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_s_query_regex_r); - __Pyx_INCREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_regex); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_regex); - PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_regex); - - /* "hunter/_predicates.pyx":165 - * ('query_endswith=%r', self.query_endswith), - * ('query_regex=%r', self.query_regex), - * ('query_lt=%r', self.query_lt), # <<<<<<<<<<<<<< - * ('query_lte=%r', self.query_lte), - * ('query_gt=%r', self.query_gt), - */ - __Pyx_TraceLine(165,0,__PYX_ERR(0, 165, __pyx_L1_error)) - if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 165, __pyx_L1_error) } - __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 165, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_INCREF(__pyx_kp_s_query_lt_r); - __Pyx_GIVEREF(__pyx_kp_s_query_lt_r); - PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_s_query_lt_r); - __Pyx_INCREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_lt); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_lt); - PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_lt); - - /* "hunter/_predicates.pyx":166 - * ('query_regex=%r', self.query_regex), - * ('query_lt=%r', self.query_lt), - * ('query_lte=%r', self.query_lte), # <<<<<<<<<<<<<< - * ('query_gt=%r', self.query_gt), - * ('query_gte=%r', self.query_gte), - */ - __Pyx_TraceLine(166,0,__PYX_ERR(0, 166, __pyx_L1_error)) - if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 166, __pyx_L1_error) } - __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 166, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_INCREF(__pyx_kp_s_query_lte_r); - __Pyx_GIVEREF(__pyx_kp_s_query_lte_r); - PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_s_query_lte_r); - __Pyx_INCREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_lte); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_lte); - PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_lte); - - /* "hunter/_predicates.pyx":167 - * ('query_lt=%r', self.query_lt), - * ('query_lte=%r', self.query_lte), - * ('query_gt=%r', self.query_gt), # <<<<<<<<<<<<<< - * ('query_gte=%r', self.query_gte), - * - */ - __Pyx_TraceLine(167,0,__PYX_ERR(0, 167, __pyx_L1_error)) - if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 167, __pyx_L1_error) } - __pyx_t_9 = PyTuple_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 167, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_INCREF(__pyx_kp_s_query_gt_r); - __Pyx_GIVEREF(__pyx_kp_s_query_gt_r); - PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_kp_s_query_gt_r); - __Pyx_INCREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_gt); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_gt); - PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_gt); - - /* "hunter/_predicates.pyx":168 - * ('query_lte=%r', self.query_lte), - * ('query_gt=%r', self.query_gt), - * ('query_gte=%r', self.query_gte), # <<<<<<<<<<<<<< - * - * ] if mapping - */ - __Pyx_TraceLine(168,0,__PYX_ERR(0, 168, __pyx_L1_error)) - if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 168, __pyx_L1_error) } - __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 168, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_10); - __Pyx_INCREF(__pyx_kp_s_query_gte_r); - __Pyx_GIVEREF(__pyx_kp_s_query_gte_r); - PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_kp_s_query_gte_r); - __Pyx_INCREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_gte); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_gte); - PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->query_gte); - - /* "hunter/_predicates.pyx":158 - * def __repr__(self): - * return '' % ' '.join( - * fmt % (mapping,) for fmt, mapping in [ # <<<<<<<<<<<<<< - * ('query_eq=%r', self.query_eq), - * ('query_in=%r', self.query_in), - */ - __Pyx_TraceLine(158,0,__PYX_ERR(0, 158, __pyx_L1_error)) - __pyx_t_11 = PyTuple_New(10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 158, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_11); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_t_2); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_11, 2, __pyx_t_3); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_11, 3, __pyx_t_4); - __Pyx_GIVEREF(__pyx_t_5); - PyTuple_SET_ITEM(__pyx_t_11, 4, __pyx_t_5); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_11, 5, __pyx_t_6); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_11, 6, __pyx_t_7); - __Pyx_GIVEREF(__pyx_t_8); - PyTuple_SET_ITEM(__pyx_t_11, 7, __pyx_t_8); - __Pyx_GIVEREF(__pyx_t_9); - PyTuple_SET_ITEM(__pyx_t_11, 8, __pyx_t_9); - __Pyx_GIVEREF(__pyx_t_10); - PyTuple_SET_ITEM(__pyx_t_11, 9, __pyx_t_10); - __pyx_t_1 = 0; - __pyx_t_2 = 0; - __pyx_t_3 = 0; - __pyx_t_4 = 0; - __pyx_t_5 = 0; - __pyx_t_6 = 0; - __pyx_t_7 = 0; - __pyx_t_8 = 0; - __pyx_t_9 = 0; - __pyx_t_10 = 0; - __pyx_t_10 = __pyx_t_11; __Pyx_INCREF(__pyx_t_10); __pyx_t_12 = 0; - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - for (;;) { - if (__pyx_t_12 >= 10) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_11 = PyTuple_GET_ITEM(__pyx_t_10, __pyx_t_12); __Pyx_INCREF(__pyx_t_11); __pyx_t_12++; if (unlikely(0 < 0)) __PYX_ERR(0, 158, __pyx_L1_error) - #else - __pyx_t_11 = PySequence_ITEM(__pyx_t_10, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 158, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_11); - #endif - if (likely(__pyx_t_11 != Py_None)) { - PyObject* sequence = __pyx_t_11; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 158, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_9 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_8 = PyTuple_GET_ITEM(sequence, 1); - __Pyx_INCREF(__pyx_t_9); + * for key, value in query.items(): + * parts = [p for p in key.split('_') if p] # <<<<<<<<<<<<<< + * count = len(parts) + * if count > 2: +*/ + __Pyx_TraceLine(142,28,0,__PYX_ERR(0, 142, __pyx_L1_error)) + { /* enter inner scope */ + __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 142, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __pyx_v_key; __Pyx_INCREF(__pyx_t_8); - #else - __pyx_t_9 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 158, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 158, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - #endif - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - } else { - __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(0, 158, __pyx_L1_error) - } - __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_fmt); - __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_fmt, __pyx_t_9); - __Pyx_GIVEREF(__pyx_t_9); - __pyx_t_9 = 0; - __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_mapping); - __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_mapping, __pyx_t_8); - __Pyx_GIVEREF(__pyx_t_8); - __pyx_t_8 = 0; + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_mstate_global->__pyx_n_u_}; + __pyx_t_5 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_split, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 142, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_5); + } + if (likely(PyList_CheckExact(__pyx_t_5)) || PyTuple_CheckExact(__pyx_t_5)) { + __pyx_t_8 = __pyx_t_5; __Pyx_INCREF(__pyx_t_8); + __pyx_t_10 = 0; + __pyx_t_11 = NULL; + } else { + __pyx_t_10 = -1; __pyx_t_8 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 142, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_11 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_8); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 142, __pyx_L7_error) + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + for (;;) { + if (likely(!__pyx_t_11)) { + if (likely(PyList_CheckExact(__pyx_t_8))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_8); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 142, __pyx_L7_error) + #endif + if (__pyx_t_10 >= __pyx_temp) break; + } + __pyx_t_5 = __Pyx_PyList_GetItemRef(__pyx_t_8, __pyx_t_10); + ++__pyx_t_10; + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_8); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 142, __pyx_L7_error) + #endif + if (__pyx_t_10 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_8, __pyx_t_10)); + #else + __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_8, __pyx_t_10); + #endif + ++__pyx_t_10; + } + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 142, __pyx_L7_error) + } else { + __pyx_t_5 = __pyx_t_11(__pyx_t_8); + if (unlikely(!__pyx_t_5)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 142, __pyx_L7_error) + PyErr_Clear(); + } + break; + } + } + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF_SET(__pyx_7genexpr__pyx_v_p, __pyx_t_5); + __pyx_t_5 = 0; + __Pyx_TraceLine(142,30,0,__PYX_ERR(0, 142, __pyx_L7_error)) + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_7genexpr__pyx_v_p); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 142, __pyx_L7_error) + if (__pyx_t_12) { + if (unlikely(__Pyx_ListComp_Append(__pyx_t_6, (PyObject*)__pyx_7genexpr__pyx_v_p))) __PYX_ERR(0, 142, __pyx_L7_error) + } + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_7genexpr__pyx_v_p); __pyx_7genexpr__pyx_v_p = 0; + goto __pyx_L12_exit_scope; + __pyx_L7_error:; + __Pyx_XDECREF(__pyx_7genexpr__pyx_v_p); __pyx_7genexpr__pyx_v_p = 0; + goto __pyx_L1_error; + __pyx_L12_exit_scope:; + } /* exit inner scope */ + __Pyx_XDECREF_SET(__pyx_v_parts, ((PyObject*)__pyx_t_6)); + __pyx_t_6 = 0; - /* "hunter/_predicates.pyx":170 - * ('query_gte=%r', self.query_gte), - * - * ] if mapping # <<<<<<<<<<<<<< - * ) - * - */ - __Pyx_TraceLine(170,0,__PYX_ERR(0, 170, __pyx_L1_error)) - __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_mapping); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 170, __pyx_L1_error) - if (__pyx_t_13) { + /* "hunter/_predicates.pyx":143 + * for key, value in query.items(): + * parts = [p for p in key.split('_') if p] + * count = len(parts) # <<<<<<<<<<<<<< + * if count > 2: + * raise TypeError( +*/ + __Pyx_TraceLine(143,40,0,__PYX_ERR(0, 143, __pyx_L1_error)) + __pyx_t_10 = __Pyx_PyList_GET_SIZE(__pyx_v_parts); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(0, 143, __pyx_L1_error) + __pyx_v_count = __pyx_t_10; - /* "hunter/_predicates.pyx":158 - * def __repr__(self): - * return '' % ' '.join( - * fmt % (mapping,) for fmt, mapping in [ # <<<<<<<<<<<<<< - * ('query_eq=%r', self.query_eq), - * ('query_in=%r', self.query_in), - */ - __Pyx_TraceLine(158,0,__PYX_ERR(0, 158, __pyx_L1_error)) - __pyx_t_11 = PyTuple_New(1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 158, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_11); - __Pyx_INCREF(__pyx_cur_scope->__pyx_v_mapping); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_mapping); - PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_cur_scope->__pyx_v_mapping); - __pyx_t_8 = PyNumber_Remainder(__pyx_cur_scope->__pyx_v_fmt, __pyx_t_11); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 158, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __pyx_r = __pyx_t_8; - __pyx_t_8 = 0; - __Pyx_XGIVEREF(__pyx_t_10); - __pyx_cur_scope->__pyx_t_0 = __pyx_t_10; - __pyx_cur_scope->__pyx_t_1 = __pyx_t_12; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - __Pyx_Coroutine_ResetAndClearException(__pyx_generator); - /* return from generator, yielding value */ - __pyx_generator->resume_label = 1; - return __pyx_r; - __pyx_L7_resume_from_yield:; - __pyx_t_10 = __pyx_cur_scope->__pyx_t_0; - __pyx_cur_scope->__pyx_t_0 = 0; - __Pyx_XGOTREF(__pyx_t_10); - __pyx_t_12 = __pyx_cur_scope->__pyx_t_1; - if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 158, __pyx_L1_error) - - /* "hunter/_predicates.pyx":170 - * ('query_gte=%r', self.query_gte), - * - * ] if mapping # <<<<<<<<<<<<<< - * ) - * - */ - } + /* "hunter/_predicates.pyx":144 + * parts = [p for p in key.split('_') if p] + * count = len(parts) + * if count > 2: # <<<<<<<<<<<<<< + * raise TypeError( + * f'Unexpected argument {key!r}. Must be one of {ALLOWED_KEYS} with optional operators like: {ALLOWED_OPERATORS}' +*/ + __Pyx_TraceLine(144,44,0,__PYX_ERR(0, 144, __pyx_L1_error)) + __pyx_t_12 = (__pyx_v_count > 2); + if (unlikely(__pyx_t_12)) { - /* "hunter/_predicates.pyx":158 - * def __repr__(self): - * return '' % ' '.join( - * fmt % (mapping,) for fmt, mapping in [ # <<<<<<<<<<<<<< - * ('query_eq=%r', self.query_eq), - * ('query_in=%r', self.query_in), - */ - __Pyx_TraceLine(158,0,__PYX_ERR(0, 158, __pyx_L1_error)) - } - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + /* "hunter/_predicates.pyx":145 + * count = len(parts) + * if count > 2: + * raise TypeError( # <<<<<<<<<<<<<< + * f'Unexpected argument {key!r}. Must be one of {ALLOWED_KEYS} with optional operators like: {ALLOWED_OPERATORS}' + * ) +*/ + __Pyx_TraceLine(145,48,0,__PYX_ERR(0, 145, __pyx_L1_error)) + __pyx_t_8 = NULL; + __Pyx_INCREF(__pyx_builtin_TypeError); + __pyx_t_5 = __pyx_builtin_TypeError; - /* function exit code */ - PyErr_SetNone(PyExc_StopIteration); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_XDECREF(__pyx_t_9); - __Pyx_XDECREF(__pyx_t_10); - __Pyx_XDECREF(__pyx_t_11); - __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_L0:; - __Pyx_XDECREF(__pyx_r); __pyx_r = 0; - #if !CYTHON_USE_EXC_INFO_STACK - __Pyx_Coroutine_ResetAndClearException(__pyx_generator); - #endif - __pyx_generator->resume_label = -1; - __Pyx_Coroutine_clear((PyObject*)__pyx_generator); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":146 + * if count > 2: + * raise TypeError( + * f'Unexpected argument {key!r}. Must be one of {ALLOWED_KEYS} with optional operators like: {ALLOWED_OPERATORS}' # <<<<<<<<<<<<<< + * ) + * elif count == 2: +*/ + __Pyx_TraceLine(146,50,0,__PYX_ERR(0, 146, __pyx_L1_error)) + __pyx_t_13 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_key), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_14 = __Pyx_PyObject_FormatSimple(__pyx_v_6hunter_11_predicates_ALLOWED_KEYS, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + __pyx_t_15 = __Pyx_PyObject_FormatSimple(__pyx_v_6hunter_11_predicates_ALLOWED_OPERATORS, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __pyx_t_16[0] = __pyx_mstate_global->__pyx_kp_u_Unexpected_argument; + __pyx_t_16[1] = __pyx_t_13; + __pyx_t_16[2] = __pyx_mstate_global->__pyx_kp_u_Must_be_one_of; + __pyx_t_16[3] = __pyx_t_14; + __pyx_t_16[4] = __pyx_mstate_global->__pyx_kp_u_with_optional_operators_like; + __pyx_t_16[5] = __pyx_t_15; + __pyx_t_17 = __Pyx_PyUnicode_Join(__pyx_t_16, 6, 20 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_13) + 17 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_14) + 31 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_15), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_13) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_14) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_15)); + if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_9 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_17}; + __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 145, __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, 145, __pyx_L1_error) -/* "hunter/_predicates.pyx":156 - * ) - * - * def __repr__(self): # <<<<<<<<<<<<<< - * return '' % ' '.join( - * fmt % (mapping,) for fmt, mapping in [ - */ + /* "hunter/_predicates.pyx":144 + * parts = [p for p in key.split('_') if p] + * count = len(parts) + * if count > 2: # <<<<<<<<<<<<<< + * raise TypeError( + * f'Unexpected argument {key!r}. Must be one of {ALLOWED_KEYS} with optional operators like: {ALLOWED_OPERATORS}' +*/ + } -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_4__repr__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self) { - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3___repr__ *__pyx_cur_scope; - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - __Pyx_RefNannySetupContext("__repr__", 0); - __pyx_cur_scope = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3___repr__ *)__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_3___repr__(__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_3___repr__, __pyx_empty_tuple, NULL); - if (unlikely(!__pyx_cur_scope)) { - __pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3___repr__ *)Py_None); - __Pyx_INCREF(Py_None); - __PYX_ERR(0, 156, __pyx_L1_error) - } else { - __Pyx_GOTREF(__pyx_cur_scope); - } - __Pyx_TraceCall("__repr__", __pyx_f[0], 156, 0, __PYX_ERR(0, 156, __pyx_L1_error)); - __pyx_cur_scope->__pyx_v_self = __pyx_v_self; - __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self); - __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self); + /* "hunter/_predicates.pyx":148 + * f'Unexpected argument {key!r}. Must be one of {ALLOWED_KEYS} with optional operators like: {ALLOWED_OPERATORS}' + * ) + * elif count == 2: # <<<<<<<<<<<<<< + * prefix, operator = parts + * if operator in ('startswith', 'sw'): +*/ + __Pyx_TraceLine(148,55,0,__PYX_ERR(0, 148, __pyx_L1_error)) + __pyx_t_12 = (__pyx_v_count == 2); + if (__pyx_t_12) { - /* "hunter/_predicates.pyx":157 - * - * def __repr__(self): - * return '' % ' '.join( # <<<<<<<<<<<<<< - * fmt % (mapping,) for fmt, mapping in [ - * ('query_eq=%r', self.query_eq), - */ - __Pyx_TraceLine(157,0,__PYX_ERR(0, 157, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); + /* "hunter/_predicates.pyx":149 + * ) + * elif count == 2: + * prefix, operator = parts # <<<<<<<<<<<<<< + * if operator in ('startswith', 'sw'): + * if not isinstance(value, basestring): +*/ + __Pyx_TraceLine(149,59,0,__PYX_ERR(0, 149, __pyx_L1_error)) + if (1) { + PyObject* sequence = __pyx_v_parts; + Py_ssize_t size = __Pyx_PyList_GET_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 149, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_6 = __Pyx_PyList_GetItemRef(sequence, 0); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_6); + __pyx_t_5 = __Pyx_PyList_GetItemRef(sequence, 1); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_5); + #else + __pyx_t_6 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } + __Pyx_XDECREF_SET(__pyx_v_prefix, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_XDECREF_SET(__pyx_v_operator, __pyx_t_5); + __pyx_t_5 = 0; - /* "hunter/_predicates.pyx":158 - * def __repr__(self): - * return '' % ' '.join( - * fmt % (mapping,) for fmt, mapping in [ # <<<<<<<<<<<<<< - * ('query_eq=%r', self.query_eq), - * ('query_in=%r', self.query_in), - */ - __Pyx_TraceLine(158,0,__PYX_ERR(0, 158, __pyx_L1_error)) - __pyx_t_1 = __pyx_pf_6hunter_11_predicates_5Query_8__repr___genexpr(((PyObject*)__pyx_cur_scope)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 158, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); + /* "hunter/_predicates.pyx":150 + * elif count == 2: + * prefix, operator = parts + * if operator in ('startswith', 'sw'): # <<<<<<<<<<<<<< + * if not isinstance(value, basestring): + * if not isinstance(value, (list, set, tuple)): +*/ + __Pyx_TraceLine(150,61,0,__PYX_ERR(0, 150, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_operator); + __pyx_t_5 = __pyx_v_operator; + __pyx_t_18 = (__Pyx_PyUnicode_Equals(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_startswith, Py_EQ)); if (unlikely((__pyx_t_18 < 0))) __PYX_ERR(0, 150, __pyx_L1_error) + if (!__pyx_t_18) { + } else { + __pyx_t_12 = __pyx_t_18; + goto __pyx_L15_bool_binop_done; + } + __pyx_t_18 = (__Pyx_PyUnicode_Equals(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_sw, Py_EQ)); if (unlikely((__pyx_t_18 < 0))) __PYX_ERR(0, 150, __pyx_L1_error) + __pyx_t_12 = __pyx_t_18; + __pyx_L15_bool_binop_done:; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_18 = __pyx_t_12; + if (__pyx_t_18) { - /* "hunter/_predicates.pyx":157 - * - * def __repr__(self): - * return '' % ' '.join( # <<<<<<<<<<<<<< - * fmt % (mapping,) for fmt, mapping in [ - * ('query_eq=%r', self.query_eq), - */ - __Pyx_TraceLine(157,0,__PYX_ERR(0, 157, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyString_Join(__pyx_kp_s__4, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 157, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_hunter__predicates_Query_s, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 157, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + /* "hunter/_predicates.pyx":151 + * prefix, operator = parts + * if operator in ('startswith', 'sw'): + * if not isinstance(value, basestring): # <<<<<<<<<<<<<< + * if not isinstance(value, (list, set, tuple)): + * raise ValueError(f'Value {value!r} for {key!r} is invalid. Must be a string, list, tuple or set.') +*/ + __Pyx_TraceLine(151,70,0,__PYX_ERR(0, 151, __pyx_L1_error)) + __pyx_t_18 = PyUnicode_Check(__pyx_v_value); + __pyx_t_12 = (!__pyx_t_18); + if (__pyx_t_12) { - /* "hunter/_predicates.pyx":156 - * ) - * - * def __repr__(self): # <<<<<<<<<<<<<< - * return '' % ' '.join( - * fmt % (mapping,) for fmt, mapping in [ - */ + /* "hunter/_predicates.pyx":152 + * if operator in ('startswith', 'sw'): + * if not isinstance(value, basestring): + * if not isinstance(value, (list, set, tuple)): # <<<<<<<<<<<<<< + * raise ValueError(f'Value {value!r} for {key!r} is invalid. Must be a string, list, tuple or set.') + * value = tuple(value) +*/ + __Pyx_TraceLine(152,76,0,__PYX_ERR(0, 152, __pyx_L1_error)) + __pyx_t_18 = PyList_Check(__pyx_v_value); + if (!__pyx_t_18) { + } else { + __pyx_t_12 = __pyx_t_18; + goto __pyx_L19_bool_binop_done; + } + __pyx_t_18 = PySet_Check(__pyx_v_value); + if (!__pyx_t_18) { + } else { + __pyx_t_12 = __pyx_t_18; + goto __pyx_L19_bool_binop_done; + } + __pyx_t_18 = PyTuple_Check(__pyx_v_value); + __pyx_t_12 = __pyx_t_18; + __pyx_L19_bool_binop_done:; + __pyx_t_18 = (!__pyx_t_12); + if (unlikely(__pyx_t_18)) { - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("hunter._predicates.Query.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":153 + * if not isinstance(value, basestring): + * if not isinstance(value, (list, set, tuple)): + * raise ValueError(f'Value {value!r} for {key!r} is invalid. Must be a string, list, tuple or set.') # <<<<<<<<<<<<<< + * value = tuple(value) + * mapping = query_startswith +*/ + __Pyx_TraceLine(153,81,0,__PYX_ERR(0, 153, __pyx_L1_error)) + __pyx_t_6 = NULL; + __Pyx_INCREF(__pyx_builtin_ValueError); + __pyx_t_17 = __pyx_builtin_ValueError; + __pyx_t_8 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_value), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_15 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_key), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __pyx_t_19[0] = __pyx_mstate_global->__pyx_kp_u_Value; + __pyx_t_19[1] = __pyx_t_8; + __pyx_t_19[2] = __pyx_mstate_global->__pyx_kp_u_for; + __pyx_t_19[3] = __pyx_t_15; + __pyx_t_19[4] = __pyx_mstate_global->__pyx_kp_u_is_invalid_Must_be_a_string_lis; + __pyx_t_14 = __Pyx_PyUnicode_Join(__pyx_t_19, 5, 6 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8) + 5 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_15) + 50, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_15)); + if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_9 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_14}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_17, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(0, 153, __pyx_L1_error) -/* "hunter/_predicates.pyx":173 - * ) - * - * def __eq__(self, other): # <<<<<<<<<<<<<< - * return ( - * isinstance(other, Query) - */ + /* "hunter/_predicates.pyx":152 + * if operator in ('startswith', 'sw'): + * if not isinstance(value, basestring): + * if not isinstance(value, (list, set, tuple)): # <<<<<<<<<<<<<< + * raise ValueError(f'Value {value!r} for {key!r} is invalid. Must be a string, list, tuple or set.') + * value = tuple(value) +*/ + } -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_7__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_7__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_6__eq__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + /* "hunter/_predicates.pyx":154 + * if not isinstance(value, (list, set, tuple)): + * raise ValueError(f'Value {value!r} for {key!r} is invalid. Must be a string, list, tuple or set.') + * value = tuple(value) # <<<<<<<<<<<<<< + * mapping = query_startswith + * elif operator in ('endswith', 'ew'): +*/ + __Pyx_TraceLine(154,88,0,__PYX_ERR(0, 154, __pyx_L1_error)) + __pyx_t_5 = __Pyx_PySequence_Tuple(__pyx_v_value); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_5); + __pyx_t_5 = 0; - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":151 + * prefix, operator = parts + * if operator in ('startswith', 'sw'): + * if not isinstance(value, basestring): # <<<<<<<<<<<<<< + * if not isinstance(value, (list, set, tuple)): + * raise ValueError(f'Value {value!r} for {key!r} is invalid. Must be a string, list, tuple or set.') +*/ + } -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_6__eq__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self, PyObject *__pyx_v_other) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - __Pyx_RefNannySetupContext("__eq__", 0); - __Pyx_TraceCall("__eq__", __pyx_f[0], 173, 0, __PYX_ERR(0, 173, __pyx_L1_error)); + /* "hunter/_predicates.pyx":155 + * raise ValueError(f'Value {value!r} for {key!r} is invalid. Must be a string, list, tuple or set.') + * value = tuple(value) + * mapping = query_startswith # <<<<<<<<<<<<<< + * elif operator in ('endswith', 'ew'): + * if not isinstance(value, basestring): +*/ + __Pyx_TraceLine(155,91,0,__PYX_ERR(0, 155, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_query_startswith); + __Pyx_XDECREF_SET(__pyx_v_mapping, __pyx_v_query_startswith); - /* "hunter/_predicates.pyx":174 - * - * def __eq__(self, other): - * return ( # <<<<<<<<<<<<<< - * isinstance(other, Query) - * and self.query_eq == ( other).query_eq - */ - __Pyx_TraceLine(174,0,__PYX_ERR(0, 174, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); + /* "hunter/_predicates.pyx":150 + * elif count == 2: + * prefix, operator = parts + * if operator in ('startswith', 'sw'): # <<<<<<<<<<<<<< + * if not isinstance(value, basestring): + * if not isinstance(value, (list, set, tuple)): +*/ + goto __pyx_L14; + } - /* "hunter/_predicates.pyx":175 - * def __eq__(self, other): - * return ( - * isinstance(other, Query) # <<<<<<<<<<<<<< - * and self.query_eq == ( other).query_eq - * and self.query_startswith == ( other).query_startswith - */ - __Pyx_TraceLine(175,0,__PYX_ERR(0, 175, __pyx_L1_error)) - __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_other, __pyx_ptype_6hunter_11_predicates_Query); - if (__pyx_t_2) { - } else { - __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 175, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __pyx_t_3; - __pyx_t_3 = 0; - goto __pyx_L3_bool_binop_done; - } + /* "hunter/_predicates.pyx":156 + * value = tuple(value) + * mapping = query_startswith + * elif operator in ('endswith', 'ew'): # <<<<<<<<<<<<<< + * if not isinstance(value, basestring): + * if not isinstance(value, (list, set, tuple)): +*/ + __Pyx_TraceLine(156,92,0,__PYX_ERR(0, 156, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_operator); + __pyx_t_5 = __pyx_v_operator; + __pyx_t_12 = (__Pyx_PyUnicode_Equals(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_endswith, Py_EQ)); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 156, __pyx_L1_error) + if (!__pyx_t_12) { + } else { + __pyx_t_18 = __pyx_t_12; + goto __pyx_L22_bool_binop_done; + } + __pyx_t_12 = (__Pyx_PyUnicode_Equals(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_ew, Py_EQ)); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 156, __pyx_L1_error) + __pyx_t_18 = __pyx_t_12; + __pyx_L22_bool_binop_done:; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_12 = __pyx_t_18; + if (__pyx_t_12) { - /* "hunter/_predicates.pyx":176 - * return ( - * isinstance(other, Query) - * and self.query_eq == ( other).query_eq # <<<<<<<<<<<<<< - * and self.query_startswith == ( other).query_startswith - * and self.query_endswith == ( other).query_endswith - */ - __Pyx_TraceLine(176,0,__PYX_ERR(0, 176, __pyx_L1_error)) - __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->query_eq, ((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_other)->query_eq, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 176, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 176, __pyx_L1_error) - if (__pyx_t_2) { - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } else { - __Pyx_INCREF(__pyx_t_3); - __pyx_t_1 = __pyx_t_3; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - goto __pyx_L3_bool_binop_done; - } + /* "hunter/_predicates.pyx":157 + * mapping = query_startswith + * elif operator in ('endswith', 'ew'): + * if not isinstance(value, basestring): # <<<<<<<<<<<<<< + * if not isinstance(value, (list, set, tuple)): + * raise ValueError(f'Value {value!r} for {key!r} is invalid. Must be a string, list, tuple or set.') +*/ + __Pyx_TraceLine(157,101,0,__PYX_ERR(0, 157, __pyx_L1_error)) + __pyx_t_12 = PyUnicode_Check(__pyx_v_value); + __pyx_t_18 = (!__pyx_t_12); + if (__pyx_t_18) { + + /* "hunter/_predicates.pyx":158 + * elif operator in ('endswith', 'ew'): + * if not isinstance(value, basestring): + * if not isinstance(value, (list, set, tuple)): # <<<<<<<<<<<<<< + * raise ValueError(f'Value {value!r} for {key!r} is invalid. Must be a string, list, tuple or set.') + * value = tuple(value) +*/ + __Pyx_TraceLine(158,107,0,__PYX_ERR(0, 158, __pyx_L1_error)) + __pyx_t_12 = PyList_Check(__pyx_v_value); + if (!__pyx_t_12) { + } else { + __pyx_t_18 = __pyx_t_12; + goto __pyx_L26_bool_binop_done; + } + __pyx_t_12 = PySet_Check(__pyx_v_value); + if (!__pyx_t_12) { + } else { + __pyx_t_18 = __pyx_t_12; + goto __pyx_L26_bool_binop_done; + } + __pyx_t_12 = PyTuple_Check(__pyx_v_value); + __pyx_t_18 = __pyx_t_12; + __pyx_L26_bool_binop_done:; + __pyx_t_12 = (!__pyx_t_18); + if (unlikely(__pyx_t_12)) { - /* "hunter/_predicates.pyx":177 - * isinstance(other, Query) - * and self.query_eq == ( other).query_eq - * and self.query_startswith == ( other).query_startswith # <<<<<<<<<<<<<< - * and self.query_endswith == ( other).query_endswith - * and self.query_in == ( other).query_in - */ - __Pyx_TraceLine(177,0,__PYX_ERR(0, 177, __pyx_L1_error)) - __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->query_startswith, ((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_other)->query_startswith, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 177, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 177, __pyx_L1_error) - if (__pyx_t_2) { - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } else { - __Pyx_INCREF(__pyx_t_3); - __pyx_t_1 = __pyx_t_3; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - goto __pyx_L3_bool_binop_done; - } + /* "hunter/_predicates.pyx":159 + * if not isinstance(value, basestring): + * if not isinstance(value, (list, set, tuple)): + * raise ValueError(f'Value {value!r} for {key!r} is invalid. Must be a string, list, tuple or set.') # <<<<<<<<<<<<<< + * value = tuple(value) + * mapping = query_endswith +*/ + __Pyx_TraceLine(159,112,0,__PYX_ERR(0, 159, __pyx_L1_error)) + __pyx_t_17 = NULL; + __Pyx_INCREF(__pyx_builtin_ValueError); + __pyx_t_14 = __pyx_builtin_ValueError; + __pyx_t_6 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_value), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_15 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_key), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __pyx_t_19[0] = __pyx_mstate_global->__pyx_kp_u_Value; + __pyx_t_19[1] = __pyx_t_6; + __pyx_t_19[2] = __pyx_mstate_global->__pyx_kp_u_for; + __pyx_t_19[3] = __pyx_t_15; + __pyx_t_19[4] = __pyx_mstate_global->__pyx_kp_u_is_invalid_Must_be_a_string_lis; + __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_19, 5, 6 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6) + 5 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_15) + 50, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_15)); + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_9 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_17, __pyx_t_8}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_14, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(0, 159, __pyx_L1_error) - /* "hunter/_predicates.pyx":178 - * and self.query_eq == ( other).query_eq - * and self.query_startswith == ( other).query_startswith - * and self.query_endswith == ( other).query_endswith # <<<<<<<<<<<<<< - * and self.query_in == ( other).query_in - * and self.query_contains == ( other).query_contains - */ - __Pyx_TraceLine(178,0,__PYX_ERR(0, 178, __pyx_L1_error)) - __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->query_endswith, ((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_other)->query_endswith, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 178, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 178, __pyx_L1_error) - if (__pyx_t_2) { - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } else { - __Pyx_INCREF(__pyx_t_3); - __pyx_t_1 = __pyx_t_3; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - goto __pyx_L3_bool_binop_done; - } + /* "hunter/_predicates.pyx":158 + * elif operator in ('endswith', 'ew'): + * if not isinstance(value, basestring): + * if not isinstance(value, (list, set, tuple)): # <<<<<<<<<<<<<< + * raise ValueError(f'Value {value!r} for {key!r} is invalid. Must be a string, list, tuple or set.') + * value = tuple(value) +*/ + } - /* "hunter/_predicates.pyx":179 - * and self.query_startswith == ( other).query_startswith - * and self.query_endswith == ( other).query_endswith - * and self.query_in == ( other).query_in # <<<<<<<<<<<<<< - * and self.query_contains == ( other).query_contains - * and self.query_regex == ( other).query_regex - */ - __Pyx_TraceLine(179,0,__PYX_ERR(0, 179, __pyx_L1_error)) - __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->query_in, ((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_other)->query_in, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 179, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 179, __pyx_L1_error) - if (__pyx_t_2) { - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } else { - __Pyx_INCREF(__pyx_t_3); - __pyx_t_1 = __pyx_t_3; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - goto __pyx_L3_bool_binop_done; - } - - /* "hunter/_predicates.pyx":180 - * and self.query_endswith == ( other).query_endswith - * and self.query_in == ( other).query_in - * and self.query_contains == ( other).query_contains # <<<<<<<<<<<<<< - * and self.query_regex == ( other).query_regex - * and self.query_lt == (other).query_lt - */ - __Pyx_TraceLine(180,0,__PYX_ERR(0, 180, __pyx_L1_error)) - __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->query_contains, ((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_other)->query_contains, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 180, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 180, __pyx_L1_error) - if (__pyx_t_2) { - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } else { - __Pyx_INCREF(__pyx_t_3); - __pyx_t_1 = __pyx_t_3; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - goto __pyx_L3_bool_binop_done; - } + /* "hunter/_predicates.pyx":160 + * if not isinstance(value, (list, set, tuple)): + * raise ValueError(f'Value {value!r} for {key!r} is invalid. Must be a string, list, tuple or set.') + * value = tuple(value) # <<<<<<<<<<<<<< + * mapping = query_endswith + * elif operator == 'in': +*/ + __Pyx_TraceLine(160,119,0,__PYX_ERR(0, 160, __pyx_L1_error)) + __pyx_t_5 = __Pyx_PySequence_Tuple(__pyx_v_value); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 160, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_5); + __pyx_t_5 = 0; - /* "hunter/_predicates.pyx":181 - * and self.query_in == ( other).query_in - * and self.query_contains == ( other).query_contains - * and self.query_regex == ( other).query_regex # <<<<<<<<<<<<<< - * and self.query_lt == (other).query_lt - * and self.query_lte == (other).query_lte - */ - __Pyx_TraceLine(181,0,__PYX_ERR(0, 181, __pyx_L1_error)) - __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->query_regex, ((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_other)->query_regex, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 181, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 181, __pyx_L1_error) - if (__pyx_t_2) { - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } else { - __Pyx_INCREF(__pyx_t_3); - __pyx_t_1 = __pyx_t_3; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - goto __pyx_L3_bool_binop_done; - } + /* "hunter/_predicates.pyx":157 + * mapping = query_startswith + * elif operator in ('endswith', 'ew'): + * if not isinstance(value, basestring): # <<<<<<<<<<<<<< + * if not isinstance(value, (list, set, tuple)): + * raise ValueError(f'Value {value!r} for {key!r} is invalid. Must be a string, list, tuple or set.') +*/ + } - /* "hunter/_predicates.pyx":182 - * and self.query_contains == ( other).query_contains - * and self.query_regex == ( other).query_regex - * and self.query_lt == (other).query_lt # <<<<<<<<<<<<<< - * and self.query_lte == (other).query_lte - * and self.query_gt == (other).query_gt - */ - __Pyx_TraceLine(182,0,__PYX_ERR(0, 182, __pyx_L1_error)) - __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->query_lt, ((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_other)->query_lt, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 182, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 182, __pyx_L1_error) - if (__pyx_t_2) { - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } else { - __Pyx_INCREF(__pyx_t_3); - __pyx_t_1 = __pyx_t_3; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - goto __pyx_L3_bool_binop_done; - } + /* "hunter/_predicates.pyx":161 + * raise ValueError(f'Value {value!r} for {key!r} is invalid. Must be a string, list, tuple or set.') + * value = tuple(value) + * mapping = query_endswith # <<<<<<<<<<<<<< + * elif operator == 'in': + * mapping = query_in +*/ + __Pyx_TraceLine(161,122,0,__PYX_ERR(0, 161, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_query_endswith); + __Pyx_XDECREF_SET(__pyx_v_mapping, __pyx_v_query_endswith); - /* "hunter/_predicates.pyx":183 - * and self.query_regex == ( other).query_regex - * and self.query_lt == (other).query_lt - * and self.query_lte == (other).query_lte # <<<<<<<<<<<<<< - * and self.query_gt == (other).query_gt - * and self.query_gte == (other).query_gte - */ - __Pyx_TraceLine(183,0,__PYX_ERR(0, 183, __pyx_L1_error)) - __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->query_lte, ((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_other)->query_lte, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 183, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 183, __pyx_L1_error) - if (__pyx_t_2) { - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } else { - __Pyx_INCREF(__pyx_t_3); - __pyx_t_1 = __pyx_t_3; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - goto __pyx_L3_bool_binop_done; - } + /* "hunter/_predicates.pyx":156 + * value = tuple(value) + * mapping = query_startswith + * elif operator in ('endswith', 'ew'): # <<<<<<<<<<<<<< + * if not isinstance(value, basestring): + * if not isinstance(value, (list, set, tuple)): +*/ + goto __pyx_L14; + } - /* "hunter/_predicates.pyx":184 - * and self.query_lt == (other).query_lt - * and self.query_lte == (other).query_lte - * and self.query_gt == (other).query_gt # <<<<<<<<<<<<<< - * and self.query_gte == (other).query_gte - * ) - */ - __Pyx_TraceLine(184,0,__PYX_ERR(0, 184, __pyx_L1_error)) - __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->query_gt, ((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_other)->query_gt, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 184, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 184, __pyx_L1_error) - if (__pyx_t_2) { - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } else { - __Pyx_INCREF(__pyx_t_3); - __pyx_t_1 = __pyx_t_3; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - goto __pyx_L3_bool_binop_done; - } + /* "hunter/_predicates.pyx":162 + * value = tuple(value) + * mapping = query_endswith + * elif operator == 'in': # <<<<<<<<<<<<<< + * mapping = query_in + * elif operator in ('contains', 'has'): +*/ + __Pyx_TraceLine(162,123,0,__PYX_ERR(0, 162, __pyx_L1_error)) + __pyx_t_12 = (__Pyx_PyUnicode_Equals(__pyx_v_operator, __pyx_mstate_global->__pyx_n_u_in, Py_EQ)); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 162, __pyx_L1_error) + if (__pyx_t_12) { - /* "hunter/_predicates.pyx":185 - * and self.query_lte == (other).query_lte - * and self.query_gt == (other).query_gt - * and self.query_gte == (other).query_gte # <<<<<<<<<<<<<< - * ) - * - */ - __Pyx_TraceLine(185,0,__PYX_ERR(0, 185, __pyx_L1_error)) - __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->query_gte, ((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_other)->query_gte, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 185, __pyx_L1_error) - __Pyx_INCREF(__pyx_t_3); - __pyx_t_1 = __pyx_t_3; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_L3_bool_binop_done:; - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + /* "hunter/_predicates.pyx":163 + * mapping = query_endswith + * elif operator == 'in': + * mapping = query_in # <<<<<<<<<<<<<< + * elif operator in ('contains', 'has'): + * mapping = query_contains +*/ + __Pyx_TraceLine(163,127,0,__PYX_ERR(0, 163, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_query_in); + __Pyx_XDECREF_SET(__pyx_v_mapping, __pyx_v_query_in); - /* "hunter/_predicates.pyx":173 - * ) - * - * def __eq__(self, other): # <<<<<<<<<<<<<< - * return ( - * isinstance(other, Query) - */ + /* "hunter/_predicates.pyx":162 + * value = tuple(value) + * mapping = query_endswith + * elif operator == 'in': # <<<<<<<<<<<<<< + * mapping = query_in + * elif operator in ('contains', 'has'): +*/ + goto __pyx_L14; + } - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("hunter._predicates.Query.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":164 + * elif operator == 'in': + * mapping = query_in + * elif operator in ('contains', 'has'): # <<<<<<<<<<<<<< + * mapping = query_contains + * elif operator in ('regex', 'rx'): +*/ + __Pyx_TraceLine(164,128,0,__PYX_ERR(0, 164, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_operator); + __pyx_t_5 = __pyx_v_operator; + __pyx_t_18 = (__Pyx_PyUnicode_Equals(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_contains, Py_EQ)); if (unlikely((__pyx_t_18 < 0))) __PYX_ERR(0, 164, __pyx_L1_error) + if (!__pyx_t_18) { + } else { + __pyx_t_12 = __pyx_t_18; + goto __pyx_L29_bool_binop_done; + } + __pyx_t_18 = (__Pyx_PyUnicode_Equals(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_has, Py_EQ)); if (unlikely((__pyx_t_18 < 0))) __PYX_ERR(0, 164, __pyx_L1_error) + __pyx_t_12 = __pyx_t_18; + __pyx_L29_bool_binop_done:; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_18 = __pyx_t_12; + if (__pyx_t_18) { -/* "hunter/_predicates.pyx":188 - * ) - * - * def __hash__(self): # <<<<<<<<<<<<<< - * return hash(( - * 'Query', - */ + /* "hunter/_predicates.pyx":165 + * mapping = query_in + * elif operator in ('contains', 'has'): + * mapping = query_contains # <<<<<<<<<<<<<< + * elif operator in ('regex', 'rx'): + * value = re_compile(value) +*/ + __Pyx_TraceLine(165,133,0,__PYX_ERR(0, 165, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_query_contains); + __Pyx_XDECREF_SET(__pyx_v_mapping, __pyx_v_query_contains); -/* Python wrapper */ -static Py_hash_t __pyx_pw_6hunter_11_predicates_5Query_9__hash__(PyObject *__pyx_v_self); /*proto*/ -static Py_hash_t __pyx_pw_6hunter_11_predicates_5Query_9__hash__(PyObject *__pyx_v_self) { - Py_hash_t __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__hash__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_8__hash__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self)); + /* "hunter/_predicates.pyx":164 + * elif operator == 'in': + * mapping = query_in + * elif operator in ('contains', 'has'): # <<<<<<<<<<<<<< + * mapping = query_contains + * elif operator in ('regex', 'rx'): +*/ + goto __pyx_L14; + } - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":166 + * elif operator in ('contains', 'has'): + * mapping = query_contains + * elif operator in ('regex', 'rx'): # <<<<<<<<<<<<<< + * value = re_compile(value) + * mapping = query_regex +*/ + __Pyx_TraceLine(166,134,0,__PYX_ERR(0, 166, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_operator); + __pyx_t_5 = __pyx_v_operator; + __pyx_t_12 = (__Pyx_PyUnicode_Equals(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_regex, Py_EQ)); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 166, __pyx_L1_error) + if (!__pyx_t_12) { + } else { + __pyx_t_18 = __pyx_t_12; + goto __pyx_L31_bool_binop_done; + } + __pyx_t_12 = (__Pyx_PyUnicode_Equals(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_rx, Py_EQ)); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 166, __pyx_L1_error) + __pyx_t_18 = __pyx_t_12; + __pyx_L31_bool_binop_done:; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_12 = __pyx_t_18; + if (__pyx_t_12) { -static Py_hash_t __pyx_pf_6hunter_11_predicates_5Query_8__hash__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self) { - Py_hash_t __pyx_r; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - Py_hash_t __pyx_t_2; - __Pyx_RefNannySetupContext("__hash__", 0); - __Pyx_TraceCall("__hash__", __pyx_f[0], 188, 0, __PYX_ERR(0, 188, __pyx_L1_error)); + /* "hunter/_predicates.pyx":167 + * mapping = query_contains + * elif operator in ('regex', 'rx'): + * value = re_compile(value) # <<<<<<<<<<<<<< + * mapping = query_regex + * elif operator == 'lt': +*/ + __Pyx_TraceLine(167,140,0,__PYX_ERR(0, 167, __pyx_L1_error)) + __pyx_t_14 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_re_compile); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_8); + assert(__pyx_t_14); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_14); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_8, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_14, __pyx_v_value}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_5); + __pyx_t_5 = 0; - /* "hunter/_predicates.pyx":190 - * def __hash__(self): - * return hash(( - * 'Query', # <<<<<<<<<<<<<< - * self.query_eq, - * self.query_in, - */ - __Pyx_TraceLine(190,0,__PYX_ERR(0, 190, __pyx_L1_error)) - __pyx_t_1 = PyTuple_New(11); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 190, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_n_s_Query); - __Pyx_GIVEREF(__pyx_n_s_Query); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_Query); - __Pyx_INCREF(__pyx_v_self->query_eq); - __Pyx_GIVEREF(__pyx_v_self->query_eq); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->query_eq); - __Pyx_INCREF(__pyx_v_self->query_in); - __Pyx_GIVEREF(__pyx_v_self->query_in); - PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_self->query_in); - __Pyx_INCREF(__pyx_v_self->query_contains); - __Pyx_GIVEREF(__pyx_v_self->query_contains); - PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_v_self->query_contains); - __Pyx_INCREF(__pyx_v_self->query_startswith); - __Pyx_GIVEREF(__pyx_v_self->query_startswith); - PyTuple_SET_ITEM(__pyx_t_1, 4, __pyx_v_self->query_startswith); - __Pyx_INCREF(__pyx_v_self->query_endswith); - __Pyx_GIVEREF(__pyx_v_self->query_endswith); - PyTuple_SET_ITEM(__pyx_t_1, 5, __pyx_v_self->query_endswith); - __Pyx_INCREF(__pyx_v_self->query_regex); - __Pyx_GIVEREF(__pyx_v_self->query_regex); - PyTuple_SET_ITEM(__pyx_t_1, 6, __pyx_v_self->query_regex); - __Pyx_INCREF(__pyx_v_self->query_lt); - __Pyx_GIVEREF(__pyx_v_self->query_lt); - PyTuple_SET_ITEM(__pyx_t_1, 7, __pyx_v_self->query_lt); - __Pyx_INCREF(__pyx_v_self->query_lte); - __Pyx_GIVEREF(__pyx_v_self->query_lte); - PyTuple_SET_ITEM(__pyx_t_1, 8, __pyx_v_self->query_lte); - __Pyx_INCREF(__pyx_v_self->query_gt); - __Pyx_GIVEREF(__pyx_v_self->query_gt); - PyTuple_SET_ITEM(__pyx_t_1, 9, __pyx_v_self->query_gt); - __Pyx_INCREF(__pyx_v_self->query_gte); - __Pyx_GIVEREF(__pyx_v_self->query_gte); - PyTuple_SET_ITEM(__pyx_t_1, 10, __pyx_v_self->query_gte); + /* "hunter/_predicates.pyx":168 + * elif operator in ('regex', 'rx'): + * value = re_compile(value) + * mapping = query_regex # <<<<<<<<<<<<<< + * elif operator == 'lt': + * mapping = query_lt +*/ + __Pyx_TraceLine(168,143,0,__PYX_ERR(0, 168, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_query_regex); + __Pyx_XDECREF_SET(__pyx_v_mapping, __pyx_v_query_regex); - /* "hunter/_predicates.pyx":189 - * - * def __hash__(self): - * return hash(( # <<<<<<<<<<<<<< - * 'Query', - * self.query_eq, - */ - __Pyx_TraceLine(189,0,__PYX_ERR(0, 189, __pyx_L1_error)) - __pyx_t_2 = PyObject_Hash(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_hash_t)-1))) __PYX_ERR(0, 189, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_2; - goto __pyx_L0; + /* "hunter/_predicates.pyx":166 + * elif operator in ('contains', 'has'): + * mapping = query_contains + * elif operator in ('regex', 'rx'): # <<<<<<<<<<<<<< + * value = re_compile(value) + * mapping = query_regex +*/ + goto __pyx_L14; + } - /* "hunter/_predicates.pyx":188 - * ) - * - * def __hash__(self): # <<<<<<<<<<<<<< - * return hash(( - * 'Query', - */ + /* "hunter/_predicates.pyx":169 + * value = re_compile(value) + * mapping = query_regex + * elif operator == 'lt': # <<<<<<<<<<<<<< + * mapping = query_lt + * elif operator == 'lte': +*/ + __Pyx_TraceLine(169,144,0,__PYX_ERR(0, 169, __pyx_L1_error)) + __pyx_t_12 = (__Pyx_PyUnicode_Equals(__pyx_v_operator, __pyx_mstate_global->__pyx_n_u_lt, Py_EQ)); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 169, __pyx_L1_error) + if (__pyx_t_12) { - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.Query.__hash__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - if (unlikely(__pyx_r == -1) && !PyErr_Occurred()) __pyx_r = -2; - __Pyx_TraceReturn(Py_None, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":170 + * mapping = query_regex + * elif operator == 'lt': + * mapping = query_lt # <<<<<<<<<<<<<< + * elif operator == 'lte': + * mapping = query_lte +*/ + __Pyx_TraceLine(170,148,0,__PYX_ERR(0, 170, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_query_lt); + __Pyx_XDECREF_SET(__pyx_v_mapping, __pyx_v_query_lt); -/* "hunter/_predicates.pyx":203 - * )) - * - * def __call__(self, Event event): # <<<<<<<<<<<<<< - * return fast_Query_call(self, event) - * - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_11__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_11__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__call__ (wrapper)", 0); - { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_event,0}; - PyObject* values[1] = {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 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_event)) != 0)) kw_args--; - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__call__") < 0)) __PYX_ERR(0, 203, __pyx_L3_error) + /* "hunter/_predicates.pyx":169 + * value = re_compile(value) + * mapping = query_regex + * elif operator == 'lt': # <<<<<<<<<<<<<< + * mapping = query_lt + * elif operator == 'lte': +*/ + goto __pyx_L14; } - } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - } - __pyx_v_event = ((struct __pyx_obj_6hunter_6_event_Event *)values[0]); - } - goto __pyx_L4_argument_unpacking_done; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__call__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 203, __pyx_L3_error) - __pyx_L3_error:; - __Pyx_AddTraceback("hunter._predicates.Query.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_event), __pyx_ptype_6hunter_6_event_Event, 1, "event", 0))) __PYX_ERR(0, 203, __pyx_L1_error) - __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_10__call__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self), __pyx_v_event); - /* function exit code */ - goto __pyx_L0; - __pyx_L1_error:; - __pyx_r = NULL; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":171 + * elif operator == 'lt': + * mapping = query_lt + * elif operator == 'lte': # <<<<<<<<<<<<<< + * mapping = query_lte + * elif operator == 'gt': +*/ + __Pyx_TraceLine(171,149,0,__PYX_ERR(0, 171, __pyx_L1_error)) + __pyx_t_12 = (__Pyx_PyUnicode_Equals(__pyx_v_operator, __pyx_mstate_global->__pyx_n_u_lte, Py_EQ)); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 171, __pyx_L1_error) + if (__pyx_t_12) { -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_10__call__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__call__", 0); - __Pyx_TraceCall("__call__", __pyx_f[0], 203, 0, __PYX_ERR(0, 203, __pyx_L1_error)); + /* "hunter/_predicates.pyx":172 + * mapping = query_lt + * elif operator == 'lte': + * mapping = query_lte # <<<<<<<<<<<<<< + * elif operator == 'gt': + * mapping = query_gt +*/ + __Pyx_TraceLine(172,153,0,__PYX_ERR(0, 172, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_query_lte); + __Pyx_XDECREF_SET(__pyx_v_mapping, __pyx_v_query_lte); - /* "hunter/_predicates.pyx":204 - * - * def __call__(self, Event event): - * return fast_Query_call(self, event) # <<<<<<<<<<<<<< - * - * def __or__(self, other): - */ - __Pyx_TraceLine(204,0,__PYX_ERR(0, 204, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_f_6hunter_11_predicates_fast_Query_call(__pyx_v_self, __pyx_v_event); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 204, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + /* "hunter/_predicates.pyx":171 + * elif operator == 'lt': + * mapping = query_lt + * elif operator == 'lte': # <<<<<<<<<<<<<< + * mapping = query_lte + * elif operator == 'gt': +*/ + goto __pyx_L14; + } - /* "hunter/_predicates.pyx":203 - * )) - * - * def __call__(self, Event event): # <<<<<<<<<<<<<< - * return fast_Query_call(self, event) - * - */ + /* "hunter/_predicates.pyx":173 + * elif operator == 'lte': + * mapping = query_lte + * elif operator == 'gt': # <<<<<<<<<<<<<< + * mapping = query_gt + * elif operator == 'gte': +*/ + __Pyx_TraceLine(173,154,0,__PYX_ERR(0, 173, __pyx_L1_error)) + __pyx_t_12 = (__Pyx_PyUnicode_Equals(__pyx_v_operator, __pyx_mstate_global->__pyx_n_u_gt, Py_EQ)); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 173, __pyx_L1_error) + if (__pyx_t_12) { - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.Query.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":174 + * mapping = query_lte + * elif operator == 'gt': + * mapping = query_gt # <<<<<<<<<<<<<< + * elif operator == 'gte': + * mapping = query_gte +*/ + __Pyx_TraceLine(174,158,0,__PYX_ERR(0, 174, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_query_gt); + __Pyx_XDECREF_SET(__pyx_v_mapping, __pyx_v_query_gt); -/* "hunter/_predicates.pyx":206 - * return fast_Query_call(self, event) - * - * def __or__(self, other): # <<<<<<<<<<<<<< - * return Or(self, other) - * - */ + /* "hunter/_predicates.pyx":173 + * elif operator == 'lte': + * mapping = query_lte + * elif operator == 'gt': # <<<<<<<<<<<<<< + * mapping = query_gt + * elif operator == 'gte': +*/ + goto __pyx_L14; + } -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_13__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_13__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__or__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_12__or__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + /* "hunter/_predicates.pyx":175 + * elif operator == 'gt': + * mapping = query_gt + * elif operator == 'gte': # <<<<<<<<<<<<<< + * mapping = query_gte + * else: +*/ + __Pyx_TraceLine(175,159,0,__PYX_ERR(0, 175, __pyx_L1_error)) + __pyx_t_12 = (__Pyx_PyUnicode_Equals(__pyx_v_operator, __pyx_mstate_global->__pyx_n_u_gte, Py_EQ)); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 175, __pyx_L1_error) + if (likely(__pyx_t_12)) { - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":176 + * mapping = query_gt + * elif operator == 'gte': + * mapping = query_gte # <<<<<<<<<<<<<< + * else: + * raise TypeError(f'Unexpected operator {operator!r}. Must be one of {ALLOWED_OPERATORS}.') +*/ + __Pyx_TraceLine(176,163,0,__PYX_ERR(0, 176, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_query_gte); + __Pyx_XDECREF_SET(__pyx_v_mapping, __pyx_v_query_gte); -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_12__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - __Pyx_RefNannySetupContext("__or__", 0); - __Pyx_TraceCall("__or__", __pyx_f[0], 206, 0, __PYX_ERR(0, 206, __pyx_L1_error)); + /* "hunter/_predicates.pyx":175 + * elif operator == 'gt': + * mapping = query_gt + * elif operator == 'gte': # <<<<<<<<<<<<<< + * mapping = query_gte + * else: +*/ + goto __pyx_L14; + } + + /* "hunter/_predicates.pyx":178 + * mapping = query_gte + * else: + * raise TypeError(f'Unexpected operator {operator!r}. Must be one of {ALLOWED_OPERATORS}.') # <<<<<<<<<<<<<< + * else: + * mapping = query_eq +*/ + __Pyx_TraceLine(178,164,0,__PYX_ERR(0, 178, __pyx_L1_error)) + /*else*/ { + __pyx_t_8 = NULL; + __Pyx_INCREF(__pyx_builtin_TypeError); + __pyx_t_14 = __pyx_builtin_TypeError; + __pyx_t_17 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_operator), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __pyx_t_15 = __Pyx_PyObject_FormatSimple(__pyx_v_6hunter_11_predicates_ALLOWED_OPERATORS, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __pyx_t_19[0] = __pyx_mstate_global->__pyx_kp_u_Unexpected_operator; + __pyx_t_19[1] = __pyx_t_17; + __pyx_t_19[2] = __pyx_mstate_global->__pyx_kp_u_Must_be_one_of; + __pyx_t_19[3] = __pyx_t_15; + __pyx_t_19[4] = __pyx_mstate_global->__pyx_kp_u__2; + __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_19, 5, 20 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_17) + 17 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_15) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_17) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_15)); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_9 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_6}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_14, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(0, 178, __pyx_L1_error) + } + __pyx_L14:; + + /* "hunter/_predicates.pyx":148 + * f'Unexpected argument {key!r}. Must be one of {ALLOWED_KEYS} with optional operators like: {ALLOWED_OPERATORS}' + * ) + * elif count == 2: # <<<<<<<<<<<<<< + * prefix, operator = parts + * if operator in ('startswith', 'sw'): +*/ + goto __pyx_L13; + } - /* "hunter/_predicates.pyx":207 + /* "hunter/_predicates.pyx":180 + * raise TypeError(f'Unexpected operator {operator!r}. Must be one of {ALLOWED_OPERATORS}.') + * else: + * mapping = query_eq # <<<<<<<<<<<<<< + * prefix = key * - * def __or__(self, other): - * return Or(self, other) # <<<<<<<<<<<<<< +*/ + __Pyx_TraceLine(180,171,0,__PYX_ERR(0, 180, __pyx_L1_error)) + /*else*/ { + __Pyx_INCREF(__pyx_v_query_eq); + __Pyx_XDECREF_SET(__pyx_v_mapping, __pyx_v_query_eq); + + /* "hunter/_predicates.pyx":181 + * else: + * mapping = query_eq + * prefix = key # <<<<<<<<<<<<<< * - * def __and__(self, other): - */ - __Pyx_TraceLine(207,0,__PYX_ERR(0, 207, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 207, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v_self); - __Pyx_GIVEREF(__pyx_v_self); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self); - __Pyx_INCREF(__pyx_v_other); - __Pyx_GIVEREF(__pyx_v_other); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_other); - __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_Or), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 207, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; + * if prefix not in ALLOWED_KEYS: +*/ + __Pyx_TraceLine(181,174,0,__PYX_ERR(0, 181, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_key); + __Pyx_XDECREF_SET(__pyx_v_prefix, __pyx_v_key); + } + __pyx_L13:; - /* "hunter/_predicates.pyx":206 - * return fast_Query_call(self, event) + /* "hunter/_predicates.pyx":183 + * prefix = key * - * def __or__(self, other): # <<<<<<<<<<<<<< - * return Or(self, other) + * if prefix not in ALLOWED_KEYS: # <<<<<<<<<<<<<< + * raise TypeError(f'Unexpected argument {key!r}. Must be one of {ALLOWED_KEYS}.') * - */ +*/ + __Pyx_TraceLine(183,178,0,__PYX_ERR(0, 183, __pyx_L1_error)) + __pyx_t_12 = (__Pyx_PySequence_ContainsTF(__pyx_v_prefix, __pyx_v_6hunter_11_predicates_ALLOWED_KEYS, Py_NE)); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 183, __pyx_L1_error) + if (unlikely(__pyx_t_12)) { - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("hunter._predicates.Query.__or__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":184 + * + * if prefix not in ALLOWED_KEYS: + * raise TypeError(f'Unexpected argument {key!r}. Must be one of {ALLOWED_KEYS}.') # <<<<<<<<<<<<<< + * + * mapping[prefix] = QueryEntry(value, prefix) +*/ + __Pyx_TraceLine(184,181,0,__PYX_ERR(0, 184, __pyx_L1_error)) + __pyx_t_14 = NULL; + __Pyx_INCREF(__pyx_builtin_TypeError); + __pyx_t_6 = __pyx_builtin_TypeError; + __pyx_t_8 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_key), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_15 = __Pyx_PyObject_FormatSimple(__pyx_v_6hunter_11_predicates_ALLOWED_KEYS, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __pyx_t_19[0] = __pyx_mstate_global->__pyx_kp_u_Unexpected_argument; + __pyx_t_19[1] = __pyx_t_8; + __pyx_t_19[2] = __pyx_mstate_global->__pyx_kp_u_Must_be_one_of; + __pyx_t_19[3] = __pyx_t_15; + __pyx_t_19[4] = __pyx_mstate_global->__pyx_kp_u__2; + __pyx_t_17 = __Pyx_PyUnicode_Join(__pyx_t_19, 5, 20 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8) + 17 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_15) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_15)); + if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_9 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_14, __pyx_t_17}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(0, 184, __pyx_L1_error) -/* "hunter/_predicates.pyx":209 - * return Or(self, other) + /* "hunter/_predicates.pyx":183 + * prefix = key * - * def __and__(self, other): # <<<<<<<<<<<<<< - * return And(self, other) + * if prefix not in ALLOWED_KEYS: # <<<<<<<<<<<<<< + * raise TypeError(f'Unexpected argument {key!r}. Must be one of {ALLOWED_KEYS}.') * - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_15__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_15__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__and__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_14__and__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_14__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - __Pyx_RefNannySetupContext("__and__", 0); - __Pyx_TraceCall("__and__", __pyx_f[0], 209, 0, __PYX_ERR(0, 209, __pyx_L1_error)); +*/ + } - /* "hunter/_predicates.pyx":210 + /* "hunter/_predicates.pyx":186 + * raise TypeError(f'Unexpected argument {key!r}. Must be one of {ALLOWED_KEYS}.') * - * def __and__(self, other): - * return And(self, other) # <<<<<<<<<<<<<< + * mapping[prefix] = QueryEntry(value, prefix) # <<<<<<<<<<<<<< * - * def __invert__(self): - */ - __Pyx_TraceLine(210,0,__PYX_ERR(0, 210, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 210, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v_self); - __Pyx_GIVEREF(__pyx_v_self); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self); - __Pyx_INCREF(__pyx_v_other); - __Pyx_GIVEREF(__pyx_v_other); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_other); - __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_And), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 210, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + * self.query_eq = tuple(sorted(query_eq.items())) +*/ + __Pyx_TraceLine(186,190,0,__PYX_ERR(0, 186, __pyx_L1_error)) + __pyx_t_6 = NULL; + __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_QueryEntry); + __pyx_t_17 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_QueryEntry); + __pyx_t_9 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_v_value, __pyx_v_prefix}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_17, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 186, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_5); + } + if (unlikely((PyDict_SetItem(__pyx_v_mapping, __pyx_v_prefix, ((PyObject *)__pyx_t_5)) < 0))) __PYX_ERR(0, 186, __pyx_L1_error) + __Pyx_DECREF((PyObject *)__pyx_t_5); __pyx_t_5 = 0; + } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - /* "hunter/_predicates.pyx":209 - * return Or(self, other) - * - * def __and__(self, other): # <<<<<<<<<<<<<< - * return And(self, other) + /* "hunter/_predicates.pyx":188 + * mapping[prefix] = QueryEntry(value, prefix) * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("hunter._predicates.Query.__and__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + * self.query_eq = tuple(sorted(query_eq.items())) # <<<<<<<<<<<<<< + * self.query_startswith = tuple(sorted(query_startswith.items())) + * self.query_endswith = tuple(sorted(query_endswith.items())) +*/ + __Pyx_TraceLine(188,200,0,__PYX_ERR(0, 188, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_Items(__pyx_v_query_eq); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = PySequence_List(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely((PyList_Sort(__pyx_t_5) < 0))) __PYX_ERR(0, 188, __pyx_L1_error) + __pyx_t_1 = PyList_AsTuple(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->query_eq); + __Pyx_DECREF(__pyx_v_self->query_eq); + __pyx_v_self->query_eq = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; -/* "hunter/_predicates.pyx":212 - * return And(self, other) - * - * def __invert__(self): # <<<<<<<<<<<<<< - * return Not(self) + /* "hunter/_predicates.pyx":189 * - */ + * self.query_eq = tuple(sorted(query_eq.items())) + * self.query_startswith = tuple(sorted(query_startswith.items())) # <<<<<<<<<<<<<< + * self.query_endswith = tuple(sorted(query_endswith.items())) + * self.query_in = tuple(sorted(query_in.items())) +*/ + __Pyx_TraceLine(189,208,0,__PYX_ERR(0, 189, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_Items(__pyx_v_query_startswith); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = PySequence_List(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely((PyList_Sort(__pyx_t_5) < 0))) __PYX_ERR(0, 189, __pyx_L1_error) + __pyx_t_1 = PyList_AsTuple(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->query_startswith); + __Pyx_DECREF(__pyx_v_self->query_startswith); + __pyx_v_self->query_startswith = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_17__invert__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_17__invert__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__invert__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_16__invert__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self)); + /* "hunter/_predicates.pyx":190 + * self.query_eq = tuple(sorted(query_eq.items())) + * self.query_startswith = tuple(sorted(query_startswith.items())) + * self.query_endswith = tuple(sorted(query_endswith.items())) # <<<<<<<<<<<<<< + * self.query_in = tuple(sorted(query_in.items())) + * self.query_contains = tuple(sorted(query_contains.items())) +*/ + __Pyx_TraceLine(190,216,0,__PYX_ERR(0, 190, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_Items(__pyx_v_query_endswith); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = PySequence_List(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely((PyList_Sort(__pyx_t_5) < 0))) __PYX_ERR(0, 190, __pyx_L1_error) + __pyx_t_1 = PyList_AsTuple(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->query_endswith); + __Pyx_DECREF(__pyx_v_self->query_endswith); + __pyx_v_self->query_endswith = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":191 + * self.query_startswith = tuple(sorted(query_startswith.items())) + * self.query_endswith = tuple(sorted(query_endswith.items())) + * self.query_in = tuple(sorted(query_in.items())) # <<<<<<<<<<<<<< + * self.query_contains = tuple(sorted(query_contains.items())) + * self.query_regex = tuple(sorted(query_regex.items())) +*/ + __Pyx_TraceLine(191,224,0,__PYX_ERR(0, 191, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_Items(__pyx_v_query_in); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 191, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = PySequence_List(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 191, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely((PyList_Sort(__pyx_t_5) < 0))) __PYX_ERR(0, 191, __pyx_L1_error) + __pyx_t_1 = PyList_AsTuple(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 191, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->query_in); + __Pyx_DECREF(__pyx_v_self->query_in); + __pyx_v_self->query_in = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_16__invert__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__invert__", 0); - __Pyx_TraceCall("__invert__", __pyx_f[0], 212, 0, __PYX_ERR(0, 212, __pyx_L1_error)); + /* "hunter/_predicates.pyx":192 + * self.query_endswith = tuple(sorted(query_endswith.items())) + * self.query_in = tuple(sorted(query_in.items())) + * self.query_contains = tuple(sorted(query_contains.items())) # <<<<<<<<<<<<<< + * self.query_regex = tuple(sorted(query_regex.items())) + * self.query_lt = tuple(sorted(query_lt.items())) +*/ + __Pyx_TraceLine(192,232,0,__PYX_ERR(0, 192, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_Items(__pyx_v_query_contains); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = PySequence_List(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely((PyList_Sort(__pyx_t_5) < 0))) __PYX_ERR(0, 192, __pyx_L1_error) + __pyx_t_1 = PyList_AsTuple(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->query_contains); + __Pyx_DECREF(__pyx_v_self->query_contains); + __pyx_v_self->query_contains = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; - /* "hunter/_predicates.pyx":213 - * - * def __invert__(self): - * return Not(self) # <<<<<<<<<<<<<< - * - * cdef fast_Query_call(Query self, Event event): - */ - __Pyx_TraceLine(213,0,__PYX_ERR(0, 213, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_6hunter_11_predicates_Not), ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 213, __pyx_L1_error) + /* "hunter/_predicates.pyx":193 + * self.query_in = tuple(sorted(query_in.items())) + * self.query_contains = tuple(sorted(query_contains.items())) + * self.query_regex = tuple(sorted(query_regex.items())) # <<<<<<<<<<<<<< + * self.query_lt = tuple(sorted(query_lt.items())) + * self.query_lte = tuple(sorted(query_lte.items())) +*/ + __Pyx_TraceLine(193,240,0,__PYX_ERR(0, 193, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_Items(__pyx_v_query_regex); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 193, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; + __pyx_t_5 = PySequence_List(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely((PyList_Sort(__pyx_t_5) < 0))) __PYX_ERR(0, 193, __pyx_L1_error) + __pyx_t_1 = PyList_AsTuple(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->query_regex); + __Pyx_DECREF(__pyx_v_self->query_regex); + __pyx_v_self->query_regex = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - goto __pyx_L0; - /* "hunter/_predicates.pyx":212 - * return And(self, other) + /* "hunter/_predicates.pyx":194 + * self.query_contains = tuple(sorted(query_contains.items())) + * self.query_regex = tuple(sorted(query_regex.items())) + * self.query_lt = tuple(sorted(query_lt.items())) # <<<<<<<<<<<<<< + * self.query_lte = tuple(sorted(query_lte.items())) + * self.query_gt = tuple(sorted(query_gt.items())) +*/ + __Pyx_TraceLine(194,248,0,__PYX_ERR(0, 194, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_Items(__pyx_v_query_lt); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = PySequence_List(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely((PyList_Sort(__pyx_t_5) < 0))) __PYX_ERR(0, 194, __pyx_L1_error) + __pyx_t_1 = PyList_AsTuple(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->query_lt); + __Pyx_DECREF(__pyx_v_self->query_lt); + __pyx_v_self->query_lt = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "hunter/_predicates.pyx":195 + * self.query_regex = tuple(sorted(query_regex.items())) + * self.query_lt = tuple(sorted(query_lt.items())) + * self.query_lte = tuple(sorted(query_lte.items())) # <<<<<<<<<<<<<< + * self.query_gt = tuple(sorted(query_gt.items())) + * self.query_gte = tuple(sorted(query_gte.items())) +*/ + __Pyx_TraceLine(195,256,0,__PYX_ERR(0, 195, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_Items(__pyx_v_query_lte); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 195, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = PySequence_List(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 195, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely((PyList_Sort(__pyx_t_5) < 0))) __PYX_ERR(0, 195, __pyx_L1_error) + __pyx_t_1 = PyList_AsTuple(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 195, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->query_lte); + __Pyx_DECREF(__pyx_v_self->query_lte); + __pyx_v_self->query_lte = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "hunter/_predicates.pyx":196 + * self.query_lt = tuple(sorted(query_lt.items())) + * self.query_lte = tuple(sorted(query_lte.items())) + * self.query_gt = tuple(sorted(query_gt.items())) # <<<<<<<<<<<<<< + * self.query_gte = tuple(sorted(query_gte.items())) * - * def __invert__(self): # <<<<<<<<<<<<<< - * return Not(self) +*/ + __Pyx_TraceLine(196,264,0,__PYX_ERR(0, 196, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_Items(__pyx_v_query_gt); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = PySequence_List(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely((PyList_Sort(__pyx_t_5) < 0))) __PYX_ERR(0, 196, __pyx_L1_error) + __pyx_t_1 = PyList_AsTuple(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->query_gt); + __Pyx_DECREF(__pyx_v_self->query_gt); + __pyx_v_self->query_gt = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "hunter/_predicates.pyx":197 + * self.query_lte = tuple(sorted(query_lte.items())) + * self.query_gt = tuple(sorted(query_gt.items())) + * self.query_gte = tuple(sorted(query_gte.items())) # <<<<<<<<<<<<<< * - */ + * def __str__(self): +*/ + __Pyx_TraceLine(197,272,0,__PYX_ERR(0, 197, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_Items(__pyx_v_query_gte); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 197, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = PySequence_List(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 197, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely((PyList_Sort(__pyx_t_5) < 0))) __PYX_ERR(0, 197, __pyx_L1_error) + __pyx_t_1 = PyList_AsTuple(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 197, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->query_gte); + __Pyx_DECREF(__pyx_v_self->query_gte); + __pyx_v_self->query_gte = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "hunter/_predicates.pyx":106 + * See :class:`hunter.event.Event` for fields that can be filtered on. + * """ + * def __init__(self, **query): # <<<<<<<<<<<<<< + * """ + * Args: +*/ /* function exit code */ + __pyx_r = 0; + __Pyx_TraceReturnCValue(__pyx_r, __Pyx_Owned_Py_None, 0, 0, __PYX_ERR(0, 106, __pyx_L1_error)); + goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.Query.__invert__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_XDECREF(__pyx_t_14); + __Pyx_XDECREF(__pyx_t_15); + __Pyx_XDECREF(__pyx_t_17); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 106, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Query.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_XDECREF(__pyx_v_query_eq); + __Pyx_XDECREF(__pyx_v_query_startswith); + __Pyx_XDECREF(__pyx_v_query_endswith); + __Pyx_XDECREF(__pyx_v_query_in); + __Pyx_XDECREF(__pyx_v_query_contains); + __Pyx_XDECREF(__pyx_v_query_regex); + __Pyx_XDECREF(__pyx_v_query_lt); + __Pyx_XDECREF(__pyx_v_query_lte); + __Pyx_XDECREF(__pyx_v_query_gt); + __Pyx_XDECREF(__pyx_v_query_gte); + __Pyx_XDECREF(__pyx_v_key); + __Pyx_XDECREF(__pyx_v_value); + __Pyx_XDECREF(__pyx_v_parts); + __Pyx_XDECREF(__pyx_v_prefix); + __Pyx_XDECREF(__pyx_v_operator); + __Pyx_XDECREF(__pyx_v_mapping); + __Pyx_XDECREF(__pyx_7genexpr__pyx_v_p); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pxd":10 - * cdef class Query: - * cdef: - * readonly tuple query_contains # <<<<<<<<<<<<<< - * readonly tuple query_endswith - * readonly tuple query_eq - */ +/* "hunter/_predicates.pyx":199 + * self.query_gte = tuple(sorted(query_gte.items())) + * + * def __str__(self): # <<<<<<<<<<<<<< + * return 'Query(%s)' % ( + * ', '.join([ +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_14query_contains_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_14query_contains_1__get__(PyObject *__pyx_v_self) { +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_3__str__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_3__str__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_14query_contains___get__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_2__str__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } +static PyObject *__pyx_gb_6hunter_11_predicates_5Query_7__str___8genexpr1_2generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_14query_contains___get__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self) { +/* "hunter/_predicates.pyx":202 + * return 'Query(%s)' % ( + * ', '.join([ + * ', '.join(f'{key}{kind}={value!r}' for key, value in mapping) # <<<<<<<<<<<<<< + * for kind, mapping in [ + * ('', self.query_eq), +*/ + +static PyObject *__pyx_pf_6hunter_11_predicates_5Query_7__str___8genexpr1_genexpr(PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0) { + struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr *__pyx_cur_scope; PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 10, 0, __PYX_ERR(1, 10, __pyx_L1_error)); - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->query_contains); - __pyx_r = __pyx_v_self->query_contains; - goto __pyx_L0; - - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.Query.query_contains.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "hunter/_predicates.pxd":11 - * cdef: - * readonly tuple query_contains - * readonly tuple query_endswith # <<<<<<<<<<<<<< - * readonly tuple query_eq - * readonly tuple query_gt - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_14query_endswith_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_14query_endswith_1__get__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_14query_endswith___get__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_14query_endswith___get__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 11, 0, __PYX_ERR(1, 11, __pyx_L1_error)); - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->query_endswith); - __pyx_r = __pyx_v_self->query_endswith; - goto __pyx_L0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("genexpr", 0); + __pyx_cur_scope = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr *)__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_1_genexpr(__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_1_genexpr, __pyx_mstate_global->__pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(0, 202, __pyx_L1_error) + } else { + __Pyx_GOTREF((PyObject *)__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__ *) __pyx_self; + __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_outer_scope); + __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_outer_scope); + __pyx_cur_scope->__pyx_genexpr_arg_0 = __pyx_genexpr_arg_0; + __Pyx_INCREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + { + __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_6hunter_11_predicates_5Query_7__str___8genexpr1_2generator, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[25]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_genexpr, __pyx_mstate_global->__pyx_n_u_str___locals_genexpr, __pyx_mstate_global->__pyx_n_u_hunter__predicates); if (unlikely(!gen)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } /* function exit code */ __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.Query.query_endswith.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("hunter._predicates.Query.__str__.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; - __pyx_L0:; + __Pyx_DECREF((PyObject *)__pyx_cur_scope); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "hunter/_predicates.pxd":12 - * readonly tuple query_contains - * readonly tuple query_endswith - * readonly tuple query_eq # <<<<<<<<<<<<<< - * readonly tuple query_gt - * readonly tuple query_gte - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_8query_eq_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_8query_eq_1__get__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_8query_eq___get__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self)); - - /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_8query_eq___get__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self) { +static PyObject *__pyx_gb_6hunter_11_predicates_5Query_7__str___8genexpr1_2generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr *__pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr *)__pyx_generator->closure); PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsGen + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *(*__pyx_t_3)(PyObject *); + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *(*__pyx_t_8)(PyObject *); + PyObject *__pyx_t_9[4]; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 12, 0, __PYX_ERR(1, 12, __pyx_L1_error)); - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->query_eq); - __pyx_r = __pyx_v_self->query_eq; - goto __pyx_L0; + __Pyx_RefNannySetupContext("genexpr", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + default: /* CPython raises the right error here */ + __Pyx_TraceStartGen("genexpr", __pyx_f[0], 202, 0, 0, 0, __PYX_ERR(0, 202, __pyx_L1_error)); + __Pyx_TraceReturnValue(Py_None, 0, 0, __PYX_ERR(0, 202, __pyx_L1_error)); + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + __Pyx_TraceStartGen("genexpr", __pyx_f[0], 202, 0, 0, 0, __PYX_ERR(0, 202, __pyx_L1_error)); + if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 202, __pyx_L1_error) + __pyx_r = PyList_New(0); if (unlikely(!__pyx_r)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_r); + if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(0, 202, __pyx_L1_error) } + if (likely(PyList_CheckExact(__pyx_cur_scope->__pyx_genexpr_arg_0)) || PyTuple_CheckExact(__pyx_cur_scope->__pyx_genexpr_arg_0)) { + __pyx_t_1 = __pyx_cur_scope->__pyx_genexpr_arg_0; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + __pyx_t_3 = NULL; + } else { + __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_cur_scope->__pyx_genexpr_arg_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 202, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_3)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 202, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + __pyx_t_4 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_2); + ++__pyx_t_2; + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 202, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2)); + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); + #endif + ++__pyx_t_2; + } + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 202, __pyx_L1_error) + } else { + __pyx_t_4 = __pyx_t_3(__pyx_t_1); + if (unlikely(!__pyx_t_4)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 202, __pyx_L1_error) + PyErr_Clear(); + } + break; + } + } + __Pyx_GOTREF(__pyx_t_4); + if ((likely(PyTuple_CheckExact(__pyx_t_4))) || (PyList_CheckExact(__pyx_t_4))) { + PyObject* sequence = __pyx_t_4; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 202, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_5); + __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_6); + } else { + __pyx_t_5 = __Pyx_PyList_GetItemRef(sequence, 0); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyList_GetItemRef(sequence, 1); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_6); + } + #else + __pyx_t_5 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #endif + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_7 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_8 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_7); + index = 0; __pyx_t_5 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_5)) goto __pyx_L6_unpacking_failed; + __Pyx_GOTREF(__pyx_t_5); + index = 1; __pyx_t_6 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L6_unpacking_failed; + __Pyx_GOTREF(__pyx_t_6); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(0, 202, __pyx_L1_error) + __pyx_t_8 = NULL; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + goto __pyx_L7_unpacking_done; + __pyx_L6_unpacking_failed:; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 202, __pyx_L1_error) + __pyx_L7_unpacking_done:; + } + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_key); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_key, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_5); + __pyx_t_5 = 0; + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_value); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_value, __pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + __pyx_t_6 = 0; + __Pyx_TraceLine(202,0,0,__PYX_ERR(0, 202, __pyx_L1_error)) + __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_cur_scope->__pyx_v_key, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_8genexpr1__pyx_v_kind)) { __Pyx_RaiseClosureNameError("kind"); __PYX_ERR(0, 202, __pyx_L1_error) } + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_cur_scope->__pyx_outer_scope->__pyx_8genexpr1__pyx_v_kind, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_cur_scope->__pyx_v_value), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_9[0] = __pyx_t_4; + __pyx_t_9[1] = __pyx_t_6; + __pyx_t_9[2] = __pyx_mstate_global->__pyx_kp_u__3; + __pyx_t_9[3] = __pyx_t_5; + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_9, 4, __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6) + 1 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5)); + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__Pyx_ListComp_Append(__pyx_r, (PyObject*)__pyx_t_7))) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + __Pyx_TraceReturnValue(Py_None, 0, 0, __PYX_ERR(0, 202, __pyx_L1_error)); /* function exit code */ + goto __pyx_L0; __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.Query.query_eq.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_XDECREF(__pyx_r); __pyx_r = 0; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + if (__Pyx_PyErr_Occurred()) { + __Pyx_TraceException(__pyx_lineno, 0, 0); + __Pyx_Generator_Replace_StopIteration(0); + __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceExceptionUnwind(0, 0); + } __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); + #if !CYTHON_USE_EXC_INFO_STACK + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + #endif + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pxd":13 - * readonly tuple query_endswith - * readonly tuple query_eq - * readonly tuple query_gt # <<<<<<<<<<<<<< - * readonly tuple query_gte - * readonly tuple query_in - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_8query_gt_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_8query_gt_1__get__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_8query_gt___get__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} +/* "hunter/_predicates.pyx":199 + * self.query_gte = tuple(sorted(query_gte.items())) + * + * def __str__(self): # <<<<<<<<<<<<<< + * return 'Query(%s)' % ( + * ', '.join([ +*/ -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_8query_gt___get__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self) { +static PyObject *__pyx_pf_6hunter_11_predicates_5Query_2__str__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self) { + struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__ *__pyx_cur_scope; + PyObject *__pyx_8genexpr1__pyx_v_mapping = NULL; + PyObject *__pyx_8genexpr1__pyx_v_0 = NULL; PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 13, 0, __PYX_ERR(1, 13, __pyx_L1_error)); + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + Py_ssize_t __pyx_t_13; + int __pyx_t_14; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[26])) + __Pyx_RefNannySetupContext("__str__", 0); + __pyx_cur_scope = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__ *)__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct____str__(__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct____str__, __pyx_mstate_global->__pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__ *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(0, 199, __pyx_L1_error) + } else { + __Pyx_GOTREF((PyObject *)__pyx_cur_scope); + } + __Pyx_TraceStartFunc("__str__", __pyx_f[0], 199, 0, 0, 0, __PYX_ERR(0, 199, __pyx_L1_error)); + + /* "hunter/_predicates.pyx":200 + * + * def __str__(self): + * return 'Query(%s)' % ( # <<<<<<<<<<<<<< + * ', '.join([ + * ', '.join(f'{key}{kind}={value!r}' for key, value in mapping) +*/ + __Pyx_TraceLine(200,1,0,__PYX_ERR(0, 200, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->query_gt); - __pyx_r = __pyx_v_self->query_gt; - goto __pyx_L0; - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.Query.query_gt.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":201 + * def __str__(self): + * return 'Query(%s)' % ( + * ', '.join([ # <<<<<<<<<<<<<< + * ', '.join(f'{key}{kind}={value!r}' for key, value in mapping) + * for kind, mapping in [ +*/ + __Pyx_TraceLine(201,6,0,__PYX_ERR(0, 201, __pyx_L1_error)) + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 201, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_1); -/* "hunter/_predicates.pxd":14 - * readonly tuple query_eq - * readonly tuple query_gt - * readonly tuple query_gte # <<<<<<<<<<<<<< - * readonly tuple query_in - * readonly tuple query_lt - */ + /* "hunter/_predicates.pyx":204 + * ', '.join(f'{key}{kind}={value!r}' for key, value in mapping) + * for kind, mapping in [ + * ('', self.query_eq), # <<<<<<<<<<<<<< + * ('_in', self.query_in), + * ('_contains', self.query_contains), +*/ + __Pyx_TraceLine(204,16,0,__PYX_ERR(0, 204, __pyx_L5_error)) + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 204, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u__5); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_kp_u__5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_mstate_global->__pyx_kp_u__5) != (0)) __PYX_ERR(0, 204, __pyx_L5_error); + __Pyx_INCREF(__pyx_v_self->query_eq); + __Pyx_GIVEREF(__pyx_v_self->query_eq); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_self->query_eq) != (0)) __PYX_ERR(0, 204, __pyx_L5_error); + + /* "hunter/_predicates.pyx":205 + * for kind, mapping in [ + * ('', self.query_eq), + * ('_in', self.query_in), # <<<<<<<<<<<<<< + * ('_contains', self.query_contains), + * ('_startswith', self.query_startswith), +*/ + __Pyx_TraceLine(205,19,0,__PYX_ERR(0, 205, __pyx_L5_error)) + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 205, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_in_2); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_in_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_mstate_global->__pyx_n_u_in_2) != (0)) __PYX_ERR(0, 205, __pyx_L5_error); + __Pyx_INCREF(__pyx_v_self->query_in); + __Pyx_GIVEREF(__pyx_v_self->query_in); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_self->query_in) != (0)) __PYX_ERR(0, 205, __pyx_L5_error); + + /* "hunter/_predicates.pyx":206 + * ('', self.query_eq), + * ('_in', self.query_in), + * ('_contains', self.query_contains), # <<<<<<<<<<<<<< + * ('_startswith', self.query_startswith), + * ('_endswith', self.query_endswith), +*/ + __Pyx_TraceLine(206,22,0,__PYX_ERR(0, 206, __pyx_L5_error)) + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 206, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_contains_2); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_contains_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_mstate_global->__pyx_n_u_contains_2) != (0)) __PYX_ERR(0, 206, __pyx_L5_error); + __Pyx_INCREF(__pyx_v_self->query_contains); + __Pyx_GIVEREF(__pyx_v_self->query_contains); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_self->query_contains) != (0)) __PYX_ERR(0, 206, __pyx_L5_error); + + /* "hunter/_predicates.pyx":207 + * ('_in', self.query_in), + * ('_contains', self.query_contains), + * ('_startswith', self.query_startswith), # <<<<<<<<<<<<<< + * ('_endswith', self.query_endswith), + * ('_regex', self.query_regex), +*/ + __Pyx_TraceLine(207,25,0,__PYX_ERR(0, 207, __pyx_L5_error)) + __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 207, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_startswith_2); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_startswith_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_mstate_global->__pyx_n_u_startswith_2) != (0)) __PYX_ERR(0, 207, __pyx_L5_error); + __Pyx_INCREF(__pyx_v_self->query_startswith); + __Pyx_GIVEREF(__pyx_v_self->query_startswith); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_v_self->query_startswith) != (0)) __PYX_ERR(0, 207, __pyx_L5_error); + + /* "hunter/_predicates.pyx":208 + * ('_contains', self.query_contains), + * ('_startswith', self.query_startswith), + * ('_endswith', self.query_endswith), # <<<<<<<<<<<<<< + * ('_regex', self.query_regex), + * ('_lt', self.query_lt), +*/ + __Pyx_TraceLine(208,28,0,__PYX_ERR(0, 208, __pyx_L5_error)) + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 208, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_endswith_2); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_endswith_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_mstate_global->__pyx_n_u_endswith_2) != (0)) __PYX_ERR(0, 208, __pyx_L5_error); + __Pyx_INCREF(__pyx_v_self->query_endswith); + __Pyx_GIVEREF(__pyx_v_self->query_endswith); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_v_self->query_endswith) != (0)) __PYX_ERR(0, 208, __pyx_L5_error); + + /* "hunter/_predicates.pyx":209 + * ('_startswith', self.query_startswith), + * ('_endswith', self.query_endswith), + * ('_regex', self.query_regex), # <<<<<<<<<<<<<< + * ('_lt', self.query_lt), + * ('_lte', self.query_lte), +*/ + __Pyx_TraceLine(209,31,0,__PYX_ERR(0, 209, __pyx_L5_error)) + __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 209, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_regex_2); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_regex_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_mstate_global->__pyx_n_u_regex_2) != (0)) __PYX_ERR(0, 209, __pyx_L5_error); + __Pyx_INCREF(__pyx_v_self->query_regex); + __Pyx_GIVEREF(__pyx_v_self->query_regex); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_v_self->query_regex) != (0)) __PYX_ERR(0, 209, __pyx_L5_error); + + /* "hunter/_predicates.pyx":210 + * ('_endswith', self.query_endswith), + * ('_regex', self.query_regex), + * ('_lt', self.query_lt), # <<<<<<<<<<<<<< + * ('_lte', self.query_lte), + * ('_gt', self.query_gt), +*/ + __Pyx_TraceLine(210,34,0,__PYX_ERR(0, 210, __pyx_L5_error)) + __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 210, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_lt_2); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_lt_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_mstate_global->__pyx_n_u_lt_2) != (0)) __PYX_ERR(0, 210, __pyx_L5_error); + __Pyx_INCREF(__pyx_v_self->query_lt); + __Pyx_GIVEREF(__pyx_v_self->query_lt); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_v_self->query_lt) != (0)) __PYX_ERR(0, 210, __pyx_L5_error); + + /* "hunter/_predicates.pyx":211 + * ('_regex', self.query_regex), + * ('_lt', self.query_lt), + * ('_lte', self.query_lte), # <<<<<<<<<<<<<< + * ('_gt', self.query_gt), + * ('_gte', self.query_gte), +*/ + __Pyx_TraceLine(211,37,0,__PYX_ERR(0, 211, __pyx_L5_error)) + __pyx_t_9 = PyTuple_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 211, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_lte_2); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_lte_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_mstate_global->__pyx_n_u_lte_2) != (0)) __PYX_ERR(0, 211, __pyx_L5_error); + __Pyx_INCREF(__pyx_v_self->query_lte); + __Pyx_GIVEREF(__pyx_v_self->query_lte); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_v_self->query_lte) != (0)) __PYX_ERR(0, 211, __pyx_L5_error); + + /* "hunter/_predicates.pyx":212 + * ('_lt', self.query_lt), + * ('_lte', self.query_lte), + * ('_gt', self.query_gt), # <<<<<<<<<<<<<< + * ('_gte', self.query_gte), + * ] +*/ + __Pyx_TraceLine(212,40,0,__PYX_ERR(0, 212, __pyx_L5_error)) + __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 212, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_gt_2); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_gt_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_mstate_global->__pyx_n_u_gt_2) != (0)) __PYX_ERR(0, 212, __pyx_L5_error); + __Pyx_INCREF(__pyx_v_self->query_gt); + __Pyx_GIVEREF(__pyx_v_self->query_gt); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_v_self->query_gt) != (0)) __PYX_ERR(0, 212, __pyx_L5_error); + + /* "hunter/_predicates.pyx":213 + * ('_lte', self.query_lte), + * ('_gt', self.query_gt), + * ('_gte', self.query_gte), # <<<<<<<<<<<<<< + * ] + * if mapping +*/ + __Pyx_TraceLine(213,43,0,__PYX_ERR(0, 213, __pyx_L5_error)) + __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 213, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_gte_2); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_gte_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_mstate_global->__pyx_n_u_gte_2) != (0)) __PYX_ERR(0, 213, __pyx_L5_error); + __Pyx_INCREF(__pyx_v_self->query_gte); + __Pyx_GIVEREF(__pyx_v_self->query_gte); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_v_self->query_gte) != (0)) __PYX_ERR(0, 213, __pyx_L5_error); + + /* "hunter/_predicates.pyx":203 + * ', '.join([ + * ', '.join(f'{key}{kind}={value!r}' for key, value in mapping) + * for kind, mapping in [ # <<<<<<<<<<<<<< + * ('', self.query_eq), + * ('_in', self.query_in), +*/ + __Pyx_TraceLine(203,15,0,__PYX_ERR(0, 203, __pyx_L5_error)) + __pyx_t_12 = PyTuple_New(10); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 203, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_2) != (0)) __PYX_ERR(0, 203, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 203, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 2, __pyx_t_4) != (0)) __PYX_ERR(0, 203, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 3, __pyx_t_5) != (0)) __PYX_ERR(0, 203, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 4, __pyx_t_6) != (0)) __PYX_ERR(0, 203, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 5, __pyx_t_7) != (0)) __PYX_ERR(0, 203, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 6, __pyx_t_8) != (0)) __PYX_ERR(0, 203, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_9); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 7, __pyx_t_9) != (0)) __PYX_ERR(0, 203, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_10); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 8, __pyx_t_10) != (0)) __PYX_ERR(0, 203, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_11); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 9, __pyx_t_11) != (0)) __PYX_ERR(0, 203, __pyx_L5_error); + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_5 = 0; + __pyx_t_6 = 0; + __pyx_t_7 = 0; + __pyx_t_8 = 0; + __pyx_t_9 = 0; + __pyx_t_10 = 0; + __pyx_t_11 = 0; + __pyx_t_11 = __pyx_t_12; __Pyx_INCREF(__pyx_t_11); + __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + for (;;) { + if (__pyx_t_13 >= 10) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_12 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_11, __pyx_t_13)); + #else + __pyx_t_12 = __Pyx_PySequence_ITEM(__pyx_t_11, __pyx_t_13); + #endif + ++__pyx_t_13; + if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 203, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_12); + if (likely(__pyx_t_12 != Py_None)) { + PyObject* sequence = __pyx_t_12; + Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 203, __pyx_L5_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_10 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_10); + __pyx_t_9 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_9); + #else + __pyx_t_10 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 203, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_9 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 203, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_9); + #endif + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(0, 203, __pyx_L5_error) + } + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_8genexpr1__pyx_v_kind); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_8genexpr1__pyx_v_kind, __pyx_t_10); + __Pyx_GIVEREF(__pyx_t_10); + __pyx_t_10 = 0; + __Pyx_XDECREF_SET(__pyx_8genexpr1__pyx_v_mapping, __pyx_t_9); + __pyx_t_9 = 0; + __Pyx_TraceLine(203,12,0,__PYX_ERR(0, 203, __pyx_L5_error)) + + /* "hunter/_predicates.pyx":215 + * ('_gte', self.query_gte), + * ] + * if mapping # <<<<<<<<<<<<<< + * ]) + * ) +*/ + __Pyx_TraceLine(215,47,0,__PYX_ERR(0, 215, __pyx_L5_error)) + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_8genexpr1__pyx_v_mapping); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 215, __pyx_L5_error) + if (__pyx_t_14) { -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_9query_gte_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_9query_gte_1__get__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_9query_gte___get__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self)); + /* "hunter/_predicates.pyx":202 + * return 'Query(%s)' % ( + * ', '.join([ + * ', '.join(f'{key}{kind}={value!r}' for key, value in mapping) # <<<<<<<<<<<<<< + * for kind, mapping in [ + * ('', self.query_eq), +*/ + __Pyx_TraceLine(202,11,0,__PYX_ERR(0, 202, __pyx_L5_error)) + __pyx_t_12 = __pyx_pf_6hunter_11_predicates_5Query_7__str___8genexpr1_genexpr(((PyObject*)__pyx_cur_scope), __pyx_8genexpr1__pyx_v_mapping); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 202, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_9 = __Pyx_Generator_GetInlinedResult(__pyx_t_12); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 202, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_12 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__4, __pyx_t_9); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 202, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_12))) __PYX_ERR(0, 201, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + + /* "hunter/_predicates.pyx":215 + * ('_gte', self.query_gte), + * ] + * if mapping # <<<<<<<<<<<<<< + * ]) + * ) +*/ + } - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":203 + * ', '.join([ + * ', '.join(f'{key}{kind}={value!r}' for key, value in mapping) + * for kind, mapping in [ # <<<<<<<<<<<<<< + * ('', self.query_eq), + * ('_in', self.query_in), +*/ + __Pyx_TraceLine(203,12,0,__PYX_ERR(0, 203, __pyx_L5_error)) + } + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_mapping); __pyx_8genexpr1__pyx_v_mapping = 0; + goto __pyx_L10_exit_scope; + __pyx_L5_error:; + __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_mapping); __pyx_8genexpr1__pyx_v_mapping = 0; + goto __pyx_L1_error; + __pyx_L10_exit_scope:; + } /* exit inner scope */ + + /* "hunter/_predicates.pyx":201 + * def __str__(self): + * return 'Query(%s)' % ( + * ', '.join([ # <<<<<<<<<<<<<< + * ', '.join(f'{key}{kind}={value!r}' for key, value in mapping) + * for kind, mapping in [ +*/ + __Pyx_TraceLine(201,6,0,__PYX_ERR(0, 201, __pyx_L1_error)) + __pyx_t_11 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__4, __pyx_t_1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_9query_gte___get__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 14, 0, __PYX_ERR(1, 14, __pyx_L1_error)); - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->query_gte); - __pyx_r = __pyx_v_self->query_gte; + /* "hunter/_predicates.pyx":200 + * + * def __str__(self): + * return 'Query(%s)' % ( # <<<<<<<<<<<<<< + * ', '.join([ + * ', '.join(f'{key}{kind}={value!r}' for key, value in mapping) +*/ + __Pyx_TraceLine(200,3,0,__PYX_ERR(0, 200, __pyx_L1_error)) + __pyx_t_1 = PyUnicode_Format(__pyx_mstate_global->__pyx_kp_u_Query_s, __pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 200, __pyx_L1_error)); goto __pyx_L0; + /* "hunter/_predicates.pyx":199 + * self.query_gte = tuple(sorted(query_gte.items())) + * + * def __str__(self): # <<<<<<<<<<<<<< + * return 'Query(%s)' % ( + * ', '.join([ +*/ + /* function exit code */ __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.Query.query_gte.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 199, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Query.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; + __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_mapping); + __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_0); + __Pyx_DECREF((PyObject *)__pyx_cur_scope); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pxd":15 - * readonly tuple query_gt - * readonly tuple query_gte - * readonly tuple query_in # <<<<<<<<<<<<<< - * readonly tuple query_lt - * readonly tuple query_lte - */ +/* "hunter/_predicates.pyx":219 + * ) + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return '' % ' '.join([ + * fmt % (mapping,) +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_8query_in_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_8query_in_1__get__(PyObject *__pyx_v_self) { +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_5__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_5__repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_8query_in___get__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_4__repr__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_8query_in___get__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self) { +static PyObject *__pyx_pf_6hunter_11_predicates_5Query_4__repr__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self) { + PyObject *__pyx_8genexpr3__pyx_v_fmt = NULL; + PyObject *__pyx_8genexpr3__pyx_v_mapping = NULL; PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 15, 0, __PYX_ERR(1, 15, __pyx_L1_error)); + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + Py_ssize_t __pyx_t_13; + int __pyx_t_14; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[27])) + __Pyx_RefNannySetupContext("__repr__", 0); + __Pyx_TraceStartFunc("__repr__", __pyx_f[0], 219, 0, 0, 0, __PYX_ERR(0, 219, __pyx_L1_error)); + + /* "hunter/_predicates.pyx":220 + * + * def __repr__(self): + * return '' % ' '.join([ # <<<<<<<<<<<<<< + * fmt % (mapping,) + * for fmt, mapping in [ +*/ + __Pyx_TraceLine(220,1,0,__PYX_ERR(0, 220, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->query_in); - __pyx_r = __pyx_v_self->query_in; - goto __pyx_L0; + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 220, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_1); - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.Query.query_in.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":223 + * fmt % (mapping,) + * for fmt, mapping in [ + * ('query_eq=%r', self.query_eq), # <<<<<<<<<<<<<< + * ('query_in=%r', self.query_in), + * ('query_contains=%r', self.query_contains), +*/ + __Pyx_TraceLine(223,15,0,__PYX_ERR(0, 223, __pyx_L5_error)) + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 223, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_query_eq_r); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_kp_u_query_eq_r); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_mstate_global->__pyx_kp_u_query_eq_r) != (0)) __PYX_ERR(0, 223, __pyx_L5_error); + __Pyx_INCREF(__pyx_v_self->query_eq); + __Pyx_GIVEREF(__pyx_v_self->query_eq); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_self->query_eq) != (0)) __PYX_ERR(0, 223, __pyx_L5_error); -/* "hunter/_predicates.pxd":16 - * readonly tuple query_gte - * readonly tuple query_in - * readonly tuple query_lt # <<<<<<<<<<<<<< - * readonly tuple query_lte - * readonly tuple query_regex - */ + /* "hunter/_predicates.pyx":224 + * for fmt, mapping in [ + * ('query_eq=%r', self.query_eq), + * ('query_in=%r', self.query_in), # <<<<<<<<<<<<<< + * ('query_contains=%r', self.query_contains), + * ('query_startswith=%r', self.query_startswith), +*/ + __Pyx_TraceLine(224,18,0,__PYX_ERR(0, 224, __pyx_L5_error)) + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 224, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_query_in_r); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_kp_u_query_in_r); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_mstate_global->__pyx_kp_u_query_in_r) != (0)) __PYX_ERR(0, 224, __pyx_L5_error); + __Pyx_INCREF(__pyx_v_self->query_in); + __Pyx_GIVEREF(__pyx_v_self->query_in); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_self->query_in) != (0)) __PYX_ERR(0, 224, __pyx_L5_error); -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_8query_lt_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_8query_lt_1__get__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_8query_lt___get__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self)); + /* "hunter/_predicates.pyx":225 + * ('query_eq=%r', self.query_eq), + * ('query_in=%r', self.query_in), + * ('query_contains=%r', self.query_contains), # <<<<<<<<<<<<<< + * ('query_startswith=%r', self.query_startswith), + * ('query_endswith=%r', self.query_endswith), +*/ + __Pyx_TraceLine(225,21,0,__PYX_ERR(0, 225, __pyx_L5_error)) + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 225, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_query_contains_r); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_kp_u_query_contains_r); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_mstate_global->__pyx_kp_u_query_contains_r) != (0)) __PYX_ERR(0, 225, __pyx_L5_error); + __Pyx_INCREF(__pyx_v_self->query_contains); + __Pyx_GIVEREF(__pyx_v_self->query_contains); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_self->query_contains) != (0)) __PYX_ERR(0, 225, __pyx_L5_error); - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":226 + * ('query_in=%r', self.query_in), + * ('query_contains=%r', self.query_contains), + * ('query_startswith=%r', self.query_startswith), # <<<<<<<<<<<<<< + * ('query_endswith=%r', self.query_endswith), + * ('query_regex=%r', self.query_regex), +*/ + __Pyx_TraceLine(226,24,0,__PYX_ERR(0, 226, __pyx_L5_error)) + __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 226, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_query_startswith_r); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_kp_u_query_startswith_r); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_mstate_global->__pyx_kp_u_query_startswith_r) != (0)) __PYX_ERR(0, 226, __pyx_L5_error); + __Pyx_INCREF(__pyx_v_self->query_startswith); + __Pyx_GIVEREF(__pyx_v_self->query_startswith); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_v_self->query_startswith) != (0)) __PYX_ERR(0, 226, __pyx_L5_error); + + /* "hunter/_predicates.pyx":227 + * ('query_contains=%r', self.query_contains), + * ('query_startswith=%r', self.query_startswith), + * ('query_endswith=%r', self.query_endswith), # <<<<<<<<<<<<<< + * ('query_regex=%r', self.query_regex), + * ('query_lt=%r', self.query_lt), +*/ + __Pyx_TraceLine(227,27,0,__PYX_ERR(0, 227, __pyx_L5_error)) + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 227, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_query_endswith_r); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_kp_u_query_endswith_r); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_mstate_global->__pyx_kp_u_query_endswith_r) != (0)) __PYX_ERR(0, 227, __pyx_L5_error); + __Pyx_INCREF(__pyx_v_self->query_endswith); + __Pyx_GIVEREF(__pyx_v_self->query_endswith); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_v_self->query_endswith) != (0)) __PYX_ERR(0, 227, __pyx_L5_error); -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_8query_lt___get__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 16, 0, __PYX_ERR(1, 16, __pyx_L1_error)); - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->query_lt); - __pyx_r = __pyx_v_self->query_lt; - goto __pyx_L0; - - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.Query.query_lt.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "hunter/_predicates.pxd":17 - * readonly tuple query_in - * readonly tuple query_lt - * readonly tuple query_lte # <<<<<<<<<<<<<< - * readonly tuple query_regex - * readonly tuple query_startswith - */ + /* "hunter/_predicates.pyx":228 + * ('query_startswith=%r', self.query_startswith), + * ('query_endswith=%r', self.query_endswith), + * ('query_regex=%r', self.query_regex), # <<<<<<<<<<<<<< + * ('query_lt=%r', self.query_lt), + * ('query_lte=%r', self.query_lte), +*/ + __Pyx_TraceLine(228,30,0,__PYX_ERR(0, 228, __pyx_L5_error)) + __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 228, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_query_regex_r); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_kp_u_query_regex_r); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_mstate_global->__pyx_kp_u_query_regex_r) != (0)) __PYX_ERR(0, 228, __pyx_L5_error); + __Pyx_INCREF(__pyx_v_self->query_regex); + __Pyx_GIVEREF(__pyx_v_self->query_regex); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_v_self->query_regex) != (0)) __PYX_ERR(0, 228, __pyx_L5_error); -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_9query_lte_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_9query_lte_1__get__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_9query_lte___get__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self)); + /* "hunter/_predicates.pyx":229 + * ('query_endswith=%r', self.query_endswith), + * ('query_regex=%r', self.query_regex), + * ('query_lt=%r', self.query_lt), # <<<<<<<<<<<<<< + * ('query_lte=%r', self.query_lte), + * ('query_gt=%r', self.query_gt), +*/ + __Pyx_TraceLine(229,33,0,__PYX_ERR(0, 229, __pyx_L5_error)) + __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 229, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_query_lt_r); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_kp_u_query_lt_r); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_mstate_global->__pyx_kp_u_query_lt_r) != (0)) __PYX_ERR(0, 229, __pyx_L5_error); + __Pyx_INCREF(__pyx_v_self->query_lt); + __Pyx_GIVEREF(__pyx_v_self->query_lt); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_v_self->query_lt) != (0)) __PYX_ERR(0, 229, __pyx_L5_error); - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":230 + * ('query_regex=%r', self.query_regex), + * ('query_lt=%r', self.query_lt), + * ('query_lte=%r', self.query_lte), # <<<<<<<<<<<<<< + * ('query_gt=%r', self.query_gt), + * ('query_gte=%r', self.query_gte), +*/ + __Pyx_TraceLine(230,36,0,__PYX_ERR(0, 230, __pyx_L5_error)) + __pyx_t_9 = PyTuple_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 230, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_query_lte_r); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_kp_u_query_lte_r); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_mstate_global->__pyx_kp_u_query_lte_r) != (0)) __PYX_ERR(0, 230, __pyx_L5_error); + __Pyx_INCREF(__pyx_v_self->query_lte); + __Pyx_GIVEREF(__pyx_v_self->query_lte); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_v_self->query_lte) != (0)) __PYX_ERR(0, 230, __pyx_L5_error); + + /* "hunter/_predicates.pyx":231 + * ('query_lt=%r', self.query_lt), + * ('query_lte=%r', self.query_lte), + * ('query_gt=%r', self.query_gt), # <<<<<<<<<<<<<< + * ('query_gte=%r', self.query_gte), + * ] +*/ + __Pyx_TraceLine(231,39,0,__PYX_ERR(0, 231, __pyx_L5_error)) + __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 231, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_query_gt_r); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_kp_u_query_gt_r); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_mstate_global->__pyx_kp_u_query_gt_r) != (0)) __PYX_ERR(0, 231, __pyx_L5_error); + __Pyx_INCREF(__pyx_v_self->query_gt); + __Pyx_GIVEREF(__pyx_v_self->query_gt); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_v_self->query_gt) != (0)) __PYX_ERR(0, 231, __pyx_L5_error); -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_9query_lte___get__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 17, 0, __PYX_ERR(1, 17, __pyx_L1_error)); - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->query_lte); - __pyx_r = __pyx_v_self->query_lte; - goto __pyx_L0; + /* "hunter/_predicates.pyx":232 + * ('query_lte=%r', self.query_lte), + * ('query_gt=%r', self.query_gt), + * ('query_gte=%r', self.query_gte), # <<<<<<<<<<<<<< + * ] + * if mapping +*/ + __Pyx_TraceLine(232,42,0,__PYX_ERR(0, 232, __pyx_L5_error)) + __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 232, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_query_gte_r); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_kp_u_query_gte_r); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_mstate_global->__pyx_kp_u_query_gte_r) != (0)) __PYX_ERR(0, 232, __pyx_L5_error); + __Pyx_INCREF(__pyx_v_self->query_gte); + __Pyx_GIVEREF(__pyx_v_self->query_gte); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_v_self->query_gte) != (0)) __PYX_ERR(0, 232, __pyx_L5_error); - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.Query.query_lte.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":222 + * return '' % ' '.join([ + * fmt % (mapping,) + * for fmt, mapping in [ # <<<<<<<<<<<<<< + * ('query_eq=%r', self.query_eq), + * ('query_in=%r', self.query_in), +*/ + __Pyx_TraceLine(222,14,0,__PYX_ERR(0, 222, __pyx_L5_error)) + __pyx_t_12 = PyTuple_New(10); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 222, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_2) != (0)) __PYX_ERR(0, 222, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 222, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 2, __pyx_t_4) != (0)) __PYX_ERR(0, 222, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 3, __pyx_t_5) != (0)) __PYX_ERR(0, 222, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 4, __pyx_t_6) != (0)) __PYX_ERR(0, 222, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 5, __pyx_t_7) != (0)) __PYX_ERR(0, 222, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 6, __pyx_t_8) != (0)) __PYX_ERR(0, 222, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_9); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 7, __pyx_t_9) != (0)) __PYX_ERR(0, 222, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_10); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 8, __pyx_t_10) != (0)) __PYX_ERR(0, 222, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_11); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 9, __pyx_t_11) != (0)) __PYX_ERR(0, 222, __pyx_L5_error); + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_5 = 0; + __pyx_t_6 = 0; + __pyx_t_7 = 0; + __pyx_t_8 = 0; + __pyx_t_9 = 0; + __pyx_t_10 = 0; + __pyx_t_11 = 0; + __pyx_t_11 = __pyx_t_12; __Pyx_INCREF(__pyx_t_11); + __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + for (;;) { + if (__pyx_t_13 >= 10) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_12 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_11, __pyx_t_13)); + #else + __pyx_t_12 = __Pyx_PySequence_ITEM(__pyx_t_11, __pyx_t_13); + #endif + ++__pyx_t_13; + if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 222, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_12); + if (likely(__pyx_t_12 != Py_None)) { + PyObject* sequence = __pyx_t_12; + Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 222, __pyx_L5_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_10 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_10); + __pyx_t_9 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_9); + #else + __pyx_t_10 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 222, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_9 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 222, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_9); + #endif + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(0, 222, __pyx_L5_error) + } + __Pyx_XDECREF_SET(__pyx_8genexpr3__pyx_v_fmt, __pyx_t_10); + __pyx_t_10 = 0; + __Pyx_XDECREF_SET(__pyx_8genexpr3__pyx_v_mapping, __pyx_t_9); + __pyx_t_9 = 0; + __Pyx_TraceLine(222,11,0,__PYX_ERR(0, 222, __pyx_L5_error)) -/* "hunter/_predicates.pxd":18 - * readonly tuple query_lt - * readonly tuple query_lte - * readonly tuple query_regex # <<<<<<<<<<<<<< - * readonly tuple query_startswith + /* "hunter/_predicates.pyx":234 + * ('query_gte=%r', self.query_gte), + * ] + * if mapping # <<<<<<<<<<<<<< + * ]) * - */ +*/ + __Pyx_TraceLine(234,46,0,__PYX_ERR(0, 234, __pyx_L5_error)) + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_8genexpr3__pyx_v_mapping); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 234, __pyx_L5_error) + if (__pyx_t_14) { -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_11query_regex_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_11query_regex_1__get__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_11query_regex___get__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self)); + /* "hunter/_predicates.pyx":221 + * def __repr__(self): + * return '' % ' '.join([ + * fmt % (mapping,) # <<<<<<<<<<<<<< + * for fmt, mapping in [ + * ('query_eq=%r', self.query_eq), +*/ + __Pyx_TraceLine(221,10,0,__PYX_ERR(0, 221, __pyx_L5_error)) + __pyx_t_12 = PyTuple_New(1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 221, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_INCREF(__pyx_8genexpr3__pyx_v_mapping); + __Pyx_GIVEREF(__pyx_8genexpr3__pyx_v_mapping); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_8genexpr3__pyx_v_mapping) != (0)) __PYX_ERR(0, 221, __pyx_L5_error); + __pyx_t_9 = PyNumber_Remainder(__pyx_8genexpr3__pyx_v_fmt, __pyx_t_12); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 221, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_9))) __PYX_ERR(0, 220, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "hunter/_predicates.pyx":234 + * ('query_gte=%r', self.query_gte), + * ] + * if mapping # <<<<<<<<<<<<<< + * ]) + * +*/ + } - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":222 + * return '' % ' '.join([ + * fmt % (mapping,) + * for fmt, mapping in [ # <<<<<<<<<<<<<< + * ('query_eq=%r', self.query_eq), + * ('query_in=%r', self.query_in), +*/ + __Pyx_TraceLine(222,11,0,__PYX_ERR(0, 222, __pyx_L5_error)) + } + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_8genexpr3__pyx_v_fmt); __pyx_8genexpr3__pyx_v_fmt = 0; + __Pyx_XDECREF(__pyx_8genexpr3__pyx_v_mapping); __pyx_8genexpr3__pyx_v_mapping = 0; + goto __pyx_L10_exit_scope; + __pyx_L5_error:; + __Pyx_XDECREF(__pyx_8genexpr3__pyx_v_fmt); __pyx_8genexpr3__pyx_v_fmt = 0; + __Pyx_XDECREF(__pyx_8genexpr3__pyx_v_mapping); __pyx_8genexpr3__pyx_v_mapping = 0; + goto __pyx_L1_error; + __pyx_L10_exit_scope:; + } /* exit inner scope */ -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_11query_regex___get__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 18, 0, __PYX_ERR(1, 18, __pyx_L1_error)); - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->query_regex); - __pyx_r = __pyx_v_self->query_regex; + /* "hunter/_predicates.pyx":220 + * + * def __repr__(self): + * return '' % ' '.join([ # <<<<<<<<<<<<<< + * fmt % (mapping,) + * for fmt, mapping in [ +*/ + __Pyx_TraceLine(220,6,0,__PYX_ERR(0, 220, __pyx_L1_error)) + __pyx_t_11 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__6, __pyx_t_1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyUnicode_Format(__pyx_mstate_global->__pyx_kp_u_hunter_predicates_Query_s, __pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 220, __pyx_L1_error)); goto __pyx_L0; - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.Query.query_regex.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "hunter/_predicates.pxd":19 - * readonly tuple query_lte - * readonly tuple query_regex - * readonly tuple query_startswith # <<<<<<<<<<<<<< + /* "hunter/_predicates.pyx":219 + * ) * - * @cython.final - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_16query_startswith_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_16query_startswith_1__get__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_16query_startswith___get__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_16query_startswith___get__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 19, 0, __PYX_ERR(1, 19, __pyx_L1_error)); - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->query_startswith); - __pyx_r = __pyx_v_self->query_startswith; - goto __pyx_L0; + * def __repr__(self): # <<<<<<<<<<<<<< + * return '' % ' '.join([ + * fmt % (mapping,) +*/ /* function exit code */ __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.Query.query_startswith.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 219, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Query.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; + __Pyx_XDECREF(__pyx_8genexpr3__pyx_v_fmt); + __Pyx_XDECREF(__pyx_8genexpr3__pyx_v_mapping); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict - */ +/* "hunter/_predicates.pyx":237 + * ]) + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return ( + * isinstance(other, Query) +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_19__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_19__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_7__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_7__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_18__reduce_cython__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_6__eq__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self), ((PyObject *)__pyx_v_other)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_18__reduce_cython__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self) { - PyObject *__pyx_v_state = 0; - PyObject *__pyx_v__dict = 0; - int __pyx_v_use_setstate; +static PyObject *__pyx_pf_6hunter_11_predicates_5Query_6__eq__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self, PyObject *__pyx_v_other) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; - int __pyx_t_3; - PyObject *__pyx_t_4 = NULL; - int __pyx_t_5; - PyObject *__pyx_t_6 = NULL; - __Pyx_RefNannySetupContext("__reduce_cython__", 0); - __Pyx_TraceCall("__reduce_cython__", __pyx_f[2], 1, 0, __PYX_ERR(2, 1, __pyx_L1_error)); + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[28])) + __Pyx_RefNannySetupContext("__eq__", 0); + __Pyx_TraceStartFunc("__eq__", __pyx_f[0], 237, 0, 0, 0, __PYX_ERR(0, 237, __pyx_L1_error)); - /* "(tree fragment)":5 - * cdef object _dict - * cdef bint use_setstate - * state = (self.query_contains, self.query_endswith, self.query_eq, self.query_gt, self.query_gte, self.query_in, self.query_lt, self.query_lte, self.query_regex, self.query_startswith) # <<<<<<<<<<<<<< - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: - */ - __Pyx_TraceLine(5,0,__PYX_ERR(2, 5, __pyx_L1_error)) - __pyx_t_1 = PyTuple_New(10); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v_self->query_contains); - __Pyx_GIVEREF(__pyx_v_self->query_contains); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->query_contains); - __Pyx_INCREF(__pyx_v_self->query_endswith); - __Pyx_GIVEREF(__pyx_v_self->query_endswith); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->query_endswith); - __Pyx_INCREF(__pyx_v_self->query_eq); - __Pyx_GIVEREF(__pyx_v_self->query_eq); - PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_self->query_eq); - __Pyx_INCREF(__pyx_v_self->query_gt); - __Pyx_GIVEREF(__pyx_v_self->query_gt); - PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_v_self->query_gt); - __Pyx_INCREF(__pyx_v_self->query_gte); - __Pyx_GIVEREF(__pyx_v_self->query_gte); - PyTuple_SET_ITEM(__pyx_t_1, 4, __pyx_v_self->query_gte); - __Pyx_INCREF(__pyx_v_self->query_in); - __Pyx_GIVEREF(__pyx_v_self->query_in); - PyTuple_SET_ITEM(__pyx_t_1, 5, __pyx_v_self->query_in); - __Pyx_INCREF(__pyx_v_self->query_lt); - __Pyx_GIVEREF(__pyx_v_self->query_lt); - PyTuple_SET_ITEM(__pyx_t_1, 6, __pyx_v_self->query_lt); - __Pyx_INCREF(__pyx_v_self->query_lte); - __Pyx_GIVEREF(__pyx_v_self->query_lte); - PyTuple_SET_ITEM(__pyx_t_1, 7, __pyx_v_self->query_lte); - __Pyx_INCREF(__pyx_v_self->query_regex); - __Pyx_GIVEREF(__pyx_v_self->query_regex); - PyTuple_SET_ITEM(__pyx_t_1, 8, __pyx_v_self->query_regex); - __Pyx_INCREF(__pyx_v_self->query_startswith); - __Pyx_GIVEREF(__pyx_v_self->query_startswith); - PyTuple_SET_ITEM(__pyx_t_1, 9, __pyx_v_self->query_startswith); - __pyx_v_state = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - - /* "(tree fragment)":6 - * cdef bint use_setstate - * state = (self.query_contains, self.query_endswith, self.query_eq, self.query_gt, self.query_gte, self.query_in, self.query_lt, self.query_lte, self.query_regex, self.query_startswith) - * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< - * if _dict is not None: - * state += (_dict,) - */ - __Pyx_TraceLine(6,0,__PYX_ERR(2, 6, __pyx_L1_error)) - __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v__dict = __pyx_t_1; - __pyx_t_1 = 0; - - /* "(tree fragment)":7 - * state = (self.query_contains, self.query_endswith, self.query_eq, self.query_gt, self.query_gte, self.query_in, self.query_lt, self.query_lte, self.query_regex, self.query_startswith) - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: # <<<<<<<<<<<<<< - * state += (_dict,) - * use_setstate = True - */ - __Pyx_TraceLine(7,0,__PYX_ERR(2, 7, __pyx_L1_error)) - __pyx_t_2 = (__pyx_v__dict != Py_None); - __pyx_t_3 = (__pyx_t_2 != 0); - if (__pyx_t_3) { + /* "hunter/_predicates.pyx":238 + * + * def __eq__(self, other): + * return ( # <<<<<<<<<<<<<< + * isinstance(other, Query) + * and self.query_eq == ( other).query_eq +*/ + __Pyx_TraceLine(238,1,0,__PYX_ERR(0, 238, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); - /* "(tree fragment)":8 - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: - * state += (_dict,) # <<<<<<<<<<<<<< - * use_setstate = True - * else: - */ - __Pyx_TraceLine(8,0,__PYX_ERR(2, 8, __pyx_L1_error)) - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v__dict); - __Pyx_GIVEREF(__pyx_v__dict); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict); - __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4)); - __pyx_t_4 = 0; + /* "hunter/_predicates.pyx":239 + * def __eq__(self, other): + * return ( + * isinstance(other, Query) # <<<<<<<<<<<<<< + * and self.query_eq == ( other).query_eq + * and self.query_startswith == ( other).query_startswith +*/ + __Pyx_TraceLine(239,5,0,__PYX_ERR(0, 239, __pyx_L1_error)) + __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_other, __pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Query); + if (__pyx_t_2) { + } else { + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L3_bool_binop_done; + } - /* "(tree fragment)":9 - * if _dict is not None: - * state += (_dict,) - * use_setstate = True # <<<<<<<<<<<<<< - * else: - * use_setstate = self.query_contains is not None or self.query_endswith is not None or self.query_eq is not None or self.query_gt is not None or self.query_gte is not None or self.query_in is not None or self.query_lt is not None or self.query_lte is not None or self.query_regex is not None or self.query_startswith is not None - */ - __Pyx_TraceLine(9,0,__PYX_ERR(2, 9, __pyx_L1_error)) - __pyx_v_use_setstate = 1; + /* "hunter/_predicates.pyx":240 + * return ( + * isinstance(other, Query) + * and self.query_eq == ( other).query_eq # <<<<<<<<<<<<<< + * and self.query_startswith == ( other).query_startswith + * and self.query_endswith == ( other).query_endswith +*/ + __Pyx_TraceLine(240,12,0,__PYX_ERR(0, 240, __pyx_L1_error)) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->query_eq, ((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_other)->query_eq, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 240, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 240, __pyx_L1_error) + if (__pyx_t_2) { + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __Pyx_INCREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L3_bool_binop_done; + } - /* "(tree fragment)":7 - * state = (self.query_contains, self.query_endswith, self.query_eq, self.query_gt, self.query_gte, self.query_in, self.query_lt, self.query_lte, self.query_regex, self.query_startswith) - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: # <<<<<<<<<<<<<< - * state += (_dict,) - * use_setstate = True - */ - goto __pyx_L3; + /* "hunter/_predicates.pyx":241 + * isinstance(other, Query) + * and self.query_eq == ( other).query_eq + * and self.query_startswith == ( other).query_startswith # <<<<<<<<<<<<<< + * and self.query_endswith == ( other).query_endswith + * and self.query_in == ( other).query_in +*/ + __Pyx_TraceLine(241,19,0,__PYX_ERR(0, 241, __pyx_L1_error)) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->query_startswith, ((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_other)->query_startswith, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 241, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 241, __pyx_L1_error) + if (__pyx_t_2) { + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __Pyx_INCREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L3_bool_binop_done; } - /* "(tree fragment)":11 - * use_setstate = True - * else: - * use_setstate = self.query_contains is not None or self.query_endswith is not None or self.query_eq is not None or self.query_gt is not None or self.query_gte is not None or self.query_in is not None or self.query_lt is not None or self.query_lte is not None or self.query_regex is not None or self.query_startswith is not None # <<<<<<<<<<<<<< - * if use_setstate: - * return __pyx_unpickle_Query, (type(self), 0x4eca0a2, None), state - */ - __Pyx_TraceLine(11,0,__PYX_ERR(2, 11, __pyx_L1_error)) - /*else*/ { - __pyx_t_2 = (__pyx_v_self->query_contains != ((PyObject*)Py_None)); - __pyx_t_5 = (__pyx_t_2 != 0); - if (!__pyx_t_5) { - } else { - __pyx_t_3 = __pyx_t_5; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_5 = (__pyx_v_self->query_endswith != ((PyObject*)Py_None)); - __pyx_t_2 = (__pyx_t_5 != 0); - if (!__pyx_t_2) { - } else { - __pyx_t_3 = __pyx_t_2; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_2 = (__pyx_v_self->query_eq != ((PyObject*)Py_None)); - __pyx_t_5 = (__pyx_t_2 != 0); - if (!__pyx_t_5) { - } else { - __pyx_t_3 = __pyx_t_5; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_5 = (__pyx_v_self->query_gt != ((PyObject*)Py_None)); - __pyx_t_2 = (__pyx_t_5 != 0); - if (!__pyx_t_2) { - } else { - __pyx_t_3 = __pyx_t_2; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_2 = (__pyx_v_self->query_gte != ((PyObject*)Py_None)); - __pyx_t_5 = (__pyx_t_2 != 0); - if (!__pyx_t_5) { - } else { - __pyx_t_3 = __pyx_t_5; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_5 = (__pyx_v_self->query_in != ((PyObject*)Py_None)); - __pyx_t_2 = (__pyx_t_5 != 0); - if (!__pyx_t_2) { - } else { - __pyx_t_3 = __pyx_t_2; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_2 = (__pyx_v_self->query_lt != ((PyObject*)Py_None)); - __pyx_t_5 = (__pyx_t_2 != 0); - if (!__pyx_t_5) { - } else { - __pyx_t_3 = __pyx_t_5; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_5 = (__pyx_v_self->query_lte != ((PyObject*)Py_None)); - __pyx_t_2 = (__pyx_t_5 != 0); - if (!__pyx_t_2) { - } else { - __pyx_t_3 = __pyx_t_2; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_2 = (__pyx_v_self->query_regex != ((PyObject*)Py_None)); - __pyx_t_5 = (__pyx_t_2 != 0); - if (!__pyx_t_5) { - } else { - __pyx_t_3 = __pyx_t_5; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_5 = (__pyx_v_self->query_startswith != ((PyObject*)Py_None)); - __pyx_t_2 = (__pyx_t_5 != 0); - __pyx_t_3 = __pyx_t_2; - __pyx_L4_bool_binop_done:; - __pyx_v_use_setstate = __pyx_t_3; + /* "hunter/_predicates.pyx":242 + * and self.query_eq == ( other).query_eq + * and self.query_startswith == ( other).query_startswith + * and self.query_endswith == ( other).query_endswith # <<<<<<<<<<<<<< + * and self.query_in == ( other).query_in + * and self.query_contains == ( other).query_contains +*/ + __Pyx_TraceLine(242,26,0,__PYX_ERR(0, 242, __pyx_L1_error)) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->query_endswith, ((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_other)->query_endswith, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 242, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 242, __pyx_L1_error) + if (__pyx_t_2) { + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __Pyx_INCREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L3_bool_binop_done; } - __pyx_L3:; - /* "(tree fragment)":12 - * else: - * use_setstate = self.query_contains is not None or self.query_endswith is not None or self.query_eq is not None or self.query_gt is not None or self.query_gte is not None or self.query_in is not None or self.query_lt is not None or self.query_lte is not None or self.query_regex is not None or self.query_startswith is not None - * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_Query, (type(self), 0x4eca0a2, None), state - * else: - */ - __Pyx_TraceLine(12,0,__PYX_ERR(2, 12, __pyx_L1_error)) - __pyx_t_3 = (__pyx_v_use_setstate != 0); - if (__pyx_t_3) { + /* "hunter/_predicates.pyx":243 + * and self.query_startswith == ( other).query_startswith + * and self.query_endswith == ( other).query_endswith + * and self.query_in == ( other).query_in # <<<<<<<<<<<<<< + * and self.query_contains == ( other).query_contains + * and self.query_regex == ( other).query_regex +*/ + __Pyx_TraceLine(243,33,0,__PYX_ERR(0, 243, __pyx_L1_error)) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->query_in, ((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_other)->query_in, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 243, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 243, __pyx_L1_error) + if (__pyx_t_2) { + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __Pyx_INCREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L3_bool_binop_done; + } - /* "(tree fragment)":13 - * use_setstate = self.query_contains is not None or self.query_endswith is not None or self.query_eq is not None or self.query_gt is not None or self.query_gte is not None or self.query_in is not None or self.query_lt is not None or self.query_lte is not None or self.query_regex is not None or self.query_startswith is not None - * if use_setstate: - * return __pyx_unpickle_Query, (type(self), 0x4eca0a2, None), state # <<<<<<<<<<<<<< - * else: - * return __pyx_unpickle_Query, (type(self), 0x4eca0a2, state) - */ - __Pyx_TraceLine(13,0,__PYX_ERR(2, 13, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Query); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_INCREF(__pyx_int_82616482); - __Pyx_GIVEREF(__pyx_int_82616482); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_82616482); - __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(Py_None); - PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None); - __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_1); - __Pyx_INCREF(__pyx_v_state); - __Pyx_GIVEREF(__pyx_v_state); - PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_v_state); - __pyx_t_4 = 0; - __pyx_t_1 = 0; - __pyx_r = __pyx_t_6; - __pyx_t_6 = 0; - goto __pyx_L0; + /* "hunter/_predicates.pyx":244 + * and self.query_endswith == ( other).query_endswith + * and self.query_in == ( other).query_in + * and self.query_contains == ( other).query_contains # <<<<<<<<<<<<<< + * and self.query_regex == ( other).query_regex + * and self.query_lt == ( other).query_lt +*/ + __Pyx_TraceLine(244,40,0,__PYX_ERR(0, 244, __pyx_L1_error)) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->query_contains, ((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_other)->query_contains, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 244, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 244, __pyx_L1_error) + if (__pyx_t_2) { + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __Pyx_INCREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L3_bool_binop_done; + } - /* "(tree fragment)":12 - * else: - * use_setstate = self.query_contains is not None or self.query_endswith is not None or self.query_eq is not None or self.query_gt is not None or self.query_gte is not None or self.query_in is not None or self.query_lt is not None or self.query_lte is not None or self.query_regex is not None or self.query_startswith is not None - * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_Query, (type(self), 0x4eca0a2, None), state - * else: - */ + /* "hunter/_predicates.pyx":245 + * and self.query_in == ( other).query_in + * and self.query_contains == ( other).query_contains + * and self.query_regex == ( other).query_regex # <<<<<<<<<<<<<< + * and self.query_lt == ( other).query_lt + * and self.query_lte == ( other).query_lte +*/ + __Pyx_TraceLine(245,47,0,__PYX_ERR(0, 245, __pyx_L1_error)) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->query_regex, ((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_other)->query_regex, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 245, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 245, __pyx_L1_error) + if (__pyx_t_2) { + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __Pyx_INCREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L3_bool_binop_done; } - /* "(tree fragment)":15 - * return __pyx_unpickle_Query, (type(self), 0x4eca0a2, None), state - * else: - * return __pyx_unpickle_Query, (type(self), 0x4eca0a2, state) # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_Query__set_state(self, __pyx_state) - */ - __Pyx_TraceLine(15,0,__PYX_ERR(2, 15, __pyx_L1_error)) - /*else*/ { - __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_pyx_unpickle_Query); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_INCREF(__pyx_int_82616482); - __Pyx_GIVEREF(__pyx_int_82616482); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_82616482); - __Pyx_INCREF(__pyx_v_state); - __Pyx_GIVEREF(__pyx_v_state); - PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state); - __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1); - __pyx_t_6 = 0; - __pyx_t_1 = 0; - __pyx_r = __pyx_t_4; - __pyx_t_4 = 0; - goto __pyx_L0; + /* "hunter/_predicates.pyx":246 + * and self.query_contains == ( other).query_contains + * and self.query_regex == ( other).query_regex + * and self.query_lt == ( other).query_lt # <<<<<<<<<<<<<< + * and self.query_lte == ( other).query_lte + * and self.query_gt == ( other).query_gt +*/ + __Pyx_TraceLine(246,54,0,__PYX_ERR(0, 246, __pyx_L1_error)) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->query_lt, ((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_other)->query_lt, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 246, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 246, __pyx_L1_error) + if (__pyx_t_2) { + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __Pyx_INCREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L3_bool_binop_done; } - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict - */ + /* "hunter/_predicates.pyx":247 + * and self.query_regex == ( other).query_regex + * and self.query_lt == ( other).query_lt + * and self.query_lte == ( other).query_lte # <<<<<<<<<<<<<< + * and self.query_gt == ( other).query_gt + * and self.query_gte == ( other).query_gte +*/ + __Pyx_TraceLine(247,61,0,__PYX_ERR(0, 247, __pyx_L1_error)) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->query_lte, ((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_other)->query_lte, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 247, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 247, __pyx_L1_error) + if (__pyx_t_2) { + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __Pyx_INCREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L3_bool_binop_done; + } + + /* "hunter/_predicates.pyx":248 + * and self.query_lt == ( other).query_lt + * and self.query_lte == ( other).query_lte + * and self.query_gt == ( other).query_gt # <<<<<<<<<<<<<< + * and self.query_gte == ( other).query_gte + * ) +*/ + __Pyx_TraceLine(248,68,0,__PYX_ERR(0, 248, __pyx_L1_error)) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->query_gt, ((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_other)->query_gt, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 248, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 248, __pyx_L1_error) + if (__pyx_t_2) { + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __Pyx_INCREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L3_bool_binop_done; + } + + /* "hunter/_predicates.pyx":249 + * and self.query_lte == ( other).query_lte + * and self.query_gt == ( other).query_gt + * and self.query_gte == ( other).query_gte # <<<<<<<<<<<<<< + * ) + * +*/ + __Pyx_TraceLine(249,75,0,__PYX_ERR(0, 249, __pyx_L1_error)) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->query_gte, ((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_other)->query_gte, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 249, __pyx_L1_error) + __Pyx_INCREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_L3_bool_binop_done:; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 238, __pyx_L1_error)); + goto __pyx_L0; + + /* "hunter/_predicates.pyx":237 + * ]) + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return ( + * isinstance(other, Query) +*/ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_AddTraceback("hunter._predicates.Query.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 237, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Query.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF(__pyx_v_state); - __Pyx_XDECREF(__pyx_v__dict); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "(tree fragment)":16 - * else: - * return __pyx_unpickle_Query, (type(self), 0x4eca0a2, state) - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle_Query__set_state(self, __pyx_state) - */ +/* "hunter/_predicates.pyx":252 + * ) + * + * def __call__(self, Event event): # <<<<<<<<<<<<<< + * return fast_Query_call(self, event) + * +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_21__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_5Query_21__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_9__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_9__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_20__setstate_cython__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + __Pyx_RefNannySetupContext("__call__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_event,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 252, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 252, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__call__", 0) < 0) __PYX_ERR(0, 252, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__call__", 1, 1, 1, i); __PYX_ERR(0, 252, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 252, __pyx_L3_error) + } + __pyx_v_event = ((struct __pyx_obj_6hunter_6_event_Event *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__call__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 252, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("hunter._predicates.Query.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_event), __pyx_mstate_global->__pyx_ptype_6hunter_6_event_Event, 1, "event", 0))) __PYX_ERR(0, 252, __pyx_L1_error) + __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_8__call__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self), __pyx_v_event); /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_20__setstate_cython__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pf_6hunter_11_predicates_5Query_8__call__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__setstate_cython__", 0); - __Pyx_TraceCall("__setstate_cython__", __pyx_f[2], 16, 0, __PYX_ERR(2, 16, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[29])) + __Pyx_RefNannySetupContext("__call__", 0); + __Pyx_TraceStartFunc("__call__", __pyx_f[0], 252, 0, 0, 0, __PYX_ERR(0, 252, __pyx_L1_error)); - /* "(tree fragment)":17 - * return __pyx_unpickle_Query, (type(self), 0x4eca0a2, state) - * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_Query__set_state(self, __pyx_state) # <<<<<<<<<<<<<< - */ - __Pyx_TraceLine(17,0,__PYX_ERR(2, 17, __pyx_L1_error)) - if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(2, 17, __pyx_L1_error) - __pyx_t_1 = __pyx_f_6hunter_11_predicates___pyx_unpickle_Query__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 17, __pyx_L1_error) + /* "hunter/_predicates.pyx":253 + * + * def __call__(self, Event event): + * return fast_Query_call(self, event) # <<<<<<<<<<<<<< + * + * def __or__(self, other): +*/ + __Pyx_TraceLine(253,1,0,__PYX_ERR(0, 253, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6hunter_11_predicates_fast_Query_call(__pyx_v_self, __pyx_v_event); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 253, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 253, __pyx_L1_error)); + goto __pyx_L0; - /* "(tree fragment)":16 - * else: - * return __pyx_unpickle_Query, (type(self), 0x4eca0a2, state) - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle_Query__set_state(self, __pyx_state) - */ + /* "hunter/_predicates.pyx":252 + * ) + * + * def __call__(self, Event event): # <<<<<<<<<<<<<< + * return fast_Query_call(self, event) + * +*/ /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.Query.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 252, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Query.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":215 - * return Not(self) +/* "hunter/_predicates.pyx":255 + * return fast_Query_call(self, event) * - * cdef fast_Query_call(Query self, Event event): # <<<<<<<<<<<<<< - * for key, value in self.query_eq: - * evalue = event[key] - */ + * def __or__(self, other): # <<<<<<<<<<<<<< + * return Or(self, other) + * +*/ -static PyObject *__pyx_f_6hunter_11_predicates_fast_Query_call(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { - PyObject *__pyx_v_key = NULL; - PyObject *__pyx_v_value = NULL; - PyObject *__pyx_v_evalue = NULL; +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_11__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_11__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__or__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_10__or__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_11_predicates_5Query_10__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - PyObject *(*__pyx_t_7)(PyObject *); - int __pyx_t_8; - int __pyx_t_9; - __Pyx_RefNannySetupContext("fast_Query_call", 0); - __Pyx_TraceCall("fast_Query_call", __pyx_f[0], 215, 0, __PYX_ERR(0, 215, __pyx_L1_error)); + size_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[30])) + __Pyx_RefNannySetupContext("__or__", 0); + __Pyx_TraceStartFunc("__or__", __pyx_f[0], 255, 0, 0, 0, __PYX_ERR(0, 255, __pyx_L1_error)); - /* "hunter/_predicates.pyx":216 + /* "hunter/_predicates.pyx":256 * - * cdef fast_Query_call(Query self, Event event): - * for key, value in self.query_eq: # <<<<<<<<<<<<<< - * evalue = event[key] - * if evalue != value: - */ - __Pyx_TraceLine(216,0,__PYX_ERR(0, 216, __pyx_L1_error)) - if (unlikely(__pyx_v_self->query_eq == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(0, 216, __pyx_L1_error) + * def __or__(self, other): + * return Or(self, other) # <<<<<<<<<<<<<< + * + * def __and__(self, other): +*/ + __Pyx_TraceLine(256,1,0,__PYX_ERR(0, 256, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = NULL; + __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Or); + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Or); + __pyx_t_4 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_v_self, __pyx_v_other}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 256, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_1); } - __pyx_t_1 = __pyx_v_self->query_eq; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; - for (;;) { - if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 216, __pyx_L1_error) - #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 216, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - #endif - if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { - PyObject* sequence = __pyx_t_3; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 216, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); - } else { - __pyx_t_4 = PyList_GET_ITEM(sequence, 0); - __pyx_t_5 = PyList_GET_ITEM(sequence, 1); - } - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(__pyx_t_5); - #else - __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 216, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 216, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - #endif - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } else { - Py_ssize_t index = -1; - __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 216, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext; - index = 0; __pyx_t_4 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_4)) goto __pyx_L5_unpacking_failed; - __Pyx_GOTREF(__pyx_t_4); - index = 1; __pyx_t_5 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L5_unpacking_failed; - __Pyx_GOTREF(__pyx_t_5); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 2) < 0) __PYX_ERR(0, 216, __pyx_L1_error) - __pyx_t_7 = NULL; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - goto __pyx_L6_unpacking_done; - __pyx_L5_unpacking_failed:; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_7 = NULL; - if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 216, __pyx_L1_error) - __pyx_L6_unpacking_done:; - } - __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_4); - __pyx_t_4 = 0; - __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_5); - __pyx_t_5 = 0; + __pyx_r = ((PyObject *)__pyx_t_1); + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 256, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":217 - * cdef fast_Query_call(Query self, Event event): - * for key, value in self.query_eq: - * evalue = event[key] # <<<<<<<<<<<<<< - * if evalue != value: - * return False - */ - __Pyx_TraceLine(217,0,__PYX_ERR(0, 217, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_event), __pyx_v_key); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 217, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_XDECREF_SET(__pyx_v_evalue, __pyx_t_3); - __pyx_t_3 = 0; + /* "hunter/_predicates.pyx":255 + * return fast_Query_call(self, event) + * + * def __or__(self, other): # <<<<<<<<<<<<<< + * return Or(self, other) + * +*/ - /* "hunter/_predicates.pyx":218 - * for key, value in self.query_eq: - * evalue = event[key] - * if evalue != value: # <<<<<<<<<<<<<< - * return False - * for key, value in self.query_in: - */ - __Pyx_TraceLine(218,0,__PYX_ERR(0, 218, __pyx_L1_error)) - __pyx_t_3 = PyObject_RichCompare(__pyx_v_evalue, __pyx_v_value, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 218, __pyx_L1_error) - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 218, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_8) { + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 255, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Query.__or__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":219 - * evalue = event[key] - * if evalue != value: - * return False # <<<<<<<<<<<<<< - * for key, value in self.query_in: - * evalue = event[key] - */ - __Pyx_TraceLine(219,0,__PYX_ERR(0, 219, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(Py_False); - __pyx_r = Py_False; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - goto __pyx_L0; +/* "hunter/_predicates.pyx":258 + * return Or(self, other) + * + * def __and__(self, other): # <<<<<<<<<<<<<< + * return And(self, other) + * +*/ - /* "hunter/_predicates.pyx":218 - * for key, value in self.query_eq: - * evalue = event[key] - * if evalue != value: # <<<<<<<<<<<<<< - * return False - * for key, value in self.query_in: - */ - } +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_13__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_13__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__and__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_12__and__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); - /* "hunter/_predicates.pyx":216 - * - * cdef fast_Query_call(Query self, Event event): - * for key, value in self.query_eq: # <<<<<<<<<<<<<< - * evalue = event[key] - * if evalue != value: - */ - __Pyx_TraceLine(216,0,__PYX_ERR(0, 216, __pyx_L1_error)) - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":220 - * if evalue != value: - * return False - * for key, value in self.query_in: # <<<<<<<<<<<<<< - * evalue = event[key] - * if evalue not in value: - */ - __Pyx_TraceLine(220,0,__PYX_ERR(0, 220, __pyx_L1_error)) - if (unlikely(__pyx_v_self->query_in == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(0, 220, __pyx_L1_error) +static PyObject *__pyx_pf_6hunter_11_predicates_5Query_12__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[31])) + __Pyx_RefNannySetupContext("__and__", 0); + __Pyx_TraceStartFunc("__and__", __pyx_f[0], 258, 0, 0, 0, __PYX_ERR(0, 258, __pyx_L1_error)); + + /* "hunter/_predicates.pyx":259 + * + * def __and__(self, other): + * return And(self, other) # <<<<<<<<<<<<<< + * + * def __invert__(self): +*/ + __Pyx_TraceLine(259,1,0,__PYX_ERR(0, 259, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = NULL; + __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_And); + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_And); + __pyx_t_4 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_v_self, __pyx_v_other}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 259, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_1); } - __pyx_t_1 = __pyx_v_self->query_in; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; - for (;;) { - if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 220, __pyx_L1_error) - #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 220, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - #endif - if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { - PyObject* sequence = __pyx_t_3; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 220, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_5 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); - } else { - __pyx_t_5 = PyList_GET_ITEM(sequence, 0); - __pyx_t_4 = PyList_GET_ITEM(sequence, 1); - } - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(__pyx_t_4); - #else - __pyx_t_5 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 220, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 220, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - #endif - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } else { - Py_ssize_t index = -1; - __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 220, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext; - index = 0; __pyx_t_5 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L10_unpacking_failed; - __Pyx_GOTREF(__pyx_t_5); - index = 1; __pyx_t_4 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_4)) goto __pyx_L10_unpacking_failed; - __Pyx_GOTREF(__pyx_t_4); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 2) < 0) __PYX_ERR(0, 220, __pyx_L1_error) - __pyx_t_7 = NULL; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - goto __pyx_L11_unpacking_done; - __pyx_L10_unpacking_failed:; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_7 = NULL; - if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 220, __pyx_L1_error) - __pyx_L11_unpacking_done:; - } - __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_5); - __pyx_t_5 = 0; - __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_4); - __pyx_t_4 = 0; + __pyx_r = ((PyObject *)__pyx_t_1); + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 259, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":221 - * return False - * for key, value in self.query_in: - * evalue = event[key] # <<<<<<<<<<<<<< - * if evalue not in value: - * return False - */ - __Pyx_TraceLine(221,0,__PYX_ERR(0, 221, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_event), __pyx_v_key); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 221, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_XDECREF_SET(__pyx_v_evalue, __pyx_t_3); - __pyx_t_3 = 0; + /* "hunter/_predicates.pyx":258 + * return Or(self, other) + * + * def __and__(self, other): # <<<<<<<<<<<<<< + * return And(self, other) + * +*/ - /* "hunter/_predicates.pyx":222 - * for key, value in self.query_in: - * evalue = event[key] - * if evalue not in value: # <<<<<<<<<<<<<< - * return False - * for key, value in self.query_contains: - */ - __Pyx_TraceLine(222,0,__PYX_ERR(0, 222, __pyx_L1_error)) - __pyx_t_8 = (__Pyx_PySequence_ContainsTF(__pyx_v_evalue, __pyx_v_value, Py_NE)); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 222, __pyx_L1_error) - __pyx_t_9 = (__pyx_t_8 != 0); - if (__pyx_t_9) { + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 258, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Query.__and__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":223 - * evalue = event[key] - * if evalue not in value: - * return False # <<<<<<<<<<<<<< - * for key, value in self.query_contains: - * evalue = event[key] - */ - __Pyx_TraceLine(223,0,__PYX_ERR(0, 223, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(Py_False); - __pyx_r = Py_False; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - goto __pyx_L0; +/* "hunter/_predicates.pyx":261 + * return And(self, other) + * + * def __invert__(self): # <<<<<<<<<<<<<< + * return Not(self) + * +*/ - /* "hunter/_predicates.pyx":222 - * for key, value in self.query_in: - * evalue = event[key] - * if evalue not in value: # <<<<<<<<<<<<<< - * return False - * for key, value in self.query_contains: - */ - } +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_15__invert__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_15__invert__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__invert__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_14__invert__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self)); - /* "hunter/_predicates.pyx":220 - * if evalue != value: - * return False - * for key, value in self.query_in: # <<<<<<<<<<<<<< - * evalue = event[key] - * if evalue not in value: - */ - __Pyx_TraceLine(220,0,__PYX_ERR(0, 220, __pyx_L1_error)) - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":224 - * if evalue not in value: - * return False - * for key, value in self.query_contains: # <<<<<<<<<<<<<< - * evalue = event[key] - * if value not in evalue: - */ - __Pyx_TraceLine(224,0,__PYX_ERR(0, 224, __pyx_L1_error)) - if (unlikely(__pyx_v_self->query_contains == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(0, 224, __pyx_L1_error) +static PyObject *__pyx_pf_6hunter_11_predicates_5Query_14__invert__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[32])) + __Pyx_RefNannySetupContext("__invert__", 0); + __Pyx_TraceStartFunc("__invert__", __pyx_f[0], 261, 0, 0, 0, __PYX_ERR(0, 261, __pyx_L1_error)); + + /* "hunter/_predicates.pyx":262 + * + * def __invert__(self): + * return Not(self) # <<<<<<<<<<<<<< + * + * cdef inline fast_Query_call(Query self, Event event): +*/ + __Pyx_TraceLine(262,1,0,__PYX_ERR(0, 262, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = NULL; + __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Not); + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Not); + __pyx_t_4 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, ((PyObject *)__pyx_v_self)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 262, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_1); } - __pyx_t_1 = __pyx_v_self->query_contains; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; - for (;;) { - if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 224, __pyx_L1_error) - #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 224, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - #endif - if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { - PyObject* sequence = __pyx_t_3; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 224, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); - } else { - __pyx_t_4 = PyList_GET_ITEM(sequence, 0); - __pyx_t_5 = PyList_GET_ITEM(sequence, 1); - } - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(__pyx_t_5); - #else - __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 224, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 224, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - #endif - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } else { - Py_ssize_t index = -1; - __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 224, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext; - index = 0; __pyx_t_4 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_4)) goto __pyx_L15_unpacking_failed; - __Pyx_GOTREF(__pyx_t_4); - index = 1; __pyx_t_5 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L15_unpacking_failed; - __Pyx_GOTREF(__pyx_t_5); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 2) < 0) __PYX_ERR(0, 224, __pyx_L1_error) - __pyx_t_7 = NULL; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - goto __pyx_L16_unpacking_done; - __pyx_L15_unpacking_failed:; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_7 = NULL; - if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 224, __pyx_L1_error) - __pyx_L16_unpacking_done:; - } - __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_4); - __pyx_t_4 = 0; - __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_5); - __pyx_t_5 = 0; + __pyx_r = ((PyObject *)__pyx_t_1); + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 262, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":225 - * return False - * for key, value in self.query_contains: - * evalue = event[key] # <<<<<<<<<<<<<< - * if value not in evalue: - * return False - */ - __Pyx_TraceLine(225,0,__PYX_ERR(0, 225, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_event), __pyx_v_key); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 225, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_XDECREF_SET(__pyx_v_evalue, __pyx_t_3); - __pyx_t_3 = 0; + /* "hunter/_predicates.pyx":261 + * return And(self, other) + * + * def __invert__(self): # <<<<<<<<<<<<<< + * return Not(self) + * +*/ - /* "hunter/_predicates.pyx":226 - * for key, value in self.query_contains: - * evalue = event[key] - * if value not in evalue: # <<<<<<<<<<<<<< - * return False - * for key, value in self.query_startswith: - */ - __Pyx_TraceLine(226,0,__PYX_ERR(0, 226, __pyx_L1_error)) - __pyx_t_9 = (__Pyx_PySequence_ContainsTF(__pyx_v_value, __pyx_v_evalue, Py_NE)); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 226, __pyx_L1_error) - __pyx_t_8 = (__pyx_t_9 != 0); - if (__pyx_t_8) { + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 261, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Query.__invert__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":227 - * evalue = event[key] - * if value not in evalue: - * return False # <<<<<<<<<<<<<< - * for key, value in self.query_startswith: - * evalue = event[key] - */ - __Pyx_TraceLine(227,0,__PYX_ERR(0, 227, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(Py_False); - __pyx_r = Py_False; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - goto __pyx_L0; +/* "hunter/_predicates.pxd":10 + * cdef class Query: + * cdef: + * readonly tuple query_contains # <<<<<<<<<<<<<< + * readonly tuple query_endswith + * readonly tuple query_eq +*/ - /* "hunter/_predicates.pyx":226 - * for key, value in self.query_contains: - * evalue = event[key] - * if value not in evalue: # <<<<<<<<<<<<<< - * return False - * for key, value in self.query_startswith: - */ - } +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_14query_contains_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_14query_contains_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_14query_contains___get__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self)); - /* "hunter/_predicates.pyx":224 - * if evalue not in value: - * return False - * for key, value in self.query_contains: # <<<<<<<<<<<<<< - * evalue = event[key] - * if value not in evalue: - */ - __Pyx_TraceLine(224,0,__PYX_ERR(0, 224, __pyx_L1_error)) - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":228 - * if value not in evalue: - * return False - * for key, value in self.query_startswith: # <<<<<<<<<<<<<< - * evalue = event[key] - * if not evalue.startswith(value): - */ - __Pyx_TraceLine(228,0,__PYX_ERR(0, 228, __pyx_L1_error)) - if (unlikely(__pyx_v_self->query_startswith == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(0, 228, __pyx_L1_error) - } - __pyx_t_1 = __pyx_v_self->query_startswith; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; - for (;;) { - if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 228, __pyx_L1_error) - #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 228, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - #endif - if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { - PyObject* sequence = __pyx_t_3; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 228, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_5 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); - } else { - __pyx_t_5 = PyList_GET_ITEM(sequence, 0); - __pyx_t_4 = PyList_GET_ITEM(sequence, 1); - } - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(__pyx_t_4); - #else - __pyx_t_5 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 228, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 228, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - #endif - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } else { - Py_ssize_t index = -1; - __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 228, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext; - index = 0; __pyx_t_5 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L20_unpacking_failed; - __Pyx_GOTREF(__pyx_t_5); - index = 1; __pyx_t_4 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_4)) goto __pyx_L20_unpacking_failed; - __Pyx_GOTREF(__pyx_t_4); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 2) < 0) __PYX_ERR(0, 228, __pyx_L1_error) - __pyx_t_7 = NULL; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - goto __pyx_L21_unpacking_done; - __pyx_L20_unpacking_failed:; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_7 = NULL; - if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 228, __pyx_L1_error) - __pyx_L21_unpacking_done:; - } - __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_5); - __pyx_t_5 = 0; - __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_4); - __pyx_t_4 = 0; +static PyObject *__pyx_pf_6hunter_11_predicates_5Query_14query_contains___get__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[33])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 10, 0, 0, 0, __PYX_ERR(2, 10, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->query_contains); + __pyx_r = __pyx_v_self->query_contains; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 10, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":229 - * return False - * for key, value in self.query_startswith: - * evalue = event[key] # <<<<<<<<<<<<<< - * if not evalue.startswith(value): - * return False - */ - __Pyx_TraceLine(229,0,__PYX_ERR(0, 229, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_event), __pyx_v_key); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 229, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_XDECREF_SET(__pyx_v_evalue, __pyx_t_3); - __pyx_t_3 = 0; + /* function exit code */ + __pyx_L1_error:; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 10, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Query.query_contains.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":230 - * for key, value in self.query_startswith: - * evalue = event[key] - * if not evalue.startswith(value): # <<<<<<<<<<<<<< - * return False - * for key, value in self.query_endswith: - */ - __Pyx_TraceLine(230,0,__PYX_ERR(0, 230, __pyx_L1_error)) - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_evalue, __pyx_n_s_startswith); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 230, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - } - } - __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_value); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 230, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 230, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_9 = ((!__pyx_t_8) != 0); - if (__pyx_t_9) { +/* "hunter/_predicates.pxd":11 + * cdef: + * readonly tuple query_contains + * readonly tuple query_endswith # <<<<<<<<<<<<<< + * readonly tuple query_eq + * readonly tuple query_gt +*/ - /* "hunter/_predicates.pyx":231 - * evalue = event[key] - * if not evalue.startswith(value): - * return False # <<<<<<<<<<<<<< - * for key, value in self.query_endswith: - * evalue = event[key] - */ - __Pyx_TraceLine(231,0,__PYX_ERR(0, 231, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(Py_False); - __pyx_r = Py_False; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - goto __pyx_L0; +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_14query_endswith_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_14query_endswith_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_14query_endswith___get__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self)); - /* "hunter/_predicates.pyx":230 - * for key, value in self.query_startswith: - * evalue = event[key] - * if not evalue.startswith(value): # <<<<<<<<<<<<<< - * return False - * for key, value in self.query_endswith: - */ - } + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":228 - * if value not in evalue: - * return False - * for key, value in self.query_startswith: # <<<<<<<<<<<<<< - * evalue = event[key] - * if not evalue.startswith(value): - */ - __Pyx_TraceLine(228,0,__PYX_ERR(0, 228, __pyx_L1_error)) - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; +static PyObject *__pyx_pf_6hunter_11_predicates_5Query_14query_endswith___get__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[34])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 11, 0, 0, 0, __PYX_ERR(2, 11, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->query_endswith); + __pyx_r = __pyx_v_self->query_endswith; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 11, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":232 - * if not evalue.startswith(value): - * return False - * for key, value in self.query_endswith: # <<<<<<<<<<<<<< - * evalue = event[key] - * if not evalue.endswith(value): - */ - __Pyx_TraceLine(232,0,__PYX_ERR(0, 232, __pyx_L1_error)) - if (unlikely(__pyx_v_self->query_endswith == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(0, 232, __pyx_L1_error) - } - __pyx_t_1 = __pyx_v_self->query_endswith; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; - for (;;) { - if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 232, __pyx_L1_error) - #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 232, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - #endif - if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { - PyObject* sequence = __pyx_t_3; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 232, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); - } else { - __pyx_t_4 = PyList_GET_ITEM(sequence, 0); - __pyx_t_5 = PyList_GET_ITEM(sequence, 1); - } - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(__pyx_t_5); - #else - __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 232, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 232, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - #endif - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } else { - Py_ssize_t index = -1; - __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 232, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext; - index = 0; __pyx_t_4 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_4)) goto __pyx_L25_unpacking_failed; - __Pyx_GOTREF(__pyx_t_4); - index = 1; __pyx_t_5 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L25_unpacking_failed; - __Pyx_GOTREF(__pyx_t_5); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 2) < 0) __PYX_ERR(0, 232, __pyx_L1_error) - __pyx_t_7 = NULL; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - goto __pyx_L26_unpacking_done; - __pyx_L25_unpacking_failed:; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_7 = NULL; - if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 232, __pyx_L1_error) - __pyx_L26_unpacking_done:; - } - __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_4); - __pyx_t_4 = 0; - __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_5); - __pyx_t_5 = 0; + /* function exit code */ + __pyx_L1_error:; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 11, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Query.query_endswith.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":233 - * return False - * for key, value in self.query_endswith: - * evalue = event[key] # <<<<<<<<<<<<<< - * if not evalue.endswith(value): - * return False - */ - __Pyx_TraceLine(233,0,__PYX_ERR(0, 233, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_event), __pyx_v_key); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 233, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_XDECREF_SET(__pyx_v_evalue, __pyx_t_3); - __pyx_t_3 = 0; +/* "hunter/_predicates.pxd":12 + * readonly tuple query_contains + * readonly tuple query_endswith + * readonly tuple query_eq # <<<<<<<<<<<<<< + * readonly tuple query_gt + * readonly tuple query_gte +*/ - /* "hunter/_predicates.pyx":234 - * for key, value in self.query_endswith: - * evalue = event[key] - * if not evalue.endswith(value): # <<<<<<<<<<<<<< - * return False - * for key, value in self.query_regex: - */ - __Pyx_TraceLine(234,0,__PYX_ERR(0, 234, __pyx_L1_error)) - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_evalue, __pyx_n_s_endswith); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 234, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - } - } - __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_4, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_value); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 234, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 234, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_8 = ((!__pyx_t_9) != 0); - if (__pyx_t_8) { +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_8query_eq_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_8query_eq_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_8query_eq___get__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self)); - /* "hunter/_predicates.pyx":235 - * evalue = event[key] - * if not evalue.endswith(value): - * return False # <<<<<<<<<<<<<< - * for key, value in self.query_regex: - * evalue = event[key] - */ - __Pyx_TraceLine(235,0,__PYX_ERR(0, 235, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(Py_False); - __pyx_r = Py_False; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - goto __pyx_L0; + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":234 - * for key, value in self.query_endswith: - * evalue = event[key] - * if not evalue.endswith(value): # <<<<<<<<<<<<<< - * return False - * for key, value in self.query_regex: - */ - } +static PyObject *__pyx_pf_6hunter_11_predicates_5Query_8query_eq___get__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[35])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 12, 0, 0, 0, __PYX_ERR(2, 12, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->query_eq); + __pyx_r = __pyx_v_self->query_eq; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 12, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":232 - * if not evalue.startswith(value): - * return False - * for key, value in self.query_endswith: # <<<<<<<<<<<<<< - * evalue = event[key] - * if not evalue.endswith(value): - */ - __Pyx_TraceLine(232,0,__PYX_ERR(0, 232, __pyx_L1_error)) - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /* function exit code */ + __pyx_L1_error:; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 12, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Query.query_eq.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":236 - * if not evalue.endswith(value): - * return False - * for key, value in self.query_regex: # <<<<<<<<<<<<<< - * evalue = event[key] - * if not value.match(evalue): - */ - __Pyx_TraceLine(236,0,__PYX_ERR(0, 236, __pyx_L1_error)) - if (unlikely(__pyx_v_self->query_regex == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(0, 236, __pyx_L1_error) - } - __pyx_t_1 = __pyx_v_self->query_regex; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; - for (;;) { - if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 236, __pyx_L1_error) - #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 236, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - #endif - if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { - PyObject* sequence = __pyx_t_3; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 236, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_5 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); - } else { - __pyx_t_5 = PyList_GET_ITEM(sequence, 0); - __pyx_t_4 = PyList_GET_ITEM(sequence, 1); - } - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(__pyx_t_4); - #else - __pyx_t_5 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 236, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 236, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - #endif - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } else { - Py_ssize_t index = -1; - __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 236, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext; - index = 0; __pyx_t_5 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L30_unpacking_failed; - __Pyx_GOTREF(__pyx_t_5); - index = 1; __pyx_t_4 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_4)) goto __pyx_L30_unpacking_failed; - __Pyx_GOTREF(__pyx_t_4); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 2) < 0) __PYX_ERR(0, 236, __pyx_L1_error) - __pyx_t_7 = NULL; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - goto __pyx_L31_unpacking_done; - __pyx_L30_unpacking_failed:; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_7 = NULL; - if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 236, __pyx_L1_error) - __pyx_L31_unpacking_done:; - } - __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_5); - __pyx_t_5 = 0; - __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_4); - __pyx_t_4 = 0; +/* "hunter/_predicates.pxd":13 + * readonly tuple query_endswith + * readonly tuple query_eq + * readonly tuple query_gt # <<<<<<<<<<<<<< + * readonly tuple query_gte + * readonly tuple query_in +*/ - /* "hunter/_predicates.pyx":237 - * return False - * for key, value in self.query_regex: - * evalue = event[key] # <<<<<<<<<<<<<< - * if not value.match(evalue): - * return False - */ - __Pyx_TraceLine(237,0,__PYX_ERR(0, 237, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_event), __pyx_v_key); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 237, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_XDECREF_SET(__pyx_v_evalue, __pyx_t_3); - __pyx_t_3 = 0; +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_8query_gt_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_8query_gt_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_8query_gt___get__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self)); - /* "hunter/_predicates.pyx":238 - * for key, value in self.query_regex: - * evalue = event[key] - * if not value.match(evalue): # <<<<<<<<<<<<<< - * return False - * for key, value in self.query_gt: - */ - __Pyx_TraceLine(238,0,__PYX_ERR(0, 238, __pyx_L1_error)) - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_value, __pyx_n_s_match); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 238, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - } - } - __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_evalue) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_evalue); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 238, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 238, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_9 = ((!__pyx_t_8) != 0); - if (__pyx_t_9) { + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":239 - * evalue = event[key] - * if not value.match(evalue): - * return False # <<<<<<<<<<<<<< - * for key, value in self.query_gt: - * evalue = event[key] - */ - __Pyx_TraceLine(239,0,__PYX_ERR(0, 239, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(Py_False); - __pyx_r = Py_False; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - goto __pyx_L0; +static PyObject *__pyx_pf_6hunter_11_predicates_5Query_8query_gt___get__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[36])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 13, 0, 0, 0, __PYX_ERR(2, 13, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->query_gt); + __pyx_r = __pyx_v_self->query_gt; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 13, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":238 - * for key, value in self.query_regex: - * evalue = event[key] - * if not value.match(evalue): # <<<<<<<<<<<<<< - * return False - * for key, value in self.query_gt: - */ - } + /* function exit code */ + __pyx_L1_error:; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 13, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Query.query_gt.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":236 - * if not evalue.endswith(value): - * return False - * for key, value in self.query_regex: # <<<<<<<<<<<<<< - * evalue = event[key] - * if not value.match(evalue): - */ - __Pyx_TraceLine(236,0,__PYX_ERR(0, 236, __pyx_L1_error)) - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; +/* "hunter/_predicates.pxd":14 + * readonly tuple query_eq + * readonly tuple query_gt + * readonly tuple query_gte # <<<<<<<<<<<<<< + * readonly tuple query_in + * readonly tuple query_lt +*/ - /* "hunter/_predicates.pyx":240 - * if not value.match(evalue): - * return False - * for key, value in self.query_gt: # <<<<<<<<<<<<<< - * evalue = event[key] - * if not evalue > value: - */ - __Pyx_TraceLine(240,0,__PYX_ERR(0, 240, __pyx_L1_error)) - if (unlikely(__pyx_v_self->query_gt == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(0, 240, __pyx_L1_error) - } - __pyx_t_1 = __pyx_v_self->query_gt; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; - for (;;) { - if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 240, __pyx_L1_error) - #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - #endif - if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { - PyObject* sequence = __pyx_t_3; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 240, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); - } else { - __pyx_t_4 = PyList_GET_ITEM(sequence, 0); - __pyx_t_5 = PyList_GET_ITEM(sequence, 1); - } - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(__pyx_t_5); - #else - __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - #endif - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } else { - Py_ssize_t index = -1; - __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext; - index = 0; __pyx_t_4 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_4)) goto __pyx_L35_unpacking_failed; - __Pyx_GOTREF(__pyx_t_4); - index = 1; __pyx_t_5 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L35_unpacking_failed; - __Pyx_GOTREF(__pyx_t_5); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 2) < 0) __PYX_ERR(0, 240, __pyx_L1_error) - __pyx_t_7 = NULL; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - goto __pyx_L36_unpacking_done; - __pyx_L35_unpacking_failed:; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_7 = NULL; - if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 240, __pyx_L1_error) - __pyx_L36_unpacking_done:; - } - __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_4); - __pyx_t_4 = 0; - __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_5); - __pyx_t_5 = 0; +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_9query_gte_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_9query_gte_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_9query_gte___get__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self)); - /* "hunter/_predicates.pyx":241 - * return False - * for key, value in self.query_gt: - * evalue = event[key] # <<<<<<<<<<<<<< - * if not evalue > value: - * return False - */ - __Pyx_TraceLine(241,0,__PYX_ERR(0, 241, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_event), __pyx_v_key); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 241, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_XDECREF_SET(__pyx_v_evalue, __pyx_t_3); - __pyx_t_3 = 0; + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":242 - * for key, value in self.query_gt: - * evalue = event[key] - * if not evalue > value: # <<<<<<<<<<<<<< - * return False - * for key, value in self.query_gte: - */ - __Pyx_TraceLine(242,0,__PYX_ERR(0, 242, __pyx_L1_error)) - __pyx_t_3 = PyObject_RichCompare(__pyx_v_evalue, __pyx_v_value, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 242, __pyx_L1_error) - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 242, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_8 = ((!__pyx_t_9) != 0); - if (__pyx_t_8) { +static PyObject *__pyx_pf_6hunter_11_predicates_5Query_9query_gte___get__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[37])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 14, 0, 0, 0, __PYX_ERR(2, 14, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->query_gte); + __pyx_r = __pyx_v_self->query_gte; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 14, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":243 - * evalue = event[key] - * if not evalue > value: - * return False # <<<<<<<<<<<<<< - * for key, value in self.query_gte: - * evalue = event[key] - */ - __Pyx_TraceLine(243,0,__PYX_ERR(0, 243, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(Py_False); - __pyx_r = Py_False; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - goto __pyx_L0; + /* function exit code */ + __pyx_L1_error:; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 14, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Query.query_gte.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":242 - * for key, value in self.query_gt: - * evalue = event[key] - * if not evalue > value: # <<<<<<<<<<<<<< - * return False - * for key, value in self.query_gte: - */ - } +/* "hunter/_predicates.pxd":15 + * readonly tuple query_gt + * readonly tuple query_gte + * readonly tuple query_in # <<<<<<<<<<<<<< + * readonly tuple query_lt + * readonly tuple query_lte +*/ - /* "hunter/_predicates.pyx":240 - * if not value.match(evalue): - * return False - * for key, value in self.query_gt: # <<<<<<<<<<<<<< - * evalue = event[key] - * if not evalue > value: - */ - __Pyx_TraceLine(240,0,__PYX_ERR(0, 240, __pyx_L1_error)) - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_8query_in_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_8query_in_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_8query_in___get__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self)); - /* "hunter/_predicates.pyx":244 - * if not evalue > value: - * return False - * for key, value in self.query_gte: # <<<<<<<<<<<<<< - * evalue = event[key] - * if not evalue >= value: - */ - __Pyx_TraceLine(244,0,__PYX_ERR(0, 244, __pyx_L1_error)) - if (unlikely(__pyx_v_self->query_gte == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(0, 244, __pyx_L1_error) - } - __pyx_t_1 = __pyx_v_self->query_gte; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; - for (;;) { - if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 244, __pyx_L1_error) - #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 244, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - #endif - if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { - PyObject* sequence = __pyx_t_3; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 244, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_5 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); - } else { - __pyx_t_5 = PyList_GET_ITEM(sequence, 0); - __pyx_t_4 = PyList_GET_ITEM(sequence, 1); - } - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(__pyx_t_4); - #else - __pyx_t_5 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 244, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 244, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - #endif - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } else { - Py_ssize_t index = -1; - __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 244, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext; - index = 0; __pyx_t_5 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L40_unpacking_failed; - __Pyx_GOTREF(__pyx_t_5); - index = 1; __pyx_t_4 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_4)) goto __pyx_L40_unpacking_failed; - __Pyx_GOTREF(__pyx_t_4); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 2) < 0) __PYX_ERR(0, 244, __pyx_L1_error) - __pyx_t_7 = NULL; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - goto __pyx_L41_unpacking_done; - __pyx_L40_unpacking_failed:; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_7 = NULL; - if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 244, __pyx_L1_error) - __pyx_L41_unpacking_done:; - } - __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_5); - __pyx_t_5 = 0; - __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_4); - __pyx_t_4 = 0; + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":245 - * return False - * for key, value in self.query_gte: - * evalue = event[key] # <<<<<<<<<<<<<< - * if not evalue >= value: - * return False - */ - __Pyx_TraceLine(245,0,__PYX_ERR(0, 245, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_event), __pyx_v_key); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 245, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_XDECREF_SET(__pyx_v_evalue, __pyx_t_3); - __pyx_t_3 = 0; +static PyObject *__pyx_pf_6hunter_11_predicates_5Query_8query_in___get__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[38])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 15, 0, 0, 0, __PYX_ERR(2, 15, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->query_in); + __pyx_r = __pyx_v_self->query_in; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 15, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":246 - * for key, value in self.query_gte: - * evalue = event[key] - * if not evalue >= value: # <<<<<<<<<<<<<< - * return False - * for key, value in self.query_lt: - */ - __Pyx_TraceLine(246,0,__PYX_ERR(0, 246, __pyx_L1_error)) - __pyx_t_3 = PyObject_RichCompare(__pyx_v_evalue, __pyx_v_value, Py_GE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 246, __pyx_L1_error) - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 246, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_9 = ((!__pyx_t_8) != 0); - if (__pyx_t_9) { - - /* "hunter/_predicates.pyx":247 - * evalue = event[key] - * if not evalue >= value: - * return False # <<<<<<<<<<<<<< - * for key, value in self.query_lt: - * evalue = event[key] - */ - __Pyx_TraceLine(247,0,__PYX_ERR(0, 247, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(Py_False); - __pyx_r = Py_False; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - goto __pyx_L0; - - /* "hunter/_predicates.pyx":246 - * for key, value in self.query_gte: - * evalue = event[key] - * if not evalue >= value: # <<<<<<<<<<<<<< - * return False - * for key, value in self.query_lt: - */ - } - - /* "hunter/_predicates.pyx":244 - * if not evalue > value: - * return False - * for key, value in self.query_gte: # <<<<<<<<<<<<<< - * evalue = event[key] - * if not evalue >= value: - */ - __Pyx_TraceLine(244,0,__PYX_ERR(0, 244, __pyx_L1_error)) - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "hunter/_predicates.pyx":248 - * if not evalue >= value: - * return False - * for key, value in self.query_lt: # <<<<<<<<<<<<<< - * evalue = event[key] - * if not evalue < value: - */ - __Pyx_TraceLine(248,0,__PYX_ERR(0, 248, __pyx_L1_error)) - if (unlikely(__pyx_v_self->query_lt == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(0, 248, __pyx_L1_error) - } - __pyx_t_1 = __pyx_v_self->query_lt; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; - for (;;) { - if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 248, __pyx_L1_error) - #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 248, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - #endif - if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { - PyObject* sequence = __pyx_t_3; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 248, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); - } else { - __pyx_t_4 = PyList_GET_ITEM(sequence, 0); - __pyx_t_5 = PyList_GET_ITEM(sequence, 1); - } - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(__pyx_t_5); - #else - __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 248, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 248, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - #endif - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } else { - Py_ssize_t index = -1; - __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 248, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext; - index = 0; __pyx_t_4 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_4)) goto __pyx_L45_unpacking_failed; - __Pyx_GOTREF(__pyx_t_4); - index = 1; __pyx_t_5 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L45_unpacking_failed; - __Pyx_GOTREF(__pyx_t_5); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 2) < 0) __PYX_ERR(0, 248, __pyx_L1_error) - __pyx_t_7 = NULL; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - goto __pyx_L46_unpacking_done; - __pyx_L45_unpacking_failed:; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_7 = NULL; - if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 248, __pyx_L1_error) - __pyx_L46_unpacking_done:; - } - __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_4); - __pyx_t_4 = 0; - __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_5); - __pyx_t_5 = 0; - - /* "hunter/_predicates.pyx":249 - * return False - * for key, value in self.query_lt: - * evalue = event[key] # <<<<<<<<<<<<<< - * if not evalue < value: - * return False - */ - __Pyx_TraceLine(249,0,__PYX_ERR(0, 249, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_event), __pyx_v_key); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 249, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_XDECREF_SET(__pyx_v_evalue, __pyx_t_3); - __pyx_t_3 = 0; - - /* "hunter/_predicates.pyx":250 - * for key, value in self.query_lt: - * evalue = event[key] - * if not evalue < value: # <<<<<<<<<<<<<< - * return False - * for key, value in self.query_lte: - */ - __Pyx_TraceLine(250,0,__PYX_ERR(0, 250, __pyx_L1_error)) - __pyx_t_3 = PyObject_RichCompare(__pyx_v_evalue, __pyx_v_value, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 250, __pyx_L1_error) - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 250, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_8 = ((!__pyx_t_9) != 0); - if (__pyx_t_8) { - - /* "hunter/_predicates.pyx":251 - * evalue = event[key] - * if not evalue < value: - * return False # <<<<<<<<<<<<<< - * for key, value in self.query_lte: - * evalue = event[key] - */ - __Pyx_TraceLine(251,0,__PYX_ERR(0, 251, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(Py_False); - __pyx_r = Py_False; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - goto __pyx_L0; + /* function exit code */ + __pyx_L1_error:; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 15, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Query.query_in.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":250 - * for key, value in self.query_lt: - * evalue = event[key] - * if not evalue < value: # <<<<<<<<<<<<<< - * return False - * for key, value in self.query_lte: - */ - } +/* "hunter/_predicates.pxd":16 + * readonly tuple query_gte + * readonly tuple query_in + * readonly tuple query_lt # <<<<<<<<<<<<<< + * readonly tuple query_lte + * readonly tuple query_regex +*/ - /* "hunter/_predicates.pyx":248 - * if not evalue >= value: - * return False - * for key, value in self.query_lt: # <<<<<<<<<<<<<< - * evalue = event[key] - * if not evalue < value: - */ - __Pyx_TraceLine(248,0,__PYX_ERR(0, 248, __pyx_L1_error)) - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_8query_lt_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_8query_lt_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_8query_lt___get__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self)); - /* "hunter/_predicates.pyx":252 - * if not evalue < value: - * return False - * for key, value in self.query_lte: # <<<<<<<<<<<<<< - * evalue = event[key] - * if not evalue <= value: - */ - __Pyx_TraceLine(252,0,__PYX_ERR(0, 252, __pyx_L1_error)) - if (unlikely(__pyx_v_self->query_lte == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(0, 252, __pyx_L1_error) - } - __pyx_t_1 = __pyx_v_self->query_lte; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; - for (;;) { - if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 252, __pyx_L1_error) - #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 252, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - #endif - if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { - PyObject* sequence = __pyx_t_3; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 252, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_5 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); - } else { - __pyx_t_5 = PyList_GET_ITEM(sequence, 0); - __pyx_t_4 = PyList_GET_ITEM(sequence, 1); - } - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(__pyx_t_4); - #else - __pyx_t_5 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 252, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 252, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - #endif - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } else { - Py_ssize_t index = -1; - __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 252, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext; - index = 0; __pyx_t_5 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L50_unpacking_failed; - __Pyx_GOTREF(__pyx_t_5); - index = 1; __pyx_t_4 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_4)) goto __pyx_L50_unpacking_failed; - __Pyx_GOTREF(__pyx_t_4); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 2) < 0) __PYX_ERR(0, 252, __pyx_L1_error) - __pyx_t_7 = NULL; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - goto __pyx_L51_unpacking_done; - __pyx_L50_unpacking_failed:; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_7 = NULL; - if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 252, __pyx_L1_error) - __pyx_L51_unpacking_done:; - } - __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_5); - __pyx_t_5 = 0; - __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_4); - __pyx_t_4 = 0; + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":253 - * return False - * for key, value in self.query_lte: - * evalue = event[key] # <<<<<<<<<<<<<< - * if not evalue <= value: - * return False - */ - __Pyx_TraceLine(253,0,__PYX_ERR(0, 253, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_event), __pyx_v_key); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 253, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_XDECREF_SET(__pyx_v_evalue, __pyx_t_3); - __pyx_t_3 = 0; +static PyObject *__pyx_pf_6hunter_11_predicates_5Query_8query_lt___get__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[39])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 16, 0, 0, 0, __PYX_ERR(2, 16, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->query_lt); + __pyx_r = __pyx_v_self->query_lt; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 16, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":254 - * for key, value in self.query_lte: - * evalue = event[key] - * if not evalue <= value: # <<<<<<<<<<<<<< - * return False - * - */ - __Pyx_TraceLine(254,0,__PYX_ERR(0, 254, __pyx_L1_error)) - __pyx_t_3 = PyObject_RichCompare(__pyx_v_evalue, __pyx_v_value, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 254, __pyx_L1_error) - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 254, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_9 = ((!__pyx_t_8) != 0); - if (__pyx_t_9) { + /* function exit code */ + __pyx_L1_error:; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 16, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Query.query_lt.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":255 - * evalue = event[key] - * if not evalue <= value: - * return False # <<<<<<<<<<<<<< - * - * return True - */ - __Pyx_TraceLine(255,0,__PYX_ERR(0, 255, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(Py_False); - __pyx_r = Py_False; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - goto __pyx_L0; +/* "hunter/_predicates.pxd":17 + * readonly tuple query_in + * readonly tuple query_lt + * readonly tuple query_lte # <<<<<<<<<<<<<< + * readonly tuple query_regex + * readonly tuple query_startswith +*/ - /* "hunter/_predicates.pyx":254 - * for key, value in self.query_lte: - * evalue = event[key] - * if not evalue <= value: # <<<<<<<<<<<<<< - * return False - * - */ - } +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_9query_lte_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_9query_lte_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_9query_lte___get__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self)); - /* "hunter/_predicates.pyx":252 - * if not evalue < value: - * return False - * for key, value in self.query_lte: # <<<<<<<<<<<<<< - * evalue = event[key] - * if not evalue <= value: - */ - __Pyx_TraceLine(252,0,__PYX_ERR(0, 252, __pyx_L1_error)) - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":257 - * return False - * - * return True # <<<<<<<<<<<<<< - * - * - */ - __Pyx_TraceLine(257,0,__PYX_ERR(0, 257, __pyx_L1_error)) +static PyObject *__pyx_pf_6hunter_11_predicates_5Query_9query_lte___get__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[40])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 17, 0, 0, 0, __PYX_ERR(2, 17, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(Py_True); - __pyx_r = Py_True; + __Pyx_INCREF(__pyx_v_self->query_lte); + __pyx_r = __pyx_v_self->query_lte; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 17, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_predicates.pyx":215 - * return Not(self) - * - * cdef fast_Query_call(Query self, Event event): # <<<<<<<<<<<<<< - * for key, value in self.query_eq: - * evalue = event[key] - */ - /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_AddTraceback("hunter._predicates.fast_Query_call", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 17, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Query.query_lte.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF(__pyx_v_key); - __Pyx_XDECREF(__pyx_v_value); - __Pyx_XDECREF(__pyx_v_evalue); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":268 - * """ - * - * def __init__(self, condition, *actions): # <<<<<<<<<<<<<< - * if not actions: - * raise TypeError('Must give at least one action.') - */ +/* "hunter/_predicates.pxd":18 + * readonly tuple query_lt + * readonly tuple query_lte + * readonly tuple query_regex # <<<<<<<<<<<<<< + * readonly tuple query_startswith + * +*/ /* Python wrapper */ -static int __pyx_pw_6hunter_11_predicates_4When_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static int __pyx_pw_6hunter_11_predicates_4When_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v_condition = 0; - PyObject *__pyx_v_actions = 0; - int __pyx_r; +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_11query_regex_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_11query_regex_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); - if (PyTuple_GET_SIZE(__pyx_args) > 1) { - __pyx_v_actions = PyTuple_GetSlice(__pyx_args, 1, PyTuple_GET_SIZE(__pyx_args)); - if (unlikely(!__pyx_v_actions)) { - __Pyx_RefNannyFinishContext(); - return -1; - } - __Pyx_GOTREF(__pyx_v_actions); - } else { - __pyx_v_actions = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple); - } - { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_condition,0}; - PyObject* values[1] = {0}; - if (unlikely(__pyx_kwds)) { - Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - default: - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { - case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_condition)) != 0)) kw_args--; - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t used_pos_args = (pos_args < 1) ? pos_args : 1; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "__init__") < 0)) __PYX_ERR(0, 268, __pyx_L3_error) - } - } else if (PyTuple_GET_SIZE(__pyx_args) < 1) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - } - __pyx_v_condition = values[0]; - } - goto __pyx_L4_argument_unpacking_done; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 268, __pyx_L3_error) - __pyx_L3_error:; - __Pyx_CLEAR(__pyx_v_actions); - __Pyx_AddTraceback("hunter._predicates.When.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return -1; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6hunter_11_predicates_4When___init__(((struct __pyx_obj_6hunter_11_predicates_When *)__pyx_v_self), __pyx_v_condition, __pyx_v_actions); + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_11query_regex___get__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self)); /* function exit code */ - __Pyx_XDECREF(__pyx_v_actions); __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_gb_6hunter_11_predicates_4When_8__init___2generator3(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ - -/* "hunter/_predicates.pyx":273 - * self.condition = condition - * self.actions = tuple( - * action() if inspect.isclass(action) and issubclass(action, Action) else action # <<<<<<<<<<<<<< - * for action in actions) - * - */ -static PyObject *__pyx_pf_6hunter_11_predicates_4When_8__init___genexpr(PyObject *__pyx_self) { - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_6_genexpr *__pyx_cur_scope; +static PyObject *__pyx_pf_6hunter_11_predicates_5Query_11query_regex___get__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self) { PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("genexpr", 0); - __pyx_cur_scope = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_6_genexpr *)__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_6_genexpr(__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_6_genexpr, __pyx_empty_tuple, NULL); - if (unlikely(!__pyx_cur_scope)) { - __pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_6_genexpr *)Py_None); - __Pyx_INCREF(Py_None); - __PYX_ERR(0, 273, __pyx_L1_error) - } else { - __Pyx_GOTREF(__pyx_cur_scope); - } - __pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5___init__ *) __pyx_self; - __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_outer_scope)); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope); - { - __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_6hunter_11_predicates_4When_8__init___2generator3, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_init___locals_genexpr, __pyx_n_s_hunter__predicates); if (unlikely(!gen)) __PYX_ERR(0, 273, __pyx_L1_error) - __Pyx_DECREF(__pyx_cur_scope); - __Pyx_RefNannyFinishContext(); - return (PyObject *) gen; - } + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[41])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 18, 0, 0, 0, __PYX_ERR(2, 18, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->query_regex); + __pyx_r = __pyx_v_self->query_regex; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 18, __pyx_L1_error)); + goto __pyx_L0; /* function exit code */ __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.When.__init__.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 18, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Query.query_regex.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; - __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_gb_6hunter_11_predicates_4When_8__init___2generator3(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ -{ - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_6_genexpr *__pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_6_genexpr *)__pyx_generator->closure); - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - PyObject *__pyx_t_1 = NULL; - Py_ssize_t __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - int __pyx_t_8; - int __pyx_t_9; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("genexpr", 0); - __Pyx_TraceCall("genexpr", __pyx_f[0], 273, 0, __PYX_ERR(0, 273, __pyx_L1_error)); - switch (__pyx_generator->resume_label) { - case 0: goto __pyx_L3_first_run; - case 1: goto __pyx_L8_resume_from_yield; - default: /* CPython raises the right error here */ - __Pyx_TraceReturn(Py_None, 0); - __Pyx_RefNannyFinishContext(); - return NULL; - } - __pyx_L3_first_run:; - if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 273, __pyx_L1_error) - - /* "hunter/_predicates.pyx":274 - * self.actions = tuple( - * action() if inspect.isclass(action) and issubclass(action, Action) else action - * for action in actions) # <<<<<<<<<<<<<< - * - * def __str__(self): - */ - __Pyx_TraceLine(274,0,__PYX_ERR(0, 274, __pyx_L1_error)) - if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_actions)) { __Pyx_RaiseClosureNameError("actions"); __PYX_ERR(0, 274, __pyx_L1_error) } - if (unlikely(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_actions == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(0, 274, __pyx_L1_error) - } - __pyx_t_1 = __pyx_cur_scope->__pyx_outer_scope->__pyx_v_actions; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; - for (;;) { - if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 274, __pyx_L1_error) - #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 274, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - #endif - __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_action); - __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_action, __pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); - __pyx_t_3 = 0; - - /* "hunter/_predicates.pyx":273 - * self.condition = condition - * self.actions = tuple( - * action() if inspect.isclass(action) and issubclass(action, Action) else action # <<<<<<<<<<<<<< - * for action in actions) +/* "hunter/_predicates.pxd":19 + * readonly tuple query_lte + * readonly tuple query_regex + * readonly tuple query_startswith # <<<<<<<<<<<<<< * - */ - __Pyx_TraceLine(273,0,__PYX_ERR(0, 273, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_inspect); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 273, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_isclass); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 273, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { - __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7); - if (likely(__pyx_t_6)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); - __Pyx_INCREF(__pyx_t_6); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_7, function); - } - } - __pyx_t_5 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_6, __pyx_cur_scope->__pyx_v_action) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_cur_scope->__pyx_v_action); - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 273, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 273, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (__pyx_t_8) { - } else { - __pyx_t_4 = __pyx_t_8; - goto __pyx_L6_bool_binop_done; - } - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_Action); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 273, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_8 = PyObject_IsSubclass(__pyx_cur_scope->__pyx_v_action, __pyx_t_5); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 273, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_9 = (__pyx_t_8 != 0); - __pyx_t_4 = __pyx_t_9; - __pyx_L6_bool_binop_done:; - if (__pyx_t_4) { - __Pyx_INCREF(__pyx_cur_scope->__pyx_v_action); - __pyx_t_7 = __pyx_cur_scope->__pyx_v_action; __pyx_t_6 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { - __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7); - if (likely(__pyx_t_6)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); - __Pyx_INCREF(__pyx_t_6); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_7, function); - } - } - __pyx_t_5 = (__pyx_t_6) ? __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6) : __Pyx_PyObject_CallNoArg(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 273, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_3 = __pyx_t_5; - __pyx_t_5 = 0; - } else { - __Pyx_INCREF(__pyx_cur_scope->__pyx_v_action); - __pyx_t_3 = __pyx_cur_scope->__pyx_v_action; - } - __pyx_r = __pyx_t_3; - __pyx_t_3 = 0; - __Pyx_XGIVEREF(__pyx_t_1); - __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; - __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - __Pyx_Coroutine_ResetAndClearException(__pyx_generator); - /* return from generator, yielding value */ - __pyx_generator->resume_label = 1; - return __pyx_r; - __pyx_L8_resume_from_yield:; - __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; - __pyx_cur_scope->__pyx_t_0 = 0; - __Pyx_XGOTREF(__pyx_t_1); - __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; - if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 273, __pyx_L1_error) - - /* "hunter/_predicates.pyx":274 - * self.actions = tuple( - * action() if inspect.isclass(action) and issubclass(action, Action) else action - * for action in actions) # <<<<<<<<<<<<<< * - * def __str__(self): - */ - __Pyx_TraceLine(274,0,__PYX_ERR(0, 274, __pyx_L1_error)) - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); +*/ - /* "hunter/_predicates.pyx":273 - * self.condition = condition - * self.actions = tuple( - * action() if inspect.isclass(action) and issubclass(action, Action) else action # <<<<<<<<<<<<<< - * for action in actions) - * - */ +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_16query_startswith_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_16query_startswith_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_16query_startswith___get__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self)); /* function exit code */ - PyErr_SetNone(PyExc_StopIteration); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_11_predicates_5Query_16query_startswith___get__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[42])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 19, 0, 0, 0, __PYX_ERR(2, 19, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->query_startswith); + __pyx_r = __pyx_v_self->query_startswith; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 19, __pyx_L1_error)); goto __pyx_L0; + + /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_L0:; - __Pyx_XDECREF(__pyx_r); __pyx_r = 0; - #if !CYTHON_USE_EXC_INFO_STACK - __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 19, __pyx_L1_error)); #endif - __pyx_generator->resume_label = -1; - __Pyx_Coroutine_clear((PyObject*)__pyx_generator); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_AddTraceback("hunter._predicates.Query.query_startswith.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":268 - * """ - * - * def __init__(self, condition, *actions): # <<<<<<<<<<<<<< - * if not actions: - * raise TypeError('Must give at least one action.') - */ +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ -static int __pyx_pf_6hunter_11_predicates_4When___init__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self, PyObject *__pyx_v_condition, PyObject *__pyx_v_actions) { - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5___init__ *__pyx_cur_scope; - int __pyx_r; - __Pyx_TraceDeclarations +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_17__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_11_predicates_5Query_17__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_5Query_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_17__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - int __pyx_t_1; + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_16__reduce_cython__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_11_predicates_5Query_16__reduce_cython__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - __Pyx_RefNannySetupContext("__init__", 0); - __pyx_cur_scope = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5___init__ *)__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_5___init__(__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_5___init__, __pyx_empty_tuple, NULL); - if (unlikely(!__pyx_cur_scope)) { - __pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5___init__ *)Py_None); - __Pyx_INCREF(Py_None); - __PYX_ERR(0, 268, __pyx_L1_error) - } else { - __Pyx_GOTREF(__pyx_cur_scope); - } - __Pyx_TraceCall("__init__", __pyx_f[0], 268, 0, __PYX_ERR(0, 268, __pyx_L1_error)); - __pyx_cur_scope->__pyx_v_actions = __pyx_v_actions; - __Pyx_INCREF(__pyx_cur_scope->__pyx_v_actions); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_actions); + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[43])) + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + __Pyx_TraceStartFunc("__reduce_cython__", __pyx_f[1], 1, 0, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); - /* "hunter/_predicates.pyx":269 - * - * def __init__(self, condition, *actions): - * if not actions: # <<<<<<<<<<<<<< - * raise TypeError('Must give at least one action.') - * self.condition = condition - */ - __Pyx_TraceLine(269,0,__PYX_ERR(0, 269, __pyx_L1_error)) - __pyx_t_1 = (PyTuple_GET_SIZE(__pyx_cur_scope->__pyx_v_actions) != 0); - __pyx_t_2 = ((!__pyx_t_1) != 0); - if (unlikely(__pyx_t_2)) { + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self.query_contains, self.query_endswith, self.query_eq, self.query_gt, self.query_gte, self.query_in, self.query_lt, self.query_lte, self.query_regex, self.query_startswith) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: +*/ + __Pyx_TraceLine(5,2,0,__PYX_ERR(1, 5, __pyx_L1_error)) + __pyx_t_1 = PyTuple_New(10); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_self->query_contains); + __Pyx_GIVEREF(__pyx_v_self->query_contains); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->query_contains) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->query_endswith); + __Pyx_GIVEREF(__pyx_v_self->query_endswith); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->query_endswith) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->query_eq); + __Pyx_GIVEREF(__pyx_v_self->query_eq); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_self->query_eq) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->query_gt); + __Pyx_GIVEREF(__pyx_v_self->query_gt); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_v_self->query_gt) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->query_gte); + __Pyx_GIVEREF(__pyx_v_self->query_gte); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 4, __pyx_v_self->query_gte) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->query_in); + __Pyx_GIVEREF(__pyx_v_self->query_in); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 5, __pyx_v_self->query_in) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->query_lt); + __Pyx_GIVEREF(__pyx_v_self->query_lt); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 6, __pyx_v_self->query_lt) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->query_lte); + __Pyx_GIVEREF(__pyx_v_self->query_lte); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 7, __pyx_v_self->query_lte) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->query_regex); + __Pyx_GIVEREF(__pyx_v_self->query_regex); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 8, __pyx_v_self->query_regex) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->query_startswith); + __Pyx_GIVEREF(__pyx_v_self->query_startswith); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 9, __pyx_v_self->query_startswith) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; - /* "hunter/_predicates.pyx":270 - * def __init__(self, condition, *actions): - * if not actions: - * raise TypeError('Must give at least one action.') # <<<<<<<<<<<<<< - * self.condition = condition - * self.actions = tuple( - */ - __Pyx_TraceLine(270,0,__PYX_ERR(0, 270, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 270, __pyx_L1_error) + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.query_contains, self.query_endswith, self.query_eq, self.query_gt, self.query_gte, self.query_in, self.query_lt, self.query_lte, self.query_regex, self.query_startswith) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) +*/ + __Pyx_TraceLine(6,24,0,__PYX_ERR(1, 6, __pyx_L1_error)) + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self.query_contains, self.query_endswith, self.query_eq, self.query_gt, self.query_gte, self.query_in, self.query_lt, self.query_lte, self.query_regex, self.query_startswith) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + __Pyx_TraceLine(7,31,0,__PYX_ERR(1, 7, __pyx_L1_error)) + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: +*/ + __Pyx_TraceLine(8,33,0,__PYX_ERR(1, 8, __pyx_L1_error)) + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict) != (0)) __PYX_ERR(1, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 270, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; - /* "hunter/_predicates.pyx":269 - * - * def __init__(self, condition, *actions): - * if not actions: # <<<<<<<<<<<<<< - * raise TypeError('Must give at least one action.') - * self.condition = condition - */ + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self.query_contains is not None or self.query_endswith is not None or self.query_eq is not None or self.query_gt is not None or self.query_gte is not None or self.query_in is not None or self.query_lt is not None or self.query_lte is not None or self.query_regex is not None or self.query_startswith is not None +*/ + __Pyx_TraceLine(9,35,0,__PYX_ERR(1, 9, __pyx_L1_error)) + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self.query_contains, self.query_endswith, self.query_eq, self.query_gt, self.query_gte, self.query_in, self.query_lt, self.query_lte, self.query_regex, self.query_startswith) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + goto __pyx_L3; } - /* "hunter/_predicates.pyx":271 - * if not actions: - * raise TypeError('Must give at least one action.') - * self.condition = condition # <<<<<<<<<<<<<< - * self.actions = tuple( - * action() if inspect.isclass(action) and issubclass(action, Action) else action - */ - __Pyx_TraceLine(271,0,__PYX_ERR(0, 271, __pyx_L1_error)) - __Pyx_INCREF(__pyx_v_condition); - __Pyx_GIVEREF(__pyx_v_condition); - __Pyx_GOTREF(__pyx_v_self->condition); - __Pyx_DECREF(__pyx_v_self->condition); - __pyx_v_self->condition = __pyx_v_condition; + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self.query_contains is not None or self.query_endswith is not None or self.query_eq is not None or self.query_gt is not None or self.query_gte is not None or self.query_in is not None or self.query_lt is not None or self.query_lte is not None or self.query_regex is not None or self.query_startswith is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Query, (type(self), 0x5503a44, None), state +*/ + __Pyx_TraceLine(11,41,0,__PYX_ERR(1, 11, __pyx_L1_error)) + /*else*/ { + __pyx_t_4 = (__pyx_v_self->query_contains != ((PyObject*)Py_None)); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->query_endswith != ((PyObject*)Py_None)); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->query_eq != ((PyObject*)Py_None)); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->query_gt != ((PyObject*)Py_None)); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->query_gte != ((PyObject*)Py_None)); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->query_in != ((PyObject*)Py_None)); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->query_lt != ((PyObject*)Py_None)); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->query_lte != ((PyObject*)Py_None)); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->query_regex != ((PyObject*)Py_None)); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->query_startswith != ((PyObject*)Py_None)); + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + __pyx_v_use_setstate = __pyx_t_2; + } + __pyx_L3:; - /* "hunter/_predicates.pyx":273 - * self.condition = condition - * self.actions = tuple( - * action() if inspect.isclass(action) and issubclass(action, Action) else action # <<<<<<<<<<<<<< - * for action in actions) - * - */ - __Pyx_TraceLine(273,0,__PYX_ERR(0, 273, __pyx_L1_error)) - __pyx_t_3 = __pyx_pf_6hunter_11_predicates_4When_8__init___genexpr(((PyObject*)__pyx_cur_scope)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 273, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + /* "(tree fragment)":12 + * else: + * use_setstate = self.query_contains is not None or self.query_endswith is not None or self.query_eq is not None or self.query_gt is not None or self.query_gte is not None or self.query_in is not None or self.query_lt is not None or self.query_lte is not None or self.query_regex is not None or self.query_startswith is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Query, (type(self), 0x5503a44, None), state + * else: +*/ + __Pyx_TraceLine(12,87,0,__PYX_ERR(1, 12, __pyx_L1_error)) + if (__pyx_v_use_setstate) { - /* "hunter/_predicates.pyx":272 - * raise TypeError('Must give at least one action.') - * self.condition = condition - * self.actions = tuple( # <<<<<<<<<<<<<< - * action() if inspect.isclass(action) and issubclass(action, Action) else action - * for action in actions) - */ - __Pyx_TraceLine(272,0,__PYX_ERR(0, 272, __pyx_L1_error)) - __pyx_t_4 = __Pyx_PySequence_Tuple(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 272, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_GIVEREF(__pyx_t_4); - __Pyx_GOTREF(__pyx_v_self->actions); - __Pyx_DECREF(__pyx_v_self->actions); - __pyx_v_self->actions = ((PyObject*)__pyx_t_4); - __pyx_t_4 = 0; + /* "(tree fragment)":13 + * use_setstate = self.query_contains is not None or self.query_endswith is not None or self.query_eq is not None or self.query_gt is not None or self.query_gte is not None or self.query_in is not None or self.query_lt is not None or self.query_lte is not None or self.query_regex is not None or self.query_startswith is not None + * if use_setstate: + * return __pyx_unpickle_Query, (type(self), 0x5503a44, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Query, (type(self), 0x5503a44, state) +*/ + __Pyx_TraceLine(13,88,0,__PYX_ERR(1, 13, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Query); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_89143876); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_89143876); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_mstate_global->__pyx_int_89143876) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + __Pyx_TraceReturnValue(__pyx_r, 88, 0, __PYX_ERR(1, 13, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":268 - * """ - * - * def __init__(self, condition, *actions): # <<<<<<<<<<<<<< - * if not actions: - * raise TypeError('Must give at least one action.') - */ + /* "(tree fragment)":12 + * else: + * use_setstate = self.query_contains is not None or self.query_endswith is not None or self.query_eq is not None or self.query_gt is not None or self.query_gte is not None or self.query_in is not None or self.query_lt is not None or self.query_lte is not None or self.query_regex is not None or self.query_startswith is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Query, (type(self), 0x5503a44, None), state + * else: +*/ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_Query, (type(self), 0x5503a44, None), state + * else: + * return __pyx_unpickle_Query, (type(self), 0x5503a44, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Query__set_state(self, __pyx_state) +*/ + __Pyx_TraceLine(15,96,0,__PYX_ERR(1, 15, __pyx_L1_error)) + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Query); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_89143876); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_89143876); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_mstate_global->__pyx_int_89143876) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + __Pyx_TraceReturnValue(__pyx_r, 96, 0, __PYX_ERR(1, 15, __pyx_L1_error)); + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("hunter._predicates.When.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Query.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; __pyx_L0:; - __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); - __Pyx_TraceReturn(Py_None, 0); + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":276 - * for action in actions) - * - * def __str__(self): # <<<<<<<<<<<<<< - * return 'When(%s, %s)' % ( - * self.condition, - */ - +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Query, (type(self), 0x5503a44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Query__set_state(self, __pyx_state) +*/ + /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_4When_3__str__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_4When_3__str__(PyObject *__pyx_v_self) { +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_19__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_11_predicates_5Query_19__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_5Query_19__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_11_predicates_5Query_19__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_4When_2__str__(((struct __pyx_obj_6hunter_11_predicates_When *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 16, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 16, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 16, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("hunter._predicates.Query.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6hunter_11_predicates_5Query_18__setstate_cython__(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_gb_6hunter_11_predicates_4When_7__str___2generator4(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ - -/* "hunter/_predicates.pyx":279 - * return 'When(%s, %s)' % ( - * self.condition, - * ', '.join(repr(p) for p in self.actions) # <<<<<<<<<<<<<< - * ) - * - */ -static PyObject *__pyx_pf_6hunter_11_predicates_4When_7__str___genexpr(PyObject *__pyx_self) { - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_8_genexpr *__pyx_cur_scope; +static PyObject *__pyx_pf_6hunter_11_predicates_5Query_18__setstate_cython__(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("genexpr", 0); - __pyx_cur_scope = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_8_genexpr *)__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_8_genexpr(__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_8_genexpr, __pyx_empty_tuple, NULL); - if (unlikely(!__pyx_cur_scope)) { - __pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_8_genexpr *)Py_None); - __Pyx_INCREF(Py_None); - __PYX_ERR(0, 279, __pyx_L1_error) - } else { - __Pyx_GOTREF(__pyx_cur_scope); - } - __pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_7___str__ *) __pyx_self; - __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_outer_scope)); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope); - { - __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_6hunter_11_predicates_4When_7__str___2generator4, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_str___locals_genexpr, __pyx_n_s_hunter__predicates); if (unlikely(!gen)) __PYX_ERR(0, 279, __pyx_L1_error) - __Pyx_DECREF(__pyx_cur_scope); - __Pyx_RefNannyFinishContext(); - return (PyObject *) gen; - } + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[44])) + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + __Pyx_TraceStartFunc("__setstate_cython__", __pyx_f[1], 16, 0, 0, 0, __PYX_ERR(1, 16, __pyx_L1_error)); + + /* "(tree fragment)":17 + * return __pyx_unpickle_Query, (type(self), 0x5503a44, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Query__set_state(self, __pyx_state) # <<<<<<<<<<<<<< +*/ + __Pyx_TraceLine(17,4,0,__PYX_ERR(1, 17, __pyx_L1_error)) + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_6hunter_11_predicates___pyx_unpickle_Query__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Query, (type(self), 0x5503a44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Query__set_state(self, __pyx_state) +*/ /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(1, 16, __pyx_L1_error)); + goto __pyx_L0; __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.When.__str__.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 16, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Query.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; - __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_gb_6hunter_11_predicates_4When_7__str___2generator4(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ -{ - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_8_genexpr *__pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_8_genexpr *)__pyx_generator->closure); +/* "hunter/_predicates.pyx":264 + * return Not(self) + * + * cdef inline fast_Query_call(Query self, Event event): # <<<<<<<<<<<<<< + * for key, entry in self.query_eq: + * value_from_event = ( entry).getter(event) +*/ + +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_fast_Query_call(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { + CYTHON_UNUSED PyObject *__pyx_v_key = NULL; + PyObject *__pyx_v_entry = NULL; + PyObject *__pyx_v_value_from_event = NULL; PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; PyObject *__pyx_t_3 = NULL; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("genexpr", 0); - __Pyx_TraceCall("genexpr", __pyx_f[0], 279, 0, __PYX_ERR(0, 279, __pyx_L1_error)); - switch (__pyx_generator->resume_label) { - case 0: goto __pyx_L3_first_run; - case 1: goto __pyx_L6_resume_from_yield; - default: /* CPython raises the right error here */ - __Pyx_TraceReturn(Py_None, 0); - __Pyx_RefNannyFinishContext(); - return NULL; - } - __pyx_L3_first_run:; - if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 279, __pyx_L1_error) - if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 279, __pyx_L1_error) } - if (unlikely(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->actions == Py_None)) { + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *(*__pyx_t_7)(PyObject *); + int __pyx_t_8; + int __pyx_t_9; + size_t __pyx_t_10; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[45])) + __Pyx_RefNannySetupContext("fast_Query_call", 0); + __Pyx_TraceStartFunc("fast_Query_call", __pyx_f[0], 264, 0, 0, 0, __PYX_ERR(0, 264, __pyx_L1_error)); + + /* "hunter/_predicates.pyx":265 + * + * cdef inline fast_Query_call(Query self, Event event): + * for key, entry in self.query_eq: # <<<<<<<<<<<<<< + * value_from_event = ( entry).getter(event) + * if value_from_event != ( entry).value: +*/ + __Pyx_TraceLine(265,5,0,__PYX_ERR(0, 265, __pyx_L1_error)) + if (unlikely(__pyx_v_self->query_eq == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(0, 279, __pyx_L1_error) + __PYX_ERR(0, 265, __pyx_L1_error) } - __pyx_t_1 = __pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->actions; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + __pyx_t_1 = __pyx_v_self->query_eq; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; for (;;) { - if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 265, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 279, __pyx_L1_error) + __pyx_t_3 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2)); #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 279, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); #endif - __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_p); - __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_p, __pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); - __pyx_t_3 = 0; - __pyx_t_3 = PyObject_Repr(__pyx_cur_scope->__pyx_v_p); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 279, __pyx_L1_error) + ++__pyx_t_2; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 265, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_r = __pyx_t_3; - __pyx_t_3 = 0; - __Pyx_XGIVEREF(__pyx_t_1); - __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; - __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - __Pyx_Coroutine_ResetAndClearException(__pyx_generator); - /* return from generator, yielding value */ - __pyx_generator->resume_label = 1; - return __pyx_r; - __pyx_L6_resume_from_yield:; - __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; - __pyx_cur_scope->__pyx_t_0 = 0; - __Pyx_XGOTREF(__pyx_t_1); - __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; - if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 279, __pyx_L1_error) - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { + PyObject* sequence = __pyx_t_3; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 265, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_4); + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_5); + } else { + __pyx_t_4 = __Pyx_PyList_GetItemRef(sequence, 0); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 265, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyList_GetItemRef(sequence, 1); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 265, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_5); + } + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); + index = 0; __pyx_t_4 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_4)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + index = 1; __pyx_t_5 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 2) < 0) __PYX_ERR(0, 265, __pyx_L1_error) + __pyx_t_7 = NULL; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L6_unpacking_done; + __pyx_L5_unpacking_failed:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_7 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 265, __pyx_L1_error) + __pyx_L6_unpacking_done:; + } + __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_4); + __pyx_t_4 = 0; + __Pyx_XDECREF_SET(__pyx_v_entry, __pyx_t_5); + __pyx_t_5 = 0; + __Pyx_TraceLine(265,1,0,__PYX_ERR(0, 265, __pyx_L1_error)) - /* function exit code */ - PyErr_SetNone(PyExc_StopIteration); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_L0:; - __Pyx_XDECREF(__pyx_r); __pyx_r = 0; - #if !CYTHON_USE_EXC_INFO_STACK - __Pyx_Coroutine_ResetAndClearException(__pyx_generator); - #endif - __pyx_generator->resume_label = -1; - __Pyx_Coroutine_clear((PyObject*)__pyx_generator); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":266 + * cdef inline fast_Query_call(Query self, Event event): + * for key, entry in self.query_eq: + * value_from_event = ( entry).getter(event) # <<<<<<<<<<<<<< + * if value_from_event != ( entry).value: + * return False +*/ + __Pyx_TraceLine(266,10,0,__PYX_ERR(0, 266, __pyx_L1_error)) + __pyx_t_3 = ((struct __pyx_obj_6hunter_11_predicates_QueryEntry *)__pyx_v_entry)->getter(__pyx_v_event); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 266, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_value_from_event, __pyx_t_3); + __pyx_t_3 = 0; -/* "hunter/_predicates.pyx":276 - * for action in actions) - * - * def __str__(self): # <<<<<<<<<<<<<< - * return 'When(%s, %s)' % ( - * self.condition, - */ + /* "hunter/_predicates.pyx":267 + * for key, entry in self.query_eq: + * value_from_event = ( entry).getter(event) + * if value_from_event != ( entry).value: # <<<<<<<<<<<<<< + * return False + * for key, entry in self.query_in: +*/ + __Pyx_TraceLine(267,17,0,__PYX_ERR(0, 267, __pyx_L1_error)) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_value_from_event, ((struct __pyx_obj_6hunter_11_predicates_QueryEntry *)__pyx_v_entry)->value, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 267, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 267, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_8) { -static PyObject *__pyx_pf_6hunter_11_predicates_4When_2__str__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self) { - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_7___str__ *__pyx_cur_scope; - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - __Pyx_RefNannySetupContext("__str__", 0); - __pyx_cur_scope = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_7___str__ *)__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_7___str__(__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_7___str__, __pyx_empty_tuple, NULL); - if (unlikely(!__pyx_cur_scope)) { - __pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_7___str__ *)Py_None); - __Pyx_INCREF(Py_None); - __PYX_ERR(0, 276, __pyx_L1_error) - } else { - __Pyx_GOTREF(__pyx_cur_scope); - } - __Pyx_TraceCall("__str__", __pyx_f[0], 276, 0, __PYX_ERR(0, 276, __pyx_L1_error)); - __pyx_cur_scope->__pyx_v_self = __pyx_v_self; - __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self); - __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self); + /* "hunter/_predicates.pyx":268 + * value_from_event = ( entry).getter(event) + * if value_from_event != ( entry).value: + * return False # <<<<<<<<<<<<<< + * for key, entry in self.query_in: + * value_from_event = ( entry).getter(event) +*/ + __Pyx_TraceLine(268,18,0,__PYX_ERR(0, 268, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + __Pyx_TraceReturnValue(__pyx_r, 18, 0, __PYX_ERR(0, 268, __pyx_L1_error)); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; - /* "hunter/_predicates.pyx":277 - * - * def __str__(self): - * return 'When(%s, %s)' % ( # <<<<<<<<<<<<<< - * self.condition, - * ', '.join(repr(p) for p in self.actions) - */ - __Pyx_TraceLine(277,0,__PYX_ERR(0, 277, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); + /* "hunter/_predicates.pyx":267 + * for key, entry in self.query_eq: + * value_from_event = ( entry).getter(event) + * if value_from_event != ( entry).value: # <<<<<<<<<<<<<< + * return False + * for key, entry in self.query_in: +*/ + } - /* "hunter/_predicates.pyx":279 - * return 'When(%s, %s)' % ( - * self.condition, - * ', '.join(repr(p) for p in self.actions) # <<<<<<<<<<<<<< - * ) + /* "hunter/_predicates.pyx":265 * - */ - __Pyx_TraceLine(279,0,__PYX_ERR(0, 279, __pyx_L1_error)) - __pyx_t_1 = __pyx_pf_6hunter_11_predicates_4When_7__str___genexpr(((PyObject*)__pyx_cur_scope)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 279, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyString_Join(__pyx_kp_s__3, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 279, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + * cdef inline fast_Query_call(Query self, Event event): + * for key, entry in self.query_eq: # <<<<<<<<<<<<<< + * value_from_event = ( entry).getter(event) + * if value_from_event != ( entry).value: +*/ + __Pyx_TraceLine(265,1,0,__PYX_ERR(0, 265, __pyx_L1_error)) + } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "hunter/_predicates.pyx":278 - * def __str__(self): - * return 'When(%s, %s)' % ( - * self.condition, # <<<<<<<<<<<<<< - * ', '.join(repr(p) for p in self.actions) - * ) - */ - __Pyx_TraceLine(278,0,__PYX_ERR(0, 278, __pyx_L1_error)) - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 278, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_cur_scope->__pyx_v_self->condition); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_self->condition); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_cur_scope->__pyx_v_self->condition); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_2); - __pyx_t_2 = 0; - - /* "hunter/_predicates.pyx":277 - * - * def __str__(self): - * return 'When(%s, %s)' % ( # <<<<<<<<<<<<<< - * self.condition, - * ', '.join(repr(p) for p in self.actions) - */ - __Pyx_TraceLine(277,0,__PYX_ERR(0, 277, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_When_s_s, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 277, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_2; + /* "hunter/_predicates.pyx":269 + * if value_from_event != ( entry).value: + * return False + * for key, entry in self.query_in: # <<<<<<<<<<<<<< + * value_from_event = ( entry).getter(event) + * if (value_from_event) not in ( entry).value: +*/ + __Pyx_TraceLine(269,24,0,__PYX_ERR(0, 269, __pyx_L1_error)) + if (unlikely(__pyx_v_self->query_in == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 269, __pyx_L1_error) + } + __pyx_t_1 = __pyx_v_self->query_in; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; - goto __pyx_L0; - - /* "hunter/_predicates.pyx":276 - * for action in actions) - * - * def __str__(self): # <<<<<<<<<<<<<< - * return 'When(%s, %s)' % ( - * self.condition, - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("hunter._predicates.When.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 269, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2)); + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); + #endif + ++__pyx_t_2; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 269, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { + PyObject* sequence = __pyx_t_3; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 269, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_5); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_4); + } else { + __pyx_t_5 = __Pyx_PyList_GetItemRef(sequence, 0); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 269, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PyList_GetItemRef(sequence, 1); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 269, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_4); + } + #else + __pyx_t_5 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 269, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 269, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 269, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); + index = 0; __pyx_t_5 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L11_unpacking_failed; + __Pyx_GOTREF(__pyx_t_5); + index = 1; __pyx_t_4 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_4)) goto __pyx_L11_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 2) < 0) __PYX_ERR(0, 269, __pyx_L1_error) + __pyx_t_7 = NULL; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L12_unpacking_done; + __pyx_L11_unpacking_failed:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_7 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 269, __pyx_L1_error) + __pyx_L12_unpacking_done:; + } + __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_5); + __pyx_t_5 = 0; + __Pyx_XDECREF_SET(__pyx_v_entry, __pyx_t_4); + __pyx_t_4 = 0; + __Pyx_TraceLine(269,20,0,__PYX_ERR(0, 269, __pyx_L1_error)) -/* "hunter/_predicates.pyx":282 - * ) - * - * def __repr__(self): # <<<<<<<<<<<<<< - * return '' % (self.condition, self.actions) - * - */ + /* "hunter/_predicates.pyx":270 + * return False + * for key, entry in self.query_in: + * value_from_event = ( entry).getter(event) # <<<<<<<<<<<<<< + * if (value_from_event) not in ( entry).value: + * return False +*/ + __Pyx_TraceLine(270,29,0,__PYX_ERR(0, 270, __pyx_L1_error)) + __pyx_t_3 = ((struct __pyx_obj_6hunter_11_predicates_QueryEntry *)__pyx_v_entry)->getter(__pyx_v_event); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 270, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_value_from_event, __pyx_t_3); + __pyx_t_3 = 0; -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_4When_5__repr__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_4When_5__repr__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_4When_4__repr__(((struct __pyx_obj_6hunter_11_predicates_When *)__pyx_v_self)); + /* "hunter/_predicates.pyx":271 + * for key, entry in self.query_in: + * value_from_event = ( entry).getter(event) + * if (value_from_event) not in ( entry).value: # <<<<<<<<<<<<<< + * return False + * for key, entry in self.query_contains: +*/ + __Pyx_TraceLine(271,33,0,__PYX_ERR(0, 271, __pyx_L1_error)) + if (!(likely(PyUnicode_CheckExact(__pyx_v_value_from_event)) || __Pyx_RaiseUnexpectedTypeError("str", __pyx_v_value_from_event))) __PYX_ERR(0, 271, __pyx_L1_error) + __pyx_t_8 = (__Pyx_PySequence_ContainsTF(__pyx_v_value_from_event, ((struct __pyx_obj_6hunter_11_predicates_QueryEntry *)__pyx_v_entry)->value, Py_NE)); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 271, __pyx_L1_error) + if (__pyx_t_8) { - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":272 + * value_from_event = ( entry).getter(event) + * if (value_from_event) not in ( entry).value: + * return False # <<<<<<<<<<<<<< + * for key, entry in self.query_contains: + * value_from_event = ( entry).getter(event) +*/ + __Pyx_TraceLine(272,38,0,__PYX_ERR(0, 272, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + __Pyx_TraceReturnValue(__pyx_r, 38, 0, __PYX_ERR(0, 272, __pyx_L1_error)); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; -static PyObject *__pyx_pf_6hunter_11_predicates_4When_4__repr__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - __Pyx_RefNannySetupContext("__repr__", 0); - __Pyx_TraceCall("__repr__", __pyx_f[0], 282, 0, __PYX_ERR(0, 282, __pyx_L1_error)); + /* "hunter/_predicates.pyx":271 + * for key, entry in self.query_in: + * value_from_event = ( entry).getter(event) + * if (value_from_event) not in ( entry).value: # <<<<<<<<<<<<<< + * return False + * for key, entry in self.query_contains: +*/ + } - /* "hunter/_predicates.pyx":283 - * - * def __repr__(self): - * return '' % (self.condition, self.actions) # <<<<<<<<<<<<<< - * - * def __eq__(self, other): - */ - __Pyx_TraceLine(283,0,__PYX_ERR(0, 283, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 283, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v_self->condition); - __Pyx_GIVEREF(__pyx_v_self->condition); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->condition); - __Pyx_INCREF(__pyx_v_self->actions); - __Pyx_GIVEREF(__pyx_v_self->actions); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->actions); - __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_hunter__predicates_When_conditi, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 283, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + /* "hunter/_predicates.pyx":269 + * if value_from_event != ( entry).value: + * return False + * for key, entry in self.query_in: # <<<<<<<<<<<<<< + * value_from_event = ( entry).getter(event) + * if (value_from_event) not in ( entry).value: +*/ + __Pyx_TraceLine(269,20,0,__PYX_ERR(0, 269, __pyx_L1_error)) + } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "hunter/_predicates.pyx":282 - * ) - * - * def __repr__(self): # <<<<<<<<<<<<<< - * return '' % (self.condition, self.actions) - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("hunter._predicates.When.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} -/* "hunter/_predicates.pyx":285 - * return '' % (self.condition, self.actions) - * - * def __eq__(self, other): # <<<<<<<<<<<<<< - * return ( - * isinstance(other, When) - */ + /* "hunter/_predicates.pyx":273 + * if (value_from_event) not in ( entry).value: + * return False + * for key, entry in self.query_contains: # <<<<<<<<<<<<<< + * value_from_event = ( entry).getter(event) + * if ( entry).value not in (value_from_event): +*/ + __Pyx_TraceLine(273,44,0,__PYX_ERR(0, 273, __pyx_L1_error)) + if (unlikely(__pyx_v_self->query_contains == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 273, __pyx_L1_error) + } + __pyx_t_1 = __pyx_v_self->query_contains; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 273, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2)); + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); + #endif + ++__pyx_t_2; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { + PyObject* sequence = __pyx_t_3; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 273, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_4); + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_5); + } else { + __pyx_t_4 = __Pyx_PyList_GetItemRef(sequence, 0); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 273, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyList_GetItemRef(sequence, 1); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 273, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_5); + } + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); + index = 0; __pyx_t_4 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_4)) goto __pyx_L17_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + index = 1; __pyx_t_5 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L17_unpacking_failed; + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 2) < 0) __PYX_ERR(0, 273, __pyx_L1_error) + __pyx_t_7 = NULL; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L18_unpacking_done; + __pyx_L17_unpacking_failed:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_7 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 273, __pyx_L1_error) + __pyx_L18_unpacking_done:; + } + __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_4); + __pyx_t_4 = 0; + __Pyx_XDECREF_SET(__pyx_v_entry, __pyx_t_5); + __pyx_t_5 = 0; + __Pyx_TraceLine(273,40,0,__PYX_ERR(0, 273, __pyx_L1_error)) -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_4When_7__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_4When_7__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_4When_6__eq__(((struct __pyx_obj_6hunter_11_predicates_When *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + /* "hunter/_predicates.pyx":274 + * return False + * for key, entry in self.query_contains: + * value_from_event = ( entry).getter(event) # <<<<<<<<<<<<<< + * if ( entry).value not in (value_from_event): + * return False +*/ + __Pyx_TraceLine(274,49,0,__PYX_ERR(0, 274, __pyx_L1_error)) + __pyx_t_3 = ((struct __pyx_obj_6hunter_11_predicates_QueryEntry *)__pyx_v_entry)->getter(__pyx_v_event); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_value_from_event, __pyx_t_3); + __pyx_t_3 = 0; - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":275 + * for key, entry in self.query_contains: + * value_from_event = ( entry).getter(event) + * if ( entry).value not in (value_from_event): # <<<<<<<<<<<<<< + * return False + * for key, entry in self.query_startswith: +*/ + __Pyx_TraceLine(275,57,0,__PYX_ERR(0, 275, __pyx_L1_error)) + if (!(likely(PyUnicode_CheckExact(__pyx_v_value_from_event)) || __Pyx_RaiseUnexpectedTypeError("str", __pyx_v_value_from_event))) __PYX_ERR(0, 275, __pyx_L1_error) + if (unlikely(__pyx_v_value_from_event == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 275, __pyx_L1_error) + } + __pyx_t_8 = (__Pyx_PyUnicode_ContainsTF(((struct __pyx_obj_6hunter_11_predicates_QueryEntry *)__pyx_v_entry)->value, ((PyObject*)__pyx_v_value_from_event), Py_NE)); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 275, __pyx_L1_error) + if (__pyx_t_8) { -static PyObject *__pyx_pf_6hunter_11_predicates_4When_6__eq__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self, PyObject *__pyx_v_other) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - __Pyx_RefNannySetupContext("__eq__", 0); - __Pyx_TraceCall("__eq__", __pyx_f[0], 285, 0, __PYX_ERR(0, 285, __pyx_L1_error)); + /* "hunter/_predicates.pyx":276 + * value_from_event = ( entry).getter(event) + * if ( entry).value not in (value_from_event): + * return False # <<<<<<<<<<<<<< + * for key, entry in self.query_startswith: + * value_from_event = ( entry).getter(event) +*/ + __Pyx_TraceLine(276,58,0,__PYX_ERR(0, 276, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + __Pyx_TraceReturnValue(__pyx_r, 58, 0, __PYX_ERR(0, 276, __pyx_L1_error)); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; - /* "hunter/_predicates.pyx":286 - * - * def __eq__(self, other): - * return ( # <<<<<<<<<<<<<< - * isinstance(other, When) - * and self.condition == ( other).condition - */ - __Pyx_TraceLine(286,0,__PYX_ERR(0, 286, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); + /* "hunter/_predicates.pyx":275 + * for key, entry in self.query_contains: + * value_from_event = ( entry).getter(event) + * if ( entry).value not in (value_from_event): # <<<<<<<<<<<<<< + * return False + * for key, entry in self.query_startswith: +*/ + } - /* "hunter/_predicates.pyx":287 - * def __eq__(self, other): - * return ( - * isinstance(other, When) # <<<<<<<<<<<<<< - * and self.condition == ( other).condition - * and self.actions == ( other).actions - */ - __Pyx_TraceLine(287,0,__PYX_ERR(0, 287, __pyx_L1_error)) - __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_other, __pyx_ptype_6hunter_11_predicates_When); - if (__pyx_t_2) { - } else { - __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 287, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __pyx_t_3; - __pyx_t_3 = 0; - goto __pyx_L3_bool_binop_done; + /* "hunter/_predicates.pyx":273 + * if (value_from_event) not in ( entry).value: + * return False + * for key, entry in self.query_contains: # <<<<<<<<<<<<<< + * value_from_event = ( entry).getter(event) + * if ( entry).value not in (value_from_event): +*/ + __Pyx_TraceLine(273,40,0,__PYX_ERR(0, 273, __pyx_L1_error)) } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "hunter/_predicates.pyx":288 - * return ( - * isinstance(other, When) - * and self.condition == ( other).condition # <<<<<<<<<<<<<< - * and self.actions == ( other).actions - * ) - */ - __Pyx_TraceLine(288,0,__PYX_ERR(0, 288, __pyx_L1_error)) - __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->condition, ((struct __pyx_obj_6hunter_11_predicates_When *)__pyx_v_other)->condition, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 288, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 288, __pyx_L1_error) - if (__pyx_t_2) { - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } else { - __Pyx_INCREF(__pyx_t_3); - __pyx_t_1 = __pyx_t_3; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - goto __pyx_L3_bool_binop_done; + /* "hunter/_predicates.pyx":277 + * if ( entry).value not in (value_from_event): + * return False + * for key, entry in self.query_startswith: # <<<<<<<<<<<<<< + * value_from_event = ( entry).getter(event) + * if not (value_from_event).startswith(( entry).value): +*/ + __Pyx_TraceLine(277,64,0,__PYX_ERR(0, 277, __pyx_L1_error)) + if (unlikely(__pyx_v_self->query_startswith == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 277, __pyx_L1_error) } + __pyx_t_1 = __pyx_v_self->query_startswith; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 277, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2)); + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); + #endif + ++__pyx_t_2; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 277, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { + PyObject* sequence = __pyx_t_3; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 277, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_5); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_4); + } else { + __pyx_t_5 = __Pyx_PyList_GetItemRef(sequence, 0); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 277, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PyList_GetItemRef(sequence, 1); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 277, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_4); + } + #else + __pyx_t_5 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 277, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 277, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 277, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); + index = 0; __pyx_t_5 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L23_unpacking_failed; + __Pyx_GOTREF(__pyx_t_5); + index = 1; __pyx_t_4 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_4)) goto __pyx_L23_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 2) < 0) __PYX_ERR(0, 277, __pyx_L1_error) + __pyx_t_7 = NULL; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L24_unpacking_done; + __pyx_L23_unpacking_failed:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_7 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 277, __pyx_L1_error) + __pyx_L24_unpacking_done:; + } + __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_5); + __pyx_t_5 = 0; + __Pyx_XDECREF_SET(__pyx_v_entry, __pyx_t_4); + __pyx_t_4 = 0; + __Pyx_TraceLine(277,60,0,__PYX_ERR(0, 277, __pyx_L1_error)) - /* "hunter/_predicates.pyx":289 - * isinstance(other, When) - * and self.condition == ( other).condition - * and self.actions == ( other).actions # <<<<<<<<<<<<<< - * ) - * - */ - __Pyx_TraceLine(289,0,__PYX_ERR(0, 289, __pyx_L1_error)) - __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->actions, ((struct __pyx_obj_6hunter_11_predicates_When *)__pyx_v_other)->actions, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 289, __pyx_L1_error) - __Pyx_INCREF(__pyx_t_3); - __pyx_t_1 = __pyx_t_3; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_L3_bool_binop_done:; - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "hunter/_predicates.pyx":285 - * return '' % (self.condition, self.actions) - * - * def __eq__(self, other): # <<<<<<<<<<<<<< - * return ( - * isinstance(other, When) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("hunter._predicates.When.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "hunter/_predicates.pyx":292 - * ) - * - * def __hash__(self): # <<<<<<<<<<<<<< - * return hash(('When', self.condition, self.actions)) - * - */ + /* "hunter/_predicates.pyx":278 + * return False + * for key, entry in self.query_startswith: + * value_from_event = ( entry).getter(event) # <<<<<<<<<<<<<< + * if not (value_from_event).startswith(( entry).value): + * return False +*/ + __Pyx_TraceLine(278,69,0,__PYX_ERR(0, 278, __pyx_L1_error)) + __pyx_t_3 = ((struct __pyx_obj_6hunter_11_predicates_QueryEntry *)__pyx_v_entry)->getter(__pyx_v_event); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 278, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_value_from_event, __pyx_t_3); + __pyx_t_3 = 0; -/* Python wrapper */ -static Py_hash_t __pyx_pw_6hunter_11_predicates_4When_9__hash__(PyObject *__pyx_v_self); /*proto*/ -static Py_hash_t __pyx_pw_6hunter_11_predicates_4When_9__hash__(PyObject *__pyx_v_self) { - Py_hash_t __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__hash__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_4When_8__hash__(((struct __pyx_obj_6hunter_11_predicates_When *)__pyx_v_self)); + /* "hunter/_predicates.pyx":279 + * for key, entry in self.query_startswith: + * value_from_event = ( entry).getter(event) + * if not (value_from_event).startswith(( entry).value): # <<<<<<<<<<<<<< + * return False + * for key, entry in self.query_endswith: +*/ + __Pyx_TraceLine(279,74,0,__PYX_ERR(0, 279, __pyx_L1_error)) + if (!(likely(PyUnicode_CheckExact(__pyx_v_value_from_event)) || __Pyx_RaiseUnexpectedTypeError("str", __pyx_v_value_from_event))) __PYX_ERR(0, 279, __pyx_L1_error) + if (unlikely(__pyx_v_value_from_event == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "startswith"); + __PYX_ERR(0, 279, __pyx_L1_error) + } + __pyx_t_8 = __Pyx_PyUnicode_Tailmatch(((PyObject*)__pyx_v_value_from_event), ((struct __pyx_obj_6hunter_11_predicates_QueryEntry *)__pyx_v_entry)->value, 0, PY_SSIZE_T_MAX, -1); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 279, __pyx_L1_error) + __pyx_t_9 = (!__pyx_t_8); + if (__pyx_t_9) { - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":280 + * value_from_event = ( entry).getter(event) + * if not (value_from_event).startswith(( entry).value): + * return False # <<<<<<<<<<<<<< + * for key, entry in self.query_endswith: + * value_from_event = ( entry).getter(event) +*/ + __Pyx_TraceLine(280,80,0,__PYX_ERR(0, 280, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + __Pyx_TraceReturnValue(__pyx_r, 80, 0, __PYX_ERR(0, 280, __pyx_L1_error)); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; -static Py_hash_t __pyx_pf_6hunter_11_predicates_4When_8__hash__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self) { - Py_hash_t __pyx_r; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - Py_hash_t __pyx_t_2; - __Pyx_RefNannySetupContext("__hash__", 0); - __Pyx_TraceCall("__hash__", __pyx_f[0], 292, 0, __PYX_ERR(0, 292, __pyx_L1_error)); + /* "hunter/_predicates.pyx":279 + * for key, entry in self.query_startswith: + * value_from_event = ( entry).getter(event) + * if not (value_from_event).startswith(( entry).value): # <<<<<<<<<<<<<< + * return False + * for key, entry in self.query_endswith: +*/ + } - /* "hunter/_predicates.pyx":293 - * - * def __hash__(self): - * return hash(('When', self.condition, self.actions)) # <<<<<<<<<<<<<< - * - * def __call__(self, Event event): - */ - __Pyx_TraceLine(293,0,__PYX_ERR(0, 293, __pyx_L1_error)) - __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 293, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_n_s_When); - __Pyx_GIVEREF(__pyx_n_s_When); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_When); - __Pyx_INCREF(__pyx_v_self->condition); - __Pyx_GIVEREF(__pyx_v_self->condition); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->condition); - __Pyx_INCREF(__pyx_v_self->actions); - __Pyx_GIVEREF(__pyx_v_self->actions); - PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_self->actions); - __pyx_t_2 = PyObject_Hash(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_hash_t)-1))) __PYX_ERR(0, 293, __pyx_L1_error) + /* "hunter/_predicates.pyx":277 + * if ( entry).value not in (value_from_event): + * return False + * for key, entry in self.query_startswith: # <<<<<<<<<<<<<< + * value_from_event = ( entry).getter(event) + * if not (value_from_event).startswith(( entry).value): +*/ + __Pyx_TraceLine(277,60,0,__PYX_ERR(0, 277, __pyx_L1_error)) + } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_2; - goto __pyx_L0; - - /* "hunter/_predicates.pyx":292 - * ) - * - * def __hash__(self): # <<<<<<<<<<<<<< - * return hash(('When', self.condition, self.actions)) - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.When.__hash__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - if (unlikely(__pyx_r == -1) && !PyErr_Occurred()) __pyx_r = -2; - __Pyx_TraceReturn(Py_None, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "hunter/_predicates.pyx":295 - * return hash(('When', self.condition, self.actions)) - * - * def __call__(self, Event event): # <<<<<<<<<<<<<< - * return fast_When_call(self, event) - * - */ -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_4When_11__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_4When_11__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__call__ (wrapper)", 0); - { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_event,0}; - PyObject* values[1] = {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 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_event)) != 0)) kw_args--; - else goto __pyx_L5_argtuple_error; + /* "hunter/_predicates.pyx":281 + * if not (value_from_event).startswith(( entry).value): + * return False + * for key, entry in self.query_endswith: # <<<<<<<<<<<<<< + * value_from_event = ( entry).getter(event) + * if not (value_from_event).endswith(( entry).value): +*/ + __Pyx_TraceLine(281,86,0,__PYX_ERR(0, 281, __pyx_L1_error)) + if (unlikely(__pyx_v_self->query_endswith == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 281, __pyx_L1_error) + } + __pyx_t_1 = __pyx_v_self->query_endswith; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 281, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2)); + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); + #endif + ++__pyx_t_2; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { + PyObject* sequence = __pyx_t_3; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 281, __pyx_L1_error) } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__call__") < 0)) __PYX_ERR(0, 295, __pyx_L3_error) + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_4); + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_5); + } else { + __pyx_t_4 = __Pyx_PyList_GetItemRef(sequence, 0); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 281, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyList_GetItemRef(sequence, 1); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 281, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_5); } - } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { - goto __pyx_L5_argtuple_error; + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + Py_ssize_t index = -1; + __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); + index = 0; __pyx_t_4 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_4)) goto __pyx_L29_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + index = 1; __pyx_t_5 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L29_unpacking_failed; + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 2) < 0) __PYX_ERR(0, 281, __pyx_L1_error) + __pyx_t_7 = NULL; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L30_unpacking_done; + __pyx_L29_unpacking_failed:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_7 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 281, __pyx_L1_error) + __pyx_L30_unpacking_done:; } - __pyx_v_event = ((struct __pyx_obj_6hunter_6_event_Event *)values[0]); - } - goto __pyx_L4_argument_unpacking_done; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__call__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 295, __pyx_L3_error) - __pyx_L3_error:; - __Pyx_AddTraceback("hunter._predicates.When.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_event), __pyx_ptype_6hunter_6_event_Event, 1, "event", 0))) __PYX_ERR(0, 295, __pyx_L1_error) - __pyx_r = __pyx_pf_6hunter_11_predicates_4When_10__call__(((struct __pyx_obj_6hunter_11_predicates_When *)__pyx_v_self), __pyx_v_event); - - /* function exit code */ - goto __pyx_L0; - __pyx_L1_error:; - __pyx_r = NULL; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_4); + __pyx_t_4 = 0; + __Pyx_XDECREF_SET(__pyx_v_entry, __pyx_t_5); + __pyx_t_5 = 0; + __Pyx_TraceLine(281,82,0,__PYX_ERR(0, 281, __pyx_L1_error)) -static PyObject *__pyx_pf_6hunter_11_predicates_4When_10__call__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__call__", 0); - __Pyx_TraceCall("__call__", __pyx_f[0], 295, 0, __PYX_ERR(0, 295, __pyx_L1_error)); + /* "hunter/_predicates.pyx":282 + * return False + * for key, entry in self.query_endswith: + * value_from_event = ( entry).getter(event) # <<<<<<<<<<<<<< + * if not (value_from_event).endswith(( entry).value): + * return False +*/ + __Pyx_TraceLine(282,91,0,__PYX_ERR(0, 282, __pyx_L1_error)) + __pyx_t_3 = ((struct __pyx_obj_6hunter_11_predicates_QueryEntry *)__pyx_v_entry)->getter(__pyx_v_event); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 282, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_value_from_event, __pyx_t_3); + __pyx_t_3 = 0; - /* "hunter/_predicates.pyx":296 - * - * def __call__(self, Event event): - * return fast_When_call(self, event) # <<<<<<<<<<<<<< - * - * def __or__(self, other): - */ - __Pyx_TraceLine(296,0,__PYX_ERR(0, 296, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_f_6hunter_11_predicates_fast_When_call(__pyx_v_self, __pyx_v_event); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 296, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + /* "hunter/_predicates.pyx":283 + * for key, entry in self.query_endswith: + * value_from_event = ( entry).getter(event) + * if not (value_from_event).endswith(( entry).value): # <<<<<<<<<<<<<< + * return False + * for key, entry in self.query_regex: +*/ + __Pyx_TraceLine(283,96,0,__PYX_ERR(0, 283, __pyx_L1_error)) + if (!(likely(PyUnicode_CheckExact(__pyx_v_value_from_event)) || __Pyx_RaiseUnexpectedTypeError("str", __pyx_v_value_from_event))) __PYX_ERR(0, 283, __pyx_L1_error) + if (unlikely(__pyx_v_value_from_event == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "endswith"); + __PYX_ERR(0, 283, __pyx_L1_error) + } + __pyx_t_9 = __Pyx_PyUnicode_Tailmatch(((PyObject*)__pyx_v_value_from_event), ((struct __pyx_obj_6hunter_11_predicates_QueryEntry *)__pyx_v_entry)->value, 0, PY_SSIZE_T_MAX, 1); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(0, 283, __pyx_L1_error) + __pyx_t_8 = (!__pyx_t_9); + if (__pyx_t_8) { - /* "hunter/_predicates.pyx":295 - * return hash(('When', self.condition, self.actions)) - * - * def __call__(self, Event event): # <<<<<<<<<<<<<< - * return fast_When_call(self, event) - * - */ + /* "hunter/_predicates.pyx":284 + * value_from_event = ( entry).getter(event) + * if not (value_from_event).endswith(( entry).value): + * return False # <<<<<<<<<<<<<< + * for key, entry in self.query_regex: + * value_from_event = ( entry).getter(event) +*/ + __Pyx_TraceLine(284,102,0,__PYX_ERR(0, 284, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + __Pyx_TraceReturnValue(__pyx_r, 102, 0, __PYX_ERR(0, 284, __pyx_L1_error)); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.When.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":283 + * for key, entry in self.query_endswith: + * value_from_event = ( entry).getter(event) + * if not (value_from_event).endswith(( entry).value): # <<<<<<<<<<<<<< + * return False + * for key, entry in self.query_regex: +*/ + } -/* "hunter/_predicates.pyx":298 - * return fast_When_call(self, event) - * - * def __or__(self, other): # <<<<<<<<<<<<<< - * return Or(self, other) - * - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_4When_13__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_4When_13__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__or__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_4When_12__or__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6hunter_11_predicates_4When_12__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - __Pyx_RefNannySetupContext("__or__", 0); - __Pyx_TraceCall("__or__", __pyx_f[0], 298, 0, __PYX_ERR(0, 298, __pyx_L1_error)); - - /* "hunter/_predicates.pyx":299 - * - * def __or__(self, other): - * return Or(self, other) # <<<<<<<<<<<<<< - * - * def __and__(self, other): - */ - __Pyx_TraceLine(299,0,__PYX_ERR(0, 299, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 299, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v_self); - __Pyx_GIVEREF(__pyx_v_self); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self); - __Pyx_INCREF(__pyx_v_other); - __Pyx_GIVEREF(__pyx_v_other); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_other); - __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_Or), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 299, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + /* "hunter/_predicates.pyx":281 + * if not (value_from_event).startswith(( entry).value): + * return False + * for key, entry in self.query_endswith: # <<<<<<<<<<<<<< + * value_from_event = ( entry).getter(event) + * if not (value_from_event).endswith(( entry).value): +*/ + __Pyx_TraceLine(281,82,0,__PYX_ERR(0, 281, __pyx_L1_error)) + } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "hunter/_predicates.pyx":298 - * return fast_When_call(self, event) - * - * def __or__(self, other): # <<<<<<<<<<<<<< - * return Or(self, other) - * - */ - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("hunter._predicates.When.__or__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":285 + * if not (value_from_event).endswith(( entry).value): + * return False + * for key, entry in self.query_regex: # <<<<<<<<<<<<<< + * value_from_event = ( entry).getter(event) + * if not ( entry).value.match(value_from_event): +*/ + __Pyx_TraceLine(285,108,0,__PYX_ERR(0, 285, __pyx_L1_error)) + if (unlikely(__pyx_v_self->query_regex == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 285, __pyx_L1_error) + } + __pyx_t_1 = __pyx_v_self->query_regex; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 285, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2)); + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); + #endif + ++__pyx_t_2; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { + PyObject* sequence = __pyx_t_3; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 285, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_5); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_4); + } else { + __pyx_t_5 = __Pyx_PyList_GetItemRef(sequence, 0); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 285, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PyList_GetItemRef(sequence, 1); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 285, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_4); + } + #else + __pyx_t_5 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); + index = 0; __pyx_t_5 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L35_unpacking_failed; + __Pyx_GOTREF(__pyx_t_5); + index = 1; __pyx_t_4 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_4)) goto __pyx_L35_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 2) < 0) __PYX_ERR(0, 285, __pyx_L1_error) + __pyx_t_7 = NULL; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L36_unpacking_done; + __pyx_L35_unpacking_failed:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_7 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 285, __pyx_L1_error) + __pyx_L36_unpacking_done:; + } + __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_5); + __pyx_t_5 = 0; + __Pyx_XDECREF_SET(__pyx_v_entry, __pyx_t_4); + __pyx_t_4 = 0; + __Pyx_TraceLine(285,104,0,__PYX_ERR(0, 285, __pyx_L1_error)) -/* "hunter/_predicates.pyx":301 - * return Or(self, other) - * - * def __and__(self, other): # <<<<<<<<<<<<<< - * return And(self, other) - * - */ + /* "hunter/_predicates.pyx":286 + * return False + * for key, entry in self.query_regex: + * value_from_event = ( entry).getter(event) # <<<<<<<<<<<<<< + * if not ( entry).value.match(value_from_event): + * return False +*/ + __Pyx_TraceLine(286,113,0,__PYX_ERR(0, 286, __pyx_L1_error)) + __pyx_t_3 = ((struct __pyx_obj_6hunter_11_predicates_QueryEntry *)__pyx_v_entry)->getter(__pyx_v_event); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_value_from_event, __pyx_t_3); + __pyx_t_3 = 0; -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_4When_15__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_4When_15__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__and__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_4When_14__and__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + /* "hunter/_predicates.pyx":287 + * for key, entry in self.query_regex: + * value_from_event = ( entry).getter(event) + * if not ( entry).value.match(value_from_event): # <<<<<<<<<<<<<< + * return False + * for key, entry in self.query_gt: +*/ + __Pyx_TraceLine(287,119,0,__PYX_ERR(0, 287, __pyx_L1_error)) + __pyx_t_4 = ((struct __pyx_obj_6hunter_11_predicates_QueryEntry *)__pyx_v_entry)->value; + __Pyx_INCREF(__pyx_t_4); + __pyx_t_10 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_value_from_event}; + __pyx_t_3 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_match, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 287, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 287, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_9 = (!__pyx_t_8); + if (__pyx_t_9) { - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":288 + * value_from_event = ( entry).getter(event) + * if not ( entry).value.match(value_from_event): + * return False # <<<<<<<<<<<<<< + * for key, entry in self.query_gt: + * value_from_event = ( entry).getter(event) +*/ + __Pyx_TraceLine(288,123,0,__PYX_ERR(0, 288, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + __Pyx_TraceReturnValue(__pyx_r, 123, 0, __PYX_ERR(0, 288, __pyx_L1_error)); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; -static PyObject *__pyx_pf_6hunter_11_predicates_4When_14__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - __Pyx_RefNannySetupContext("__and__", 0); - __Pyx_TraceCall("__and__", __pyx_f[0], 301, 0, __PYX_ERR(0, 301, __pyx_L1_error)); + /* "hunter/_predicates.pyx":287 + * for key, entry in self.query_regex: + * value_from_event = ( entry).getter(event) + * if not ( entry).value.match(value_from_event): # <<<<<<<<<<<<<< + * return False + * for key, entry in self.query_gt: +*/ + } - /* "hunter/_predicates.pyx":302 - * - * def __and__(self, other): - * return And(self, other) # <<<<<<<<<<<<<< - * - * def __invert__(self): - */ - __Pyx_TraceLine(302,0,__PYX_ERR(0, 302, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 302, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v_self); - __Pyx_GIVEREF(__pyx_v_self); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self); - __Pyx_INCREF(__pyx_v_other); - __Pyx_GIVEREF(__pyx_v_other); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_other); - __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_And), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 302, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + /* "hunter/_predicates.pyx":285 + * if not (value_from_event).endswith(( entry).value): + * return False + * for key, entry in self.query_regex: # <<<<<<<<<<<<<< + * value_from_event = ( entry).getter(event) + * if not ( entry).value.match(value_from_event): +*/ + __Pyx_TraceLine(285,104,0,__PYX_ERR(0, 285, __pyx_L1_error)) + } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - /* "hunter/_predicates.pyx":301 - * return Or(self, other) - * - * def __and__(self, other): # <<<<<<<<<<<<<< - * return And(self, other) - * - */ + /* "hunter/_predicates.pyx":289 + * if not ( entry).value.match(value_from_event): + * return False + * for key, entry in self.query_gt: # <<<<<<<<<<<<<< + * value_from_event = ( entry).getter(event) + * if not value_from_event > ( entry).value: +*/ + __Pyx_TraceLine(289,129,0,__PYX_ERR(0, 289, __pyx_L1_error)) + if (unlikely(__pyx_v_self->query_gt == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 289, __pyx_L1_error) + } + __pyx_t_1 = __pyx_v_self->query_gt; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 289, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2)); + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); + #endif + ++__pyx_t_2; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { + PyObject* sequence = __pyx_t_3; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 289, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_4); + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_5); + } else { + __pyx_t_4 = __Pyx_PyList_GetItemRef(sequence, 0); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 289, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyList_GetItemRef(sequence, 1); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 289, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_5); + } + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); + index = 0; __pyx_t_4 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_4)) goto __pyx_L41_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + index = 1; __pyx_t_5 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L41_unpacking_failed; + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 2) < 0) __PYX_ERR(0, 289, __pyx_L1_error) + __pyx_t_7 = NULL; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L42_unpacking_done; + __pyx_L41_unpacking_failed:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_7 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 289, __pyx_L1_error) + __pyx_L42_unpacking_done:; + } + __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_4); + __pyx_t_4 = 0; + __Pyx_XDECREF_SET(__pyx_v_entry, __pyx_t_5); + __pyx_t_5 = 0; + __Pyx_TraceLine(289,125,0,__PYX_ERR(0, 289, __pyx_L1_error)) - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("hunter._predicates.When.__and__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":290 + * return False + * for key, entry in self.query_gt: + * value_from_event = ( entry).getter(event) # <<<<<<<<<<<<<< + * if not value_from_event > ( entry).value: + * return False +*/ + __Pyx_TraceLine(290,134,0,__PYX_ERR(0, 290, __pyx_L1_error)) + __pyx_t_3 = ((struct __pyx_obj_6hunter_11_predicates_QueryEntry *)__pyx_v_entry)->getter(__pyx_v_event); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 290, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_value_from_event, __pyx_t_3); + __pyx_t_3 = 0; -/* "hunter/_predicates.pyx":304 - * return And(self, other) - * - * def __invert__(self): # <<<<<<<<<<<<<< - * return Not(self) - * - */ + /* "hunter/_predicates.pyx":291 + * for key, entry in self.query_gt: + * value_from_event = ( entry).getter(event) + * if not value_from_event > ( entry).value: # <<<<<<<<<<<<<< + * return False + * for key, entry in self.query_gte: +*/ + __Pyx_TraceLine(291,142,0,__PYX_ERR(0, 291, __pyx_L1_error)) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_value_from_event, ((struct __pyx_obj_6hunter_11_predicates_QueryEntry *)__pyx_v_entry)->value, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 291, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(0, 291, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_8 = (!__pyx_t_9); + if (__pyx_t_8) { -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_4When_17__invert__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_4When_17__invert__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__invert__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_4When_16__invert__(((struct __pyx_obj_6hunter_11_predicates_When *)__pyx_v_self)); + /* "hunter/_predicates.pyx":292 + * value_from_event = ( entry).getter(event) + * if not value_from_event > ( entry).value: + * return False # <<<<<<<<<<<<<< + * for key, entry in self.query_gte: + * value_from_event = ( entry).getter(event) +*/ + __Pyx_TraceLine(292,143,0,__PYX_ERR(0, 292, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + __Pyx_TraceReturnValue(__pyx_r, 143, 0, __PYX_ERR(0, 292, __pyx_L1_error)); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":291 + * for key, entry in self.query_gt: + * value_from_event = ( entry).getter(event) + * if not value_from_event > ( entry).value: # <<<<<<<<<<<<<< + * return False + * for key, entry in self.query_gte: +*/ + } -static PyObject *__pyx_pf_6hunter_11_predicates_4When_16__invert__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__invert__", 0); - __Pyx_TraceCall("__invert__", __pyx_f[0], 304, 0, __PYX_ERR(0, 304, __pyx_L1_error)); + /* "hunter/_predicates.pyx":289 + * if not ( entry).value.match(value_from_event): + * return False + * for key, entry in self.query_gt: # <<<<<<<<<<<<<< + * value_from_event = ( entry).getter(event) + * if not value_from_event > ( entry).value: +*/ + __Pyx_TraceLine(289,125,0,__PYX_ERR(0, 289, __pyx_L1_error)) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "hunter/_predicates.pyx":305 + /* "hunter/_predicates.pyx":293 + * if not value_from_event > ( entry).value: + * return False + * for key, entry in self.query_gte: # <<<<<<<<<<<<<< + * value_from_event = ( entry).getter(event) + * if not value_from_event >= ( entry).value: +*/ + __Pyx_TraceLine(293,149,0,__PYX_ERR(0, 293, __pyx_L1_error)) + if (unlikely(__pyx_v_self->query_gte == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 293, __pyx_L1_error) + } + __pyx_t_1 = __pyx_v_self->query_gte; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 293, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2)); + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); + #endif + ++__pyx_t_2; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 293, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { + PyObject* sequence = __pyx_t_3; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 293, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_5); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_4); + } else { + __pyx_t_5 = __Pyx_PyList_GetItemRef(sequence, 0); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 293, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PyList_GetItemRef(sequence, 1); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 293, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_4); + } + #else + __pyx_t_5 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 293, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 293, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 293, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); + index = 0; __pyx_t_5 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L47_unpacking_failed; + __Pyx_GOTREF(__pyx_t_5); + index = 1; __pyx_t_4 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_4)) goto __pyx_L47_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 2) < 0) __PYX_ERR(0, 293, __pyx_L1_error) + __pyx_t_7 = NULL; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L48_unpacking_done; + __pyx_L47_unpacking_failed:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_7 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 293, __pyx_L1_error) + __pyx_L48_unpacking_done:; + } + __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_5); + __pyx_t_5 = 0; + __Pyx_XDECREF_SET(__pyx_v_entry, __pyx_t_4); + __pyx_t_4 = 0; + __Pyx_TraceLine(293,145,0,__PYX_ERR(0, 293, __pyx_L1_error)) + + /* "hunter/_predicates.pyx":294 + * return False + * for key, entry in self.query_gte: + * value_from_event = ( entry).getter(event) # <<<<<<<<<<<<<< + * if not value_from_event >= ( entry).value: + * return False +*/ + __Pyx_TraceLine(294,154,0,__PYX_ERR(0, 294, __pyx_L1_error)) + __pyx_t_3 = ((struct __pyx_obj_6hunter_11_predicates_QueryEntry *)__pyx_v_entry)->getter(__pyx_v_event); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 294, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_value_from_event, __pyx_t_3); + __pyx_t_3 = 0; + + /* "hunter/_predicates.pyx":295 + * for key, entry in self.query_gte: + * value_from_event = ( entry).getter(event) + * if not value_from_event >= ( entry).value: # <<<<<<<<<<<<<< + * return False + * for key, entry in self.query_lt: +*/ + __Pyx_TraceLine(295,162,0,__PYX_ERR(0, 295, __pyx_L1_error)) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_value_from_event, ((struct __pyx_obj_6hunter_11_predicates_QueryEntry *)__pyx_v_entry)->value, Py_GE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 295, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 295, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_9 = (!__pyx_t_8); + if (__pyx_t_9) { + + /* "hunter/_predicates.pyx":296 + * value_from_event = ( entry).getter(event) + * if not value_from_event >= ( entry).value: + * return False # <<<<<<<<<<<<<< + * for key, entry in self.query_lt: + * value_from_event = ( entry).getter(event) +*/ + __Pyx_TraceLine(296,163,0,__PYX_ERR(0, 296, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + __Pyx_TraceReturnValue(__pyx_r, 163, 0, __PYX_ERR(0, 296, __pyx_L1_error)); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + + /* "hunter/_predicates.pyx":295 + * for key, entry in self.query_gte: + * value_from_event = ( entry).getter(event) + * if not value_from_event >= ( entry).value: # <<<<<<<<<<<<<< + * return False + * for key, entry in self.query_lt: +*/ + } + + /* "hunter/_predicates.pyx":293 + * if not value_from_event > ( entry).value: + * return False + * for key, entry in self.query_gte: # <<<<<<<<<<<<<< + * value_from_event = ( entry).getter(event) + * if not value_from_event >= ( entry).value: +*/ + __Pyx_TraceLine(293,145,0,__PYX_ERR(0, 293, __pyx_L1_error)) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "hunter/_predicates.pyx":297 + * if not value_from_event >= ( entry).value: + * return False + * for key, entry in self.query_lt: # <<<<<<<<<<<<<< + * value_from_event = ( entry).getter(event) + * if not value_from_event < ( entry).value: +*/ + __Pyx_TraceLine(297,169,0,__PYX_ERR(0, 297, __pyx_L1_error)) + if (unlikely(__pyx_v_self->query_lt == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 297, __pyx_L1_error) + } + __pyx_t_1 = __pyx_v_self->query_lt; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 297, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2)); + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); + #endif + ++__pyx_t_2; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { + PyObject* sequence = __pyx_t_3; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 297, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_4); + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_5); + } else { + __pyx_t_4 = __Pyx_PyList_GetItemRef(sequence, 0); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 297, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyList_GetItemRef(sequence, 1); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 297, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_5); + } + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); + index = 0; __pyx_t_4 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_4)) goto __pyx_L53_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + index = 1; __pyx_t_5 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L53_unpacking_failed; + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 2) < 0) __PYX_ERR(0, 297, __pyx_L1_error) + __pyx_t_7 = NULL; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L54_unpacking_done; + __pyx_L53_unpacking_failed:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_7 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 297, __pyx_L1_error) + __pyx_L54_unpacking_done:; + } + __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_4); + __pyx_t_4 = 0; + __Pyx_XDECREF_SET(__pyx_v_entry, __pyx_t_5); + __pyx_t_5 = 0; + __Pyx_TraceLine(297,165,0,__PYX_ERR(0, 297, __pyx_L1_error)) + + /* "hunter/_predicates.pyx":298 + * return False + * for key, entry in self.query_lt: + * value_from_event = ( entry).getter(event) # <<<<<<<<<<<<<< + * if not value_from_event < ( entry).value: + * return False +*/ + __Pyx_TraceLine(298,174,0,__PYX_ERR(0, 298, __pyx_L1_error)) + __pyx_t_3 = ((struct __pyx_obj_6hunter_11_predicates_QueryEntry *)__pyx_v_entry)->getter(__pyx_v_event); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 298, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_value_from_event, __pyx_t_3); + __pyx_t_3 = 0; + + /* "hunter/_predicates.pyx":299 + * for key, entry in self.query_lt: + * value_from_event = ( entry).getter(event) + * if not value_from_event < ( entry).value: # <<<<<<<<<<<<<< + * return False + * for key, entry in self.query_lte: +*/ + __Pyx_TraceLine(299,182,0,__PYX_ERR(0, 299, __pyx_L1_error)) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_value_from_event, ((struct __pyx_obj_6hunter_11_predicates_QueryEntry *)__pyx_v_entry)->value, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 299, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(0, 299, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_8 = (!__pyx_t_9); + if (__pyx_t_8) { + + /* "hunter/_predicates.pyx":300 + * value_from_event = ( entry).getter(event) + * if not value_from_event < ( entry).value: + * return False # <<<<<<<<<<<<<< + * for key, entry in self.query_lte: + * value_from_event = ( entry).getter(event) +*/ + __Pyx_TraceLine(300,183,0,__PYX_ERR(0, 300, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + __Pyx_TraceReturnValue(__pyx_r, 183, 0, __PYX_ERR(0, 300, __pyx_L1_error)); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + + /* "hunter/_predicates.pyx":299 + * for key, entry in self.query_lt: + * value_from_event = ( entry).getter(event) + * if not value_from_event < ( entry).value: # <<<<<<<<<<<<<< + * return False + * for key, entry in self.query_lte: +*/ + } + + /* "hunter/_predicates.pyx":297 + * if not value_from_event >= ( entry).value: + * return False + * for key, entry in self.query_lt: # <<<<<<<<<<<<<< + * value_from_event = ( entry).getter(event) + * if not value_from_event < ( entry).value: +*/ + __Pyx_TraceLine(297,165,0,__PYX_ERR(0, 297, __pyx_L1_error)) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "hunter/_predicates.pyx":301 + * if not value_from_event < ( entry).value: + * return False + * for key, entry in self.query_lte: # <<<<<<<<<<<<<< + * value_from_event = ( entry).getter(event) + * if not value_from_event <= ( entry).value: +*/ + __Pyx_TraceLine(301,189,0,__PYX_ERR(0, 301, __pyx_L1_error)) + if (unlikely(__pyx_v_self->query_lte == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 301, __pyx_L1_error) + } + __pyx_t_1 = __pyx_v_self->query_lte; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 301, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2)); + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); + #endif + ++__pyx_t_2; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { + PyObject* sequence = __pyx_t_3; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 301, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_5); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_4); + } else { + __pyx_t_5 = __Pyx_PyList_GetItemRef(sequence, 0); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 301, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PyList_GetItemRef(sequence, 1); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 301, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_4); + } + #else + __pyx_t_5 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); + index = 0; __pyx_t_5 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L59_unpacking_failed; + __Pyx_GOTREF(__pyx_t_5); + index = 1; __pyx_t_4 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_4)) goto __pyx_L59_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 2) < 0) __PYX_ERR(0, 301, __pyx_L1_error) + __pyx_t_7 = NULL; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L60_unpacking_done; + __pyx_L59_unpacking_failed:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_7 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 301, __pyx_L1_error) + __pyx_L60_unpacking_done:; + } + __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_5); + __pyx_t_5 = 0; + __Pyx_XDECREF_SET(__pyx_v_entry, __pyx_t_4); + __pyx_t_4 = 0; + __Pyx_TraceLine(301,185,0,__PYX_ERR(0, 301, __pyx_L1_error)) + + /* "hunter/_predicates.pyx":302 + * return False + * for key, entry in self.query_lte: + * value_from_event = ( entry).getter(event) # <<<<<<<<<<<<<< + * if not value_from_event <= ( entry).value: + * return False +*/ + __Pyx_TraceLine(302,194,0,__PYX_ERR(0, 302, __pyx_L1_error)) + __pyx_t_3 = ((struct __pyx_obj_6hunter_11_predicates_QueryEntry *)__pyx_v_entry)->getter(__pyx_v_event); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 302, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_value_from_event, __pyx_t_3); + __pyx_t_3 = 0; + + /* "hunter/_predicates.pyx":303 + * for key, entry in self.query_lte: + * value_from_event = ( entry).getter(event) + * if not value_from_event <= ( entry).value: # <<<<<<<<<<<<<< + * return False * - * def __invert__(self): - * return Not(self) # <<<<<<<<<<<<<< +*/ + __Pyx_TraceLine(303,202,0,__PYX_ERR(0, 303, __pyx_L1_error)) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_value_from_event, ((struct __pyx_obj_6hunter_11_predicates_QueryEntry *)__pyx_v_entry)->value, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 303, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 303, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_9 = (!__pyx_t_8); + if (__pyx_t_9) { + + /* "hunter/_predicates.pyx":304 + * value_from_event = ( entry).getter(event) + * if not value_from_event <= ( entry).value: + * return False # <<<<<<<<<<<<<< * - * cdef inline fast_When_call(When self, Event event): - */ - __Pyx_TraceLine(305,0,__PYX_ERR(0, 305, __pyx_L1_error)) + * return True +*/ + __Pyx_TraceLine(304,203,0,__PYX_ERR(0, 304, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + __Pyx_TraceReturnValue(__pyx_r, 203, 0, __PYX_ERR(0, 304, __pyx_L1_error)); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + + /* "hunter/_predicates.pyx":303 + * for key, entry in self.query_lte: + * value_from_event = ( entry).getter(event) + * if not value_from_event <= ( entry).value: # <<<<<<<<<<<<<< + * return False + * +*/ + } + + /* "hunter/_predicates.pyx":301 + * if not value_from_event < ( entry).value: + * return False + * for key, entry in self.query_lte: # <<<<<<<<<<<<<< + * value_from_event = ( entry).getter(event) + * if not value_from_event <= ( entry).value: +*/ + __Pyx_TraceLine(301,185,0,__PYX_ERR(0, 301, __pyx_L1_error)) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "hunter/_predicates.pyx":306 + * return False + * + * return True # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_TraceLine(306,205,0,__PYX_ERR(0, 306, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_6hunter_11_predicates_Not), ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 305, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; + __Pyx_INCREF(Py_True); + __pyx_r = Py_True; + __Pyx_TraceReturnValue(__pyx_r, 205, 0, __PYX_ERR(0, 306, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_predicates.pyx":304 - * return And(self, other) - * - * def __invert__(self): # <<<<<<<<<<<<<< + /* "hunter/_predicates.pyx":264 * return Not(self) * - */ + * cdef inline fast_Query_call(Query self, Event event): # <<<<<<<<<<<<<< + * for key, entry in self.query_eq: + * value_from_event = ( entry).getter(event) +*/ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.When.__invert__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 264, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.fast_Query_call", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; + __Pyx_XDECREF(__pyx_v_key); + __Pyx_XDECREF(__pyx_v_entry); + __Pyx_XDECREF(__pyx_v_value_from_event); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pxd":39 - * cdef class When: - * cdef: - * readonly object condition # <<<<<<<<<<<<<< - * readonly tuple actions +/* "hunter/_predicates.pyx":317 + * """ * - */ + * def __init__(self, condition, *actions): # <<<<<<<<<<<<<< + * if not actions: + * raise TypeError('Must give at least one action.') +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_4When_9condition_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_4When_9condition_1__get__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_4When_9condition___get__(((struct __pyx_obj_6hunter_11_predicates_When *)__pyx_v_self)); +static int __pyx_pw_6hunter_11_predicates_4When_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_6hunter_11_predicates_4When_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_condition = 0; + PyObject *__pyx_v_actions = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_v_actions = __Pyx_ArgsSlice_VARARGS(__pyx_args, 1, __pyx_nargs); + if (unlikely(!__pyx_v_actions)) { + __Pyx_RefNannyFinishContext(); + return -1; + } + __Pyx_GOTREF(__pyx_v_actions); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_condition,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 317, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + default: + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 317, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + const Py_ssize_t used_pos_args = (kwd_pos_args < 1) ? kwd_pos_args : 1; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, used_pos_args, __pyx_kwds_len, "__init__", 0) < 0) __PYX_ERR(0, 317, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 1, i); __PYX_ERR(0, 317, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs < 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 317, __pyx_L3_error) + } + __pyx_v_condition = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 1, __pyx_nargs); __PYX_ERR(0, 317, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_actions); __pyx_v_actions = 0; + __Pyx_AddTraceback("hunter._predicates.When.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6hunter_11_predicates_4When___init__(((struct __pyx_obj_6hunter_11_predicates_When *)__pyx_v_self), __pyx_v_condition, __pyx_v_actions); /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_actions); __Pyx_RefNannyFinishContext(); return __pyx_r; } +static PyObject *__pyx_gb_6hunter_11_predicates_4When_8__init___2generator1(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_4When_9condition___get__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self) { +/* "hunter/_predicates.pyx":322 + * self.condition = condition + * self.actions = tuple( + * action() if isclass(action) and issubclass(action, Action) else action # <<<<<<<<<<<<<< + * for action in actions) + * +*/ + +static PyObject *__pyx_pf_6hunter_11_predicates_4When_8__init___genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0) { + struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr *__pyx_cur_scope; PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 39, 0, __PYX_ERR(1, 39, __pyx_L1_error)); - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->condition); - __pyx_r = __pyx_v_self->condition; - goto __pyx_L0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("genexpr", 0); + __pyx_cur_scope = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr *)__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_2_genexpr(__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_2_genexpr, __pyx_mstate_global->__pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(0, 322, __pyx_L1_error) + } else { + __Pyx_GOTREF((PyObject *)__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_genexpr_arg_0 = __pyx_genexpr_arg_0; + __Pyx_INCREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + { + __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_6hunter_11_predicates_4When_8__init___2generator1, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[46]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_genexpr, __pyx_mstate_global->__pyx_n_u_init___locals_genexpr, __pyx_mstate_global->__pyx_n_u_hunter__predicates); if (unlikely(!gen)) __PYX_ERR(0, 322, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } /* function exit code */ __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.When.condition.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("hunter._predicates.When.__init__.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; - __pyx_L0:; + __Pyx_DECREF((PyObject *)__pyx_cur_scope); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pxd":40 - * cdef: - * readonly object condition - * readonly tuple actions # <<<<<<<<<<<<<< +static PyObject *__pyx_gb_6hunter_11_predicates_4When_8__init___2generator1(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr *__pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsGen + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + size_t __pyx_t_8; + int __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("genexpr", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + case 1: goto __pyx_L8_resume_from_yield; + default: /* CPython raises the right error here */ + __Pyx_TraceStartGen("genexpr", __pyx_f[0], 322, 0, 0, 0, __PYX_ERR(0, 322, __pyx_L1_error)); + __Pyx_TraceReturnValue(Py_None, 0, 0, __PYX_ERR(0, 322, __pyx_L1_error)); + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + __Pyx_TraceStartGen("genexpr", __pyx_f[0], 322, 0, 0, 0, __PYX_ERR(0, 322, __pyx_L1_error)); + if (unlikely(__pyx_sent_value != Py_None)) { + if (unlikely(__pyx_sent_value)) PyErr_SetString(PyExc_TypeError, "can't send non-None value to a just-started generator"); + __PYX_ERR(0, 322, __pyx_L1_error) + } + + /* "hunter/_predicates.pyx":323 + * self.actions = tuple( + * action() if isclass(action) and issubclass(action, Action) else action + * for action in actions) # <<<<<<<<<<<<<< * - * @cython.final - */ + * def __str__(self): +*/ + __Pyx_TraceLine(323,0,0,__PYX_ERR(0, 323, __pyx_L1_error)) + if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(0, 323, __pyx_L1_error) } + __pyx_t_1 = __pyx_cur_scope->__pyx_genexpr_arg_0; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 323, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2)); + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); + #endif + ++__pyx_t_2; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 323, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_action); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_action, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; + __Pyx_TraceLine(323,0,0,__PYX_ERR(0, 323, __pyx_L1_error)) -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_4When_7actions_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_4When_7actions_1__get__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_4When_7actions___get__(((struct __pyx_obj_6hunter_11_predicates_When *)__pyx_v_self)); + /* "hunter/_predicates.pyx":322 + * self.condition = condition + * self.actions = tuple( + * action() if isclass(action) and issubclass(action, Action) else action # <<<<<<<<<<<<<< + * for action in actions) + * +*/ + __Pyx_TraceLine(322,0,0,__PYX_ERR(0, 322, __pyx_L1_error)) + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_isclass); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_7, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_cur_scope->__pyx_v_action}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(0, 322, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (__pyx_t_9) { + } else { + __pyx_t_4 = __pyx_t_9; + goto __pyx_L6_bool_binop_done; + } + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_Action); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_9 = PyObject_IsSubclass(__pyx_cur_scope->__pyx_v_action, __pyx_t_5); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(0, 322, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_4 = __pyx_t_9; + __pyx_L6_bool_binop_done:; + if (__pyx_t_4) { + __pyx_t_7 = NULL; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_action); + __pyx_t_6 = __pyx_cur_scope->__pyx_v_action; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_7); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_8, (1-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + __pyx_t_3 = __pyx_t_5; + __pyx_t_5 = 0; + } else { + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_action); + __pyx_t_3 = __pyx_cur_scope->__pyx_v_action; + } + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + __Pyx_XGIVEREF(__pyx_t_1); + __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; + __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; + __Pyx_TraceYield(__pyx_r, 0, __PYX_ERR(0, 322, __pyx_L1_error)); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 1; + return __pyx_r; + __pyx_L8_resume_from_yield:; + __Pyx_TraceResumeGen("genexpr", __pyx_f[0], 322, 0, __PYX_ERR(0, 322, __pyx_L1_error)); + __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; + __pyx_cur_scope->__pyx_t_0 = 0; + __Pyx_XGOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 322, __pyx_L1_error) - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":323 + * self.actions = tuple( + * action() if isclass(action) and issubclass(action, Action) else action + * for action in actions) # <<<<<<<<<<<<<< + * + * def __str__(self): +*/ + __Pyx_TraceLine(323,0,0,__PYX_ERR(0, 323, __pyx_L1_error)) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + __Pyx_TraceReturnValue(Py_None, 0, 0, __PYX_ERR(0, 322, __pyx_L1_error)); -static PyObject *__pyx_pf_6hunter_11_predicates_4When_7actions___get__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 40, 0, __PYX_ERR(1, 40, __pyx_L1_error)); - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->actions); - __pyx_r = __pyx_v_self->actions; - goto __pyx_L0; + /* "hunter/_predicates.pyx":322 + * self.condition = condition + * self.actions = tuple( + * action() if isclass(action) and issubclass(action, Action) else action # <<<<<<<<<<<<<< + * for action in actions) + * +*/ /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.When.actions.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + if (__Pyx_PyErr_Occurred()) { + __Pyx_TraceException(__pyx_lineno, 0, 0); + __Pyx_Generator_Replace_StopIteration(0); + __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceExceptionUnwind(0, 0); + } __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); + #if !CYTHON_USE_EXC_INFO_STACK + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + #endif + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_4When_19__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_4When_19__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_4When_18__reduce_cython__(((struct __pyx_obj_6hunter_11_predicates_When *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} +/* "hunter/_predicates.pyx":317 + * """ + * + * def __init__(self, condition, *actions): # <<<<<<<<<<<<<< + * if not actions: + * raise TypeError('Must give at least one action.') +*/ -static PyObject *__pyx_pf_6hunter_11_predicates_4When_18__reduce_cython__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self) { - PyObject *__pyx_v_state = 0; - PyObject *__pyx_v__dict = 0; - int __pyx_v_use_setstate; - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations +static int __pyx_pf_6hunter_11_predicates_4When___init__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self, PyObject *__pyx_v_condition, PyObject *__pyx_v_actions) { + PyObject *__pyx_gb_6hunter_11_predicates_4When_8__init___2generator1 = 0; + int __pyx_r; + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; + int __pyx_t_1; int __pyx_t_2; - int __pyx_t_3; + PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; - int __pyx_t_5; - PyObject *__pyx_t_6 = NULL; - __Pyx_RefNannySetupContext("__reduce_cython__", 0); - __Pyx_TraceCall("__reduce_cython__", __pyx_f[2], 1, 0, __PYX_ERR(2, 1, __pyx_L1_error)); + PyObject *__pyx_t_5 = NULL; + size_t __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[47])) + __Pyx_RefNannySetupContext("__init__", 0); + __Pyx_TraceStartFunc("__init__", __pyx_f[0], 317, 0, 0, 0, __PYX_ERR(0, 317, __pyx_L1_error)); - /* "(tree fragment)":5 - * cdef object _dict - * cdef bint use_setstate - * state = (self.actions, self.condition) # <<<<<<<<<<<<<< - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: - */ - __Pyx_TraceLine(5,0,__PYX_ERR(2, 5, __pyx_L1_error)) - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v_self->actions); - __Pyx_GIVEREF(__pyx_v_self->actions); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->actions); - __Pyx_INCREF(__pyx_v_self->condition); - __Pyx_GIVEREF(__pyx_v_self->condition); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->condition); - __pyx_v_state = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - - /* "(tree fragment)":6 - * cdef bint use_setstate - * state = (self.actions, self.condition) - * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< - * if _dict is not None: - * state += (_dict,) - */ - __Pyx_TraceLine(6,0,__PYX_ERR(2, 6, __pyx_L1_error)) - __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v__dict = __pyx_t_1; - __pyx_t_1 = 0; - - /* "(tree fragment)":7 - * state = (self.actions, self.condition) - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: # <<<<<<<<<<<<<< - * state += (_dict,) - * use_setstate = True - */ - __Pyx_TraceLine(7,0,__PYX_ERR(2, 7, __pyx_L1_error)) - __pyx_t_2 = (__pyx_v__dict != Py_None); - __pyx_t_3 = (__pyx_t_2 != 0); - if (__pyx_t_3) { - - /* "(tree fragment)":8 - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: - * state += (_dict,) # <<<<<<<<<<<<<< - * use_setstate = True - * else: - */ - __Pyx_TraceLine(8,0,__PYX_ERR(2, 8, __pyx_L1_error)) - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v__dict); - __Pyx_GIVEREF(__pyx_v__dict); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict); - __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4)); - __pyx_t_4 = 0; - - /* "(tree fragment)":9 - * if _dict is not None: - * state += (_dict,) - * use_setstate = True # <<<<<<<<<<<<<< - * else: - * use_setstate = self.actions is not None or self.condition is not None - */ - __Pyx_TraceLine(9,0,__PYX_ERR(2, 9, __pyx_L1_error)) - __pyx_v_use_setstate = 1; - - /* "(tree fragment)":7 - * state = (self.actions, self.condition) - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: # <<<<<<<<<<<<<< - * state += (_dict,) - * use_setstate = True - */ - goto __pyx_L3; - } + /* "hunter/_predicates.pyx":318 + * + * def __init__(self, condition, *actions): + * if not actions: # <<<<<<<<<<<<<< + * raise TypeError('Must give at least one action.') + * self.condition = condition +*/ + __Pyx_TraceLine(318,3,0,__PYX_ERR(0, 318, __pyx_L1_error)) + __pyx_t_1 = (__Pyx_PyTuple_GET_SIZE(__pyx_v_actions) != 0); + if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_1 < 0))) __PYX_ERR(0, 318, __pyx_L1_error) + __pyx_t_2 = (!__pyx_t_1); + if (unlikely(__pyx_t_2)) { - /* "(tree fragment)":11 - * use_setstate = True - * else: - * use_setstate = self.actions is not None or self.condition is not None # <<<<<<<<<<<<<< - * if use_setstate: - * return __pyx_unpickle_When, (type(self), 0xb55b71c, None), state - */ - __Pyx_TraceLine(11,0,__PYX_ERR(2, 11, __pyx_L1_error)) - /*else*/ { - __pyx_t_2 = (__pyx_v_self->actions != ((PyObject*)Py_None)); - __pyx_t_5 = (__pyx_t_2 != 0); - if (!__pyx_t_5) { - } else { - __pyx_t_3 = __pyx_t_5; - goto __pyx_L4_bool_binop_done; + /* "hunter/_predicates.pyx":319 + * def __init__(self, condition, *actions): + * if not actions: + * raise TypeError('Must give at least one action.') # <<<<<<<<<<<<<< + * self.condition = condition + * self.actions = tuple( +*/ + __Pyx_TraceLine(319,6,0,__PYX_ERR(0, 319, __pyx_L1_error)) + __pyx_t_4 = NULL; + __Pyx_INCREF(__pyx_builtin_TypeError); + __pyx_t_5 = __pyx_builtin_TypeError; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_Must_give_at_least_one_action}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 319, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); } - __pyx_t_5 = (__pyx_v_self->condition != Py_None); - __pyx_t_2 = (__pyx_t_5 != 0); - __pyx_t_3 = __pyx_t_2; - __pyx_L4_bool_binop_done:; - __pyx_v_use_setstate = __pyx_t_3; - } - __pyx_L3:; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 319, __pyx_L1_error) - /* "(tree fragment)":12 - * else: - * use_setstate = self.actions is not None or self.condition is not None - * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_When, (type(self), 0xb55b71c, None), state - * else: - */ - __Pyx_TraceLine(12,0,__PYX_ERR(2, 12, __pyx_L1_error)) - __pyx_t_3 = (__pyx_v_use_setstate != 0); - if (__pyx_t_3) { + /* "hunter/_predicates.pyx":318 + * + * def __init__(self, condition, *actions): + * if not actions: # <<<<<<<<<<<<<< + * raise TypeError('Must give at least one action.') + * self.condition = condition +*/ + } - /* "(tree fragment)":13 - * use_setstate = self.actions is not None or self.condition is not None - * if use_setstate: - * return __pyx_unpickle_When, (type(self), 0xb55b71c, None), state # <<<<<<<<<<<<<< - * else: - * return __pyx_unpickle_When, (type(self), 0xb55b71c, state) - */ - __Pyx_TraceLine(13,0,__PYX_ERR(2, 13, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_When); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_INCREF(__pyx_int_190166812); - __Pyx_GIVEREF(__pyx_int_190166812); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_190166812); - __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(Py_None); - PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None); - __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_1); - __Pyx_INCREF(__pyx_v_state); - __Pyx_GIVEREF(__pyx_v_state); - PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_v_state); - __pyx_t_4 = 0; - __pyx_t_1 = 0; - __pyx_r = __pyx_t_6; - __pyx_t_6 = 0; - goto __pyx_L0; + /* "hunter/_predicates.pyx":320 + * if not actions: + * raise TypeError('Must give at least one action.') + * self.condition = condition # <<<<<<<<<<<<<< + * self.actions = tuple( + * action() if isclass(action) and issubclass(action, Action) else action +*/ + __Pyx_TraceLine(320,8,0,__PYX_ERR(0, 320, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_condition); + __Pyx_GIVEREF(__pyx_v_condition); + __Pyx_GOTREF(__pyx_v_self->condition); + __Pyx_DECREF(__pyx_v_self->condition); + __pyx_v_self->condition = __pyx_v_condition; - /* "(tree fragment)":12 - * else: - * use_setstate = self.actions is not None or self.condition is not None - * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_When, (type(self), 0xb55b71c, None), state - * else: - */ - } + /* "hunter/_predicates.pyx":322 + * self.condition = condition + * self.actions = tuple( + * action() if isclass(action) and issubclass(action, Action) else action # <<<<<<<<<<<<<< + * for action in actions) + * +*/ + __Pyx_TraceLine(322,15,0,__PYX_ERR(0, 322, __pyx_L1_error)) + __pyx_t_3 = __pyx_pf_6hunter_11_predicates_4When_8__init___genexpr(NULL, __pyx_v_actions); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); - /* "(tree fragment)":15 - * return __pyx_unpickle_When, (type(self), 0xb55b71c, None), state - * else: - * return __pyx_unpickle_When, (type(self), 0xb55b71c, state) # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_When__set_state(self, __pyx_state) - */ - __Pyx_TraceLine(15,0,__PYX_ERR(2, 15, __pyx_L1_error)) - /*else*/ { - __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_pyx_unpickle_When); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_INCREF(__pyx_int_190166812); - __Pyx_GIVEREF(__pyx_int_190166812); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_190166812); - __Pyx_INCREF(__pyx_v_state); - __Pyx_GIVEREF(__pyx_v_state); - PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state); - __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1); - __pyx_t_6 = 0; - __pyx_t_1 = 0; - __pyx_r = __pyx_t_4; - __pyx_t_4 = 0; - goto __pyx_L0; - } + /* "hunter/_predicates.pyx":321 + * raise TypeError('Must give at least one action.') + * self.condition = condition + * self.actions = tuple( # <<<<<<<<<<<<<< + * action() if isclass(action) and issubclass(action, Action) else action + * for action in actions) +*/ + __Pyx_TraceLine(321,14,0,__PYX_ERR(0, 321, __pyx_L1_error)) + __pyx_t_5 = __Pyx_PySequence_Tuple(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 321, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GIVEREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_v_self->actions); + __Pyx_DECREF(__pyx_v_self->actions); + __pyx_v_self->actions = ((PyObject*)__pyx_t_5); + __pyx_t_5 = 0; - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict - */ + /* "hunter/_predicates.pyx":317 + * """ + * + * def __init__(self, condition, *actions): # <<<<<<<<<<<<<< + * if not actions: + * raise TypeError('Must give at least one action.') +*/ /* function exit code */ + __pyx_r = 0; + __Pyx_TraceReturnCValue(__pyx_r, __Pyx_Owned_Py_None, 0, 0, __PYX_ERR(0, 317, __pyx_L1_error)); + goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_AddTraceback("hunter._predicates.When.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 317, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.When.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; __pyx_L0:; - __Pyx_XDECREF(__pyx_v_state); - __Pyx_XDECREF(__pyx_v__dict); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_XDECREF(__pyx_gb_6hunter_11_predicates_4When_8__init___2generator1); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "(tree fragment)":16 - * else: - * return __pyx_unpickle_When, (type(self), 0xb55b71c, state) - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle_When__set_state(self, __pyx_state) - */ +/* "hunter/_predicates.pyx":325 + * for action in actions) + * + * def __str__(self): # <<<<<<<<<<<<<< + * return 'When(%s, %s)' % ( + * self.condition, +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_4When_21__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_4When_21__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_6hunter_11_predicates_4When_3__str__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_4When_3__str__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_4When_20__setstate_cython__(((struct __pyx_obj_6hunter_11_predicates_When *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_4When_2__str__(((struct __pyx_obj_6hunter_11_predicates_When *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } +static PyObject *__pyx_gb_6hunter_11_predicates_4When_7__str___2generator2(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ + +/* "hunter/_predicates.pyx":328 + * return 'When(%s, %s)' % ( + * self.condition, + * ', '.join(repr(p) for p in self.actions) # <<<<<<<<<<<<<< + * ) + * +*/ -static PyObject *__pyx_pf_6hunter_11_predicates_4When_20__setstate_cython__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pf_6hunter_11_predicates_4When_7__str___genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0) { + struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3_genexpr *__pyx_cur_scope; PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__setstate_cython__", 0); - __Pyx_TraceCall("__setstate_cython__", __pyx_f[2], 16, 0, __PYX_ERR(2, 16, __pyx_L1_error)); - - /* "(tree fragment)":17 - * return __pyx_unpickle_When, (type(self), 0xb55b71c, state) - * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_When__set_state(self, __pyx_state) # <<<<<<<<<<<<<< - */ - __Pyx_TraceLine(17,0,__PYX_ERR(2, 17, __pyx_L1_error)) - if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(2, 17, __pyx_L1_error) - __pyx_t_1 = __pyx_f_6hunter_11_predicates___pyx_unpickle_When__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 17, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "(tree fragment)":16 - * else: - * return __pyx_unpickle_When, (type(self), 0xb55b71c, state) - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle_When__set_state(self, __pyx_state) - */ + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("genexpr", 0); + __pyx_cur_scope = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3_genexpr *)__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_3_genexpr(__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_3_genexpr, __pyx_mstate_global->__pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3_genexpr *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(0, 328, __pyx_L1_error) + } else { + __Pyx_GOTREF((PyObject *)__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_genexpr_arg_0 = __pyx_genexpr_arg_0; + __Pyx_INCREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + { + __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_6hunter_11_predicates_4When_7__str___2generator2, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[48]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_genexpr, __pyx_mstate_global->__pyx_n_u_str___locals_genexpr, __pyx_mstate_global->__pyx_n_u_hunter__predicates); if (unlikely(!gen)) __PYX_ERR(0, 328, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.When.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("hunter._predicates.When.__str__.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; - __pyx_L0:; + __Pyx_DECREF((PyObject *)__pyx_cur_scope); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":307 - * return Not(self) - * - * cdef inline fast_When_call(When self, Event event): # <<<<<<<<<<<<<< - * cdef object result - * - */ +static PyObject *__pyx_gb_6hunter_11_predicates_4When_7__str___2generator2(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3_genexpr *__pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3_genexpr *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsGen + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("genexpr", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + default: /* CPython raises the right error here */ + __Pyx_TraceStartGen("genexpr", __pyx_f[0], 328, 0, 0, 0, __PYX_ERR(0, 328, __pyx_L1_error)); + __Pyx_TraceReturnValue(Py_None, 0, 0, __PYX_ERR(0, 328, __pyx_L1_error)); + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + __Pyx_TraceStartGen("genexpr", __pyx_f[0], 328, 0, 0, 0, __PYX_ERR(0, 328, __pyx_L1_error)); + if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 328, __pyx_L1_error) + __pyx_r = PyList_New(0); if (unlikely(!__pyx_r)) __PYX_ERR(0, 328, __pyx_L1_error) + __Pyx_GOTREF(__pyx_r); + if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(0, 328, __pyx_L1_error) } + if (unlikely(__pyx_cur_scope->__pyx_genexpr_arg_0 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 328, __pyx_L1_error) + } + __pyx_t_1 = __pyx_cur_scope->__pyx_genexpr_arg_0; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 328, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2)); + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); + #endif + ++__pyx_t_2; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 328, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_p); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_p, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; + __Pyx_TraceLine(328,0,0,__PYX_ERR(0, 328, __pyx_L1_error)) + __pyx_t_3 = PyObject_Repr(__pyx_cur_scope->__pyx_v_p); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 328, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (unlikely(__Pyx_ListComp_Append(__pyx_r, (PyObject*)__pyx_t_3))) __PYX_ERR(0, 328, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + __Pyx_TraceReturnValue(Py_None, 0, 0, __PYX_ERR(0, 328, __pyx_L1_error)); -static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_fast_When_call(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { - PyObject *__pyx_v_result = 0; - PyObject *__pyx_v_action = NULL; + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_r); __pyx_r = 0; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + if (__Pyx_PyErr_Occurred()) { + __Pyx_TraceException(__pyx_lineno, 0, 0); + __Pyx_Generator_Replace_StopIteration(0); + __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceExceptionUnwind(0, 0); + } + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + #if !CYTHON_USE_EXC_INFO_STACK + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + #endif + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/_predicates.pyx":325 + * for action in actions) + * + * def __str__(self): # <<<<<<<<<<<<<< + * return 'When(%s, %s)' % ( + * self.condition, +*/ + +static PyObject *__pyx_pf_6hunter_11_predicates_4When_2__str__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self) { + PyObject *__pyx_gb_6hunter_11_predicates_4When_7__str___2generator2 = 0; PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; - int __pyx_t_3; - Py_ssize_t __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - __Pyx_RefNannySetupContext("fast_When_call", 0); - __Pyx_TraceCall("fast_When_call", __pyx_f[0], 307, 0, __PYX_ERR(0, 307, __pyx_L1_error)); + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4[5]; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[49])) + __Pyx_RefNannySetupContext("__str__", 0); + __Pyx_TraceStartFunc("__str__", __pyx_f[0], 325, 0, 0, 0, __PYX_ERR(0, 325, __pyx_L1_error)); - /* "hunter/_predicates.pyx":310 - * cdef object result + /* "hunter/_predicates.pyx":326 * - * result = fast_call(self.condition, event) # <<<<<<<<<<<<<< + * def __str__(self): + * return 'When(%s, %s)' % ( # <<<<<<<<<<<<<< + * self.condition, + * ', '.join(repr(p) for p in self.actions) +*/ + __Pyx_TraceLine(326,1,0,__PYX_ERR(0, 326, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + + /* "hunter/_predicates.pyx":327 + * def __str__(self): + * return 'When(%s, %s)' % ( + * self.condition, # <<<<<<<<<<<<<< + * ', '.join(repr(p) for p in self.actions) + * ) +*/ + __Pyx_TraceLine(327,4,0,__PYX_ERR(0, 327, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_self->condition), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 327, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "hunter/_predicates.pyx":328 + * return 'When(%s, %s)' % ( + * self.condition, + * ', '.join(repr(p) for p in self.actions) # <<<<<<<<<<<<<< + * ) * - * if result: - */ - __Pyx_TraceLine(310,0,__PYX_ERR(0, 310, __pyx_L1_error)) - __pyx_t_1 = __pyx_v_self->condition; - __Pyx_INCREF(__pyx_t_1); - __pyx_t_2 = __pyx_f_6hunter_11_predicates_fast_call(__pyx_t_1, __pyx_v_event); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 310, __pyx_L1_error) +*/ + __Pyx_TraceLine(328,8,0,__PYX_ERR(0, 328, __pyx_L1_error)) + __pyx_t_2 = __pyx_pf_6hunter_11_predicates_4When_7__str___genexpr(NULL, __pyx_v_self->actions); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 328, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_result = __pyx_t_2; - __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_Generator_GetInlinedResult(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 328, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 328, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4[0] = __pyx_mstate_global->__pyx_kp_u_When; + __pyx_t_4[1] = __pyx_t_1; + __pyx_t_4[2] = __pyx_mstate_global->__pyx_kp_u__4; + __pyx_t_4[3] = __pyx_t_2; + __pyx_t_4[4] = __pyx_mstate_global->__pyx_kp_u__7; - /* "hunter/_predicates.pyx":312 - * result = fast_call(self.condition, event) + /* "hunter/_predicates.pyx":326 * - * if result: # <<<<<<<<<<<<<< - * for action in self.actions: - * action(event) - */ - __Pyx_TraceLine(312,0,__PYX_ERR(0, 312, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_result); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 312, __pyx_L1_error) - if (__pyx_t_3) { + * def __str__(self): + * return 'When(%s, %s)' % ( # <<<<<<<<<<<<<< + * self.condition, + * ', '.join(repr(p) for p in self.actions) +*/ + __Pyx_TraceLine(326,2,0,__PYX_ERR(0, 326, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_4, 5, 5 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1) + 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2)); + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 326, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 326, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":313 - * - * if result: - * for action in self.actions: # <<<<<<<<<<<<<< - * action(event) + /* "hunter/_predicates.pyx":325 + * for action in actions) * - */ - __Pyx_TraceLine(313,0,__PYX_ERR(0, 313, __pyx_L1_error)) - if (unlikely(__pyx_v_self->actions == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(0, 313, __pyx_L1_error) - } - __pyx_t_2 = __pyx_v_self->actions; __Pyx_INCREF(__pyx_t_2); __pyx_t_4 = 0; - for (;;) { - if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_2)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 313, __pyx_L1_error) - #else - __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 313, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - #endif - __Pyx_XDECREF_SET(__pyx_v_action, __pyx_t_1); - __pyx_t_1 = 0; + * def __str__(self): # <<<<<<<<<<<<<< + * return 'When(%s, %s)' % ( + * self.condition, +*/ - /* "hunter/_predicates.pyx":314 - * if result: - * for action in self.actions: - * action(event) # <<<<<<<<<<<<<< - * - * return result - */ - __Pyx_TraceLine(314,0,__PYX_ERR(0, 314, __pyx_L1_error)) - __Pyx_INCREF(__pyx_v_action); - __pyx_t_5 = __pyx_v_action; __pyx_t_6 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_6)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_6); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - } - } - __pyx_t_1 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, ((PyObject *)__pyx_v_event)) : __Pyx_PyObject_CallOneArg(__pyx_t_5, ((PyObject *)__pyx_v_event)); - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 314, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 325, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.When.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_gb_6hunter_11_predicates_4When_7__str___2generator2); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":313 +/* "hunter/_predicates.pyx":331 + * ) * - * if result: - * for action in self.actions: # <<<<<<<<<<<<<< - * action(event) + * def __repr__(self): # <<<<<<<<<<<<<< + * return '' % (self.condition, self.actions) * - */ - __Pyx_TraceLine(313,0,__PYX_ERR(0, 313, __pyx_L1_error)) - } - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; +*/ - /* "hunter/_predicates.pyx":312 - * result = fast_call(self.condition, event) - * - * if result: # <<<<<<<<<<<<<< - * for action in self.actions: - * action(event) - */ - } +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_4When_5__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_4When_5__repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_4When_4__repr__(((struct __pyx_obj_6hunter_11_predicates_When *)__pyx_v_self)); - /* "hunter/_predicates.pyx":316 - * action(event) - * - * return result # <<<<<<<<<<<<<< + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_11_predicates_4When_4__repr__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3[5]; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[50])) + __Pyx_RefNannySetupContext("__repr__", 0); + __Pyx_TraceStartFunc("__repr__", __pyx_f[0], 331, 0, 0, 0, __PYX_ERR(0, 331, __pyx_L1_error)); + + /* "hunter/_predicates.pyx":332 * + * def __repr__(self): + * return '' % (self.condition, self.actions) # <<<<<<<<<<<<<< * - */ - __Pyx_TraceLine(316,0,__PYX_ERR(0, 316, __pyx_L1_error)) + * def __eq__(self, other): +*/ + __Pyx_TraceLine(332,1,0,__PYX_ERR(0, 332, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_result); - __pyx_r = __pyx_v_result; + __pyx_t_1 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_self->condition), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 332, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_self->actions), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 332, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3[0] = __pyx_mstate_global->__pyx_kp_u_hunter__predicates_When_conditi; + __pyx_t_3[1] = __pyx_t_1; + __pyx_t_3[2] = __pyx_mstate_global->__pyx_kp_u_actions; + __pyx_t_3[3] = __pyx_t_2; + __pyx_t_3[4] = __pyx_mstate_global->__pyx_kp_u__8; + __pyx_t_4 = __Pyx_PyUnicode_Join(__pyx_t_3, 5, 36 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1) + 10 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2)); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 332, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 332, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_predicates.pyx":307 - * return Not(self) + /* "hunter/_predicates.pyx":331 + * ) * - * cdef inline fast_When_call(When self, Event event): # <<<<<<<<<<<<<< - * cdef object result + * def __repr__(self): # <<<<<<<<<<<<<< + * return '' % (self.condition, self.actions) * - */ +*/ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_AddTraceback("hunter._predicates.fast_When_call", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 331, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.When.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF(__pyx_v_result); - __Pyx_XDECREF(__pyx_v_action); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":325 - * """ +/* "hunter/_predicates.pyx":334 + * return '' % (self.condition, self.actions) * - * def __init__(self, condition, predicate=None, watermark=0): # <<<<<<<<<<<<<< - * self.condition = condition - * self.predicate = predicate - */ + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return ( + * isinstance(other, When) +*/ /* Python wrapper */ -static int __pyx_pw_6hunter_11_predicates_4From_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static int __pyx_pw_6hunter_11_predicates_4From_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v_condition = 0; - PyObject *__pyx_v_predicate = 0; - PyObject *__pyx_v_watermark = 0; - int __pyx_r; +static PyObject *__pyx_pw_6hunter_11_predicates_4When_7__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_4When_7__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); - { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_condition,&__pyx_n_s_predicate,&__pyx_n_s_watermark,0}; - PyObject* values[3] = {0,0,0}; - values[1] = ((PyObject *)Py_None); - values[2] = ((PyObject *)__pyx_int_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 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_condition)) != 0)) kw_args--; - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_predicate); - if (value) { values[1] = value; kw_args--; } - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_watermark); - if (value) { values[2] = value; kw_args--; } - } - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 325, __pyx_L3_error) - } - } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - 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); - break; - default: goto __pyx_L5_argtuple_error; - } - } - __pyx_v_condition = values[0]; - __pyx_v_predicate = values[1]; - __pyx_v_watermark = values[2]; - } - goto __pyx_L4_argument_unpacking_done; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 325, __pyx_L3_error) - __pyx_L3_error:; - __Pyx_AddTraceback("hunter._predicates.From.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return -1; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6hunter_11_predicates_4From___init__(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_self), __pyx_v_condition, __pyx_v_predicate, __pyx_v_watermark); + __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_4When_6__eq__(((struct __pyx_obj_6hunter_11_predicates_When *)__pyx_v_self), ((PyObject *)__pyx_v_other)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static int __pyx_pf_6hunter_11_predicates_4From___init__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self, PyObject *__pyx_v_condition, PyObject *__pyx_v_predicate, PyObject *__pyx_v_watermark) { - int __pyx_r; - __Pyx_TraceDeclarations +static PyObject *__pyx_pf_6hunter_11_predicates_4When_6__eq__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - int __pyx_t_1; - __Pyx_RefNannySetupContext("__init__", 0); - __Pyx_TraceCall("__init__", __pyx_f[0], 325, 0, __PYX_ERR(0, 325, __pyx_L1_error)); + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[51])) + __Pyx_RefNannySetupContext("__eq__", 0); + __Pyx_TraceStartFunc("__eq__", __pyx_f[0], 334, 0, 0, 0, __PYX_ERR(0, 334, __pyx_L1_error)); - /* "hunter/_predicates.pyx":326 + /* "hunter/_predicates.pyx":335 * - * def __init__(self, condition, predicate=None, watermark=0): - * self.condition = condition # <<<<<<<<<<<<<< - * self.predicate = predicate - * self.watermark = watermark - */ - __Pyx_TraceLine(326,0,__PYX_ERR(0, 326, __pyx_L1_error)) - __Pyx_INCREF(__pyx_v_condition); - __Pyx_GIVEREF(__pyx_v_condition); - __Pyx_GOTREF(__pyx_v_self->condition); - __Pyx_DECREF(__pyx_v_self->condition); - __pyx_v_self->condition = __pyx_v_condition; - - /* "hunter/_predicates.pyx":327 - * def __init__(self, condition, predicate=None, watermark=0): - * self.condition = condition - * self.predicate = predicate # <<<<<<<<<<<<<< - * self.watermark = watermark - * self.origin_depth = -1 - */ - __Pyx_TraceLine(327,0,__PYX_ERR(0, 327, __pyx_L1_error)) - __Pyx_INCREF(__pyx_v_predicate); - __Pyx_GIVEREF(__pyx_v_predicate); - __Pyx_GOTREF(__pyx_v_self->predicate); - __Pyx_DECREF(__pyx_v_self->predicate); - __pyx_v_self->predicate = __pyx_v_predicate; + * def __eq__(self, other): + * return ( # <<<<<<<<<<<<<< + * isinstance(other, When) + * and self.condition == ( other).condition +*/ + __Pyx_TraceLine(335,1,0,__PYX_ERR(0, 335, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); - /* "hunter/_predicates.pyx":328 - * self.condition = condition - * self.predicate = predicate - * self.watermark = watermark # <<<<<<<<<<<<<< - * self.origin_depth = -1 - * self.origin_calls = -1 - */ - __Pyx_TraceLine(328,0,__PYX_ERR(0, 328, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_watermark); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 328, __pyx_L1_error) - __pyx_v_self->watermark = __pyx_t_1; + /* "hunter/_predicates.pyx":336 + * def __eq__(self, other): + * return ( + * isinstance(other, When) # <<<<<<<<<<<<<< + * and self.condition == ( other).condition + * and self.actions == ( other).actions +*/ + __Pyx_TraceLine(336,5,0,__PYX_ERR(0, 336, __pyx_L1_error)) + __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_other, __pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_When); + if (__pyx_t_2) { + } else { + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 336, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L3_bool_binop_done; + } - /* "hunter/_predicates.pyx":329 - * self.predicate = predicate - * self.watermark = watermark - * self.origin_depth = -1 # <<<<<<<<<<<<<< - * self.origin_calls = -1 - * - */ - __Pyx_TraceLine(329,0,__PYX_ERR(0, 329, __pyx_L1_error)) - __pyx_v_self->origin_depth = -1; + /* "hunter/_predicates.pyx":337 + * return ( + * isinstance(other, When) + * and self.condition == ( other).condition # <<<<<<<<<<<<<< + * and self.actions == ( other).actions + * ) +*/ + __Pyx_TraceLine(337,12,0,__PYX_ERR(0, 337, __pyx_L1_error)) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->condition, ((struct __pyx_obj_6hunter_11_predicates_When *)__pyx_v_other)->condition, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 337, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 337, __pyx_L1_error) + if (__pyx_t_2) { + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __Pyx_INCREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L3_bool_binop_done; + } - /* "hunter/_predicates.pyx":330 - * self.watermark = watermark - * self.origin_depth = -1 - * self.origin_calls = -1 # <<<<<<<<<<<<<< + /* "hunter/_predicates.pyx":338 + * isinstance(other, When) + * and self.condition == ( other).condition + * and self.actions == ( other).actions # <<<<<<<<<<<<<< + * ) * - * def __str__(self): - */ - __Pyx_TraceLine(330,0,__PYX_ERR(0, 330, __pyx_L1_error)) - __pyx_v_self->origin_calls = -1; +*/ + __Pyx_TraceLine(338,19,0,__PYX_ERR(0, 338, __pyx_L1_error)) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->actions, ((struct __pyx_obj_6hunter_11_predicates_When *)__pyx_v_other)->actions, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 338, __pyx_L1_error) + __Pyx_INCREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_L3_bool_binop_done:; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 335, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":325 - * """ + /* "hunter/_predicates.pyx":334 + * return '' % (self.condition, self.actions) * - * def __init__(self, condition, predicate=None, watermark=0): # <<<<<<<<<<<<<< - * self.condition = condition - * self.predicate = predicate - */ + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return ( + * isinstance(other, When) +*/ /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.From.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 334, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.When.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; __pyx_L0:; - __Pyx_TraceReturn(Py_None, 0); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":332 - * self.origin_calls = -1 +/* "hunter/_predicates.pyx":341 + * ) * - * def __str__(self): # <<<<<<<<<<<<<< - * return 'From(%s, %s, watermark=%s)' % ( - * self.condition, self.predicate, self.watermark - */ + * def __call__(self, Event event): # <<<<<<<<<<<<<< + * return fast_When_call(self, event) + * +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_4From_3__str__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_4From_3__str__(PyObject *__pyx_v_self) { +static PyObject *__pyx_pw_6hunter_11_predicates_4When_9__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_4When_9__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_4From_2__str__(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__call__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_event,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 341, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 341, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__call__", 0) < 0) __PYX_ERR(0, 341, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__call__", 1, 1, 1, i); __PYX_ERR(0, 341, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 341, __pyx_L3_error) + } + __pyx_v_event = ((struct __pyx_obj_6hunter_6_event_Event *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__call__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 341, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("hunter._predicates.When.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_event), __pyx_mstate_global->__pyx_ptype_6hunter_6_event_Event, 1, "event", 0))) __PYX_ERR(0, 341, __pyx_L1_error) + __pyx_r = __pyx_pf_6hunter_11_predicates_4When_8__call__(((struct __pyx_obj_6hunter_11_predicates_When *)__pyx_v_self), __pyx_v_event); /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_4From_2__str__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self) { +static PyObject *__pyx_pf_6hunter_11_predicates_4When_8__call__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - __Pyx_RefNannySetupContext("__str__", 0); - __Pyx_TraceCall("__str__", __pyx_f[0], 332, 0, __PYX_ERR(0, 332, __pyx_L1_error)); - - /* "hunter/_predicates.pyx":333 - * - * def __str__(self): - * return 'From(%s, %s, watermark=%s)' % ( # <<<<<<<<<<<<<< - * self.condition, self.predicate, self.watermark - * ) - */ - __Pyx_TraceLine(333,0,__PYX_ERR(0, 333, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[52])) + __Pyx_RefNannySetupContext("__call__", 0); + __Pyx_TraceStartFunc("__call__", __pyx_f[0], 341, 0, 0, 0, __PYX_ERR(0, 341, __pyx_L1_error)); - /* "hunter/_predicates.pyx":334 - * def __str__(self): - * return 'From(%s, %s, watermark=%s)' % ( - * self.condition, self.predicate, self.watermark # <<<<<<<<<<<<<< - * ) + /* "hunter/_predicates.pyx":342 * - */ - __Pyx_TraceLine(334,0,__PYX_ERR(0, 334, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->watermark); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 334, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 334, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_v_self->condition); - __Pyx_GIVEREF(__pyx_v_self->condition); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_self->condition); - __Pyx_INCREF(__pyx_v_self->predicate); - __Pyx_GIVEREF(__pyx_v_self->predicate); - PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_self->predicate); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_1); - __pyx_t_1 = 0; - - /* "hunter/_predicates.pyx":333 + * def __call__(self, Event event): + * return fast_When_call(self, event) # <<<<<<<<<<<<<< * - * def __str__(self): - * return 'From(%s, %s, watermark=%s)' % ( # <<<<<<<<<<<<<< - * self.condition, self.predicate, self.watermark - * ) - */ - __Pyx_TraceLine(333,0,__PYX_ERR(0, 333, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_From_s_s_watermark_s, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 333, __pyx_L1_error) + * def __or__(self, other): +*/ + __Pyx_TraceLine(342,1,0,__PYX_ERR(0, 342, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6hunter_11_predicates_fast_When_call(__pyx_v_self, __pyx_v_event); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 342, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 342, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_predicates.pyx":332 - * self.origin_calls = -1 + /* "hunter/_predicates.pyx":341 + * ) * - * def __str__(self): # <<<<<<<<<<<<<< - * return 'From(%s, %s, watermark=%s)' % ( - * self.condition, self.predicate, self.watermark - */ + * def __call__(self, Event event): # <<<<<<<<<<<<<< + * return fast_When_call(self, event) + * +*/ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("hunter._predicates.From.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 341, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.When.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":337 - * ) +/* "hunter/_predicates.pyx":344 + * return fast_When_call(self, event) * - * def __repr__(self): # <<<<<<<<<<<<<< - * return '' % ( - * self.condition, self.predicate, self.watermark - */ + * def __or__(self, other): # <<<<<<<<<<<<<< + * return Or(self, other) + * +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_4From_5__repr__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_4From_5__repr__(PyObject *__pyx_v_self) { +static PyObject *__pyx_pw_6hunter_11_predicates_4When_11__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_4When_11__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_4From_4__repr__(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__or__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_4When_10__or__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_4From_4__repr__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self) { +static PyObject *__pyx_pf_6hunter_11_predicates_4When_10__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; - __Pyx_RefNannySetupContext("__repr__", 0); - __Pyx_TraceCall("__repr__", __pyx_f[0], 337, 0, __PYX_ERR(0, 337, __pyx_L1_error)); - - /* "hunter/_predicates.pyx":338 - * - * def __repr__(self): - * return '' % ( # <<<<<<<<<<<<<< - * self.condition, self.predicate, self.watermark - * ) - */ - __Pyx_TraceLine(338,0,__PYX_ERR(0, 338, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[53])) + __Pyx_RefNannySetupContext("__or__", 0); + __Pyx_TraceStartFunc("__or__", __pyx_f[0], 344, 0, 0, 0, __PYX_ERR(0, 344, __pyx_L1_error)); - /* "hunter/_predicates.pyx":339 - * def __repr__(self): - * return '' % ( - * self.condition, self.predicate, self.watermark # <<<<<<<<<<<<<< - * ) + /* "hunter/_predicates.pyx":345 * - */ - __Pyx_TraceLine(339,0,__PYX_ERR(0, 339, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->watermark); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 339, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 339, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_v_self->condition); - __Pyx_GIVEREF(__pyx_v_self->condition); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_self->condition); - __Pyx_INCREF(__pyx_v_self->predicate); - __Pyx_GIVEREF(__pyx_v_self->predicate); - PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_self->predicate); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_1); - __pyx_t_1 = 0; - - /* "hunter/_predicates.pyx":338 + * def __or__(self, other): + * return Or(self, other) # <<<<<<<<<<<<<< * - * def __repr__(self): - * return '' % ( # <<<<<<<<<<<<<< - * self.condition, self.predicate, self.watermark - * ) - */ - __Pyx_TraceLine(338,0,__PYX_ERR(0, 338, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_hunter__predicates_From_conditi, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 338, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_r = __pyx_t_1; + * def __and__(self, other): +*/ + __Pyx_TraceLine(345,1,0,__PYX_ERR(0, 345, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = NULL; + __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Or); + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Or); + __pyx_t_4 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_v_self, __pyx_v_other}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 345, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_1); + } + __pyx_r = ((PyObject *)__pyx_t_1); __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 345, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_predicates.pyx":337 - * ) + /* "hunter/_predicates.pyx":344 + * return fast_When_call(self, event) * - * def __repr__(self): # <<<<<<<<<<<<<< - * return '' % ( - * self.condition, self.predicate, self.watermark - */ + * def __or__(self, other): # <<<<<<<<<<<<<< + * return Or(self, other) + * +*/ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("hunter._predicates.From.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 344, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.When.__or__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":342 - * ) +/* "hunter/_predicates.pyx":347 + * return Or(self, other) * - * def __eq__(self, other): # <<<<<<<<<<<<<< - * return ( - * isinstance(other, From) - */ + * def __and__(self, other): # <<<<<<<<<<<<<< + * return And(self, other) + * +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_4From_7__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_4From_7__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { +static PyObject *__pyx_pw_6hunter_11_predicates_4When_13__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_4When_13__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_4From_6__eq__(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + __Pyx_RefNannySetupContext("__and__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_4When_12__and__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_4From_6__eq__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self, PyObject *__pyx_v_other) { +static PyObject *__pyx_pf_6hunter_11_predicates_4When_12__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - int __pyx_t_2; + PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; - __Pyx_RefNannySetupContext("__eq__", 0); - __Pyx_TraceCall("__eq__", __pyx_f[0], 342, 0, __PYX_ERR(0, 342, __pyx_L1_error)); + size_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[54])) + __Pyx_RefNannySetupContext("__and__", 0); + __Pyx_TraceStartFunc("__and__", __pyx_f[0], 347, 0, 0, 0, __PYX_ERR(0, 347, __pyx_L1_error)); - /* "hunter/_predicates.pyx":343 + /* "hunter/_predicates.pyx":348 * - * def __eq__(self, other): - * return ( # <<<<<<<<<<<<<< - * isinstance(other, From) - * and self.condition == ( other).condition - */ - __Pyx_TraceLine(343,0,__PYX_ERR(0, 343, __pyx_L1_error)) + * def __and__(self, other): + * return And(self, other) # <<<<<<<<<<<<<< + * + * def __invert__(self): +*/ + __Pyx_TraceLine(348,1,0,__PYX_ERR(0, 348, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - - /* "hunter/_predicates.pyx":344 - * def __eq__(self, other): - * return ( - * isinstance(other, From) # <<<<<<<<<<<<<< - * and self.condition == ( other).condition - * and self.predicate == ( other).predicate - */ - __Pyx_TraceLine(344,0,__PYX_ERR(0, 344, __pyx_L1_error)) - __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_other, __pyx_ptype_6hunter_11_predicates_From); - if (__pyx_t_2) { - } else { - __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 344, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __pyx_t_3; - __pyx_t_3 = 0; - goto __pyx_L3_bool_binop_done; - } - - /* "hunter/_predicates.pyx":345 - * return ( - * isinstance(other, From) - * and self.condition == ( other).condition # <<<<<<<<<<<<<< - * and self.predicate == ( other).predicate - * ) - */ - __Pyx_TraceLine(345,0,__PYX_ERR(0, 345, __pyx_L1_error)) - __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->condition, ((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_other)->condition, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 345, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 345, __pyx_L1_error) - if (__pyx_t_2) { - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } else { - __Pyx_INCREF(__pyx_t_3); - __pyx_t_1 = __pyx_t_3; + __pyx_t_2 = NULL; + __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_And); + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_And); + __pyx_t_4 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_v_self, __pyx_v_other}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - goto __pyx_L3_bool_binop_done; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 348, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_1); } - - /* "hunter/_predicates.pyx":346 - * isinstance(other, From) - * and self.condition == ( other).condition - * and self.predicate == ( other).predicate # <<<<<<<<<<<<<< - * ) - * - */ - __Pyx_TraceLine(346,0,__PYX_ERR(0, 346, __pyx_L1_error)) - __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->predicate, ((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_other)->predicate, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 346, __pyx_L1_error) - __Pyx_INCREF(__pyx_t_3); - __pyx_t_1 = __pyx_t_3; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_L3_bool_binop_done:; - __pyx_r = __pyx_t_1; + __pyx_r = ((PyObject *)__pyx_t_1); __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 348, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_predicates.pyx":342 - * ) + /* "hunter/_predicates.pyx":347 + * return Or(self, other) * - * def __eq__(self, other): # <<<<<<<<<<<<<< - * return ( - * isinstance(other, From) - */ + * def __and__(self, other): # <<<<<<<<<<<<<< + * return And(self, other) + * +*/ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("hunter._predicates.From.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 347, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.When.__and__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":349 - * ) +/* "hunter/_predicates.pyx":350 + * return And(self, other) * - * def __hash__(self): # <<<<<<<<<<<<<< - * return hash(('From', self.condition, self.predicate)) + * def __invert__(self): # <<<<<<<<<<<<<< + * return Not(self) * - */ +*/ /* Python wrapper */ -static Py_hash_t __pyx_pw_6hunter_11_predicates_4From_9__hash__(PyObject *__pyx_v_self); /*proto*/ -static Py_hash_t __pyx_pw_6hunter_11_predicates_4From_9__hash__(PyObject *__pyx_v_self) { - Py_hash_t __pyx_r; +static PyObject *__pyx_pw_6hunter_11_predicates_4When_15__invert__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_4When_15__invert__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__hash__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_4From_8__hash__(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__invert__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_4When_14__invert__(((struct __pyx_obj_6hunter_11_predicates_When *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static Py_hash_t __pyx_pf_6hunter_11_predicates_4From_8__hash__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self) { - Py_hash_t __pyx_r; - __Pyx_TraceDeclarations +static PyObject *__pyx_pf_6hunter_11_predicates_4When_14__invert__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - Py_hash_t __pyx_t_2; - __Pyx_RefNannySetupContext("__hash__", 0); - __Pyx_TraceCall("__hash__", __pyx_f[0], 349, 0, __PYX_ERR(0, 349, __pyx_L1_error)); + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[55])) + __Pyx_RefNannySetupContext("__invert__", 0); + __Pyx_TraceStartFunc("__invert__", __pyx_f[0], 350, 0, 0, 0, __PYX_ERR(0, 350, __pyx_L1_error)); - /* "hunter/_predicates.pyx":350 + /* "hunter/_predicates.pyx":351 * - * def __hash__(self): - * return hash(('From', self.condition, self.predicate)) # <<<<<<<<<<<<<< + * def __invert__(self): + * return Not(self) # <<<<<<<<<<<<<< * - * def __call__(self, Event event): - */ - __Pyx_TraceLine(350,0,__PYX_ERR(0, 350, __pyx_L1_error)) - __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 350, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_n_s_From); - __Pyx_GIVEREF(__pyx_n_s_From); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_From); - __Pyx_INCREF(__pyx_v_self->condition); - __Pyx_GIVEREF(__pyx_v_self->condition); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->condition); - __Pyx_INCREF(__pyx_v_self->predicate); - __Pyx_GIVEREF(__pyx_v_self->predicate); - PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_self->predicate); - __pyx_t_2 = PyObject_Hash(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_hash_t)-1))) __PYX_ERR(0, 350, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_2; + * cdef inline fast_When_call(When self, Event event): +*/ + __Pyx_TraceLine(351,1,0,__PYX_ERR(0, 351, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = NULL; + __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Not); + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Not); + __pyx_t_4 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, ((PyObject *)__pyx_v_self)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 351, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_1); + } + __pyx_r = ((PyObject *)__pyx_t_1); + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 351, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_predicates.pyx":349 - * ) + /* "hunter/_predicates.pyx":350 + * return And(self, other) * - * def __hash__(self): # <<<<<<<<<<<<<< - * return hash(('From', self.condition, self.predicate)) + * def __invert__(self): # <<<<<<<<<<<<<< + * return Not(self) * - */ +*/ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.From.__hash__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 350, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.When.__invert__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; __pyx_L0:; - if (unlikely(__pyx_r == -1) && !PyErr_Occurred()) __pyx_r = -2; - __Pyx_TraceReturn(Py_None, 0); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":352 - * return hash(('From', self.condition, self.predicate)) - * - * def __call__(self, Event event): # <<<<<<<<<<<<<< - * return fast_From_call(self, event) +/* "hunter/_predicates.pxd":43 + * cdef class When: + * cdef: + * readonly object condition # <<<<<<<<<<<<<< + * readonly tuple actions * - */ +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_4From_11__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_4From_11__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event = 0; +static PyObject *__pyx_pw_6hunter_11_predicates_4When_9condition_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_4When_9condition_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__call__ (wrapper)", 0); - { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_event,0}; - PyObject* values[1] = {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 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_event)) != 0)) kw_args--; - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__call__") < 0)) __PYX_ERR(0, 352, __pyx_L3_error) - } - } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - } - __pyx_v_event = ((struct __pyx_obj_6hunter_6_event_Event *)values[0]); - } - goto __pyx_L4_argument_unpacking_done; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__call__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 352, __pyx_L3_error) - __pyx_L3_error:; - __Pyx_AddTraceback("hunter._predicates.From.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_event), __pyx_ptype_6hunter_6_event_Event, 1, "event", 0))) __PYX_ERR(0, 352, __pyx_L1_error) - __pyx_r = __pyx_pf_6hunter_11_predicates_4From_10__call__(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_self), __pyx_v_event); + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_4When_9condition___get__(((struct __pyx_obj_6hunter_11_predicates_When *)__pyx_v_self)); /* function exit code */ - goto __pyx_L0; - __pyx_L1_error:; - __pyx_r = NULL; - __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_4From_10__call__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { +static PyObject *__pyx_pf_6hunter_11_predicates_4When_9condition___get__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__call__", 0); - __Pyx_TraceCall("__call__", __pyx_f[0], 352, 0, __PYX_ERR(0, 352, __pyx_L1_error)); - - /* "hunter/_predicates.pyx":353 - * - * def __call__(self, Event event): - * return fast_From_call(self, event) # <<<<<<<<<<<<<< - * - * def __or__(self, other): - */ - __Pyx_TraceLine(353,0,__PYX_ERR(0, 353, __pyx_L1_error)) + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[56])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 43, 0, 0, 0, __PYX_ERR(2, 43, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_f_6hunter_11_predicates_fast_From_call(__pyx_v_self, __pyx_v_event); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 353, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; + __Pyx_INCREF(__pyx_v_self->condition); + __pyx_r = __pyx_v_self->condition; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 43, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_predicates.pyx":352 - * return hash(('From', self.condition, self.predicate)) - * - * def __call__(self, Event event): # <<<<<<<<<<<<<< - * return fast_From_call(self, event) - * - */ - /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.From.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 43, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.When.condition.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":355 - * return fast_From_call(self, event) +/* "hunter/_predicates.pxd":44 + * cdef: + * readonly object condition + * readonly tuple actions # <<<<<<<<<<<<<< * - * def __or__(self, other): # <<<<<<<<<<<<<< - * return Or(self, other) * - */ +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_4From_13__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_4From_13__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { +static PyObject *__pyx_pw_6hunter_11_predicates_4When_7actions_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_4When_7actions_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__or__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_4From_12__or__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_4When_7actions___get__(((struct __pyx_obj_6hunter_11_predicates_When *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_4From_12__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { +static PyObject *__pyx_pf_6hunter_11_predicates_4When_7actions___get__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - __Pyx_RefNannySetupContext("__or__", 0); - __Pyx_TraceCall("__or__", __pyx_f[0], 355, 0, __PYX_ERR(0, 355, __pyx_L1_error)); - - /* "hunter/_predicates.pyx":356 - * - * def __or__(self, other): - * return Or(self, other) # <<<<<<<<<<<<<< - * - * def __and__(self, other): - */ - __Pyx_TraceLine(356,0,__PYX_ERR(0, 356, __pyx_L1_error)) + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[57])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 44, 0, 0, 0, __PYX_ERR(2, 44, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 356, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v_self); - __Pyx_GIVEREF(__pyx_v_self); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self); - __Pyx_INCREF(__pyx_v_other); - __Pyx_GIVEREF(__pyx_v_other); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_other); - __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_Or), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 356, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; + __Pyx_INCREF(__pyx_v_self->actions); + __pyx_r = __pyx_v_self->actions; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 44, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_predicates.pyx":355 - * return fast_From_call(self, event) - * - * def __or__(self, other): # <<<<<<<<<<<<<< - * return Or(self, other) - * - */ - /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("hunter._predicates.From.__or__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 44, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.When.actions.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":358 - * return Or(self, other) - * - * def __and__(self, other): # <<<<<<<<<<<<<< - * return And(self, other) - * - */ +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_4From_15__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_4From_15__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { +static PyObject *__pyx_pw_6hunter_11_predicates_4When_17__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_11_predicates_4When_17__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_4When_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_11_predicates_4When_17__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__and__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_4From_14__and__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_6hunter_11_predicates_4When_16__reduce_cython__(((struct __pyx_obj_6hunter_11_predicates_When *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_4From_14__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { +static PyObject *__pyx_pf_6hunter_11_predicates_4When_16__reduce_cython__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - __Pyx_RefNannySetupContext("__and__", 0); - __Pyx_TraceCall("__and__", __pyx_f[0], 358, 0, __PYX_ERR(0, 358, __pyx_L1_error)); + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[58])) + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + __Pyx_TraceStartFunc("__reduce_cython__", __pyx_f[1], 1, 0, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); - /* "hunter/_predicates.pyx":359 - * - * def __and__(self, other): - * return And(self, other) # <<<<<<<<<<<<<< - * - * def __invert__(self): - */ - __Pyx_TraceLine(359,0,__PYX_ERR(0, 359, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 359, __pyx_L1_error) + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self.actions, self.condition) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: +*/ + __Pyx_TraceLine(5,2,0,__PYX_ERR(1, 5, __pyx_L1_error)) + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v_self); - __Pyx_GIVEREF(__pyx_v_self); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self); - __Pyx_INCREF(__pyx_v_other); - __Pyx_GIVEREF(__pyx_v_other); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_other); - __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_And), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 359, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; + __Pyx_INCREF(__pyx_v_self->actions); + __Pyx_GIVEREF(__pyx_v_self->actions); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->actions) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->condition); + __Pyx_GIVEREF(__pyx_v_self->condition); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->condition) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; - /* "hunter/_predicates.pyx":358 - * return Or(self, other) - * - * def __and__(self, other): # <<<<<<<<<<<<<< - * return And(self, other) - * - */ + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.actions, self.condition) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) +*/ + __Pyx_TraceLine(6,8,0,__PYX_ERR(1, 6, __pyx_L1_error)) + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self.actions, self.condition) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + __Pyx_TraceLine(7,15,0,__PYX_ERR(1, 7, __pyx_L1_error)) + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: +*/ + __Pyx_TraceLine(8,17,0,__PYX_ERR(1, 8, __pyx_L1_error)) + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict) != (0)) __PYX_ERR(1, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self.actions is not None or self.condition is not None +*/ + __Pyx_TraceLine(9,19,0,__PYX_ERR(1, 9, __pyx_L1_error)) + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self.actions, self.condition) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self.actions is not None or self.condition is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_When, (type(self), 0xe710366, None), state +*/ + __Pyx_TraceLine(11,25,0,__PYX_ERR(1, 11, __pyx_L1_error)) + /*else*/ { + __pyx_t_4 = (__pyx_v_self->actions != ((PyObject*)Py_None)); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->condition != Py_None); + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + __pyx_v_use_setstate = __pyx_t_2; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.actions is not None or self.condition is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_When, (type(self), 0xe710366, None), state + * else: +*/ + __Pyx_TraceLine(12,31,0,__PYX_ERR(1, 12, __pyx_L1_error)) + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self.actions is not None or self.condition is not None + * if use_setstate: + * return __pyx_unpickle_When, (type(self), 0xe710366, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_When, (type(self), 0xe710366, state) +*/ + __Pyx_TraceLine(13,32,0,__PYX_ERR(1, 13, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_When); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_242287462); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_242287462); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_mstate_global->__pyx_int_242287462) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + __Pyx_TraceReturnValue(__pyx_r, 32, 0, __PYX_ERR(1, 13, __pyx_L1_error)); + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.actions is not None or self.condition is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_When, (type(self), 0xe710366, None), state + * else: +*/ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_When, (type(self), 0xe710366, None), state + * else: + * return __pyx_unpickle_When, (type(self), 0xe710366, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_When__set_state(self, __pyx_state) +*/ + __Pyx_TraceLine(15,40,0,__PYX_ERR(1, 15, __pyx_L1_error)) + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_When); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_242287462); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_242287462); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_mstate_global->__pyx_int_242287462) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + __Pyx_TraceReturnValue(__pyx_r, 40, 0, __PYX_ERR(1, 15, __pyx_L1_error)); + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("hunter._predicates.From.__and__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.When.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":361 - * return And(self, other) - * - * def __invert__(self): # <<<<<<<<<<<<<< - * return Not(self) - * - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_4From_17__invert__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_4From_17__invert__(PyObject *__pyx_v_self) { +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_When, (type(self), 0xe710366, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_When__set_state(self, __pyx_state) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_4When_19__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_11_predicates_4When_19__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_4When_19__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_11_predicates_4When_19__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__invert__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_4From_16__invert__(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 16, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 16, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 16, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("hunter._predicates.When.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6hunter_11_predicates_4When_18__setstate_cython__(((struct __pyx_obj_6hunter_11_predicates_When *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_4From_16__invert__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self) { +static PyObject *__pyx_pf_6hunter_11_predicates_4When_18__setstate_cython__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__invert__", 0); - __Pyx_TraceCall("__invert__", __pyx_f[0], 361, 0, __PYX_ERR(0, 361, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[59])) + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + __Pyx_TraceStartFunc("__setstate_cython__", __pyx_f[1], 16, 0, 0, 0, __PYX_ERR(1, 16, __pyx_L1_error)); - /* "hunter/_predicates.pyx":362 - * - * def __invert__(self): - * return Not(self) # <<<<<<<<<<<<<< - * - * cdef inline fast_From_call(From self, Event event): - */ - __Pyx_TraceLine(362,0,__PYX_ERR(0, 362, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_6hunter_11_predicates_Not), ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 362, __pyx_L1_error) + /* "(tree fragment)":17 + * return __pyx_unpickle_When, (type(self), 0xe710366, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_When__set_state(self, __pyx_state) # <<<<<<<<<<<<<< +*/ + __Pyx_TraceLine(17,4,0,__PYX_ERR(1, 17, __pyx_L1_error)) + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_6hunter_11_predicates___pyx_unpickle_When__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "hunter/_predicates.pyx":361 - * return And(self, other) - * - * def __invert__(self): # <<<<<<<<<<<<<< - * return Not(self) - * - */ + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_When, (type(self), 0xe710366, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_When__set_state(self, __pyx_state) +*/ /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(1, 16, __pyx_L1_error)); + goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.From.__invert__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 16, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.When.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pxd":45 - * cdef class From: - * cdef: - * readonly object condition # <<<<<<<<<<<<<< - * readonly object predicate - * readonly int watermark - */ +/* "hunter/_predicates.pyx":353 + * return Not(self) + * + * cdef inline fast_When_call(When self, Event event): # <<<<<<<<<<<<<< + * cdef object result + * +*/ -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_4From_9condition_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_4From_9condition_1__get__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_fast_When_call(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { + PyObject *__pyx_v_result = 0; + PyObject *__pyx_v_action = NULL; + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_4From_9condition___get__(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_self)); + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + Py_ssize_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + size_t __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[60])) + __Pyx_RefNannySetupContext("fast_When_call", 0); + __Pyx_TraceStartFunc("fast_When_call", __pyx_f[0], 353, 0, 0, 0, __PYX_ERR(0, 353, __pyx_L1_error)); - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":356 + * cdef object result + * + * result = fast_call(self.condition, event) # <<<<<<<<<<<<<< + * + * if result: +*/ + __Pyx_TraceLine(356,5,0,__PYX_ERR(0, 356, __pyx_L1_error)) + __pyx_t_1 = __pyx_v_self->condition; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = __pyx_f_6hunter_11_predicates_fast_call(__pyx_t_1, __pyx_v_event); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 356, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_result = __pyx_t_2; + __pyx_t_2 = 0; -static PyObject *__pyx_pf_6hunter_11_predicates_4From_9condition___get__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 45, 0, __PYX_ERR(1, 45, __pyx_L1_error)); - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->condition); - __pyx_r = __pyx_v_self->condition; - goto __pyx_L0; + /* "hunter/_predicates.pyx":358 + * result = fast_call(self.condition, event) + * + * if result: # <<<<<<<<<<<<<< + * for action in self.actions: + * action(event) +*/ + __Pyx_TraceLine(358,8,0,__PYX_ERR(0, 358, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_result); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 358, __pyx_L1_error) + if (__pyx_t_3) { - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.From.condition.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":359 + * + * if result: + * for action in self.actions: # <<<<<<<<<<<<<< + * action(event) + * +*/ + __Pyx_TraceLine(359,12,0,__PYX_ERR(0, 359, __pyx_L1_error)) + if (unlikely(__pyx_v_self->actions == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 359, __pyx_L1_error) + } + __pyx_t_2 = __pyx_v_self->actions; __Pyx_INCREF(__pyx_t_2); + __pyx_t_4 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 359, __pyx_L1_error) + #endif + if (__pyx_t_4 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4)); + #else + __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_4); + #endif + ++__pyx_t_4; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 359, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_action, __pyx_t_1); + __pyx_t_1 = 0; + __Pyx_TraceLine(359,9,0,__PYX_ERR(0, 359, __pyx_L1_error)) -/* "hunter/_predicates.pxd":46 - * cdef: - * readonly object condition - * readonly object predicate # <<<<<<<<<<<<<< - * readonly int watermark - * readonly int origin_depth - */ + /* "hunter/_predicates.pyx":360 + * if result: + * for action in self.actions: + * action(event) # <<<<<<<<<<<<<< + * + * return result +*/ + __Pyx_TraceLine(360,14,0,__PYX_ERR(0, 360, __pyx_L1_error)) + __pyx_t_5 = NULL; + __Pyx_INCREF(__pyx_v_action); + __pyx_t_6 = __pyx_v_action; + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, ((PyObject *)__pyx_v_event)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 360, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_4From_9predicate_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_4From_9predicate_1__get__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_4From_9predicate___get__(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_self)); + /* "hunter/_predicates.pyx":359 + * + * if result: + * for action in self.actions: # <<<<<<<<<<<<<< + * action(event) + * +*/ + __Pyx_TraceLine(359,9,0,__PYX_ERR(0, 359, __pyx_L1_error)) + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":358 + * result = fast_call(self.condition, event) + * + * if result: # <<<<<<<<<<<<<< + * for action in self.actions: + * action(event) +*/ + } -static PyObject *__pyx_pf_6hunter_11_predicates_4From_9predicate___get__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 46, 0, __PYX_ERR(1, 46, __pyx_L1_error)); + /* "hunter/_predicates.pyx":362 + * action(event) + * + * return result # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_TraceLine(362,16,0,__PYX_ERR(0, 362, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->predicate); - __pyx_r = __pyx_v_self->predicate; + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + __Pyx_TraceReturnValue(__pyx_r, 16, 0, __PYX_ERR(0, 362, __pyx_L1_error)); goto __pyx_L0; + /* "hunter/_predicates.pyx":353 + * return Not(self) + * + * cdef inline fast_When_call(When self, Event event): # <<<<<<<<<<<<<< + * cdef object result + * +*/ + /* function exit code */ __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.From.predicate.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 353, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.fast_When_call", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_action); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pxd":47 - * readonly object condition - * readonly object predicate - * readonly int watermark # <<<<<<<<<<<<<< - * readonly int origin_depth - * readonly int origin_calls - */ +/* "hunter/_predicates.pyx":371 + * """ + * + * def __init__(self, condition, predicate=None, watermark=0): # <<<<<<<<<<<<<< + * self.condition = condition + * self.predicate = predicate +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_4From_9watermark_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_4From_9watermark_1__get__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; +static int __pyx_pw_6hunter_11_predicates_4From_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_6hunter_11_predicates_4From_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_condition = 0; + PyObject *__pyx_v_predicate = 0; + PyObject *__pyx_v_watermark = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_4From_9watermark___get__(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_condition,&__pyx_mstate_global->__pyx_n_u_predicate,&__pyx_mstate_global->__pyx_n_u_watermark,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 371, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 371, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 371, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 371, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__init__", 0) < 0) __PYX_ERR(0, 371, __pyx_L3_error) + if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_0)); + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 3, i); __PYX_ERR(0, 371, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 371, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 371, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 371, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_0)); + } + __pyx_v_condition = values[0]; + __pyx_v_predicate = values[1]; + __pyx_v_watermark = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 3, __pyx_nargs); __PYX_ERR(0, 371, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("hunter._predicates.From.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6hunter_11_predicates_4From___init__(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_self), __pyx_v_condition, __pyx_v_predicate, __pyx_v_watermark); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_4From_9watermark___get__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations +static int __pyx_pf_6hunter_11_predicates_4From___init__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self, PyObject *__pyx_v_condition, PyObject *__pyx_v_predicate, PyObject *__pyx_v_watermark) { + int __pyx_r; + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 47, 0, __PYX_ERR(1, 47, __pyx_L1_error)); - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->watermark); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 47, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[61])) + __Pyx_RefNannySetupContext("__init__", 0); + __Pyx_TraceStartFunc("__init__", __pyx_f[0], 371, 0, 0, 0, __PYX_ERR(0, 371, __pyx_L1_error)); + + /* "hunter/_predicates.pyx":372 + * + * def __init__(self, condition, predicate=None, watermark=0): + * self.condition = condition # <<<<<<<<<<<<<< + * self.predicate = predicate + * self.watermark = watermark +*/ + __Pyx_TraceLine(372,3,0,__PYX_ERR(0, 372, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_condition); + __Pyx_GIVEREF(__pyx_v_condition); + __Pyx_GOTREF(__pyx_v_self->condition); + __Pyx_DECREF(__pyx_v_self->condition); + __pyx_v_self->condition = __pyx_v_condition; + + /* "hunter/_predicates.pyx":373 + * def __init__(self, condition, predicate=None, watermark=0): + * self.condition = condition + * self.predicate = predicate # <<<<<<<<<<<<<< + * self.watermark = watermark + * self.origin_depth = -1 +*/ + __Pyx_TraceLine(373,6,0,__PYX_ERR(0, 373, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_predicate); + __Pyx_GIVEREF(__pyx_v_predicate); + __Pyx_GOTREF(__pyx_v_self->predicate); + __Pyx_DECREF(__pyx_v_self->predicate); + __pyx_v_self->predicate = __pyx_v_predicate; + + /* "hunter/_predicates.pyx":374 + * self.condition = condition + * self.predicate = predicate + * self.watermark = watermark # <<<<<<<<<<<<<< + * self.origin_depth = -1 + * self.origin_calls = -1 +*/ + __Pyx_TraceLine(374,11,0,__PYX_ERR(0, 374, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyLong_As_int(__pyx_v_watermark); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 374, __pyx_L1_error) + __pyx_v_self->watermark = __pyx_t_1; + + /* "hunter/_predicates.pyx":375 + * self.predicate = predicate + * self.watermark = watermark + * self.origin_depth = -1 # <<<<<<<<<<<<<< + * self.origin_calls = -1 + * +*/ + __Pyx_TraceLine(375,12,0,__PYX_ERR(0, 375, __pyx_L1_error)) + __pyx_v_self->origin_depth = -1; + + /* "hunter/_predicates.pyx":376 + * self.watermark = watermark + * self.origin_depth = -1 + * self.origin_calls = -1 # <<<<<<<<<<<<<< + * + * def __str__(self): +*/ + __Pyx_TraceLine(376,15,0,__PYX_ERR(0, 376, __pyx_L1_error)) + __pyx_v_self->origin_calls = -1; + + /* "hunter/_predicates.pyx":371 + * """ + * + * def __init__(self, condition, predicate=None, watermark=0): # <<<<<<<<<<<<<< + * self.condition = condition + * self.predicate = predicate +*/ /* function exit code */ + __pyx_r = 0; + __Pyx_TraceReturnCValue(__pyx_r, __Pyx_Owned_Py_None, 0, 0, __PYX_ERR(0, 371, __pyx_L1_error)); + goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.From.watermark.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 371, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.From.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pxd":48 - * readonly object predicate - * readonly int watermark - * readonly int origin_depth # <<<<<<<<<<<<<< - * readonly int origin_calls +/* "hunter/_predicates.pyx":378 + * self.origin_calls = -1 * - */ + * def __str__(self): # <<<<<<<<<<<<<< + * return 'From(%s, %s, watermark=%s)' % ( + * self.condition, self.predicate, self.watermark +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_4From_12origin_depth_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_4From_12origin_depth_1__get__(PyObject *__pyx_v_self) { +static PyObject *__pyx_pw_6hunter_11_predicates_4From_3__str__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_4From_3__str__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_4From_12origin_depth___get__(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_4From_2__str__(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_4From_12origin_depth___get__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self) { +static PyObject *__pyx_pf_6hunter_11_predicates_4From_2__str__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 48, 0, __PYX_ERR(1, 48, __pyx_L1_error)); + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4[7]; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[62])) + __Pyx_RefNannySetupContext("__str__", 0); + __Pyx_TraceStartFunc("__str__", __pyx_f[0], 378, 0, 0, 0, __PYX_ERR(0, 378, __pyx_L1_error)); + + /* "hunter/_predicates.pyx":379 + * + * def __str__(self): + * return 'From(%s, %s, watermark=%s)' % ( # <<<<<<<<<<<<<< + * self.condition, self.predicate, self.watermark + * ) +*/ + __Pyx_TraceLine(379,1,0,__PYX_ERR(0, 379, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->origin_depth); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 48, __pyx_L1_error) + + /* "hunter/_predicates.pyx":380 + * def __str__(self): + * return 'From(%s, %s, watermark=%s)' % ( + * self.condition, self.predicate, self.watermark # <<<<<<<<<<<<<< + * ) + * +*/ + __Pyx_TraceLine(380,4,0,__PYX_ERR(0, 380, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_self->condition), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 380, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; + __pyx_t_2 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_self->predicate), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 380, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyUnicode_From_int(__pyx_v_self->watermark, 0, ' ', 'd'); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 380, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4[0] = __pyx_mstate_global->__pyx_kp_u_From; + __pyx_t_4[1] = __pyx_t_1; + __pyx_t_4[2] = __pyx_mstate_global->__pyx_kp_u__4; + __pyx_t_4[3] = __pyx_t_2; + __pyx_t_4[4] = __pyx_mstate_global->__pyx_kp_u_watermark_2; + __pyx_t_4[5] = __pyx_t_3; + __pyx_t_4[6] = __pyx_mstate_global->__pyx_kp_u__7; + + /* "hunter/_predicates.pyx":379 + * + * def __str__(self): + * return 'From(%s, %s, watermark=%s)' % ( # <<<<<<<<<<<<<< + * self.condition, self.predicate, self.watermark + * ) +*/ + __Pyx_TraceLine(379,2,0,__PYX_ERR(0, 379, __pyx_L1_error)) + __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_4, 7, 5 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1) + 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2) + 12 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2)); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 379, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 379, __pyx_L1_error)); goto __pyx_L0; + /* "hunter/_predicates.pyx":378 + * self.origin_calls = -1 + * + * def __str__(self): # <<<<<<<<<<<<<< + * return 'From(%s, %s, watermark=%s)' % ( + * self.condition, self.predicate, self.watermark +*/ + /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.From.origin_depth.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 378, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.From.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pxd":49 - * readonly int watermark - * readonly int origin_depth - * readonly int origin_calls # <<<<<<<<<<<<<< +/* "hunter/_predicates.pyx":383 + * ) * - * cdef fast_And_call(And self, Event event) - */ + * def __repr__(self): # <<<<<<<<<<<<<< + * return '' % ( + * self.condition, self.predicate, self.watermark +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_4From_12origin_calls_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_4From_12origin_calls_1__get__(PyObject *__pyx_v_self) { +static PyObject *__pyx_pw_6hunter_11_predicates_4From_5__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_4From_5__repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_4From_12origin_calls___get__(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_4From_4__repr__(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_4From_12origin_calls___get__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self) { +static PyObject *__pyx_pf_6hunter_11_predicates_4From_4__repr__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 49, 0, __PYX_ERR(1, 49, __pyx_L1_error)); + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4[7]; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[63])) + __Pyx_RefNannySetupContext("__repr__", 0); + __Pyx_TraceStartFunc("__repr__", __pyx_f[0], 383, 0, 0, 0, __PYX_ERR(0, 383, __pyx_L1_error)); + + /* "hunter/_predicates.pyx":384 + * + * def __repr__(self): + * return '' % ( # <<<<<<<<<<<<<< + * self.condition, self.predicate, self.watermark + * ) +*/ + __Pyx_TraceLine(384,1,0,__PYX_ERR(0, 384, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->origin_calls); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 49, __pyx_L1_error) + + /* "hunter/_predicates.pyx":385 + * def __repr__(self): + * return '' % ( + * self.condition, self.predicate, self.watermark # <<<<<<<<<<<<<< + * ) + * +*/ + __Pyx_TraceLine(385,4,0,__PYX_ERR(0, 385, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_self->condition), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 385, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; + __pyx_t_2 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_self->predicate), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 385, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyUnicode_From_int(__pyx_v_self->watermark, 0, ' ', 'd'); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 385, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4[0] = __pyx_mstate_global->__pyx_kp_u_hunter__predicates_From_conditi; + __pyx_t_4[1] = __pyx_t_1; + __pyx_t_4[2] = __pyx_mstate_global->__pyx_kp_u_predicate_2; + __pyx_t_4[3] = __pyx_t_2; + __pyx_t_4[4] = __pyx_mstate_global->__pyx_kp_u_watermark_2; + __pyx_t_4[5] = __pyx_t_3; + __pyx_t_4[6] = __pyx_mstate_global->__pyx_kp_u__8; + + /* "hunter/_predicates.pyx":384 + * + * def __repr__(self): + * return '' % ( # <<<<<<<<<<<<<< + * self.condition, self.predicate, self.watermark + * ) +*/ + __Pyx_TraceLine(384,2,0,__PYX_ERR(0, 384, __pyx_L1_error)) + __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_4, 7, 36 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1) + 12 * 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2)); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 384, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 384, __pyx_L1_error)); goto __pyx_L0; + /* "hunter/_predicates.pyx":383 + * ) + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return '' % ( + * self.condition, self.predicate, self.watermark +*/ + /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.From.origin_calls.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 383, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.From.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict - */ +/* "hunter/_predicates.pyx":388 + * ) + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return ( + * isinstance(other, From) +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_4From_19__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_4From_19__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_6hunter_11_predicates_4From_7__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_4From_7__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_4From_18__reduce_cython__(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_4From_6__eq__(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_self), ((PyObject *)__pyx_v_other)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_4From_18__reduce_cython__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self) { - PyObject *__pyx_v_state = 0; - PyObject *__pyx_v__dict = 0; - int __pyx_v_use_setstate; +static PyObject *__pyx_pf_6hunter_11_predicates_4From_6__eq__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self, PyObject *__pyx_v_other) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; + int __pyx_t_2; PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - int __pyx_t_5; - int __pyx_t_6; - int __pyx_t_7; - __Pyx_RefNannySetupContext("__reduce_cython__", 0); - __Pyx_TraceCall("__reduce_cython__", __pyx_f[2], 1, 0, __PYX_ERR(2, 1, __pyx_L1_error)); - - /* "(tree fragment)":5 - * cdef object _dict - * cdef bint use_setstate - * state = (self.condition, self.origin_calls, self.origin_depth, self.predicate, self.watermark) # <<<<<<<<<<<<<< - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: - */ - __Pyx_TraceLine(5,0,__PYX_ERR(2, 5, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->origin_calls); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->origin_depth); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->watermark); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyTuple_New(5); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_INCREF(__pyx_v_self->condition); - __Pyx_GIVEREF(__pyx_v_self->condition); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_self->condition); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_2); - __Pyx_INCREF(__pyx_v_self->predicate); - __Pyx_GIVEREF(__pyx_v_self->predicate); - PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_v_self->predicate); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_4, 4, __pyx_t_3); - __pyx_t_1 = 0; - __pyx_t_2 = 0; - __pyx_t_3 = 0; - __pyx_v_state = ((PyObject*)__pyx_t_4); - __pyx_t_4 = 0; - - /* "(tree fragment)":6 - * cdef bint use_setstate - * state = (self.condition, self.origin_calls, self.origin_depth, self.predicate, self.watermark) - * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< - * if _dict is not None: - * state += (_dict,) - */ - __Pyx_TraceLine(6,0,__PYX_ERR(2, 6, __pyx_L1_error)) - __pyx_t_4 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_v__dict = __pyx_t_4; - __pyx_t_4 = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[64])) + __Pyx_RefNannySetupContext("__eq__", 0); + __Pyx_TraceStartFunc("__eq__", __pyx_f[0], 388, 0, 0, 0, __PYX_ERR(0, 388, __pyx_L1_error)); - /* "(tree fragment)":7 - * state = (self.condition, self.origin_calls, self.origin_depth, self.predicate, self.watermark) - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: # <<<<<<<<<<<<<< - * state += (_dict,) - * use_setstate = True - */ - __Pyx_TraceLine(7,0,__PYX_ERR(2, 7, __pyx_L1_error)) - __pyx_t_5 = (__pyx_v__dict != Py_None); - __pyx_t_6 = (__pyx_t_5 != 0); - if (__pyx_t_6) { + /* "hunter/_predicates.pyx":389 + * + * def __eq__(self, other): + * return ( # <<<<<<<<<<<<<< + * isinstance(other, From) + * and self.condition == ( other).condition +*/ + __Pyx_TraceLine(389,1,0,__PYX_ERR(0, 389, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); - /* "(tree fragment)":8 - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: - * state += (_dict,) # <<<<<<<<<<<<<< - * use_setstate = True - * else: - */ - __Pyx_TraceLine(8,0,__PYX_ERR(2, 8, __pyx_L1_error)) - __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_INCREF(__pyx_v__dict); - __Pyx_GIVEREF(__pyx_v__dict); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v__dict); - __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 8, __pyx_L1_error) + /* "hunter/_predicates.pyx":390 + * def __eq__(self, other): + * return ( + * isinstance(other, From) # <<<<<<<<<<<<<< + * and self.condition == ( other).condition + * and self.predicate == ( other).predicate +*/ + __Pyx_TraceLine(390,5,0,__PYX_ERR(0, 390, __pyx_L1_error)) + __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_other, __pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_From); + if (__pyx_t_2) { + } else { + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 390, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_1 = __pyx_t_3; __pyx_t_3 = 0; - - /* "(tree fragment)":9 - * if _dict is not None: - * state += (_dict,) - * use_setstate = True # <<<<<<<<<<<<<< - * else: - * use_setstate = self.condition is not None or self.predicate is not None - */ - __Pyx_TraceLine(9,0,__PYX_ERR(2, 9, __pyx_L1_error)) - __pyx_v_use_setstate = 1; - - /* "(tree fragment)":7 - * state = (self.condition, self.origin_calls, self.origin_depth, self.predicate, self.watermark) - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: # <<<<<<<<<<<<<< - * state += (_dict,) - * use_setstate = True - */ - goto __pyx_L3; - } - - /* "(tree fragment)":11 - * use_setstate = True - * else: - * use_setstate = self.condition is not None or self.predicate is not None # <<<<<<<<<<<<<< - * if use_setstate: - * return __pyx_unpickle_From, (type(self), 0x1acd5f7, None), state - */ - __Pyx_TraceLine(11,0,__PYX_ERR(2, 11, __pyx_L1_error)) - /*else*/ { - __pyx_t_5 = (__pyx_v_self->condition != Py_None); - __pyx_t_7 = (__pyx_t_5 != 0); - if (!__pyx_t_7) { - } else { - __pyx_t_6 = __pyx_t_7; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_7 = (__pyx_v_self->predicate != Py_None); - __pyx_t_5 = (__pyx_t_7 != 0); - __pyx_t_6 = __pyx_t_5; - __pyx_L4_bool_binop_done:; - __pyx_v_use_setstate = __pyx_t_6; + goto __pyx_L3_bool_binop_done; } - __pyx_L3:; - - /* "(tree fragment)":12 - * else: - * use_setstate = self.condition is not None or self.predicate is not None - * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_From, (type(self), 0x1acd5f7, None), state - * else: - */ - __Pyx_TraceLine(12,0,__PYX_ERR(2, 12, __pyx_L1_error)) - __pyx_t_6 = (__pyx_v_use_setstate != 0); - if (__pyx_t_6) { - - /* "(tree fragment)":13 - * use_setstate = self.condition is not None or self.predicate is not None - * if use_setstate: - * return __pyx_unpickle_From, (type(self), 0x1acd5f7, None), state # <<<<<<<<<<<<<< - * else: - * return __pyx_unpickle_From, (type(self), 0x1acd5f7, state) - */ - __Pyx_TraceLine(13,0,__PYX_ERR(2, 13, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_From); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_INCREF(__pyx_int_28104183); - __Pyx_GIVEREF(__pyx_int_28104183); - PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_int_28104183); - __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(Py_None); - PyTuple_SET_ITEM(__pyx_t_4, 2, Py_None); - __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4); - __Pyx_INCREF(__pyx_v_state); - __Pyx_GIVEREF(__pyx_v_state); - PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_state); - __pyx_t_3 = 0; - __pyx_t_4 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - /* "(tree fragment)":12 - * else: - * use_setstate = self.condition is not None or self.predicate is not None - * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_From, (type(self), 0x1acd5f7, None), state - * else: - */ + /* "hunter/_predicates.pyx":391 + * return ( + * isinstance(other, From) + * and self.condition == ( other).condition # <<<<<<<<<<<<<< + * and self.predicate == ( other).predicate + * ) +*/ + __Pyx_TraceLine(391,12,0,__PYX_ERR(0, 391, __pyx_L1_error)) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->condition, ((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_other)->condition, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 391, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 391, __pyx_L1_error) + if (__pyx_t_2) { + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __Pyx_INCREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L3_bool_binop_done; } - /* "(tree fragment)":15 - * return __pyx_unpickle_From, (type(self), 0x1acd5f7, None), state - * else: - * return __pyx_unpickle_From, (type(self), 0x1acd5f7, state) # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_From__set_state(self, __pyx_state) - */ - __Pyx_TraceLine(15,0,__PYX_ERR(2, 15, __pyx_L1_error)) - /*else*/ { - __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_pyx_unpickle_From); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_INCREF(__pyx_int_28104183); - __Pyx_GIVEREF(__pyx_int_28104183); - PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_int_28104183); - __Pyx_INCREF(__pyx_v_state); - __Pyx_GIVEREF(__pyx_v_state); - PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state); - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4); - __pyx_t_2 = 0; - __pyx_t_4 = 0; - __pyx_r = __pyx_t_3; - __pyx_t_3 = 0; - goto __pyx_L0; - } + /* "hunter/_predicates.pyx":392 + * isinstance(other, From) + * and self.condition == ( other).condition + * and self.predicate == ( other).predicate # <<<<<<<<<<<<<< + * ) + * +*/ + __Pyx_TraceLine(392,19,0,__PYX_ERR(0, 392, __pyx_L1_error)) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->predicate, ((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_other)->predicate, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 392, __pyx_L1_error) + __Pyx_INCREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_L3_bool_binop_done:; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 389, __pyx_L1_error)); + goto __pyx_L0; - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict - */ + /* "hunter/_predicates.pyx":388 + * ) + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return ( + * isinstance(other, From) +*/ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("hunter._predicates.From.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 388, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.From.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF(__pyx_v_state); - __Pyx_XDECREF(__pyx_v__dict); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "(tree fragment)":16 - * else: - * return __pyx_unpickle_From, (type(self), 0x1acd5f7, state) - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle_From__set_state(self, __pyx_state) - */ +/* "hunter/_predicates.pyx":395 + * ) + * + * def __call__(self, Event event): # <<<<<<<<<<<<<< + * return fast_From_call(self, event) + * +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_4From_21__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_4From_21__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_6hunter_11_predicates_4From_9__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_4From_9__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_4From_20__setstate_cython__(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6hunter_11_predicates_4From_20__setstate_cython__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__setstate_cython__", 0); - __Pyx_TraceCall("__setstate_cython__", __pyx_f[2], 16, 0, __PYX_ERR(2, 16, __pyx_L1_error)); - - /* "(tree fragment)":17 - * return __pyx_unpickle_From, (type(self), 0x1acd5f7, state) - * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_From__set_state(self, __pyx_state) # <<<<<<<<<<<<<< - */ - __Pyx_TraceLine(17,0,__PYX_ERR(2, 17, __pyx_L1_error)) - if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(2, 17, __pyx_L1_error) - __pyx_t_1 = __pyx_f_6hunter_11_predicates___pyx_unpickle_From__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 17, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "(tree fragment)":16 - * else: - * return __pyx_unpickle_From, (type(self), 0x1acd5f7, state) - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle_From__set_state(self, __pyx_state) - */ + __Pyx_RefNannySetupContext("__call__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_event,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 395, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 395, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__call__", 0) < 0) __PYX_ERR(0, 395, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__call__", 1, 1, 1, i); __PYX_ERR(0, 395, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 395, __pyx_L3_error) + } + __pyx_v_event = ((struct __pyx_obj_6hunter_6_event_Event *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__call__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 395, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("hunter._predicates.From.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_event), __pyx_mstate_global->__pyx_ptype_6hunter_6_event_Event, 1, "event", 0))) __PYX_ERR(0, 395, __pyx_L1_error) + __pyx_r = __pyx_pf_6hunter_11_predicates_4From_8__call__(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_self), __pyx_v_event); /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_11_predicates_4From_8__call__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[65])) + __Pyx_RefNannySetupContext("__call__", 0); + __Pyx_TraceStartFunc("__call__", __pyx_f[0], 395, 0, 0, 0, __PYX_ERR(0, 395, __pyx_L1_error)); + + /* "hunter/_predicates.pyx":396 + * + * def __call__(self, Event event): + * return fast_From_call(self, event) # <<<<<<<<<<<<<< + * + * def __or__(self, other): +*/ + __Pyx_TraceLine(396,1,0,__PYX_ERR(0, 396, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6hunter_11_predicates_fast_From_call(__pyx_v_self, __pyx_v_event); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 396, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 396, __pyx_L1_error)); + goto __pyx_L0; + + /* "hunter/_predicates.pyx":395 + * ) + * + * def __call__(self, Event event): # <<<<<<<<<<<<<< + * return fast_From_call(self, event) + * +*/ + + /* function exit code */ + __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.From.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 395, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.From.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":364 - * return Not(self) +/* "hunter/_predicates.pyx":398 + * return fast_From_call(self, event) * - * cdef inline fast_From_call(From self, Event event): # <<<<<<<<<<<<<< - * cdef object result - * cdef int delta_depth - */ + * def __or__(self, other): # <<<<<<<<<<<<<< + * return Or(self, other) + * +*/ -static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_fast_From_call(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { - PyObject *__pyx_v_result = 0; - int __pyx_v_delta_depth; - int __pyx_v_delta_calls; - struct __pyx_obj_6hunter_6_event_Event *__pyx_v_relative_event = NULL; +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_4From_11__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_4From_11__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__or__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_4From_10__or__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_11_predicates_4From_10__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - int __pyx_t_1; + PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - int __pyx_t_5; - __Pyx_RefNannySetupContext("fast_From_call", 0); - __Pyx_TraceCall("fast_From_call", __pyx_f[0], 364, 0, __PYX_ERR(0, 364, __pyx_L1_error)); + size_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[66])) + __Pyx_RefNannySetupContext("__or__", 0); + __Pyx_TraceStartFunc("__or__", __pyx_f[0], 398, 0, 0, 0, __PYX_ERR(0, 398, __pyx_L1_error)); - /* "hunter/_predicates.pyx":369 - * cdef int delta_calls + /* "hunter/_predicates.pyx":399 * - * if self.origin_depth == -1: # <<<<<<<<<<<<<< - * result = fast_call(self.condition, event) + * def __or__(self, other): + * return Or(self, other) # <<<<<<<<<<<<<< * - */ - __Pyx_TraceLine(369,0,__PYX_ERR(0, 369, __pyx_L1_error)) - __pyx_t_1 = ((__pyx_v_self->origin_depth == -1L) != 0); - if (__pyx_t_1) { + * def __and__(self, other): +*/ + __Pyx_TraceLine(399,1,0,__PYX_ERR(0, 399, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = NULL; + __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Or); + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Or); + __pyx_t_4 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_v_self, __pyx_v_other}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 399, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_1); + } + __pyx_r = ((PyObject *)__pyx_t_1); + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 399, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":370 + /* "hunter/_predicates.pyx":398 + * return fast_From_call(self, event) * - * if self.origin_depth == -1: - * result = fast_call(self.condition, event) # <<<<<<<<<<<<<< + * def __or__(self, other): # <<<<<<<<<<<<<< + * return Or(self, other) * - * if result: - */ - __Pyx_TraceLine(370,0,__PYX_ERR(0, 370, __pyx_L1_error)) - __pyx_t_2 = __pyx_v_self->condition; - __Pyx_INCREF(__pyx_t_2); - __pyx_t_3 = __pyx_f_6hunter_11_predicates_fast_call(__pyx_t_2, __pyx_v_event); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 370, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v_result = __pyx_t_3; - __pyx_t_3 = 0; +*/ - /* "hunter/_predicates.pyx":372 - * result = fast_call(self.condition, event) - * - * if result: # <<<<<<<<<<<<<< - * self.origin_depth = event.depth - * self.origin_calls = event.calls - */ - __Pyx_TraceLine(372,0,__PYX_ERR(0, 372, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_result); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 372, __pyx_L1_error) - if (__pyx_t_1) { + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 398, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.From.__or__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":373 +/* "hunter/_predicates.pyx":401 + * return Or(self, other) * - * if result: - * self.origin_depth = event.depth # <<<<<<<<<<<<<< - * self.origin_calls = event.calls - * delta_depth = delta_calls = 0 - */ - __Pyx_TraceLine(373,0,__PYX_ERR(0, 373, __pyx_L1_error)) - __pyx_t_4 = __pyx_v_event->depth; - __pyx_v_self->origin_depth = __pyx_t_4; - - /* "hunter/_predicates.pyx":374 - * if result: - * self.origin_depth = event.depth - * self.origin_calls = event.calls # <<<<<<<<<<<<<< - * delta_depth = delta_calls = 0 - * else: - */ - __Pyx_TraceLine(374,0,__PYX_ERR(0, 374, __pyx_L1_error)) - __pyx_t_4 = __pyx_v_event->calls; - __pyx_v_self->origin_calls = __pyx_t_4; + * def __and__(self, other): # <<<<<<<<<<<<<< + * return And(self, other) + * +*/ - /* "hunter/_predicates.pyx":375 - * self.origin_depth = event.depth - * self.origin_calls = event.calls - * delta_depth = delta_calls = 0 # <<<<<<<<<<<<<< - * else: - * return False - */ - __Pyx_TraceLine(375,0,__PYX_ERR(0, 375, __pyx_L1_error)) - __pyx_v_delta_depth = 0; - __pyx_v_delta_calls = 0; +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_4From_13__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_4From_13__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__and__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_4From_12__and__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); - /* "hunter/_predicates.pyx":372 - * result = fast_call(self.condition, event) - * - * if result: # <<<<<<<<<<<<<< - * self.origin_depth = event.depth - * self.origin_calls = event.calls - */ - goto __pyx_L4; - } + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":377 - * delta_depth = delta_calls = 0 - * else: - * return False # <<<<<<<<<<<<<< - * else: - * delta_depth = event.depth - self.origin_depth - */ - __Pyx_TraceLine(377,0,__PYX_ERR(0, 377, __pyx_L1_error)) - /*else*/ { - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(Py_False); - __pyx_r = Py_False; - goto __pyx_L0; - } - __pyx_L4:; +static PyObject *__pyx_pf_6hunter_11_predicates_4From_12__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[67])) + __Pyx_RefNannySetupContext("__and__", 0); + __Pyx_TraceStartFunc("__and__", __pyx_f[0], 401, 0, 0, 0, __PYX_ERR(0, 401, __pyx_L1_error)); - /* "hunter/_predicates.pyx":369 - * cdef int delta_calls + /* "hunter/_predicates.pyx":402 * - * if self.origin_depth == -1: # <<<<<<<<<<<<<< - * result = fast_call(self.condition, event) + * def __and__(self, other): + * return And(self, other) # <<<<<<<<<<<<<< * - */ - goto __pyx_L3; + * def __invert__(self): +*/ + __Pyx_TraceLine(402,1,0,__PYX_ERR(0, 402, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = NULL; + __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_And); + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_And); + __pyx_t_4 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_v_self, __pyx_v_other}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 402, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_1); } + __pyx_r = ((PyObject *)__pyx_t_1); + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 402, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":379 - * return False - * else: - * delta_depth = event.depth - self.origin_depth # <<<<<<<<<<<<<< - * delta_calls = event.calls - self.origin_calls - * if delta_depth < self.watermark: - */ - __Pyx_TraceLine(379,0,__PYX_ERR(0, 379, __pyx_L1_error)) - /*else*/ { - __pyx_v_delta_depth = (__pyx_v_event->depth - __pyx_v_self->origin_depth); - - /* "hunter/_predicates.pyx":380 - * else: - * delta_depth = event.depth - self.origin_depth - * delta_calls = event.calls - self.origin_calls # <<<<<<<<<<<<<< - * if delta_depth < self.watermark: - * self.origin_depth = -1 - */ - __Pyx_TraceLine(380,0,__PYX_ERR(0, 380, __pyx_L1_error)) - __pyx_v_delta_calls = (__pyx_v_event->calls - __pyx_v_self->origin_calls); - - /* "hunter/_predicates.pyx":381 - * delta_depth = event.depth - self.origin_depth - * delta_calls = event.calls - self.origin_calls - * if delta_depth < self.watermark: # <<<<<<<<<<<<<< - * self.origin_depth = -1 - * return False - */ - __Pyx_TraceLine(381,0,__PYX_ERR(0, 381, __pyx_L1_error)) - __pyx_t_1 = ((__pyx_v_delta_depth < __pyx_v_self->watermark) != 0); - if (__pyx_t_1) { - - /* "hunter/_predicates.pyx":382 - * delta_calls = event.calls - self.origin_calls - * if delta_depth < self.watermark: - * self.origin_depth = -1 # <<<<<<<<<<<<<< - * return False + /* "hunter/_predicates.pyx":401 + * return Or(self, other) * - */ - __Pyx_TraceLine(382,0,__PYX_ERR(0, 382, __pyx_L1_error)) - __pyx_v_self->origin_depth = -1; - - /* "hunter/_predicates.pyx":383 - * if delta_depth < self.watermark: - * self.origin_depth = -1 - * return False # <<<<<<<<<<<<<< + * def __and__(self, other): # <<<<<<<<<<<<<< + * return And(self, other) * - * if self.predicate is None: - */ - __Pyx_TraceLine(383,0,__PYX_ERR(0, 383, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(Py_False); - __pyx_r = Py_False; - goto __pyx_L0; +*/ - /* "hunter/_predicates.pyx":381 - * delta_depth = event.depth - self.origin_depth - * delta_calls = event.calls - self.origin_calls - * if delta_depth < self.watermark: # <<<<<<<<<<<<<< - * self.origin_depth = -1 - * return False - */ - } - } - __pyx_L3:; + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 401, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.From.__and__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":385 - * return False +/* "hunter/_predicates.pyx":404 + * return And(self, other) * - * if self.predicate is None: # <<<<<<<<<<<<<< - * return True - * else: - */ - __Pyx_TraceLine(385,0,__PYX_ERR(0, 385, __pyx_L1_error)) - __pyx_t_1 = (__pyx_v_self->predicate == Py_None); - __pyx_t_5 = (__pyx_t_1 != 0); - if (__pyx_t_5) { - - /* "hunter/_predicates.pyx":386 + * def __invert__(self): # <<<<<<<<<<<<<< + * return Not(self) * - * if self.predicate is None: - * return True # <<<<<<<<<<<<<< - * else: - * relative_event = event.clone() - */ - __Pyx_TraceLine(386,0,__PYX_ERR(0, 386, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(Py_True); - __pyx_r = Py_True; - goto __pyx_L0; +*/ - /* "hunter/_predicates.pyx":385 - * return False - * - * if self.predicate is None: # <<<<<<<<<<<<<< - * return True - * else: - */ - } +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_4From_15__invert__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_4From_15__invert__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__invert__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_4From_14__invert__(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_self)); - /* "hunter/_predicates.pyx":388 - * return True - * else: - * relative_event = event.clone() # <<<<<<<<<<<<<< - * relative_event.depth = delta_depth - * relative_event.calls = delta_calls - */ - __Pyx_TraceLine(388,0,__PYX_ERR(0, 388, __pyx_L1_error)) - /*else*/ { - __pyx_t_3 = ((PyObject *)((struct __pyx_vtabstruct_6hunter_6_event_Event *)__pyx_v_event->__pyx_vtab)->clone(__pyx_v_event)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 388, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_v_relative_event = ((struct __pyx_obj_6hunter_6_event_Event *)__pyx_t_3); - __pyx_t_3 = 0; + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":389 - * else: - * relative_event = event.clone() - * relative_event.depth = delta_depth # <<<<<<<<<<<<<< - * relative_event.calls = delta_calls - * return fast_call(self.predicate, relative_event) - */ - __Pyx_TraceLine(389,0,__PYX_ERR(0, 389, __pyx_L1_error)) - __pyx_v_relative_event->depth = __pyx_v_delta_depth; +static PyObject *__pyx_pf_6hunter_11_predicates_4From_14__invert__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[68])) + __Pyx_RefNannySetupContext("__invert__", 0); + __Pyx_TraceStartFunc("__invert__", __pyx_f[0], 404, 0, 0, 0, __PYX_ERR(0, 404, __pyx_L1_error)); - /* "hunter/_predicates.pyx":390 - * relative_event = event.clone() - * relative_event.depth = delta_depth - * relative_event.calls = delta_calls # <<<<<<<<<<<<<< - * return fast_call(self.predicate, relative_event) + /* "hunter/_predicates.pyx":405 * - */ - __Pyx_TraceLine(390,0,__PYX_ERR(0, 390, __pyx_L1_error)) - __pyx_v_relative_event->calls = __pyx_v_delta_calls; - - /* "hunter/_predicates.pyx":391 - * relative_event.depth = delta_depth - * relative_event.calls = delta_calls - * return fast_call(self.predicate, relative_event) # <<<<<<<<<<<<<< + * def __invert__(self): + * return Not(self) # <<<<<<<<<<<<<< * - * @cython.final - */ - __Pyx_TraceLine(391,0,__PYX_ERR(0, 391, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __pyx_v_self->predicate; - __Pyx_INCREF(__pyx_t_3); - __pyx_t_2 = __pyx_f_6hunter_11_predicates_fast_call(__pyx_t_3, __pyx_v_relative_event); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 391, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + * cdef inline fast_From_call(From self, Event event): +*/ + __Pyx_TraceLine(405,1,0,__PYX_ERR(0, 405, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = NULL; + __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Not); + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Not); + __pyx_t_4 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, ((PyObject *)__pyx_v_self)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 405, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_1); } + __pyx_r = ((PyObject *)__pyx_t_1); + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 405, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":364 + /* "hunter/_predicates.pyx":404 + * return And(self, other) + * + * def __invert__(self): # <<<<<<<<<<<<<< * return Not(self) * - * cdef inline fast_From_call(From self, Event event): # <<<<<<<<<<<<<< - * cdef object result - * cdef int delta_depth - */ +*/ /* function exit code */ __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("hunter._predicates.fast_From_call", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 404, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.From.__invert__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF(__pyx_v_result); - __Pyx_XDECREF((PyObject *)__pyx_v_relative_event); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":398 - * `And` predicate. Exits at the first sub-predicate that returns ``False``. - * """ - * def __init__(self, *predicates): # <<<<<<<<<<<<<< - * self.predicates = predicates - * - */ +/* "hunter/_predicates.pxd":50 + * cdef class From: + * cdef: + * readonly object condition # <<<<<<<<<<<<<< + * readonly object predicate + * readonly int watermark +*/ /* Python wrapper */ -static int __pyx_pw_6hunter_11_predicates_3And_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static int __pyx_pw_6hunter_11_predicates_3And_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v_predicates = 0; - int __pyx_r; +static PyObject *__pyx_pw_6hunter_11_predicates_4From_9condition_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_4From_9condition_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); - if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1; - __Pyx_INCREF(__pyx_args); - __pyx_v_predicates = __pyx_args; - __pyx_r = __pyx_pf_6hunter_11_predicates_3And___init__(((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v_self), __pyx_v_predicates); + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_4From_9condition___get__(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_self)); /* function exit code */ - __Pyx_XDECREF(__pyx_v_predicates); __Pyx_RefNannyFinishContext(); return __pyx_r; } -static int __pyx_pf_6hunter_11_predicates_3And___init__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self, PyObject *__pyx_v_predicates) { - int __pyx_r; - __Pyx_TraceDeclarations +static PyObject *__pyx_pf_6hunter_11_predicates_4From_9condition___get__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__init__", 0); - __Pyx_TraceCall("__init__", __pyx_f[0], 398, 0, __PYX_ERR(0, 398, __pyx_L1_error)); - - /* "hunter/_predicates.pyx":399 - * """ - * def __init__(self, *predicates): - * self.predicates = predicates # <<<<<<<<<<<<<< - * - * def __str__(self): - */ - __Pyx_TraceLine(399,0,__PYX_ERR(0, 399, __pyx_L1_error)) - __Pyx_INCREF(__pyx_v_predicates); - __Pyx_GIVEREF(__pyx_v_predicates); - __Pyx_GOTREF(__pyx_v_self->predicates); - __Pyx_DECREF(__pyx_v_self->predicates); - __pyx_v_self->predicates = __pyx_v_predicates; - - /* "hunter/_predicates.pyx":398 - * `And` predicate. Exits at the first sub-predicate that returns ``False``. - * """ - * def __init__(self, *predicates): # <<<<<<<<<<<<<< - * self.predicates = predicates - * - */ + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[69])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 50, 0, 0, 0, __PYX_ERR(2, 50, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->condition); + __pyx_r = __pyx_v_self->condition; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 50, __pyx_L1_error)); + goto __pyx_L0; /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.And.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 50, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.From.condition.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; __pyx_L0:; - __Pyx_TraceReturn(Py_None, 0); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":401 - * self.predicates = predicates - * - * def __str__(self): # <<<<<<<<<<<<<< - * return 'And(%s)' % ', '.join(str(p) for p in self.predicates) - * - */ +/* "hunter/_predicates.pxd":51 + * cdef: + * readonly object condition + * readonly object predicate # <<<<<<<<<<<<<< + * readonly int watermark + * readonly int origin_depth +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_3And_3__str__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_3And_3__str__(PyObject *__pyx_v_self) { +static PyObject *__pyx_pw_6hunter_11_predicates_4From_9predicate_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_4From_9predicate_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_3And_2__str__(((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_4From_9predicate___get__(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_gb_6hunter_11_predicates_3And_7__str___2generator5(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ - -/* "hunter/_predicates.pyx":402 - * - * def __str__(self): - * return 'And(%s)' % ', '.join(str(p) for p in self.predicates) # <<<<<<<<<<<<<< - * - * def __repr__(self): - */ -static PyObject *__pyx_pf_6hunter_11_predicates_3And_7__str___genexpr(PyObject *__pyx_self) { - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_10_genexpr *__pyx_cur_scope; +static PyObject *__pyx_pf_6hunter_11_predicates_4From_9predicate___get__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self) { PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("genexpr", 0); - __pyx_cur_scope = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_10_genexpr *)__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_10_genexpr(__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_10_genexpr, __pyx_empty_tuple, NULL); - if (unlikely(!__pyx_cur_scope)) { - __pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_10_genexpr *)Py_None); - __Pyx_INCREF(Py_None); - __PYX_ERR(0, 402, __pyx_L1_error) - } else { - __Pyx_GOTREF(__pyx_cur_scope); - } - __pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_9___str__ *) __pyx_self; - __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_outer_scope)); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope); - { - __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_6hunter_11_predicates_3And_7__str___2generator5, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_str___locals_genexpr, __pyx_n_s_hunter__predicates); if (unlikely(!gen)) __PYX_ERR(0, 402, __pyx_L1_error) - __Pyx_DECREF(__pyx_cur_scope); - __Pyx_RefNannyFinishContext(); - return (PyObject *) gen; - } + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[70])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 51, 0, 0, 0, __PYX_ERR(2, 51, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->predicate); + __pyx_r = __pyx_v_self->predicate; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 51, __pyx_L1_error)); + goto __pyx_L0; /* function exit code */ __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.And.__str__.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 51, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.From.predicate.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; - __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_gb_6hunter_11_predicates_3And_7__str___2generator5(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ -{ - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_10_genexpr *__pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_10_genexpr *)__pyx_generator->closure); - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - PyObject *__pyx_t_1 = NULL; - Py_ssize_t __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("genexpr", 0); - __Pyx_TraceCall("genexpr", __pyx_f[0], 402, 0, __PYX_ERR(0, 402, __pyx_L1_error)); - switch (__pyx_generator->resume_label) { - case 0: goto __pyx_L3_first_run; - case 1: goto __pyx_L6_resume_from_yield; - default: /* CPython raises the right error here */ - __Pyx_TraceReturn(Py_None, 0); - __Pyx_RefNannyFinishContext(); - return NULL; - } - __pyx_L3_first_run:; - if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 402, __pyx_L1_error) - if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 402, __pyx_L1_error) } - if (unlikely(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->predicates == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(0, 402, __pyx_L1_error) - } - __pyx_t_1 = __pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->predicates; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; - for (;;) { - if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 402, __pyx_L1_error) - #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 402, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - #endif - __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_p); - __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_p, __pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyString_Type)), __pyx_cur_scope->__pyx_v_p); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 402, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_r = __pyx_t_3; - __pyx_t_3 = 0; - __Pyx_XGIVEREF(__pyx_t_1); - __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; - __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - __Pyx_Coroutine_ResetAndClearException(__pyx_generator); - /* return from generator, yielding value */ - __pyx_generator->resume_label = 1; - return __pyx_r; - __pyx_L6_resume_from_yield:; - __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; - __pyx_cur_scope->__pyx_t_0 = 0; - __Pyx_XGOTREF(__pyx_t_1); - __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; - if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 402, __pyx_L1_error) - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); +/* "hunter/_predicates.pxd":52 + * readonly object condition + * readonly object predicate + * readonly int watermark # <<<<<<<<<<<<<< + * readonly int origin_depth + * readonly int origin_calls +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_4From_9watermark_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_4From_9watermark_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_4From_9watermark___get__(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_self)); /* function exit code */ - PyErr_SetNone(PyExc_StopIteration); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_L0:; - __Pyx_XDECREF(__pyx_r); __pyx_r = 0; - #if !CYTHON_USE_EXC_INFO_STACK - __Pyx_Coroutine_ResetAndClearException(__pyx_generator); - #endif - __pyx_generator->resume_label = -1; - __Pyx_Coroutine_clear((PyObject*)__pyx_generator); - __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":401 - * self.predicates = predicates - * - * def __str__(self): # <<<<<<<<<<<<<< - * return 'And(%s)' % ', '.join(str(p) for p in self.predicates) - * - */ - -static PyObject *__pyx_pf_6hunter_11_predicates_3And_2__str__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self) { - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_9___str__ *__pyx_cur_scope; +static PyObject *__pyx_pf_6hunter_11_predicates_4From_9watermark___get__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - __Pyx_RefNannySetupContext("__str__", 0); - __pyx_cur_scope = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_9___str__ *)__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_9___str__(__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_9___str__, __pyx_empty_tuple, NULL); - if (unlikely(!__pyx_cur_scope)) { - __pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_9___str__ *)Py_None); - __Pyx_INCREF(Py_None); - __PYX_ERR(0, 401, __pyx_L1_error) - } else { - __Pyx_GOTREF(__pyx_cur_scope); - } - __Pyx_TraceCall("__str__", __pyx_f[0], 401, 0, __PYX_ERR(0, 401, __pyx_L1_error)); - __pyx_cur_scope->__pyx_v_self = __pyx_v_self; - __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self); - __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self); - - /* "hunter/_predicates.pyx":402 - * - * def __str__(self): - * return 'And(%s)' % ', '.join(str(p) for p in self.predicates) # <<<<<<<<<<<<<< - * - * def __repr__(self): - */ - __Pyx_TraceLine(402,0,__PYX_ERR(0, 402, __pyx_L1_error)) + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[71])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 52, 0, 0, 0, __PYX_ERR(2, 52, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_pf_6hunter_11_predicates_3And_7__str___genexpr(((PyObject*)__pyx_cur_scope)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 402, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyString_Join(__pyx_kp_s__3, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 402, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_And_s, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 402, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->watermark); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 52, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 52, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_predicates.pyx":401 - * self.predicates = predicates - * - * def __str__(self): # <<<<<<<<<<<<<< - * return 'And(%s)' % ', '.join(str(p) for p in self.predicates) - * - */ - /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("hunter._predicates.And.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 52, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.From.watermark.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":404 - * return 'And(%s)' % ', '.join(str(p) for p in self.predicates) - * - * def __repr__(self): # <<<<<<<<<<<<<< - * return '' % (self.predicates,) +/* "hunter/_predicates.pxd":53 + * readonly object predicate + * readonly int watermark + * readonly int origin_depth # <<<<<<<<<<<<<< + * readonly int origin_calls * - */ +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_3And_5__repr__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_3And_5__repr__(PyObject *__pyx_v_self) { +static PyObject *__pyx_pw_6hunter_11_predicates_4From_12origin_depth_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_4From_12origin_depth_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_3And_4__repr__(((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_4From_12origin_depth___get__(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_3And_4__repr__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self) { +static PyObject *__pyx_pf_6hunter_11_predicates_4From_12origin_depth___get__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - __Pyx_RefNannySetupContext("__repr__", 0); - __Pyx_TraceCall("__repr__", __pyx_f[0], 404, 0, __PYX_ERR(0, 404, __pyx_L1_error)); - - /* "hunter/_predicates.pyx":405 - * - * def __repr__(self): - * return '' % (self.predicates,) # <<<<<<<<<<<<<< - * - * def __eq__(self, other): - */ - __Pyx_TraceLine(405,0,__PYX_ERR(0, 405, __pyx_L1_error)) + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[72])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 53, 0, 0, 0, __PYX_ERR(2, 53, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 405, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->origin_depth); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 53, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v_self->predicates); - __Pyx_GIVEREF(__pyx_v_self->predicates); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->predicates); - __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_hunter__predicates_And_predicat, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 405, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 53, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_predicates.pyx":404 - * return 'And(%s)' % ', '.join(str(p) for p in self.predicates) - * - * def __repr__(self): # <<<<<<<<<<<<<< - * return '' % (self.predicates,) - * - */ - /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("hunter._predicates.And.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 53, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.From.origin_depth.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":407 - * return '' % (self.predicates,) +/* "hunter/_predicates.pxd":54 + * readonly int watermark + * readonly int origin_depth + * readonly int origin_calls # <<<<<<<<<<<<<< * - * def __eq__(self, other): # <<<<<<<<<<<<<< - * return ( - * isinstance(other, And) - */ + * +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_3And_7__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_3And_7__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { +static PyObject *__pyx_pw_6hunter_11_predicates_4From_12origin_calls_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_4From_12origin_calls_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_3And_6__eq__(((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_4From_12origin_calls___get__(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_3And_6__eq__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self, PyObject *__pyx_v_other) { +static PyObject *__pyx_pf_6hunter_11_predicates_4From_12origin_calls___get__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - __Pyx_RefNannySetupContext("__eq__", 0); - __Pyx_TraceCall("__eq__", __pyx_f[0], 407, 0, __PYX_ERR(0, 407, __pyx_L1_error)); - - /* "hunter/_predicates.pyx":408 - * - * def __eq__(self, other): - * return ( # <<<<<<<<<<<<<< - * isinstance(other, And) - * and self.predicates == ( other).predicates - */ - __Pyx_TraceLine(408,0,__PYX_ERR(0, 408, __pyx_L1_error)) + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[73])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 54, 0, 0, 0, __PYX_ERR(2, 54, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); - - /* "hunter/_predicates.pyx":409 - * def __eq__(self, other): - * return ( - * isinstance(other, And) # <<<<<<<<<<<<<< - * and self.predicates == ( other).predicates - * ) - */ - __Pyx_TraceLine(409,0,__PYX_ERR(0, 409, __pyx_L1_error)) - __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_other, __pyx_ptype_6hunter_11_predicates_And); - if (__pyx_t_2) { - } else { - __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 409, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __pyx_t_3; - __pyx_t_3 = 0; - goto __pyx_L3_bool_binop_done; - } - - /* "hunter/_predicates.pyx":410 - * return ( - * isinstance(other, And) - * and self.predicates == ( other).predicates # <<<<<<<<<<<<<< - * ) - * - */ - __Pyx_TraceLine(410,0,__PYX_ERR(0, 410, __pyx_L1_error)) - __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->predicates, ((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v_other)->predicates, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 410, __pyx_L1_error) - __Pyx_INCREF(__pyx_t_3); - __pyx_t_1 = __pyx_t_3; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_L3_bool_binop_done:; + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->origin_calls); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 54, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_predicates.pyx":407 - * return '' % (self.predicates,) - * - * def __eq__(self, other): # <<<<<<<<<<<<<< - * return ( - * isinstance(other, And) - */ - /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("hunter._predicates.And.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 54, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.From.origin_calls.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":413 - * ) - * - * def __hash__(self): # <<<<<<<<<<<<<< - * return hash(('And', self.predicates)) - * - */ +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ /* Python wrapper */ -static Py_hash_t __pyx_pw_6hunter_11_predicates_3And_9__hash__(PyObject *__pyx_v_self); /*proto*/ -static Py_hash_t __pyx_pw_6hunter_11_predicates_3And_9__hash__(PyObject *__pyx_v_self) { - Py_hash_t __pyx_r; +static PyObject *__pyx_pw_6hunter_11_predicates_4From_17__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_11_predicates_4From_17__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_4From_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_11_predicates_4From_17__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__hash__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_3And_8__hash__(((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_6hunter_11_predicates_4From_16__reduce_cython__(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static Py_hash_t __pyx_pf_6hunter_11_predicates_3And_8__hash__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self) { - Py_hash_t __pyx_r; - __Pyx_TraceDeclarations +static PyObject *__pyx_pf_6hunter_11_predicates_4From_16__reduce_cython__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - Py_hash_t __pyx_t_2; - __Pyx_RefNannySetupContext("__hash__", 0); - __Pyx_TraceCall("__hash__", __pyx_f[0], 413, 0, __PYX_ERR(0, 413, __pyx_L1_error)); + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[74])) + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + __Pyx_TraceStartFunc("__reduce_cython__", __pyx_f[1], 1, 0, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); - /* "hunter/_predicates.pyx":414 - * - * def __hash__(self): - * return hash(('And', self.predicates)) # <<<<<<<<<<<<<< - * - * def __call__(self, Event event): - */ - __Pyx_TraceLine(414,0,__PYX_ERR(0, 414, __pyx_L1_error)) - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 414, __pyx_L1_error) + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self.condition, self.origin_calls, self.origin_depth, self.predicate, self.watermark) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: +*/ + __Pyx_TraceLine(5,5,0,__PYX_ERR(1, 5, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->origin_calls); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_n_s_And); - __Pyx_GIVEREF(__pyx_n_s_And); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_And); - __Pyx_INCREF(__pyx_v_self->predicates); - __Pyx_GIVEREF(__pyx_v_self->predicates); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->predicates); - __pyx_t_2 = PyObject_Hash(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_hash_t)-1))) __PYX_ERR(0, 414, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_2; - goto __pyx_L0; + __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_self->origin_depth); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_self->watermark); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(5); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_self->condition); + __Pyx_GIVEREF(__pyx_v_self->condition); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_self->condition) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_2) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->predicate); + __Pyx_GIVEREF(__pyx_v_self->predicate); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_v_self->predicate) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 4, __pyx_t_3) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_v_state = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; - /* "hunter/_predicates.pyx":413 - * ) - * - * def __hash__(self): # <<<<<<<<<<<<<< - * return hash(('And', self.predicates)) - * - */ + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.condition, self.origin_calls, self.origin_depth, self.predicate, self.watermark) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) +*/ + __Pyx_TraceLine(6,14,0,__PYX_ERR(1, 6, __pyx_L1_error)) + __pyx_t_4 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_dict, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_v__dict = __pyx_t_4; + __pyx_t_4 = 0; + + /* "(tree fragment)":7 + * state = (self.condition, self.origin_calls, self.origin_depth, self.predicate, self.watermark) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + __Pyx_TraceLine(7,21,0,__PYX_ERR(1, 7, __pyx_L1_error)) + __pyx_t_5 = (__pyx_v__dict != Py_None); + if (__pyx_t_5) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: +*/ + __Pyx_TraceLine(8,23,0,__PYX_ERR(1, 8, __pyx_L1_error)) + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v__dict) != (0)) __PYX_ERR(1, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self.condition is not None or self.predicate is not None +*/ + __Pyx_TraceLine(9,25,0,__PYX_ERR(1, 9, __pyx_L1_error)) + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self.condition, self.origin_calls, self.origin_depth, self.predicate, self.watermark) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self.condition is not None or self.predicate is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_From, (type(self), 0xcfd05cc, None), state +*/ + __Pyx_TraceLine(11,31,0,__PYX_ERR(1, 11, __pyx_L1_error)) + /*else*/ { + __pyx_t_6 = (__pyx_v_self->condition != Py_None); + if (!__pyx_t_6) { + } else { + __pyx_t_5 = __pyx_t_6; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_6 = (__pyx_v_self->predicate != Py_None); + __pyx_t_5 = __pyx_t_6; + __pyx_L4_bool_binop_done:; + __pyx_v_use_setstate = __pyx_t_5; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.condition is not None or self.predicate is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_From, (type(self), 0xcfd05cc, None), state + * else: +*/ + __Pyx_TraceLine(12,37,0,__PYX_ERR(1, 12, __pyx_L1_error)) + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self.condition is not None or self.predicate is not None + * if use_setstate: + * return __pyx_unpickle_From, (type(self), 0xcfd05cc, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_From, (type(self), 0xcfd05cc, state) +*/ + __Pyx_TraceLine(13,38,0,__PYX_ERR(1, 13, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_From); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_217908684); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_217908684); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_mstate_global->__pyx_int_217908684) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, Py_None) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_TraceReturnValue(__pyx_r, 38, 0, __PYX_ERR(1, 13, __pyx_L1_error)); + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.condition is not None or self.predicate is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_From, (type(self), 0xcfd05cc, None), state + * else: +*/ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_From, (type(self), 0xcfd05cc, None), state + * else: + * return __pyx_unpickle_From, (type(self), 0xcfd05cc, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_From__set_state(self, __pyx_state) +*/ + __Pyx_TraceLine(15,46,0,__PYX_ERR(1, 15, __pyx_L1_error)) + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_From); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_217908684); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_217908684); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_mstate_global->__pyx_int_217908684) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __pyx_t_2 = 0; + __pyx_t_4 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + __Pyx_TraceReturnValue(__pyx_r, 46, 0, __PYX_ERR(1, 15, __pyx_L1_error)); + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.And.__hash__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.From.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; __pyx_L0:; - if (unlikely(__pyx_r == -1) && !PyErr_Occurred()) __pyx_r = -2; - __Pyx_TraceReturn(Py_None, 0); + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":416 - * return hash(('And', self.predicates)) - * - * def __call__(self, Event event): # <<<<<<<<<<<<<< - * return fast_And_call(self, event) - * - */ +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_From, (type(self), 0xcfd05cc, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_From__set_state(self, __pyx_state) +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_3And_11__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_3And_11__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event = 0; +static PyObject *__pyx_pw_6hunter_11_predicates_4From_19__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_11_predicates_4From_19__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_4From_19__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_11_predicates_4From_19__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__call__ (wrapper)", 0); + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_event,0}; - PyObject* values[1] = {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 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 16, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) 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_event)) != 0)) kw_args--; - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__call__") < 0)) __PYX_ERR(0, 416, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 16, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 16, __pyx_L3_error) } } - } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { + } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) } - __pyx_v_event = ((struct __pyx_obj_6hunter_6_event_Event *)values[0]); + __pyx_v___pyx_state = values[0]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__call__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 416, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - __Pyx_AddTraceback("hunter._predicates.And.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("hunter._predicates.From.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_event), __pyx_ptype_6hunter_6_event_Event, 1, "event", 0))) __PYX_ERR(0, 416, __pyx_L1_error) - __pyx_r = __pyx_pf_6hunter_11_predicates_3And_10__call__(((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v_self), __pyx_v_event); + __pyx_r = __pyx_pf_6hunter_11_predicates_4From_18__setstate_cython__(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ - goto __pyx_L0; - __pyx_L1_error:; - __pyx_r = NULL; - __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_3And_10__call__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { +static PyObject *__pyx_pf_6hunter_11_predicates_4From_18__setstate_cython__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__call__", 0); - __Pyx_TraceCall("__call__", __pyx_f[0], 416, 0, __PYX_ERR(0, 416, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[75])) + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + __Pyx_TraceStartFunc("__setstate_cython__", __pyx_f[1], 16, 0, 0, 0, __PYX_ERR(1, 16, __pyx_L1_error)); - /* "hunter/_predicates.pyx":417 - * - * def __call__(self, Event event): - * return fast_And_call(self, event) # <<<<<<<<<<<<<< - * - * def __or__(self, other): - */ - __Pyx_TraceLine(417,0,__PYX_ERR(0, 417, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_f_6hunter_11_predicates_fast_And_call(__pyx_v_self, __pyx_v_event); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 417, __pyx_L1_error) + /* "(tree fragment)":17 + * return __pyx_unpickle_From, (type(self), 0xcfd05cc, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_From__set_state(self, __pyx_state) # <<<<<<<<<<<<<< +*/ + __Pyx_TraceLine(17,4,0,__PYX_ERR(1, 17, __pyx_L1_error)) + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_6hunter_11_predicates___pyx_unpickle_From__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "hunter/_predicates.pyx":416 - * return hash(('And', self.predicates)) - * - * def __call__(self, Event event): # <<<<<<<<<<<<<< - * return fast_And_call(self, event) - * - */ + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_From, (type(self), 0xcfd05cc, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_From__set_state(self, __pyx_state) +*/ /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(1, 16, __pyx_L1_error)); + goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.And.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 16, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.From.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":419 - * return fast_And_call(self, event) - * - * def __or__(self, other): # <<<<<<<<<<<<<< - * return Or(self, other) +/* "hunter/_predicates.pyx":407 + * return Not(self) * - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_3And_13__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_3And_13__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__or__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_3And_12__or__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + * cdef inline fast_From_call(From self, Event event): # <<<<<<<<<<<<<< + * cdef object result + * cdef int delta_depth +*/ -static PyObject *__pyx_pf_6hunter_11_predicates_3And_12__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_fast_From_call(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { + PyObject *__pyx_v_result = 0; + int __pyx_v_delta_depth; + int __pyx_v_delta_calls; + struct __pyx_obj_6hunter_6_event_Event *__pyx_v_relative_event = NULL; PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; + int __pyx_t_1; PyObject *__pyx_t_2 = NULL; - __Pyx_RefNannySetupContext("__or__", 0); - __Pyx_TraceCall("__or__", __pyx_f[0], 419, 0, __PYX_ERR(0, 419, __pyx_L1_error)); + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[76])) + __Pyx_RefNannySetupContext("fast_From_call", 0); + __Pyx_TraceStartFunc("fast_From_call", __pyx_f[0], 407, 0, 0, 0, __PYX_ERR(0, 407, __pyx_L1_error)); - /* "hunter/_predicates.pyx":420 + /* "hunter/_predicates.pyx":412 + * cdef int delta_calls * - * def __or__(self, other): - * return Or(self, other) # <<<<<<<<<<<<<< + * if self.origin_depth == -1: # <<<<<<<<<<<<<< + * result = fast_call(self.condition, event) * - * def __and__(self, other): - */ - __Pyx_TraceLine(420,0,__PYX_ERR(0, 420, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 420, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v_self); - __Pyx_GIVEREF(__pyx_v_self); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self); - __Pyx_INCREF(__pyx_v_other); - __Pyx_GIVEREF(__pyx_v_other); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_other); - __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_Or), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 420, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; +*/ + __Pyx_TraceLine(412,4,0,__PYX_ERR(0, 412, __pyx_L1_error)) + __pyx_t_1 = (__pyx_v_self->origin_depth == -1L); + if (__pyx_t_1) { - /* "hunter/_predicates.pyx":419 - * return fast_And_call(self, event) + /* "hunter/_predicates.pyx":413 * - * def __or__(self, other): # <<<<<<<<<<<<<< - * return Or(self, other) + * if self.origin_depth == -1: + * result = fast_call(self.condition, event) # <<<<<<<<<<<<<< * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("hunter._predicates.And.__or__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + * if result: +*/ + __Pyx_TraceLine(413,10,0,__PYX_ERR(0, 413, __pyx_L1_error)) + __pyx_t_2 = __pyx_v_self->condition; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = __pyx_f_6hunter_11_predicates_fast_call(__pyx_t_2, __pyx_v_event); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 413, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_result = __pyx_t_3; + __pyx_t_3 = 0; -/* "hunter/_predicates.pyx":422 - * return Or(self, other) + /* "hunter/_predicates.pyx":415 + * result = fast_call(self.condition, event) * - * def __and__(self, other): # <<<<<<<<<<<<<< - * cdef list predicates - * if type(self) is And: - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_3And_15__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_3And_15__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__and__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_3And_14__and__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + * if result: # <<<<<<<<<<<<<< + * self.origin_depth = event.depth + * self.origin_calls = event.calls +*/ + __Pyx_TraceLine(415,13,0,__PYX_ERR(0, 415, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_result); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 415, __pyx_L1_error) + if (__pyx_t_1) { -static PyObject *__pyx_pf_6hunter_11_predicates_3And_14__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { - PyObject *__pyx_v_predicates = 0; - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - __Pyx_RefNannySetupContext("__and__", 0); - __Pyx_TraceCall("__and__", __pyx_f[0], 422, 0, __PYX_ERR(0, 422, __pyx_L1_error)); + /* "hunter/_predicates.pyx":416 + * + * if result: + * self.origin_depth = event.depth # <<<<<<<<<<<<<< + * self.origin_calls = event.calls + * delta_depth = delta_calls = 0 +*/ + __Pyx_TraceLine(416,17,0,__PYX_ERR(0, 416, __pyx_L1_error)) + __pyx_t_4 = __pyx_v_event->depth; + __pyx_v_self->origin_depth = __pyx_t_4; - /* "hunter/_predicates.pyx":424 - * def __and__(self, other): - * cdef list predicates - * if type(self) is And: # <<<<<<<<<<<<<< - * predicates = list((self).predicates) + /* "hunter/_predicates.pyx":417 + * if result: + * self.origin_depth = event.depth + * self.origin_calls = event.calls # <<<<<<<<<<<<<< + * delta_depth = delta_calls = 0 * else: - */ - __Pyx_TraceLine(424,0,__PYX_ERR(0, 424, __pyx_L1_error)) - __pyx_t_1 = (((PyObject *)Py_TYPE(__pyx_v_self)) == ((PyObject *)__pyx_ptype_6hunter_11_predicates_And)); - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { +*/ + __Pyx_TraceLine(417,21,0,__PYX_ERR(0, 417, __pyx_L1_error)) + __pyx_t_4 = __pyx_v_event->calls; + __pyx_v_self->origin_calls = __pyx_t_4; - /* "hunter/_predicates.pyx":425 - * cdef list predicates - * if type(self) is And: - * predicates = list((self).predicates) # <<<<<<<<<<<<<< + /* "hunter/_predicates.pyx":418 + * self.origin_depth = event.depth + * self.origin_calls = event.calls + * delta_depth = delta_calls = 0 # <<<<<<<<<<<<<< * else: - * predicates = [self] - */ - __Pyx_TraceLine(425,0,__PYX_ERR(0, 425, __pyx_L1_error)) - __pyx_t_3 = PySequence_List(((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v_self)->predicates); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 425, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_v_predicates = ((PyObject*)__pyx_t_3); - __pyx_t_3 = 0; + * return False +*/ + __Pyx_TraceLine(418,24,0,__PYX_ERR(0, 418, __pyx_L1_error)) + __pyx_v_delta_depth = 0; + __pyx_v_delta_calls = 0; - /* "hunter/_predicates.pyx":424 - * def __and__(self, other): - * cdef list predicates - * if type(self) is And: # <<<<<<<<<<<<<< - * predicates = list((self).predicates) + /* "hunter/_predicates.pyx":415 + * result = fast_call(self.condition, event) + * + * if result: # <<<<<<<<<<<<<< + * self.origin_depth = event.depth + * self.origin_calls = event.calls +*/ + goto __pyx_L4; + } + + /* "hunter/_predicates.pyx":420 + * delta_depth = delta_calls = 0 * else: - */ + * return False # <<<<<<<<<<<<<< + * else: + * delta_depth = event.depth - self.origin_depth +*/ + __Pyx_TraceLine(420,25,0,__PYX_ERR(0, 420, __pyx_L1_error)) + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + __Pyx_TraceReturnValue(__pyx_r, 25, 0, __PYX_ERR(0, 420, __pyx_L1_error)); + goto __pyx_L0; + } + __pyx_L4:; + + /* "hunter/_predicates.pyx":412 + * cdef int delta_calls + * + * if self.origin_depth == -1: # <<<<<<<<<<<<<< + * result = fast_call(self.condition, event) + * +*/ goto __pyx_L3; } - /* "hunter/_predicates.pyx":427 - * predicates = list((self).predicates) - * else: - * predicates = [self] # <<<<<<<<<<<<<< - * if isinstance(other, And): - * predicates.extend(( other).predicates) - */ - __Pyx_TraceLine(427,0,__PYX_ERR(0, 427, __pyx_L1_error)) + /* "hunter/_predicates.pyx":422 + * return False + * else: + * delta_depth = event.depth - self.origin_depth # <<<<<<<<<<<<<< + * delta_calls = event.calls - self.origin_calls + * if delta_depth < self.watermark: +*/ + __Pyx_TraceLine(422,27,0,__PYX_ERR(0, 422, __pyx_L1_error)) /*else*/ { - __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 427, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(__pyx_v_self); - __Pyx_GIVEREF(__pyx_v_self); - PyList_SET_ITEM(__pyx_t_3, 0, __pyx_v_self); - __pyx_v_predicates = ((PyObject*)__pyx_t_3); - __pyx_t_3 = 0; + __pyx_v_delta_depth = (__pyx_v_event->depth - __pyx_v_self->origin_depth); + + /* "hunter/_predicates.pyx":423 + * else: + * delta_depth = event.depth - self.origin_depth + * delta_calls = event.calls - self.origin_calls # <<<<<<<<<<<<<< + * if delta_depth < self.watermark: + * self.origin_depth = -1 +*/ + __Pyx_TraceLine(423,36,0,__PYX_ERR(0, 423, __pyx_L1_error)) + __pyx_v_delta_calls = (__pyx_v_event->calls - __pyx_v_self->origin_calls); + + /* "hunter/_predicates.pyx":424 + * delta_depth = event.depth - self.origin_depth + * delta_calls = event.calls - self.origin_calls + * if delta_depth < self.watermark: # <<<<<<<<<<<<<< + * self.origin_depth = -1 + * return False +*/ + __Pyx_TraceLine(424,41,0,__PYX_ERR(0, 424, __pyx_L1_error)) + __pyx_t_1 = (__pyx_v_delta_depth < __pyx_v_self->watermark); + if (__pyx_t_1) { + + /* "hunter/_predicates.pyx":425 + * delta_calls = event.calls - self.origin_calls + * if delta_depth < self.watermark: + * self.origin_depth = -1 # <<<<<<<<<<<<<< + * return False + * +*/ + __Pyx_TraceLine(425,44,0,__PYX_ERR(0, 425, __pyx_L1_error)) + __pyx_v_self->origin_depth = -1; + + /* "hunter/_predicates.pyx":426 + * if delta_depth < self.watermark: + * self.origin_depth = -1 + * return False # <<<<<<<<<<<<<< + * + * if self.predicate is None: +*/ + __Pyx_TraceLine(426,47,0,__PYX_ERR(0, 426, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + __Pyx_TraceReturnValue(__pyx_r, 47, 0, __PYX_ERR(0, 426, __pyx_L1_error)); + goto __pyx_L0; + + /* "hunter/_predicates.pyx":424 + * delta_depth = event.depth - self.origin_depth + * delta_calls = event.calls - self.origin_calls + * if delta_depth < self.watermark: # <<<<<<<<<<<<<< + * self.origin_depth = -1 + * return False +*/ + } } __pyx_L3:; /* "hunter/_predicates.pyx":428 - * else: - * predicates = [self] - * if isinstance(other, And): # <<<<<<<<<<<<<< - * predicates.extend(( other).predicates) - * else: - */ - __Pyx_TraceLine(428,0,__PYX_ERR(0, 428, __pyx_L1_error)) - __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_other, __pyx_ptype_6hunter_11_predicates_And); - __pyx_t_1 = (__pyx_t_2 != 0); + * return False + * + * if self.predicate is None: # <<<<<<<<<<<<<< + * return True + * else: +*/ + __Pyx_TraceLine(428,53,0,__PYX_ERR(0, 428, __pyx_L1_error)) + __pyx_t_1 = (__pyx_v_self->predicate == Py_None); if (__pyx_t_1) { /* "hunter/_predicates.pyx":429 - * predicates = [self] - * if isinstance(other, And): - * predicates.extend(( other).predicates) # <<<<<<<<<<<<<< - * else: - * predicates.append(other) - */ - __Pyx_TraceLine(429,0,__PYX_ERR(0, 429, __pyx_L1_error)) - __pyx_t_3 = ((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v_other)->predicates; - __Pyx_INCREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyList_Extend(__pyx_v_predicates, __pyx_t_3); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 429, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + * + * if self.predicate is None: + * return True # <<<<<<<<<<<<<< + * else: + * relative_event = fast_clone(event) +*/ + __Pyx_TraceLine(429,54,0,__PYX_ERR(0, 429, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_True); + __pyx_r = Py_True; + __Pyx_TraceReturnValue(__pyx_r, 54, 0, __PYX_ERR(0, 429, __pyx_L1_error)); + goto __pyx_L0; /* "hunter/_predicates.pyx":428 - * else: - * predicates = [self] - * if isinstance(other, And): # <<<<<<<<<<<<<< - * predicates.extend(( other).predicates) - * else: - */ - goto __pyx_L4; + * return False + * + * if self.predicate is None: # <<<<<<<<<<<<<< + * return True + * else: +*/ } /* "hunter/_predicates.pyx":431 - * predicates.extend(( other).predicates) - * else: - * predicates.append(other) # <<<<<<<<<<<<<< - * return And(*predicates) - * - */ - __Pyx_TraceLine(431,0,__PYX_ERR(0, 431, __pyx_L1_error)) + * return True + * else: + * relative_event = fast_clone(event) # <<<<<<<<<<<<<< + * relative_event.depth = delta_depth + * relative_event.calls = delta_calls +*/ + __Pyx_TraceLine(431,56,0,__PYX_ERR(0, 431, __pyx_L1_error)) /*else*/ { - __pyx_t_4 = __Pyx_PyList_Append(__pyx_v_predicates, __pyx_v_other); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 431, __pyx_L1_error) - } - __pyx_L4:; + __pyx_t_3 = ((PyObject *)__pyx_f_6hunter_6_event_fast_clone(__pyx_v_event)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 431, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_relative_event = ((struct __pyx_obj_6hunter_6_event_Event *)__pyx_t_3); + __pyx_t_3 = 0; - /* "hunter/_predicates.pyx":432 - * else: - * predicates.append(other) - * return And(*predicates) # <<<<<<<<<<<<<< + /* "hunter/_predicates.pyx":432 + * else: + * relative_event = fast_clone(event) + * relative_event.depth = delta_depth # <<<<<<<<<<<<<< + * relative_event.calls = delta_calls + * return fast_call(self.predicate, relative_event) +*/ + __Pyx_TraceLine(432,60,0,__PYX_ERR(0, 432, __pyx_L1_error)) + __pyx_v_relative_event->depth = __pyx_v_delta_depth; + + /* "hunter/_predicates.pyx":433 + * relative_event = fast_clone(event) + * relative_event.depth = delta_depth + * relative_event.calls = delta_calls # <<<<<<<<<<<<<< + * return fast_call(self.predicate, relative_event) * - * def __invert__(self): - */ - __Pyx_TraceLine(432,0,__PYX_ERR(0, 432, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = PySequence_Tuple(__pyx_v_predicates); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 432, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_And), __pyx_t_3, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 432, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; - goto __pyx_L0; +*/ + __Pyx_TraceLine(433,63,0,__PYX_ERR(0, 433, __pyx_L1_error)) + __pyx_v_relative_event->calls = __pyx_v_delta_calls; - /* "hunter/_predicates.pyx":422 - * return Or(self, other) + /* "hunter/_predicates.pyx":434 + * relative_event.depth = delta_depth + * relative_event.calls = delta_calls + * return fast_call(self.predicate, relative_event) # <<<<<<<<<<<<<< * - * def __and__(self, other): # <<<<<<<<<<<<<< - * cdef list predicates - * if type(self) is And: - */ + * +*/ + __Pyx_TraceLine(434,66,0,__PYX_ERR(0, 434, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = __pyx_v_self->predicate; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_2 = __pyx_f_6hunter_11_predicates_fast_call(__pyx_t_3, __pyx_v_relative_event); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 434, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_TraceReturnValue(__pyx_r, 66, 0, __PYX_ERR(0, 434, __pyx_L1_error)); + goto __pyx_L0; + } + + /* "hunter/_predicates.pyx":407 + * return Not(self) + * + * cdef inline fast_From_call(From self, Event event): # <<<<<<<<<<<<<< + * cdef object result + * cdef int delta_depth +*/ /* function exit code */ __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("hunter._predicates.And.__and__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 407, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.fast_From_call", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; - __Pyx_XDECREF(__pyx_v_predicates); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF((PyObject *)__pyx_v_relative_event); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":434 - * return And(*predicates) - * - * def __invert__(self): # <<<<<<<<<<<<<< - * return Not(self) +/* "hunter/_predicates.pyx":442 + * `And` predicate. Exits at the first sub-predicate that returns ``False``. + * """ + * def __init__(self, *predicates): # <<<<<<<<<<<<<< + * self.predicates = predicates * - */ +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_3And_17__invert__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_3And_17__invert__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; +static int __pyx_pw_6hunter_11_predicates_3And_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_6hunter_11_predicates_3And_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_predicates = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__invert__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_3And_16__invert__(((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return -1; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__init__", __pyx_kwds); return -1;} + __Pyx_INCREF(__pyx_args); + __pyx_v_predicates = __pyx_args; + __pyx_r = __pyx_pf_6hunter_11_predicates_3And___init__(((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v_self), __pyx_v_predicates); /* function exit code */ + __Pyx_DECREF(__pyx_v_predicates); __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_3And_16__invert__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations +static int __pyx_pf_6hunter_11_predicates_3And___init__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self, PyObject *__pyx_v_predicates) { + int __pyx_r; + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__invert__", 0); - __Pyx_TraceCall("__invert__", __pyx_f[0], 434, 0, __PYX_ERR(0, 434, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[77])) + __Pyx_RefNannySetupContext("__init__", 0); + __Pyx_TraceStartFunc("__init__", __pyx_f[0], 442, 0, 0, 0, __PYX_ERR(0, 442, __pyx_L1_error)); - /* "hunter/_predicates.pyx":435 - * - * def __invert__(self): - * return Not(self) # <<<<<<<<<<<<<< + /* "hunter/_predicates.pyx":443 + * """ + * def __init__(self, *predicates): + * self.predicates = predicates # <<<<<<<<<<<<<< * - * cdef inline fast_And_call(And self, Event event): - */ - __Pyx_TraceLine(435,0,__PYX_ERR(0, 435, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_6hunter_11_predicates_Not), ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 435, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + * def __str__(self): +*/ + __Pyx_TraceLine(443,1,0,__PYX_ERR(0, 443, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_predicates); + __Pyx_GIVEREF(__pyx_v_predicates); + __Pyx_GOTREF(__pyx_v_self->predicates); + __Pyx_DECREF(__pyx_v_self->predicates); + __pyx_v_self->predicates = __pyx_v_predicates; - /* "hunter/_predicates.pyx":434 - * return And(*predicates) - * - * def __invert__(self): # <<<<<<<<<<<<<< - * return Not(self) + /* "hunter/_predicates.pyx":442 + * `And` predicate. Exits at the first sub-predicate that returns ``False``. + * """ + * def __init__(self, *predicates): # <<<<<<<<<<<<<< + * self.predicates = predicates * - */ +*/ /* function exit code */ + __pyx_r = 0; + __Pyx_TraceReturnCValue(__pyx_r, __Pyx_Owned_Py_None, 0, 0, __PYX_ERR(0, 442, __pyx_L1_error)); + goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.And.__invert__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 442, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.And.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pxd":24 - * cdef class And: - * cdef: - * readonly tuple predicates # <<<<<<<<<<<<<< +/* "hunter/_predicates.pyx":445 + * self.predicates = predicates * - * @cython.final - */ + * def __str__(self): # <<<<<<<<<<<<<< + * return 'And(%s)' % ', '.join(str(p) for p in self.predicates) + * +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_3And_10predicates_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_3And_10predicates_1__get__(PyObject *__pyx_v_self) { +static PyObject *__pyx_pw_6hunter_11_predicates_3And_3__str__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_3And_3__str__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_3And_10predicates___get__(((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_3And_2__str__(((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } +static PyObject *__pyx_gb_6hunter_11_predicates_3And_7__str___2generator3(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ -static PyObject *__pyx_pf_6hunter_11_predicates_3And_10predicates___get__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self) { +/* "hunter/_predicates.pyx":446 + * + * def __str__(self): + * return 'And(%s)' % ', '.join(str(p) for p in self.predicates) # <<<<<<<<<<<<<< + * + * def __repr__(self): +*/ + +static PyObject *__pyx_pf_6hunter_11_predicates_3And_7__str___genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0) { + struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr *__pyx_cur_scope; PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 24, 0, __PYX_ERR(1, 24, __pyx_L1_error)); - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->predicates); - __pyx_r = __pyx_v_self->predicates; - goto __pyx_L0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("genexpr", 0); + __pyx_cur_scope = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr *)__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_4_genexpr(__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_4_genexpr, __pyx_mstate_global->__pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(0, 446, __pyx_L1_error) + } else { + __Pyx_GOTREF((PyObject *)__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_genexpr_arg_0 = __pyx_genexpr_arg_0; + __Pyx_INCREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + { + __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_6hunter_11_predicates_3And_7__str___2generator3, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[78]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_genexpr, __pyx_mstate_global->__pyx_n_u_str___locals_genexpr, __pyx_mstate_global->__pyx_n_u_hunter__predicates); if (unlikely(!gen)) __PYX_ERR(0, 446, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } /* function exit code */ __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.And.predicates.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("hunter._predicates.And.__str__.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; - __pyx_L0:; + __Pyx_DECREF((PyObject *)__pyx_cur_scope); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_3And_19__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_3And_19__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { - PyObject *__pyx_r = 0; +static PyObject *__pyx_gb_6hunter_11_predicates_3And_7__str___2generator3(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr *__pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsGen + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_3And_18__reduce_cython__(((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v_self)); + __Pyx_RefNannySetupContext("genexpr", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + default: /* CPython raises the right error here */ + __Pyx_TraceStartGen("genexpr", __pyx_f[0], 446, 0, 0, 0, __PYX_ERR(0, 446, __pyx_L1_error)); + __Pyx_TraceReturnValue(Py_None, 0, 0, __PYX_ERR(0, 446, __pyx_L1_error)); + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + __Pyx_TraceStartGen("genexpr", __pyx_f[0], 446, 0, 0, 0, __PYX_ERR(0, 446, __pyx_L1_error)); + if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 446, __pyx_L1_error) + __pyx_r = PyList_New(0); if (unlikely(!__pyx_r)) __PYX_ERR(0, 446, __pyx_L1_error) + __Pyx_GOTREF(__pyx_r); + if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(0, 446, __pyx_L1_error) } + if (unlikely(__pyx_cur_scope->__pyx_genexpr_arg_0 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 446, __pyx_L1_error) + } + __pyx_t_1 = __pyx_cur_scope->__pyx_genexpr_arg_0; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 446, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2)); + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); + #endif + ++__pyx_t_2; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 446, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_p); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_p, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; + __Pyx_TraceLine(446,0,0,__PYX_ERR(0, 446, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyObject_Unicode(__pyx_cur_scope->__pyx_v_p); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 446, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (unlikely(__Pyx_ListComp_Append(__pyx_r, (PyObject*)__pyx_t_3))) __PYX_ERR(0, 446, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + __Pyx_TraceReturnValue(Py_None, 0, 0, __PYX_ERR(0, 446, __pyx_L1_error)); /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_r); __pyx_r = 0; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + if (__Pyx_PyErr_Occurred()) { + __Pyx_TraceException(__pyx_lineno, 0, 0); + __Pyx_Generator_Replace_StopIteration(0); + __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceExceptionUnwind(0, 0); + } + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + #if !CYTHON_USE_EXC_INFO_STACK + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + #endif + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_3And_18__reduce_cython__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self) { - PyObject *__pyx_v_state = 0; - PyObject *__pyx_v__dict = 0; - int __pyx_v_use_setstate; +/* "hunter/_predicates.pyx":445 + * self.predicates = predicates + * + * def __str__(self): # <<<<<<<<<<<<<< + * return 'And(%s)' % ', '.join(str(p) for p in self.predicates) + * +*/ + +static PyObject *__pyx_pf_6hunter_11_predicates_3And_2__str__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self) { + PyObject *__pyx_gb_6hunter_11_predicates_3And_7__str___2generator3 = 0; PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - int __pyx_t_2; - int __pyx_t_3; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - __Pyx_RefNannySetupContext("__reduce_cython__", 0); - __Pyx_TraceCall("__reduce_cython__", __pyx_f[2], 1, 0, __PYX_ERR(2, 1, __pyx_L1_error)); + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[79])) + __Pyx_RefNannySetupContext("__str__", 0); + __Pyx_TraceStartFunc("__str__", __pyx_f[0], 445, 0, 0, 0, __PYX_ERR(0, 445, __pyx_L1_error)); - /* "(tree fragment)":5 - * cdef object _dict - * cdef bint use_setstate - * state = (self.predicates,) # <<<<<<<<<<<<<< - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: - */ - __Pyx_TraceLine(5,0,__PYX_ERR(2, 5, __pyx_L1_error)) - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5, __pyx_L1_error) + /* "hunter/_predicates.pyx":446 + * + * def __str__(self): + * return 'And(%s)' % ', '.join(str(p) for p in self.predicates) # <<<<<<<<<<<<<< + * + * def __repr__(self): +*/ + __Pyx_TraceLine(446,1,0,__PYX_ERR(0, 446, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_pf_6hunter_11_predicates_3And_7__str___genexpr(NULL, __pyx_v_self->predicates); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 446, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v_self->predicates); - __Pyx_GIVEREF(__pyx_v_self->predicates); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->predicates); - __pyx_v_state = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - - /* "(tree fragment)":6 - * cdef bint use_setstate - * state = (self.predicates,) - * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< - * if _dict is not None: - * state += (_dict,) - */ - __Pyx_TraceLine(6,0,__PYX_ERR(2, 6, __pyx_L1_error)) - __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 6, __pyx_L1_error) + __pyx_t_2 = __Pyx_Generator_GetInlinedResult(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 446, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__4, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 446, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_v__dict = __pyx_t_1; - __pyx_t_1 = 0; - - /* "(tree fragment)":7 - * state = (self.predicates,) - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: # <<<<<<<<<<<<<< - * state += (_dict,) - * use_setstate = True - */ - __Pyx_TraceLine(7,0,__PYX_ERR(2, 7, __pyx_L1_error)) - __pyx_t_2 = (__pyx_v__dict != Py_None); - __pyx_t_3 = (__pyx_t_2 != 0); - if (__pyx_t_3) { - - /* "(tree fragment)":8 - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: - * state += (_dict,) # <<<<<<<<<<<<<< - * use_setstate = True - * else: - */ - __Pyx_TraceLine(8,0,__PYX_ERR(2, 8, __pyx_L1_error)) - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v__dict); - __Pyx_GIVEREF(__pyx_v__dict); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict); - __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4)); - __pyx_t_4 = 0; - - /* "(tree fragment)":9 - * if _dict is not None: - * state += (_dict,) - * use_setstate = True # <<<<<<<<<<<<<< - * else: - * use_setstate = self.predicates is not None - */ - __Pyx_TraceLine(9,0,__PYX_ERR(2, 9, __pyx_L1_error)) - __pyx_v_use_setstate = 1; - - /* "(tree fragment)":7 - * state = (self.predicates,) - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: # <<<<<<<<<<<<<< - * state += (_dict,) - * use_setstate = True - */ - goto __pyx_L3; - } - - /* "(tree fragment)":11 - * use_setstate = True - * else: - * use_setstate = self.predicates is not None # <<<<<<<<<<<<<< - * if use_setstate: - * return __pyx_unpickle_And, (type(self), 0xaa8cbda, None), state - */ - __Pyx_TraceLine(11,0,__PYX_ERR(2, 11, __pyx_L1_error)) - /*else*/ { - __pyx_t_3 = (__pyx_v_self->predicates != ((PyObject*)Py_None)); - __pyx_v_use_setstate = __pyx_t_3; - } - __pyx_L3:; - - /* "(tree fragment)":12 - * else: - * use_setstate = self.predicates is not None - * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_And, (type(self), 0xaa8cbda, None), state - * else: - */ - __Pyx_TraceLine(12,0,__PYX_ERR(2, 12, __pyx_L1_error)) - __pyx_t_3 = (__pyx_v_use_setstate != 0); - if (__pyx_t_3) { - - /* "(tree fragment)":13 - * use_setstate = self.predicates is not None - * if use_setstate: - * return __pyx_unpickle_And, (type(self), 0xaa8cbda, None), state # <<<<<<<<<<<<<< - * else: - * return __pyx_unpickle_And, (type(self), 0xaa8cbda, state) - */ - __Pyx_TraceLine(13,0,__PYX_ERR(2, 13, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_And); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_INCREF(__pyx_int_178834394); - __Pyx_GIVEREF(__pyx_int_178834394); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_178834394); - __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(Py_None); - PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None); - __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1); - __Pyx_INCREF(__pyx_v_state); - __Pyx_GIVEREF(__pyx_v_state); - PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state); - __pyx_t_4 = 0; - __pyx_t_1 = 0; - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; - goto __pyx_L0; - - /* "(tree fragment)":12 - * else: - * use_setstate = self.predicates is not None - * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_And, (type(self), 0xaa8cbda, None), state - * else: - */ - } - - /* "(tree fragment)":15 - * return __pyx_unpickle_And, (type(self), 0xaa8cbda, None), state - * else: - * return __pyx_unpickle_And, (type(self), 0xaa8cbda, state) # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_And__set_state(self, __pyx_state) - */ - __Pyx_TraceLine(15,0,__PYX_ERR(2, 15, __pyx_L1_error)) - /*else*/ { - __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_And); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_INCREF(__pyx_int_178834394); - __Pyx_GIVEREF(__pyx_int_178834394); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_178834394); - __Pyx_INCREF(__pyx_v_state); - __Pyx_GIVEREF(__pyx_v_state); - PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state); - __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_5); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1); - __pyx_t_5 = 0; - __pyx_t_1 = 0; - __pyx_r = __pyx_t_4; - __pyx_t_4 = 0; - goto __pyx_L0; - } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyUnicode_Format(__pyx_mstate_global->__pyx_kp_u_And_s, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 446, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 446, __pyx_L1_error)); + goto __pyx_L0; - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict - */ + /* "hunter/_predicates.pyx":445 + * self.predicates = predicates + * + * def __str__(self): # <<<<<<<<<<<<<< + * return 'And(%s)' % ', '.join(str(p) for p in self.predicates) + * +*/ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("hunter._predicates.And.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 445, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.And.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF(__pyx_v_state); - __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XDECREF(__pyx_gb_6hunter_11_predicates_3And_7__str___2generator3); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "(tree fragment)":16 - * else: - * return __pyx_unpickle_And, (type(self), 0xaa8cbda, state) - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle_And__set_state(self, __pyx_state) - */ +/* "hunter/_predicates.pyx":448 + * return 'And(%s)' % ', '.join(str(p) for p in self.predicates) + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return '' % (self.predicates,) + * +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_3And_21__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_3And_21__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_6hunter_11_predicates_3And_5__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_3And_5__repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_3And_20__setstate_cython__(((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_3And_4__repr__(((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_3And_20__setstate_cython__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pf_6hunter_11_predicates_3And_4__repr__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__setstate_cython__", 0); - __Pyx_TraceCall("__setstate_cython__", __pyx_f[2], 16, 0, __PYX_ERR(2, 16, __pyx_L1_error)); + PyObject *__pyx_t_2[3]; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[80])) + __Pyx_RefNannySetupContext("__repr__", 0); + __Pyx_TraceStartFunc("__repr__", __pyx_f[0], 448, 0, 0, 0, __PYX_ERR(0, 448, __pyx_L1_error)); - /* "(tree fragment)":17 - * return __pyx_unpickle_And, (type(self), 0xaa8cbda, state) - * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_And__set_state(self, __pyx_state) # <<<<<<<<<<<<<< - */ - __Pyx_TraceLine(17,0,__PYX_ERR(2, 17, __pyx_L1_error)) - if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(2, 17, __pyx_L1_error) - __pyx_t_1 = __pyx_f_6hunter_11_predicates___pyx_unpickle_And__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 17, __pyx_L1_error) + /* "hunter/_predicates.pyx":449 + * + * def __repr__(self): + * return '' % (self.predicates,) # <<<<<<<<<<<<<< + * + * def __eq__(self, other): +*/ + __Pyx_TraceLine(449,1,0,__PYX_ERR(0, 449, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_self->predicates), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 449, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2[0] = __pyx_mstate_global->__pyx_kp_u_hunter__predicates_And_predicat; + __pyx_t_2[1] = __pyx_t_1; + __pyx_t_2[2] = __pyx_mstate_global->__pyx_kp_u__8; + __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_2, 3, 36 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1)); + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 449, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 449, __pyx_L1_error)); + goto __pyx_L0; - /* "(tree fragment)":16 - * else: - * return __pyx_unpickle_And, (type(self), 0xaa8cbda, state) - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle_And__set_state(self, __pyx_state) - */ + /* "hunter/_predicates.pyx":448 + * return 'And(%s)' % ', '.join(str(p) for p in self.predicates) + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return '' % (self.predicates,) + * +*/ /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.And.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 448, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.And.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":437 - * return Not(self) +/* "hunter/_predicates.pyx":451 + * return '' % (self.predicates,) * - * cdef inline fast_And_call(And self, Event event): # <<<<<<<<<<<<<< - * for predicate in self.predicates: - * if not fast_call(predicate, event): - */ + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return ( + * isinstance(other, And) +*/ -static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_fast_And_call(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { - PyObject *__pyx_v_predicate = NULL; +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_3And_7__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_3And_7__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_3And_6__eq__(((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_11_predicates_3And_6__eq__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self, PyObject *__pyx_v_other) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - Py_ssize_t __pyx_t_2; + int __pyx_t_2; PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - int __pyx_t_5; - __Pyx_RefNannySetupContext("fast_And_call", 0); - __Pyx_TraceCall("fast_And_call", __pyx_f[0], 437, 0, __PYX_ERR(0, 437, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[81])) + __Pyx_RefNannySetupContext("__eq__", 0); + __Pyx_TraceStartFunc("__eq__", __pyx_f[0], 451, 0, 0, 0, __PYX_ERR(0, 451, __pyx_L1_error)); - /* "hunter/_predicates.pyx":438 + /* "hunter/_predicates.pyx":452 * - * cdef inline fast_And_call(And self, Event event): - * for predicate in self.predicates: # <<<<<<<<<<<<<< - * if not fast_call(predicate, event): - * return False - */ - __Pyx_TraceLine(438,0,__PYX_ERR(0, 438, __pyx_L1_error)) - if (unlikely(__pyx_v_self->predicates == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(0, 438, __pyx_L1_error) - } - __pyx_t_1 = __pyx_v_self->predicates; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; - for (;;) { - if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 438, __pyx_L1_error) - #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 438, __pyx_L1_error) + * def __eq__(self, other): + * return ( # <<<<<<<<<<<<<< + * isinstance(other, And) + * and self.predicates == ( other).predicates +*/ + __Pyx_TraceLine(452,1,0,__PYX_ERR(0, 452, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + + /* "hunter/_predicates.pyx":453 + * def __eq__(self, other): + * return ( + * isinstance(other, And) # <<<<<<<<<<<<<< + * and self.predicates == ( other).predicates + * ) +*/ + __Pyx_TraceLine(453,5,0,__PYX_ERR(0, 453, __pyx_L1_error)) + __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_other, __pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_And); + if (__pyx_t_2) { + } else { + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 453, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - #endif - __Pyx_XDECREF_SET(__pyx_v_predicate, __pyx_t_3); + __pyx_t_1 = __pyx_t_3; __pyx_t_3 = 0; + goto __pyx_L3_bool_binop_done; + } - /* "hunter/_predicates.pyx":439 - * cdef inline fast_And_call(And self, Event event): - * for predicate in self.predicates: - * if not fast_call(predicate, event): # <<<<<<<<<<<<<< - * return False - * else: - */ - __Pyx_TraceLine(439,0,__PYX_ERR(0, 439, __pyx_L1_error)) - __pyx_t_3 = __pyx_f_6hunter_11_predicates_fast_call(__pyx_v_predicate, __pyx_v_event); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 439, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 439, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_5 = ((!__pyx_t_4) != 0); - if (__pyx_t_5) { - - /* "hunter/_predicates.pyx":440 - * for predicate in self.predicates: - * if not fast_call(predicate, event): - * return False # <<<<<<<<<<<<<< - * else: - * return True - */ - __Pyx_TraceLine(440,0,__PYX_ERR(0, 440, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(Py_False); - __pyx_r = Py_False; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - goto __pyx_L0; - - /* "hunter/_predicates.pyx":439 - * cdef inline fast_And_call(And self, Event event): - * for predicate in self.predicates: - * if not fast_call(predicate, event): # <<<<<<<<<<<<<< - * return False - * else: - */ - } - - /* "hunter/_predicates.pyx":438 - * - * cdef inline fast_And_call(And self, Event event): - * for predicate in self.predicates: # <<<<<<<<<<<<<< - * if not fast_call(predicate, event): - * return False - */ - __Pyx_TraceLine(438,0,__PYX_ERR(0, 438, __pyx_L1_error)) - } - /*else*/ { - - /* "hunter/_predicates.pyx":442 - * return False - * else: - * return True # <<<<<<<<<<<<<< - * - * - */ - __Pyx_TraceLine(442,0,__PYX_ERR(0, 442, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(Py_True); - __pyx_r = Py_True; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - goto __pyx_L0; - } - - /* "hunter/_predicates.pyx":438 + /* "hunter/_predicates.pyx":454 + * return ( + * isinstance(other, And) + * and self.predicates == ( other).predicates # <<<<<<<<<<<<<< + * ) * - * cdef inline fast_And_call(And self, Event event): - * for predicate in self.predicates: # <<<<<<<<<<<<<< - * if not fast_call(predicate, event): - * return False - */ - __Pyx_TraceLine(438,0,__PYX_ERR(0, 438, __pyx_L1_error)) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; +*/ + __Pyx_TraceLine(454,12,0,__PYX_ERR(0, 454, __pyx_L1_error)) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->predicates, ((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v_other)->predicates, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 454, __pyx_L1_error) + __Pyx_INCREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_L3_bool_binop_done:; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 452, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":437 - * return Not(self) + /* "hunter/_predicates.pyx":451 + * return '' % (self.predicates,) * - * cdef inline fast_And_call(And self, Event event): # <<<<<<<<<<<<<< - * for predicate in self.predicates: - * if not fast_call(predicate, event): - */ + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return ( + * isinstance(other, And) +*/ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("hunter._predicates.fast_And_call", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 451, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.And.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF(__pyx_v_predicate); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":451 - * """ +/* "hunter/_predicates.pyx":457 + * ) * - * def __init__(self, *predicates): # <<<<<<<<<<<<<< - * self.predicates = predicates + * def __call__(self, Event event): # <<<<<<<<<<<<<< + * return fast_And_call(self, event) * - */ +*/ /* Python wrapper */ -static int __pyx_pw_6hunter_11_predicates_2Or_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static int __pyx_pw_6hunter_11_predicates_2Or_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v_predicates = 0; - int __pyx_r; +static PyObject *__pyx_pw_6hunter_11_predicates_3And_9__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_3And_9__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); - if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1; - __Pyx_INCREF(__pyx_args); - __pyx_v_predicates = __pyx_args; - __pyx_r = __pyx_pf_6hunter_11_predicates_2Or___init__(((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_self), __pyx_v_predicates); + __Pyx_RefNannySetupContext("__call__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_event,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 457, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 457, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__call__", 0) < 0) __PYX_ERR(0, 457, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__call__", 1, 1, 1, i); __PYX_ERR(0, 457, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 457, __pyx_L3_error) + } + __pyx_v_event = ((struct __pyx_obj_6hunter_6_event_Event *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__call__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 457, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("hunter._predicates.And.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_event), __pyx_mstate_global->__pyx_ptype_6hunter_6_event_Event, 1, "event", 0))) __PYX_ERR(0, 457, __pyx_L1_error) + __pyx_r = __pyx_pf_6hunter_11_predicates_3And_8__call__(((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v_self), __pyx_v_event); /* function exit code */ - __Pyx_XDECREF(__pyx_v_predicates); + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static int __pyx_pf_6hunter_11_predicates_2Or___init__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self, PyObject *__pyx_v_predicates) { - int __pyx_r; - __Pyx_TraceDeclarations +static PyObject *__pyx_pf_6hunter_11_predicates_3And_8__call__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__init__", 0); - __Pyx_TraceCall("__init__", __pyx_f[0], 451, 0, __PYX_ERR(0, 451, __pyx_L1_error)); + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[82])) + __Pyx_RefNannySetupContext("__call__", 0); + __Pyx_TraceStartFunc("__call__", __pyx_f[0], 457, 0, 0, 0, __PYX_ERR(0, 457, __pyx_L1_error)); - /* "hunter/_predicates.pyx":452 + /* "hunter/_predicates.pyx":458 * - * def __init__(self, *predicates): - * self.predicates = predicates # <<<<<<<<<<<<<< + * def __call__(self, Event event): + * return fast_And_call(self, event) # <<<<<<<<<<<<<< * - * def __str__(self): - */ - __Pyx_TraceLine(452,0,__PYX_ERR(0, 452, __pyx_L1_error)) - __Pyx_INCREF(__pyx_v_predicates); - __Pyx_GIVEREF(__pyx_v_predicates); - __Pyx_GOTREF(__pyx_v_self->predicates); - __Pyx_DECREF(__pyx_v_self->predicates); - __pyx_v_self->predicates = __pyx_v_predicates; + * def __or__(self, other): +*/ + __Pyx_TraceLine(458,1,0,__PYX_ERR(0, 458, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6hunter_11_predicates_fast_And_call(__pyx_v_self, __pyx_v_event); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 458, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 458, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":451 - * """ + /* "hunter/_predicates.pyx":457 + * ) * - * def __init__(self, *predicates): # <<<<<<<<<<<<<< - * self.predicates = predicates + * def __call__(self, Event event): # <<<<<<<<<<<<<< + * return fast_And_call(self, event) * - */ +*/ /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.Or.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 457, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.And.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; __pyx_L0:; - __Pyx_TraceReturn(Py_None, 0); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":454 - * self.predicates = predicates +/* "hunter/_predicates.pyx":460 + * return fast_And_call(self, event) * - * def __str__(self): # <<<<<<<<<<<<<< - * return 'Or(%s)' % ', '.join(str(p) for p in self.predicates) + * def __or__(self, other): # <<<<<<<<<<<<<< + * return Or(self, other) * - */ +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_2Or_3__str__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_2Or_3__str__(PyObject *__pyx_v_self) { +static PyObject *__pyx_pw_6hunter_11_predicates_3And_11__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_3And_11__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_2Or_2__str__(((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__or__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_3And_10__or__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_gb_6hunter_11_predicates_2Or_7__str___2generator6(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ - -/* "hunter/_predicates.pyx":455 - * - * def __str__(self): - * return 'Or(%s)' % ', '.join(str(p) for p in self.predicates) # <<<<<<<<<<<<<< - * - * def __repr__(self): - */ -static PyObject *__pyx_pf_6hunter_11_predicates_2Or_7__str___genexpr(PyObject *__pyx_self) { - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_12_genexpr *__pyx_cur_scope; +static PyObject *__pyx_pf_6hunter_11_predicates_3And_10__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("genexpr", 0); - __pyx_cur_scope = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_12_genexpr *)__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_12_genexpr(__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_12_genexpr, __pyx_empty_tuple, NULL); - if (unlikely(!__pyx_cur_scope)) { - __pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_12_genexpr *)Py_None); - __Pyx_INCREF(Py_None); - __PYX_ERR(0, 455, __pyx_L1_error) - } else { - __Pyx_GOTREF(__pyx_cur_scope); - } - __pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_11___str__ *) __pyx_self; - __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_outer_scope)); - __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope); + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[83])) + __Pyx_RefNannySetupContext("__or__", 0); + __Pyx_TraceStartFunc("__or__", __pyx_f[0], 460, 0, 0, 0, __PYX_ERR(0, 460, __pyx_L1_error)); + + /* "hunter/_predicates.pyx":461 + * + * def __or__(self, other): + * return Or(self, other) # <<<<<<<<<<<<<< + * + * def __and__(self, other): +*/ + __Pyx_TraceLine(461,1,0,__PYX_ERR(0, 461, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = NULL; + __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Or); + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Or); + __pyx_t_4 = 1; { - __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_6hunter_11_predicates_2Or_7__str___2generator6, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_str___locals_genexpr, __pyx_n_s_hunter__predicates); if (unlikely(!gen)) __PYX_ERR(0, 455, __pyx_L1_error) - __Pyx_DECREF(__pyx_cur_scope); - __Pyx_RefNannyFinishContext(); - return (PyObject *) gen; + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_v_self, __pyx_v_other}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 461, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_1); } + __pyx_r = ((PyObject *)__pyx_t_1); + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 461, __pyx_L1_error)); + goto __pyx_L0; + + /* "hunter/_predicates.pyx":460 + * return fast_And_call(self, event) + * + * def __or__(self, other): # <<<<<<<<<<<<<< + * return Or(self, other) + * +*/ /* function exit code */ __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.Or.__str__.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 460, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.And.__or__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; - __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_gb_6hunter_11_predicates_2Or_7__str___2generator6(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ -{ - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_12_genexpr *__pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_12_genexpr *)__pyx_generator->closure); - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - PyObject *__pyx_t_1 = NULL; - Py_ssize_t __pyx_t_2; - PyObject *__pyx_t_3 = NULL; +/* "hunter/_predicates.pyx":463 + * return Or(self, other) + * + * def __and__(self, other): # <<<<<<<<<<<<<< + * cdef list predicates + * if type(self) is And: +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_3And_13__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_3And_13__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("genexpr", 0); - __Pyx_TraceCall("genexpr", __pyx_f[0], 455, 0, __PYX_ERR(0, 455, __pyx_L1_error)); - switch (__pyx_generator->resume_label) { - case 0: goto __pyx_L3_first_run; - case 1: goto __pyx_L6_resume_from_yield; - default: /* CPython raises the right error here */ - __Pyx_TraceReturn(Py_None, 0); - __Pyx_RefNannyFinishContext(); - return NULL; - } - __pyx_L3_first_run:; - if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 455, __pyx_L1_error) - if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 455, __pyx_L1_error) } - if (unlikely(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->predicates == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(0, 455, __pyx_L1_error) - } - __pyx_t_1 = __pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->predicates; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; - for (;;) { - if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 455, __pyx_L1_error) - #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 455, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - #endif - __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_p); - __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_p, __pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyString_Type)), __pyx_cur_scope->__pyx_v_p); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 455, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_r = __pyx_t_3; - __pyx_t_3 = 0; - __Pyx_XGIVEREF(__pyx_t_1); - __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; - __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - __Pyx_Coroutine_ResetAndClearException(__pyx_generator); - /* return from generator, yielding value */ - __pyx_generator->resume_label = 1; - return __pyx_r; - __pyx_L6_resume_from_yield:; - __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; - __pyx_cur_scope->__pyx_t_0 = 0; - __Pyx_XGOTREF(__pyx_t_1); - __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; - if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 455, __pyx_L1_error) - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + __Pyx_RefNannySetupContext("__and__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_3And_12__and__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); /* function exit code */ - PyErr_SetNone(PyExc_StopIteration); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_L0:; - __Pyx_XDECREF(__pyx_r); __pyx_r = 0; - #if !CYTHON_USE_EXC_INFO_STACK - __Pyx_Coroutine_ResetAndClearException(__pyx_generator); - #endif - __pyx_generator->resume_label = -1; - __Pyx_Coroutine_clear((PyObject*)__pyx_generator); - __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":454 - * self.predicates = predicates - * - * def __str__(self): # <<<<<<<<<<<<<< - * return 'Or(%s)' % ', '.join(str(p) for p in self.predicates) - * - */ - -static PyObject *__pyx_pf_6hunter_11_predicates_2Or_2__str__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self) { - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_11___str__ *__pyx_cur_scope; +static PyObject *__pyx_pf_6hunter_11_predicates_3And_12__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_v_predicates = 0; PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; + int __pyx_t_1; PyObject *__pyx_t_2 = NULL; - __Pyx_RefNannySetupContext("__str__", 0); - __pyx_cur_scope = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_11___str__ *)__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_11___str__(__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_11___str__, __pyx_empty_tuple, NULL); - if (unlikely(!__pyx_cur_scope)) { - __pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_11___str__ *)Py_None); - __Pyx_INCREF(Py_None); - __PYX_ERR(0, 454, __pyx_L1_error) - } else { - __Pyx_GOTREF(__pyx_cur_scope); + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[84])) + __Pyx_RefNannySetupContext("__and__", 0); + __Pyx_TraceStartFunc("__and__", __pyx_f[0], 463, 0, 0, 0, __PYX_ERR(0, 463, __pyx_L1_error)); + + /* "hunter/_predicates.pyx":465 + * def __and__(self, other): + * cdef list predicates + * if type(self) is And: # <<<<<<<<<<<<<< + * predicates = list(( self).predicates) + * else: +*/ + __Pyx_TraceLine(465,6,0,__PYX_ERR(0, 465, __pyx_L1_error)) + __pyx_t_1 = (((PyObject *)Py_TYPE(__pyx_v_self)) == ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_And)); + if (__pyx_t_1) { + + /* "hunter/_predicates.pyx":466 + * cdef list predicates + * if type(self) is And: + * predicates = list(( self).predicates) # <<<<<<<<<<<<<< + * else: + * predicates = [self] +*/ + __Pyx_TraceLine(466,9,0,__PYX_ERR(0, 466, __pyx_L1_error)) + __pyx_t_2 = PySequence_List(((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v_self)->predicates); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 466, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_predicates = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "hunter/_predicates.pyx":465 + * def __and__(self, other): + * cdef list predicates + * if type(self) is And: # <<<<<<<<<<<<<< + * predicates = list(( self).predicates) + * else: +*/ + goto __pyx_L3; + } + + /* "hunter/_predicates.pyx":468 + * predicates = list(( self).predicates) + * else: + * predicates = [self] # <<<<<<<<<<<<<< + * if isinstance(other, And): + * predicates.extend(( other).predicates) +*/ + __Pyx_TraceLine(468,14,0,__PYX_ERR(0, 468, __pyx_L1_error)) + /*else*/ { + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 468, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_self); + __Pyx_GIVEREF(__pyx_v_self); + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_v_self) != (0)) __PYX_ERR(0, 468, __pyx_L1_error); + __pyx_v_predicates = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + } + __pyx_L3:; + + /* "hunter/_predicates.pyx":469 + * else: + * predicates = [self] + * if isinstance(other, And): # <<<<<<<<<<<<<< + * predicates.extend(( other).predicates) + * else: +*/ + __Pyx_TraceLine(469,20,0,__PYX_ERR(0, 469, __pyx_L1_error)) + __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_other, __pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_And); + if (__pyx_t_1) { + + /* "hunter/_predicates.pyx":470 + * predicates = [self] + * if isinstance(other, And): + * predicates.extend(( other).predicates) # <<<<<<<<<<<<<< + * else: + * predicates.append(other) +*/ + __Pyx_TraceLine(470,26,0,__PYX_ERR(0, 470, __pyx_L1_error)) + __pyx_t_2 = ((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v_other)->predicates; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyList_Extend(__pyx_v_predicates, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 470, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "hunter/_predicates.pyx":469 + * else: + * predicates = [self] + * if isinstance(other, And): # <<<<<<<<<<<<<< + * predicates.extend(( other).predicates) + * else: +*/ + goto __pyx_L4; } - __Pyx_TraceCall("__str__", __pyx_f[0], 454, 0, __PYX_ERR(0, 454, __pyx_L1_error)); - __pyx_cur_scope->__pyx_v_self = __pyx_v_self; - __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self); - __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self); - /* "hunter/_predicates.pyx":455 + /* "hunter/_predicates.pyx":472 + * predicates.extend(( other).predicates) + * else: + * predicates.append(other) # <<<<<<<<<<<<<< + * return And(*predicates) * - * def __str__(self): - * return 'Or(%s)' % ', '.join(str(p) for p in self.predicates) # <<<<<<<<<<<<<< +*/ + __Pyx_TraceLine(472,29,0,__PYX_ERR(0, 472, __pyx_L1_error)) + /*else*/ { + __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_predicates, __pyx_v_other); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 472, __pyx_L1_error) + } + __pyx_L4:; + + /* "hunter/_predicates.pyx":473 + * else: + * predicates.append(other) + * return And(*predicates) # <<<<<<<<<<<<<< * - * def __repr__(self): - */ - __Pyx_TraceLine(455,0,__PYX_ERR(0, 455, __pyx_L1_error)) + * def __invert__(self): +*/ + __Pyx_TraceLine(473,31,0,__PYX_ERR(0, 473, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_pf_6hunter_11_predicates_2Or_7__str___genexpr(((PyObject*)__pyx_cur_scope)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 455, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyString_Join(__pyx_kp_s__3, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 455, __pyx_L1_error) + __pyx_t_2 = PySequence_Tuple(__pyx_v_predicates); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 473, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Or_s, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 455, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_And), __pyx_t_2, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 473, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + __Pyx_TraceReturnValue(__pyx_r, 31, 0, __PYX_ERR(0, 473, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_predicates.pyx":454 - * self.predicates = predicates - * - * def __str__(self): # <<<<<<<<<<<<<< - * return 'Or(%s)' % ', '.join(str(p) for p in self.predicates) + /* "hunter/_predicates.pyx":463 + * return Or(self, other) * - */ + * def __and__(self, other): # <<<<<<<<<<<<<< + * cdef list predicates + * if type(self) is And: +*/ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("hunter._predicates.Or.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 463, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.And.__and__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __Pyx_XDECREF(__pyx_v_predicates); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":457 - * return 'Or(%s)' % ', '.join(str(p) for p in self.predicates) +/* "hunter/_predicates.pyx":475 + * return And(*predicates) * - * def __repr__(self): # <<<<<<<<<<<<<< - * return '' % (self.predicates,) + * def __invert__(self): # <<<<<<<<<<<<<< + * return Not(self) * - */ +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_2Or_5__repr__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_2Or_5__repr__(PyObject *__pyx_v_self) { +static PyObject *__pyx_pw_6hunter_11_predicates_3And_15__invert__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_3And_15__invert__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_2Or_4__repr__(((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__invert__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_3And_14__invert__(((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_2Or_4__repr__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self) { +static PyObject *__pyx_pf_6hunter_11_predicates_3And_14__invert__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; - __Pyx_RefNannySetupContext("__repr__", 0); - __Pyx_TraceCall("__repr__", __pyx_f[0], 457, 0, __PYX_ERR(0, 457, __pyx_L1_error)); + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[85])) + __Pyx_RefNannySetupContext("__invert__", 0); + __Pyx_TraceStartFunc("__invert__", __pyx_f[0], 475, 0, 0, 0, __PYX_ERR(0, 475, __pyx_L1_error)); - /* "hunter/_predicates.pyx":458 + /* "hunter/_predicates.pyx":476 * - * def __repr__(self): - * return '' % (self.predicates,) # <<<<<<<<<<<<<< + * def __invert__(self): + * return Not(self) # <<<<<<<<<<<<<< * - * def __eq__(self, other): - */ - __Pyx_TraceLine(458,0,__PYX_ERR(0, 458, __pyx_L1_error)) + * cdef inline fast_And_call(And self, Event event): +*/ + __Pyx_TraceLine(476,1,0,__PYX_ERR(0, 476, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 458, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v_self->predicates); - __Pyx_GIVEREF(__pyx_v_self->predicates); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->predicates); - __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_hunter__predicates_Or_predicate, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 458, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Not); + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Not); + __pyx_t_4 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, ((PyObject *)__pyx_v_self)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 476, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_1); + } + __pyx_r = ((PyObject *)__pyx_t_1); + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 476, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_predicates.pyx":457 - * return 'Or(%s)' % ', '.join(str(p) for p in self.predicates) + /* "hunter/_predicates.pyx":475 + * return And(*predicates) * - * def __repr__(self): # <<<<<<<<<<<<<< - * return '' % (self.predicates,) + * def __invert__(self): # <<<<<<<<<<<<<< + * return Not(self) * - */ +*/ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("hunter._predicates.Or.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 475, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.And.__invert__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":460 - * return '' % (self.predicates,) +/* "hunter/_predicates.pxd":25 + * cdef class And: + * cdef: + * readonly tuple predicates # <<<<<<<<<<<<<< * - * def __eq__(self, other): # <<<<<<<<<<<<<< - * return ( - * isinstance(other, Or) - */ + * +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_2Or_7__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_2Or_7__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { +static PyObject *__pyx_pw_6hunter_11_predicates_3And_10predicates_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_3And_10predicates_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_2Or_6__eq__(((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_3And_10predicates___get__(((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_2Or_6__eq__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self, PyObject *__pyx_v_other) { +static PyObject *__pyx_pf_6hunter_11_predicates_3And_10predicates___get__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - __Pyx_RefNannySetupContext("__eq__", 0); - __Pyx_TraceCall("__eq__", __pyx_f[0], 460, 0, __PYX_ERR(0, 460, __pyx_L1_error)); - - /* "hunter/_predicates.pyx":461 - * - * def __eq__(self, other): - * return ( # <<<<<<<<<<<<<< - * isinstance(other, Or) - * and self.predicates == ( other).predicates - */ - __Pyx_TraceLine(461,0,__PYX_ERR(0, 461, __pyx_L1_error)) + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[86])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 25, 0, 0, 0, __PYX_ERR(2, 25, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); - - /* "hunter/_predicates.pyx":462 - * def __eq__(self, other): - * return ( - * isinstance(other, Or) # <<<<<<<<<<<<<< - * and self.predicates == ( other).predicates - * ) - */ - __Pyx_TraceLine(462,0,__PYX_ERR(0, 462, __pyx_L1_error)) - __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_other, __pyx_ptype_6hunter_11_predicates_Or); - if (__pyx_t_2) { - } else { - __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 462, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __pyx_t_3; - __pyx_t_3 = 0; - goto __pyx_L3_bool_binop_done; - } - - /* "hunter/_predicates.pyx":463 - * return ( - * isinstance(other, Or) - * and self.predicates == ( other).predicates # <<<<<<<<<<<<<< - * ) - * - */ - __Pyx_TraceLine(463,0,__PYX_ERR(0, 463, __pyx_L1_error)) - __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->predicates, ((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_other)->predicates, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 463, __pyx_L1_error) - __Pyx_INCREF(__pyx_t_3); - __pyx_t_1 = __pyx_t_3; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_L3_bool_binop_done:; - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "hunter/_predicates.pyx":460 - * return '' % (self.predicates,) - * - * def __eq__(self, other): # <<<<<<<<<<<<<< - * return ( - * isinstance(other, Or) - */ + __Pyx_INCREF(__pyx_v_self->predicates); + __pyx_r = __pyx_v_self->predicates; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 25, __pyx_L1_error)); + goto __pyx_L0; /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("hunter._predicates.Or.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 25, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.And.predicates.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":466 - * ) - * - * def __hash__(self): # <<<<<<<<<<<<<< - * return hash(('Or', self.predicates)) - * - */ +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ /* Python wrapper */ -static Py_hash_t __pyx_pw_6hunter_11_predicates_2Or_9__hash__(PyObject *__pyx_v_self); /*proto*/ -static Py_hash_t __pyx_pw_6hunter_11_predicates_2Or_9__hash__(PyObject *__pyx_v_self) { - Py_hash_t __pyx_r; +static PyObject *__pyx_pw_6hunter_11_predicates_3And_17__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_11_predicates_3And_17__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_3And_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_11_predicates_3And_17__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__hash__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_2Or_8__hash__(((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_6hunter_11_predicates_3And_16__reduce_cython__(((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static Py_hash_t __pyx_pf_6hunter_11_predicates_2Or_8__hash__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self) { - Py_hash_t __pyx_r; - __Pyx_TraceDeclarations +static PyObject *__pyx_pf_6hunter_11_predicates_3And_16__reduce_cython__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - Py_hash_t __pyx_t_2; - __Pyx_RefNannySetupContext("__hash__", 0); - __Pyx_TraceCall("__hash__", __pyx_f[0], 466, 0, __PYX_ERR(0, 466, __pyx_L1_error)); + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[87])) + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + __Pyx_TraceStartFunc("__reduce_cython__", __pyx_f[1], 1, 0, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); - /* "hunter/_predicates.pyx":467 - * - * def __hash__(self): - * return hash(('Or', self.predicates)) # <<<<<<<<<<<<<< - * - * def __call__(self, Event event): - */ - __Pyx_TraceLine(467,0,__PYX_ERR(0, 467, __pyx_L1_error)) - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 467, __pyx_L1_error) + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self.predicates,) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: +*/ + __Pyx_TraceLine(5,2,0,__PYX_ERR(1, 5, __pyx_L1_error)) + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_n_s_Or); - __Pyx_GIVEREF(__pyx_n_s_Or); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_Or); __Pyx_INCREF(__pyx_v_self->predicates); __Pyx_GIVEREF(__pyx_v_self->predicates); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->predicates); - __pyx_t_2 = PyObject_Hash(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_hash_t)-1))) __PYX_ERR(0, 467, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_2; - goto __pyx_L0; + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->predicates) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; - /* "hunter/_predicates.pyx":466 - * ) - * - * def __hash__(self): # <<<<<<<<<<<<<< - * return hash(('Or', self.predicates)) - * - */ + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.predicates,) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) +*/ + __Pyx_TraceLine(6,6,0,__PYX_ERR(1, 6, __pyx_L1_error)) + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self.predicates,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + __Pyx_TraceLine(7,13,0,__PYX_ERR(1, 7, __pyx_L1_error)) + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: +*/ + __Pyx_TraceLine(8,15,0,__PYX_ERR(1, 8, __pyx_L1_error)) + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict) != (0)) __PYX_ERR(1, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self.predicates is not None +*/ + __Pyx_TraceLine(9,17,0,__PYX_ERR(1, 9, __pyx_L1_error)) + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self.predicates,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self.predicates is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_And, (type(self), 0x8e21672, None), state +*/ + __Pyx_TraceLine(11,21,0,__PYX_ERR(1, 11, __pyx_L1_error)) + /*else*/ { + __pyx_t_2 = (__pyx_v_self->predicates != ((PyObject*)Py_None)); + __pyx_v_use_setstate = __pyx_t_2; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.predicates is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_And, (type(self), 0x8e21672, None), state + * else: +*/ + __Pyx_TraceLine(12,24,0,__PYX_ERR(1, 12, __pyx_L1_error)) + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self.predicates is not None + * if use_setstate: + * return __pyx_unpickle_And, (type(self), 0x8e21672, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_And, (type(self), 0x8e21672, state) +*/ + __Pyx_TraceLine(13,25,0,__PYX_ERR(1, 13, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_And); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_149034610); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_149034610); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_mstate_global->__pyx_int_149034610) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + __Pyx_TraceReturnValue(__pyx_r, 25, 0, __PYX_ERR(1, 13, __pyx_L1_error)); + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.predicates is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_And, (type(self), 0x8e21672, None), state + * else: +*/ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_And, (type(self), 0x8e21672, None), state + * else: + * return __pyx_unpickle_And, (type(self), 0x8e21672, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_And__set_state(self, __pyx_state) +*/ + __Pyx_TraceLine(15,33,0,__PYX_ERR(1, 15, __pyx_L1_error)) + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_And); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_149034610); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_149034610); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_mstate_global->__pyx_int_149034610) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + __Pyx_TraceReturnValue(__pyx_r, 33, 0, __PYX_ERR(1, 15, __pyx_L1_error)); + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.Or.__hash__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.And.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; __pyx_L0:; - if (unlikely(__pyx_r == -1) && !PyErr_Occurred()) __pyx_r = -2; - __Pyx_TraceReturn(Py_None, 0); + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":469 - * return hash(('Or', self.predicates)) - * - * def __call__(self, Event event): # <<<<<<<<<<<<<< - * return fast_Or_call(self, event) - * - */ +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_And, (type(self), 0x8e21672, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_And__set_state(self, __pyx_state) +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_2Or_11__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_2Or_11__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event = 0; +static PyObject *__pyx_pw_6hunter_11_predicates_3And_19__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_11_predicates_3And_19__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_3And_19__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_11_predicates_3And_19__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__call__ (wrapper)", 0); + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_event,0}; - PyObject* values[1] = {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 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 16, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) 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_event)) != 0)) kw_args--; - else goto __pyx_L5_argtuple_error; + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 16, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 16, __pyx_L3_error) } } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__call__") < 0)) __PYX_ERR(0, 469, __pyx_L3_error) - } - } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { + } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) } - __pyx_v_event = ((struct __pyx_obj_6hunter_6_event_Event *)values[0]); + __pyx_v___pyx_state = values[0]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__call__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 469, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - __Pyx_AddTraceback("hunter._predicates.Or.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("hunter._predicates.And.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_event), __pyx_ptype_6hunter_6_event_Event, 1, "event", 0))) __PYX_ERR(0, 469, __pyx_L1_error) - __pyx_r = __pyx_pf_6hunter_11_predicates_2Or_10__call__(((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_self), __pyx_v_event); + __pyx_r = __pyx_pf_6hunter_11_predicates_3And_18__setstate_cython__(((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ - goto __pyx_L0; - __pyx_L1_error:; - __pyx_r = NULL; - __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_2Or_10__call__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { +static PyObject *__pyx_pf_6hunter_11_predicates_3And_18__setstate_cython__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__call__", 0); - __Pyx_TraceCall("__call__", __pyx_f[0], 469, 0, __PYX_ERR(0, 469, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[88])) + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + __Pyx_TraceStartFunc("__setstate_cython__", __pyx_f[1], 16, 0, 0, 0, __PYX_ERR(1, 16, __pyx_L1_error)); - /* "hunter/_predicates.pyx":470 - * - * def __call__(self, Event event): - * return fast_Or_call(self, event) # <<<<<<<<<<<<<< - * - * def __or__(self, other): - */ - __Pyx_TraceLine(470,0,__PYX_ERR(0, 470, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_f_6hunter_11_predicates_fast_Or_call(__pyx_v_self, __pyx_v_event); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 470, __pyx_L1_error) + /* "(tree fragment)":17 + * return __pyx_unpickle_And, (type(self), 0x8e21672, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_And__set_state(self, __pyx_state) # <<<<<<<<<<<<<< +*/ + __Pyx_TraceLine(17,4,0,__PYX_ERR(1, 17, __pyx_L1_error)) + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_6hunter_11_predicates___pyx_unpickle_And__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "hunter/_predicates.pyx":469 - * return hash(('Or', self.predicates)) - * - * def __call__(self, Event event): # <<<<<<<<<<<<<< - * return fast_Or_call(self, event) - * - */ + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_And, (type(self), 0x8e21672, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_And__set_state(self, __pyx_state) +*/ /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(1, 16, __pyx_L1_error)); + goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.Or.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 16, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.And.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":472 - * return fast_Or_call(self, event) +/* "hunter/_predicates.pyx":478 + * return Not(self) * - * def __or__(self, other): # <<<<<<<<<<<<<< - * cdef list predicates - * if type(self) is Or: - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_2Or_13__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_2Or_13__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__or__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_2Or_12__or__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + * cdef inline fast_And_call(And self, Event event): # <<<<<<<<<<<<<< + * for predicate in self.predicates: + * if not fast_call(predicate, event): +*/ -static PyObject *__pyx_pf_6hunter_11_predicates_2Or_12__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { - PyObject *__pyx_v_predicates = 0; +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_fast_And_call(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { + PyObject *__pyx_v_predicate = NULL; PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - __Pyx_RefNannySetupContext("__or__", 0); - __Pyx_TraceCall("__or__", __pyx_f[0], 472, 0, __PYX_ERR(0, 472, __pyx_L1_error)); - - /* "hunter/_predicates.pyx":474 - * def __or__(self, other): - * cdef list predicates - * if type(self) is Or: # <<<<<<<<<<<<<< - * predicates = list(( self).predicates) - * else: - */ - __Pyx_TraceLine(474,0,__PYX_ERR(0, 474, __pyx_L1_error)) - __pyx_t_1 = (((PyObject *)Py_TYPE(__pyx_v_self)) == ((PyObject *)__pyx_ptype_6hunter_11_predicates_Or)); - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { - - /* "hunter/_predicates.pyx":475 - * cdef list predicates - * if type(self) is Or: - * predicates = list(( self).predicates) # <<<<<<<<<<<<<< - * else: - * predicates = [self] - */ - __Pyx_TraceLine(475,0,__PYX_ERR(0, 475, __pyx_L1_error)) - __pyx_t_3 = PySequence_List(((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_self)->predicates); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 475, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_v_predicates = ((PyObject*)__pyx_t_3); - __pyx_t_3 = 0; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[89])) + __Pyx_RefNannySetupContext("fast_And_call", 0); + __Pyx_TraceStartFunc("fast_And_call", __pyx_f[0], 478, 0, 0, 0, __PYX_ERR(0, 478, __pyx_L1_error)); - /* "hunter/_predicates.pyx":474 - * def __or__(self, other): - * cdef list predicates - * if type(self) is Or: # <<<<<<<<<<<<<< - * predicates = list(( self).predicates) - * else: - */ - goto __pyx_L3; + /* "hunter/_predicates.pyx":479 + * + * cdef inline fast_And_call(And self, Event event): + * for predicate in self.predicates: # <<<<<<<<<<<<<< + * if not fast_call(predicate, event): + * return False +*/ + __Pyx_TraceLine(479,4,0,__PYX_ERR(0, 479, __pyx_L1_error)) + if (unlikely(__pyx_v_self->predicates == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 479, __pyx_L1_error) } - - /* "hunter/_predicates.pyx":477 - * predicates = list(( self).predicates) - * else: - * predicates = [self] # <<<<<<<<<<<<<< - * if type(other) is Or: - * predicates.extend(( other).predicates) - */ - __Pyx_TraceLine(477,0,__PYX_ERR(0, 477, __pyx_L1_error)) - /*else*/ { - __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 477, __pyx_L1_error) + __pyx_t_1 = __pyx_v_self->predicates; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 479, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2)); + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); + #endif + ++__pyx_t_2; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 479, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(__pyx_v_self); - __Pyx_GIVEREF(__pyx_v_self); - PyList_SET_ITEM(__pyx_t_3, 0, __pyx_v_self); - __pyx_v_predicates = ((PyObject*)__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_predicate, __pyx_t_3); __pyx_t_3 = 0; - } - __pyx_L3:; + __Pyx_TraceLine(479,1,0,__PYX_ERR(0, 479, __pyx_L1_error)) - /* "hunter/_predicates.pyx":478 - * else: - * predicates = [self] - * if type(other) is Or: # <<<<<<<<<<<<<< - * predicates.extend(( other).predicates) - * else: - */ - __Pyx_TraceLine(478,0,__PYX_ERR(0, 478, __pyx_L1_error)) - __pyx_t_2 = (((PyObject *)Py_TYPE(__pyx_v_other)) == ((PyObject *)__pyx_ptype_6hunter_11_predicates_Or)); - __pyx_t_1 = (__pyx_t_2 != 0); - if (__pyx_t_1) { - - /* "hunter/_predicates.pyx":479 - * predicates = [self] - * if type(other) is Or: - * predicates.extend(( other).predicates) # <<<<<<<<<<<<<< - * else: - * predicates.append(other) - */ - __Pyx_TraceLine(479,0,__PYX_ERR(0, 479, __pyx_L1_error)) - __pyx_t_3 = ((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_other)->predicates; - __Pyx_INCREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyList_Extend(__pyx_v_predicates, __pyx_t_3); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 479, __pyx_L1_error) + /* "hunter/_predicates.pyx":480 + * cdef inline fast_And_call(And self, Event event): + * for predicate in self.predicates: + * if not fast_call(predicate, event): # <<<<<<<<<<<<<< + * return False + * else: +*/ + __Pyx_TraceLine(480,8,0,__PYX_ERR(0, 480, __pyx_L1_error)) + __pyx_t_3 = __pyx_f_6hunter_11_predicates_fast_call(__pyx_v_predicate, __pyx_v_event); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 480, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 480, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = (!__pyx_t_4); + if (__pyx_t_5) { - /* "hunter/_predicates.pyx":478 - * else: - * predicates = [self] - * if type(other) is Or: # <<<<<<<<<<<<<< - * predicates.extend(( other).predicates) - * else: - */ - goto __pyx_L4; - } + /* "hunter/_predicates.pyx":481 + * for predicate in self.predicates: + * if not fast_call(predicate, event): + * return False # <<<<<<<<<<<<<< + * else: + * return True +*/ + __Pyx_TraceLine(481,11,0,__PYX_ERR(0, 481, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + __Pyx_TraceReturnValue(__pyx_r, 11, 0, __PYX_ERR(0, 481, __pyx_L1_error)); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; - /* "hunter/_predicates.pyx":481 - * predicates.extend(( other).predicates) - * else: - * predicates.append(other) # <<<<<<<<<<<<<< - * return Or(*predicates) + /* "hunter/_predicates.pyx":480 + * cdef inline fast_And_call(And self, Event event): + * for predicate in self.predicates: + * if not fast_call(predicate, event): # <<<<<<<<<<<<<< + * return False + * else: +*/ + } + + /* "hunter/_predicates.pyx":479 * - */ - __Pyx_TraceLine(481,0,__PYX_ERR(0, 481, __pyx_L1_error)) - /*else*/ { - __pyx_t_4 = __Pyx_PyList_Append(__pyx_v_predicates, __pyx_v_other); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 481, __pyx_L1_error) + * cdef inline fast_And_call(And self, Event event): + * for predicate in self.predicates: # <<<<<<<<<<<<<< + * if not fast_call(predicate, event): + * return False +*/ + __Pyx_TraceLine(479,1,0,__PYX_ERR(0, 479, __pyx_L1_error)) } - __pyx_L4:; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /*else*/ { - /* "hunter/_predicates.pyx":482 - * else: - * predicates.append(other) - * return Or(*predicates) # <<<<<<<<<<<<<< + /* "hunter/_predicates.pyx":483 + * return False + * else: + * return True # <<<<<<<<<<<<<< * - * def __and__(self, other): - */ - __Pyx_TraceLine(482,0,__PYX_ERR(0, 482, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = PySequence_Tuple(__pyx_v_predicates); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 482, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_Or), __pyx_t_3, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 482, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; - goto __pyx_L0; + * +*/ + __Pyx_TraceLine(483,13,0,__PYX_ERR(0, 483, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_True); + __pyx_r = Py_True; + __Pyx_TraceReturnValue(__pyx_r, 13, 0, __PYX_ERR(0, 483, __pyx_L1_error)); + goto __pyx_L0; + } - /* "hunter/_predicates.pyx":472 - * return fast_Or_call(self, event) + /* "hunter/_predicates.pyx":478 + * return Not(self) * - * def __or__(self, other): # <<<<<<<<<<<<<< - * cdef list predicates - * if type(self) is Or: - */ + * cdef inline fast_And_call(And self, Event event): # <<<<<<<<<<<<<< + * for predicate in self.predicates: + * if not fast_call(predicate, event): +*/ /* function exit code */ __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("hunter._predicates.Or.__or__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 478, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.fast_And_call", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; - __Pyx_XDECREF(__pyx_v_predicates); + __Pyx_XDECREF(__pyx_v_predicate); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":484 - * return Or(*predicates) +/* "hunter/_predicates.pyx":492 + * """ * - * def __and__(self, other): # <<<<<<<<<<<<<< - * return And(self, other) + * def __init__(self, *predicates): # <<<<<<<<<<<<<< + * self.predicates = predicates * - */ +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_2Or_15__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_2Or_15__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { - PyObject *__pyx_r = 0; +static int __pyx_pw_6hunter_11_predicates_2Or_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_6hunter_11_predicates_2Or_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_predicates = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__and__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_2Or_14__and__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return -1; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__init__", __pyx_kwds); return -1;} + __Pyx_INCREF(__pyx_args); + __pyx_v_predicates = __pyx_args; + __pyx_r = __pyx_pf_6hunter_11_predicates_2Or___init__(((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_self), __pyx_v_predicates); /* function exit code */ + __Pyx_DECREF(__pyx_v_predicates); __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_2Or_14__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations +static int __pyx_pf_6hunter_11_predicates_2Or___init__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self, PyObject *__pyx_v_predicates) { + int __pyx_r; + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - __Pyx_RefNannySetupContext("__and__", 0); - __Pyx_TraceCall("__and__", __pyx_f[0], 484, 0, __PYX_ERR(0, 484, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[90])) + __Pyx_RefNannySetupContext("__init__", 0); + __Pyx_TraceStartFunc("__init__", __pyx_f[0], 492, 0, 0, 0, __PYX_ERR(0, 492, __pyx_L1_error)); - /* "hunter/_predicates.pyx":485 + /* "hunter/_predicates.pyx":493 * - * def __and__(self, other): - * return And(self, other) # <<<<<<<<<<<<<< + * def __init__(self, *predicates): + * self.predicates = predicates # <<<<<<<<<<<<<< * - * def __invert__(self): - */ - __Pyx_TraceLine(485,0,__PYX_ERR(0, 485, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 485, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v_self); - __Pyx_GIVEREF(__pyx_v_self); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self); - __Pyx_INCREF(__pyx_v_other); - __Pyx_GIVEREF(__pyx_v_other); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_other); - __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_And), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 485, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; + * def __str__(self): +*/ + __Pyx_TraceLine(493,1,0,__PYX_ERR(0, 493, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_predicates); + __Pyx_GIVEREF(__pyx_v_predicates); + __Pyx_GOTREF(__pyx_v_self->predicates); + __Pyx_DECREF(__pyx_v_self->predicates); + __pyx_v_self->predicates = __pyx_v_predicates; - /* "hunter/_predicates.pyx":484 - * return Or(*predicates) + /* "hunter/_predicates.pyx":492 + * """ * - * def __and__(self, other): # <<<<<<<<<<<<<< - * return And(self, other) + * def __init__(self, *predicates): # <<<<<<<<<<<<<< + * self.predicates = predicates * - */ +*/ /* function exit code */ + __pyx_r = 0; + __Pyx_TraceReturnCValue(__pyx_r, __Pyx_Owned_Py_None, 0, 0, __PYX_ERR(0, 492, __pyx_L1_error)); + goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("hunter._predicates.Or.__and__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 492, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Or.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":487 - * return And(self, other) +/* "hunter/_predicates.pyx":495 + * self.predicates = predicates * - * def __invert__(self): # <<<<<<<<<<<<<< - * return Not(self) + * def __str__(self): # <<<<<<<<<<<<<< + * return 'Or(%s)' % ', '.join(str(p) for p in self.predicates) * - */ +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_2Or_17__invert__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_2Or_17__invert__(PyObject *__pyx_v_self) { +static PyObject *__pyx_pw_6hunter_11_predicates_2Or_3__str__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_2Or_3__str__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__invert__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_2Or_16__invert__(((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_2Or_2__str__(((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } +static PyObject *__pyx_gb_6hunter_11_predicates_2Or_7__str___2generator4(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ + +/* "hunter/_predicates.pyx":496 + * + * def __str__(self): + * return 'Or(%s)' % ', '.join(str(p) for p in self.predicates) # <<<<<<<<<<<<<< + * + * def __repr__(self): +*/ -static PyObject *__pyx_pf_6hunter_11_predicates_2Or_16__invert__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self) { +static PyObject *__pyx_pf_6hunter_11_predicates_2Or_7__str___genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0) { + struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5_genexpr *__pyx_cur_scope; PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("genexpr", 0); + __pyx_cur_scope = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5_genexpr *)__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_5_genexpr(__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_5_genexpr, __pyx_mstate_global->__pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5_genexpr *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(0, 496, __pyx_L1_error) + } else { + __Pyx_GOTREF((PyObject *)__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_genexpr_arg_0 = __pyx_genexpr_arg_0; + __Pyx_INCREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + { + __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_6hunter_11_predicates_2Or_7__str___2generator4, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[91]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_genexpr, __pyx_mstate_global->__pyx_n_u_str___locals_genexpr, __pyx_mstate_global->__pyx_n_u_hunter__predicates); if (unlikely(!gen)) __PYX_ERR(0, 496, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("hunter._predicates.Or.__str__.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF((PyObject *)__pyx_cur_scope); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_6hunter_11_predicates_2Or_7__str___2generator4(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5_genexpr *__pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5_genexpr *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsGen PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__invert__", 0); - __Pyx_TraceCall("__invert__", __pyx_f[0], 487, 0, __PYX_ERR(0, 487, __pyx_L1_error)); + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("genexpr", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + default: /* CPython raises the right error here */ + __Pyx_TraceStartGen("genexpr", __pyx_f[0], 496, 0, 0, 0, __PYX_ERR(0, 496, __pyx_L1_error)); + __Pyx_TraceReturnValue(Py_None, 0, 0, __PYX_ERR(0, 496, __pyx_L1_error)); + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + __Pyx_TraceStartGen("genexpr", __pyx_f[0], 496, 0, 0, 0, __PYX_ERR(0, 496, __pyx_L1_error)); + if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 496, __pyx_L1_error) + __pyx_r = PyList_New(0); if (unlikely(!__pyx_r)) __PYX_ERR(0, 496, __pyx_L1_error) + __Pyx_GOTREF(__pyx_r); + if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(0, 496, __pyx_L1_error) } + if (unlikely(__pyx_cur_scope->__pyx_genexpr_arg_0 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 496, __pyx_L1_error) + } + __pyx_t_1 = __pyx_cur_scope->__pyx_genexpr_arg_0; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 496, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2)); + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); + #endif + ++__pyx_t_2; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 496, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_p); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_p, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; + __Pyx_TraceLine(496,0,0,__PYX_ERR(0, 496, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyObject_Unicode(__pyx_cur_scope->__pyx_v_p); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 496, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (unlikely(__Pyx_ListComp_Append(__pyx_r, (PyObject*)__pyx_t_3))) __PYX_ERR(0, 496, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + __Pyx_TraceReturnValue(Py_None, 0, 0, __PYX_ERR(0, 496, __pyx_L1_error)); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_r); __pyx_r = 0; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + if (__Pyx_PyErr_Occurred()) { + __Pyx_TraceException(__pyx_lineno, 0, 0); + __Pyx_Generator_Replace_StopIteration(0); + __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceExceptionUnwind(0, 0); + } + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + #if !CYTHON_USE_EXC_INFO_STACK + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + #endif + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":488 +/* "hunter/_predicates.pyx":495 + * self.predicates = predicates * - * def __invert__(self): - * return Not(self) # <<<<<<<<<<<<<< + * def __str__(self): # <<<<<<<<<<<<<< + * return 'Or(%s)' % ', '.join(str(p) for p in self.predicates) * - * cdef inline fast_Or_call(Or self, Event event): - */ - __Pyx_TraceLine(488,0,__PYX_ERR(0, 488, __pyx_L1_error)) +*/ + +static PyObject *__pyx_pf_6hunter_11_predicates_2Or_2__str__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self) { + PyObject *__pyx_gb_6hunter_11_predicates_2Or_7__str___2generator4 = 0; + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[92])) + __Pyx_RefNannySetupContext("__str__", 0); + __Pyx_TraceStartFunc("__str__", __pyx_f[0], 495, 0, 0, 0, __PYX_ERR(0, 495, __pyx_L1_error)); + + /* "hunter/_predicates.pyx":496 + * + * def __str__(self): + * return 'Or(%s)' % ', '.join(str(p) for p in self.predicates) # <<<<<<<<<<<<<< + * + * def __repr__(self): +*/ + __Pyx_TraceLine(496,1,0,__PYX_ERR(0, 496, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_6hunter_11_predicates_Not), ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 488, __pyx_L1_error) + __pyx_t_1 = __pyx_pf_6hunter_11_predicates_2Or_7__str___genexpr(NULL, __pyx_v_self->predicates); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 496, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; + __pyx_t_2 = __Pyx_Generator_GetInlinedResult(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 496, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__4, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 496, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyUnicode_Format(__pyx_mstate_global->__pyx_kp_u_Or_s, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 496, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 496, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_predicates.pyx":487 - * return And(self, other) + /* "hunter/_predicates.pyx":495 + * self.predicates = predicates * - * def __invert__(self): # <<<<<<<<<<<<<< - * return Not(self) + * def __str__(self): # <<<<<<<<<<<<<< + * return 'Or(%s)' % ', '.join(str(p) for p in self.predicates) * - */ +*/ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.Or.__invert__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 495, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Or.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; + __Pyx_XDECREF(__pyx_gb_6hunter_11_predicates_2Or_7__str___2generator4); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pxd":29 - * cdef class Or: - * cdef: - * readonly tuple predicates # <<<<<<<<<<<<<< +/* "hunter/_predicates.pyx":498 + * return 'Or(%s)' % ', '.join(str(p) for p in self.predicates) * - * @cython.final - */ + * def __repr__(self): # <<<<<<<<<<<<<< + * return '' % (self.predicates,) + * +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_2Or_10predicates_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_2Or_10predicates_1__get__(PyObject *__pyx_v_self) { +static PyObject *__pyx_pw_6hunter_11_predicates_2Or_5__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_2Or_5__repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_2Or_10predicates___get__(((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_2Or_4__repr__(((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_2Or_10predicates___get__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self) { +static PyObject *__pyx_pf_6hunter_11_predicates_2Or_4__repr__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 29, 0, __PYX_ERR(1, 29, __pyx_L1_error)); + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2[3]; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[93])) + __Pyx_RefNannySetupContext("__repr__", 0); + __Pyx_TraceStartFunc("__repr__", __pyx_f[0], 498, 0, 0, 0, __PYX_ERR(0, 498, __pyx_L1_error)); + + /* "hunter/_predicates.pyx":499 + * + * def __repr__(self): + * return '' % (self.predicates,) # <<<<<<<<<<<<<< + * + * def __eq__(self, other): +*/ + __Pyx_TraceLine(499,1,0,__PYX_ERR(0, 499, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->predicates); - __pyx_r = __pyx_v_self->predicates; + __pyx_t_1 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_self->predicates), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 499, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2[0] = __pyx_mstate_global->__pyx_kp_u_hunter__predicates_Or_predicate; + __pyx_t_2[1] = __pyx_t_1; + __pyx_t_2[2] = __pyx_mstate_global->__pyx_kp_u__8; + __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_2, 3, 35 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1)); + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 499, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 499, __pyx_L1_error)); goto __pyx_L0; + /* "hunter/_predicates.pyx":498 + * return 'Or(%s)' % ', '.join(str(p) for p in self.predicates) + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return '' % (self.predicates,) + * +*/ + /* function exit code */ __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.Or.predicates.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 498, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Or.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict - */ +/* "hunter/_predicates.pyx":501 + * return '' % (self.predicates,) + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return ( + * isinstance(other, Or) +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_2Or_19__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_2Or_19__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_6hunter_11_predicates_2Or_7__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_2Or_7__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_2Or_18__reduce_cython__(((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_2Or_6__eq__(((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_self), ((PyObject *)__pyx_v_other)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_2Or_18__reduce_cython__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self) { - PyObject *__pyx_v_state = 0; - PyObject *__pyx_v__dict = 0; - int __pyx_v_use_setstate; +static PyObject *__pyx_pf_6hunter_11_predicates_2Or_6__eq__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self, PyObject *__pyx_v_other) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; - int __pyx_t_3; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - __Pyx_RefNannySetupContext("__reduce_cython__", 0); - __Pyx_TraceCall("__reduce_cython__", __pyx_f[2], 1, 0, __PYX_ERR(2, 1, __pyx_L1_error)); + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[94])) + __Pyx_RefNannySetupContext("__eq__", 0); + __Pyx_TraceStartFunc("__eq__", __pyx_f[0], 501, 0, 0, 0, __PYX_ERR(0, 501, __pyx_L1_error)); - /* "(tree fragment)":5 - * cdef object _dict - * cdef bint use_setstate - * state = (self.predicates,) # <<<<<<<<<<<<<< - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: - */ - __Pyx_TraceLine(5,0,__PYX_ERR(2, 5, __pyx_L1_error)) - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v_self->predicates); - __Pyx_GIVEREF(__pyx_v_self->predicates); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->predicates); - __pyx_v_state = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; + /* "hunter/_predicates.pyx":502 + * + * def __eq__(self, other): + * return ( # <<<<<<<<<<<<<< + * isinstance(other, Or) + * and self.predicates == ( other).predicates +*/ + __Pyx_TraceLine(502,1,0,__PYX_ERR(0, 502, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); - /* "(tree fragment)":6 - * cdef bint use_setstate - * state = (self.predicates,) - * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< - * if _dict is not None: - * state += (_dict,) - */ - __Pyx_TraceLine(6,0,__PYX_ERR(2, 6, __pyx_L1_error)) - __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v__dict = __pyx_t_1; - __pyx_t_1 = 0; + /* "hunter/_predicates.pyx":503 + * def __eq__(self, other): + * return ( + * isinstance(other, Or) # <<<<<<<<<<<<<< + * and self.predicates == ( other).predicates + * ) +*/ + __Pyx_TraceLine(503,5,0,__PYX_ERR(0, 503, __pyx_L1_error)) + __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_other, __pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Or); + if (__pyx_t_2) { + } else { + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 503, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L3_bool_binop_done; + } - /* "(tree fragment)":7 - * state = (self.predicates,) - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: # <<<<<<<<<<<<<< - * state += (_dict,) - * use_setstate = True - */ - __Pyx_TraceLine(7,0,__PYX_ERR(2, 7, __pyx_L1_error)) - __pyx_t_2 = (__pyx_v__dict != Py_None); - __pyx_t_3 = (__pyx_t_2 != 0); - if (__pyx_t_3) { - - /* "(tree fragment)":8 - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: - * state += (_dict,) # <<<<<<<<<<<<<< - * use_setstate = True - * else: - */ - __Pyx_TraceLine(8,0,__PYX_ERR(2, 8, __pyx_L1_error)) - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v__dict); - __Pyx_GIVEREF(__pyx_v__dict); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict); - __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4)); - __pyx_t_4 = 0; - - /* "(tree fragment)":9 - * if _dict is not None: - * state += (_dict,) - * use_setstate = True # <<<<<<<<<<<<<< - * else: - * use_setstate = self.predicates is not None - */ - __Pyx_TraceLine(9,0,__PYX_ERR(2, 9, __pyx_L1_error)) - __pyx_v_use_setstate = 1; - - /* "(tree fragment)":7 - * state = (self.predicates,) - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: # <<<<<<<<<<<<<< - * state += (_dict,) - * use_setstate = True - */ - goto __pyx_L3; - } - - /* "(tree fragment)":11 - * use_setstate = True - * else: - * use_setstate = self.predicates is not None # <<<<<<<<<<<<<< - * if use_setstate: - * return __pyx_unpickle_Or, (type(self), 0xaa8cbda, None), state - */ - __Pyx_TraceLine(11,0,__PYX_ERR(2, 11, __pyx_L1_error)) - /*else*/ { - __pyx_t_3 = (__pyx_v_self->predicates != ((PyObject*)Py_None)); - __pyx_v_use_setstate = __pyx_t_3; - } - __pyx_L3:; - - /* "(tree fragment)":12 - * else: - * use_setstate = self.predicates is not None - * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_Or, (type(self), 0xaa8cbda, None), state - * else: - */ - __Pyx_TraceLine(12,0,__PYX_ERR(2, 12, __pyx_L1_error)) - __pyx_t_3 = (__pyx_v_use_setstate != 0); - if (__pyx_t_3) { - - /* "(tree fragment)":13 - * use_setstate = self.predicates is not None - * if use_setstate: - * return __pyx_unpickle_Or, (type(self), 0xaa8cbda, None), state # <<<<<<<<<<<<<< - * else: - * return __pyx_unpickle_Or, (type(self), 0xaa8cbda, state) - */ - __Pyx_TraceLine(13,0,__PYX_ERR(2, 13, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Or); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_INCREF(__pyx_int_178834394); - __Pyx_GIVEREF(__pyx_int_178834394); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_178834394); - __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(Py_None); - PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None); - __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1); - __Pyx_INCREF(__pyx_v_state); - __Pyx_GIVEREF(__pyx_v_state); - PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state); - __pyx_t_4 = 0; - __pyx_t_1 = 0; - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; - goto __pyx_L0; - - /* "(tree fragment)":12 - * else: - * use_setstate = self.predicates is not None - * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_Or, (type(self), 0xaa8cbda, None), state - * else: - */ - } - - /* "(tree fragment)":15 - * return __pyx_unpickle_Or, (type(self), 0xaa8cbda, None), state - * else: - * return __pyx_unpickle_Or, (type(self), 0xaa8cbda, state) # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_Or__set_state(self, __pyx_state) - */ - __Pyx_TraceLine(15,0,__PYX_ERR(2, 15, __pyx_L1_error)) - /*else*/ { - __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_Or); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_INCREF(__pyx_int_178834394); - __Pyx_GIVEREF(__pyx_int_178834394); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_178834394); - __Pyx_INCREF(__pyx_v_state); - __Pyx_GIVEREF(__pyx_v_state); - PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state); - __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_5); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1); - __pyx_t_5 = 0; - __pyx_t_1 = 0; - __pyx_r = __pyx_t_4; - __pyx_t_4 = 0; - goto __pyx_L0; - } + /* "hunter/_predicates.pyx":504 + * return ( + * isinstance(other, Or) + * and self.predicates == ( other).predicates # <<<<<<<<<<<<<< + * ) + * +*/ + __Pyx_TraceLine(504,12,0,__PYX_ERR(0, 504, __pyx_L1_error)) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->predicates, ((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_other)->predicates, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 504, __pyx_L1_error) + __Pyx_INCREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_L3_bool_binop_done:; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 502, __pyx_L1_error)); + goto __pyx_L0; - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict - */ + /* "hunter/_predicates.pyx":501 + * return '' % (self.predicates,) + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return ( + * isinstance(other, Or) +*/ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("hunter._predicates.Or.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 501, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Or.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF(__pyx_v_state); - __Pyx_XDECREF(__pyx_v__dict); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "(tree fragment)":16 - * else: - * return __pyx_unpickle_Or, (type(self), 0xaa8cbda, state) - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle_Or__set_state(self, __pyx_state) - */ +/* "hunter/_predicates.pyx":507 + * ) + * + * def __call__(self, Event event): # <<<<<<<<<<<<<< + * return fast_Or_call(self, event) + * +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_2Or_21__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_2Or_21__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_6hunter_11_predicates_2Or_9__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_2Or_9__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_2Or_20__setstate_cython__(((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + __Pyx_RefNannySetupContext("__call__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_event,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 507, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 507, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__call__", 0) < 0) __PYX_ERR(0, 507, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__call__", 1, 1, 1, i); __PYX_ERR(0, 507, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 507, __pyx_L3_error) + } + __pyx_v_event = ((struct __pyx_obj_6hunter_6_event_Event *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__call__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 507, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("hunter._predicates.Or.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_event), __pyx_mstate_global->__pyx_ptype_6hunter_6_event_Event, 1, "event", 0))) __PYX_ERR(0, 507, __pyx_L1_error) + __pyx_r = __pyx_pf_6hunter_11_predicates_2Or_8__call__(((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_self), __pyx_v_event); /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_2Or_20__setstate_cython__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pf_6hunter_11_predicates_2Or_8__call__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__setstate_cython__", 0); - __Pyx_TraceCall("__setstate_cython__", __pyx_f[2], 16, 0, __PYX_ERR(2, 16, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[95])) + __Pyx_RefNannySetupContext("__call__", 0); + __Pyx_TraceStartFunc("__call__", __pyx_f[0], 507, 0, 0, 0, __PYX_ERR(0, 507, __pyx_L1_error)); - /* "(tree fragment)":17 - * return __pyx_unpickle_Or, (type(self), 0xaa8cbda, state) - * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_Or__set_state(self, __pyx_state) # <<<<<<<<<<<<<< - */ - __Pyx_TraceLine(17,0,__PYX_ERR(2, 17, __pyx_L1_error)) - if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(2, 17, __pyx_L1_error) - __pyx_t_1 = __pyx_f_6hunter_11_predicates___pyx_unpickle_Or__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 17, __pyx_L1_error) + /* "hunter/_predicates.pyx":508 + * + * def __call__(self, Event event): + * return fast_Or_call(self, event) # <<<<<<<<<<<<<< + * + * def __or__(self, other): +*/ + __Pyx_TraceLine(508,1,0,__PYX_ERR(0, 508, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6hunter_11_predicates_fast_Or_call(__pyx_v_self, __pyx_v_event); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 508, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 508, __pyx_L1_error)); + goto __pyx_L0; - /* "(tree fragment)":16 - * else: - * return __pyx_unpickle_Or, (type(self), 0xaa8cbda, state) - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle_Or__set_state(self, __pyx_state) - */ + /* "hunter/_predicates.pyx":507 + * ) + * + * def __call__(self, Event event): # <<<<<<<<<<<<<< + * return fast_Or_call(self, event) + * +*/ /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.Or.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 507, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Or.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":490 - * return Not(self) +/* "hunter/_predicates.pyx":510 + * return fast_Or_call(self, event) * - * cdef inline fast_Or_call(Or self, Event event): # <<<<<<<<<<<<<< - * for predicate in self.predicates: - * if fast_call(predicate, event): - */ + * def __or__(self, other): # <<<<<<<<<<<<<< + * cdef list predicates + * if type(self) is Or: +*/ -static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_fast_Or_call(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { - PyObject *__pyx_v_predicate = NULL; +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_2Or_11__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_2Or_11__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__or__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_2Or_10__or__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_11_predicates_2Or_10__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_v_predicates = 0; PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - Py_ssize_t __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - __Pyx_RefNannySetupContext("fast_Or_call", 0); - __Pyx_TraceCall("fast_Or_call", __pyx_f[0], 490, 0, __PYX_ERR(0, 490, __pyx_L1_error)); + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[96])) + __Pyx_RefNannySetupContext("__or__", 0); + __Pyx_TraceStartFunc("__or__", __pyx_f[0], 510, 0, 0, 0, __PYX_ERR(0, 510, __pyx_L1_error)); - /* "hunter/_predicates.pyx":491 - * - * cdef inline fast_Or_call(Or self, Event event): - * for predicate in self.predicates: # <<<<<<<<<<<<<< - * if fast_call(predicate, event): - * return True - */ - __Pyx_TraceLine(491,0,__PYX_ERR(0, 491, __pyx_L1_error)) - if (unlikely(__pyx_v_self->predicates == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(0, 491, __pyx_L1_error) + /* "hunter/_predicates.pyx":512 + * def __or__(self, other): + * cdef list predicates + * if type(self) is Or: # <<<<<<<<<<<<<< + * predicates = list(( self).predicates) + * else: +*/ + __Pyx_TraceLine(512,6,0,__PYX_ERR(0, 512, __pyx_L1_error)) + __pyx_t_1 = (((PyObject *)Py_TYPE(__pyx_v_self)) == ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Or)); + if (__pyx_t_1) { + + /* "hunter/_predicates.pyx":513 + * cdef list predicates + * if type(self) is Or: + * predicates = list(( self).predicates) # <<<<<<<<<<<<<< + * else: + * predicates = [self] +*/ + __Pyx_TraceLine(513,9,0,__PYX_ERR(0, 513, __pyx_L1_error)) + __pyx_t_2 = PySequence_List(((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_self)->predicates); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 513, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_predicates = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "hunter/_predicates.pyx":512 + * def __or__(self, other): + * cdef list predicates + * if type(self) is Or: # <<<<<<<<<<<<<< + * predicates = list(( self).predicates) + * else: +*/ + goto __pyx_L3; } - __pyx_t_1 = __pyx_v_self->predicates; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; - for (;;) { - if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 491, __pyx_L1_error) - #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 491, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - #endif - __Pyx_XDECREF_SET(__pyx_v_predicate, __pyx_t_3); - __pyx_t_3 = 0; - /* "hunter/_predicates.pyx":492 - * cdef inline fast_Or_call(Or self, Event event): - * for predicate in self.predicates: - * if fast_call(predicate, event): # <<<<<<<<<<<<<< - * return True - * else: - */ - __Pyx_TraceLine(492,0,__PYX_ERR(0, 492, __pyx_L1_error)) - __pyx_t_3 = __pyx_f_6hunter_11_predicates_fast_call(__pyx_v_predicate, __pyx_v_event); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 492, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 492, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_4) { + /* "hunter/_predicates.pyx":515 + * predicates = list(( self).predicates) + * else: + * predicates = [self] # <<<<<<<<<<<<<< + * if type(other) is Or: + * predicates.extend(( other).predicates) +*/ + __Pyx_TraceLine(515,14,0,__PYX_ERR(0, 515, __pyx_L1_error)) + /*else*/ { + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 515, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_self); + __Pyx_GIVEREF(__pyx_v_self); + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_v_self) != (0)) __PYX_ERR(0, 515, __pyx_L1_error); + __pyx_v_predicates = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + } + __pyx_L3:; - /* "hunter/_predicates.pyx":493 - * for predicate in self.predicates: - * if fast_call(predicate, event): - * return True # <<<<<<<<<<<<<< - * else: - * return False - */ - __Pyx_TraceLine(493,0,__PYX_ERR(0, 493, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(Py_True); - __pyx_r = Py_True; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - goto __pyx_L0; + /* "hunter/_predicates.pyx":516 + * else: + * predicates = [self] + * if type(other) is Or: # <<<<<<<<<<<<<< + * predicates.extend(( other).predicates) + * else: +*/ + __Pyx_TraceLine(516,21,0,__PYX_ERR(0, 516, __pyx_L1_error)) + __pyx_t_1 = (((PyObject *)Py_TYPE(__pyx_v_other)) == ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Or)); + if (__pyx_t_1) { - /* "hunter/_predicates.pyx":492 - * cdef inline fast_Or_call(Or self, Event event): - * for predicate in self.predicates: - * if fast_call(predicate, event): # <<<<<<<<<<<<<< - * return True - * else: - */ - } + /* "hunter/_predicates.pyx":517 + * predicates = [self] + * if type(other) is Or: + * predicates.extend(( other).predicates) # <<<<<<<<<<<<<< + * else: + * predicates.append(other) +*/ + __Pyx_TraceLine(517,27,0,__PYX_ERR(0, 517, __pyx_L1_error)) + __pyx_t_2 = ((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_other)->predicates; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyList_Extend(__pyx_v_predicates, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 517, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "hunter/_predicates.pyx":491 - * - * cdef inline fast_Or_call(Or self, Event event): - * for predicate in self.predicates: # <<<<<<<<<<<<<< - * if fast_call(predicate, event): - * return True - */ - __Pyx_TraceLine(491,0,__PYX_ERR(0, 491, __pyx_L1_error)) + /* "hunter/_predicates.pyx":516 + * else: + * predicates = [self] + * if type(other) is Or: # <<<<<<<<<<<<<< + * predicates.extend(( other).predicates) + * else: +*/ + goto __pyx_L4; } - /*else*/ { - /* "hunter/_predicates.pyx":495 - * return True - * else: - * return False # <<<<<<<<<<<<<< - * + /* "hunter/_predicates.pyx":519 + * predicates.extend(( other).predicates) + * else: + * predicates.append(other) # <<<<<<<<<<<<<< + * return Or(*predicates) * - */ - __Pyx_TraceLine(495,0,__PYX_ERR(0, 495, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(Py_False); - __pyx_r = Py_False; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - goto __pyx_L0; +*/ + __Pyx_TraceLine(519,30,0,__PYX_ERR(0, 519, __pyx_L1_error)) + /*else*/ { + __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_predicates, __pyx_v_other); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 519, __pyx_L1_error) } + __pyx_L4:; - /* "hunter/_predicates.pyx":491 + /* "hunter/_predicates.pyx":520 + * else: + * predicates.append(other) + * return Or(*predicates) # <<<<<<<<<<<<<< * - * cdef inline fast_Or_call(Or self, Event event): - * for predicate in self.predicates: # <<<<<<<<<<<<<< - * if fast_call(predicate, event): - * return True - */ - __Pyx_TraceLine(491,0,__PYX_ERR(0, 491, __pyx_L1_error)) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + * def __and__(self, other): +*/ + __Pyx_TraceLine(520,32,0,__PYX_ERR(0, 520, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = PySequence_Tuple(__pyx_v_predicates); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 520, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Or), __pyx_t_2, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 520, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + __Pyx_TraceReturnValue(__pyx_r, 32, 0, __PYX_ERR(0, 520, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":490 - * return Not(self) + /* "hunter/_predicates.pyx":510 + * return fast_Or_call(self, event) * - * cdef inline fast_Or_call(Or self, Event event): # <<<<<<<<<<<<<< - * for predicate in self.predicates: - * if fast_call(predicate, event): - */ + * def __or__(self, other): # <<<<<<<<<<<<<< + * cdef list predicates + * if type(self) is Or: +*/ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("hunter._predicates.fast_Or_call", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 510, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Or.__or__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF(__pyx_v_predicate); + __Pyx_XDECREF(__pyx_v_predicates); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":502 - * `Not` predicate. - * """ - * def __init__(self, predicate): # <<<<<<<<<<<<<< - * self.predicate = predicate +/* "hunter/_predicates.pyx":522 + * return Or(*predicates) * - */ + * def __and__(self, other): # <<<<<<<<<<<<<< + * return And(self, other) + * +*/ /* Python wrapper */ -static int __pyx_pw_6hunter_11_predicates_3Not_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static int __pyx_pw_6hunter_11_predicates_3Not_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v_predicate = 0; - int __pyx_r; +static PyObject *__pyx_pw_6hunter_11_predicates_2Or_13__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_2Or_13__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); - { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_predicate,0}; - PyObject* values[1] = {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 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_predicate)) != 0)) kw_args--; - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 502, __pyx_L3_error) - } - } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - } - __pyx_v_predicate = values[0]; - } - goto __pyx_L4_argument_unpacking_done; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 502, __pyx_L3_error) - __pyx_L3_error:; - __Pyx_AddTraceback("hunter._predicates.Not.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return -1; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6hunter_11_predicates_3Not___init__(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self), __pyx_v_predicate); + __Pyx_RefNannySetupContext("__and__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_2Or_12__and__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static int __pyx_pf_6hunter_11_predicates_3Not___init__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self, PyObject *__pyx_v_predicate) { - int __pyx_r; - __Pyx_TraceDeclarations +static PyObject *__pyx_pf_6hunter_11_predicates_2Or_12__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__init__", 0); - __Pyx_TraceCall("__init__", __pyx_f[0], 502, 0, __PYX_ERR(0, 502, __pyx_L1_error)); + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[97])) + __Pyx_RefNannySetupContext("__and__", 0); + __Pyx_TraceStartFunc("__and__", __pyx_f[0], 522, 0, 0, 0, __PYX_ERR(0, 522, __pyx_L1_error)); - /* "hunter/_predicates.pyx":503 - * """ - * def __init__(self, predicate): - * self.predicate = predicate # <<<<<<<<<<<<<< + /* "hunter/_predicates.pyx":523 * - * def __str__(self): - */ - __Pyx_TraceLine(503,0,__PYX_ERR(0, 503, __pyx_L1_error)) - __Pyx_INCREF(__pyx_v_predicate); - __Pyx_GIVEREF(__pyx_v_predicate); - __Pyx_GOTREF(__pyx_v_self->predicate); - __Pyx_DECREF(__pyx_v_self->predicate); - __pyx_v_self->predicate = __pyx_v_predicate; + * def __and__(self, other): + * return And(self, other) # <<<<<<<<<<<<<< + * + * def __invert__(self): +*/ + __Pyx_TraceLine(523,1,0,__PYX_ERR(0, 523, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = NULL; + __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_And); + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_And); + __pyx_t_4 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_v_self, __pyx_v_other}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_1); + } + __pyx_r = ((PyObject *)__pyx_t_1); + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 523, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":502 - * `Not` predicate. - * """ - * def __init__(self, predicate): # <<<<<<<<<<<<<< - * self.predicate = predicate + /* "hunter/_predicates.pyx":522 + * return Or(*predicates) * - */ + * def __and__(self, other): # <<<<<<<<<<<<<< + * return And(self, other) + * +*/ /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.Not.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 522, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Or.__and__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; __pyx_L0:; - __Pyx_TraceReturn(Py_None, 0); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":505 - * self.predicate = predicate +/* "hunter/_predicates.pyx":525 + * return And(self, other) * - * def __str__(self): # <<<<<<<<<<<<<< - * return 'Not(%s)' % self.predicate + * def __invert__(self): # <<<<<<<<<<<<<< + * return Not(self) * - */ +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_3Not_3__str__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_3Not_3__str__(PyObject *__pyx_v_self) { +static PyObject *__pyx_pw_6hunter_11_predicates_2Or_15__invert__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_2Or_15__invert__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_3Not_2__str__(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__invert__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_2Or_14__invert__(((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_3Not_2__str__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self) { +static PyObject *__pyx_pf_6hunter_11_predicates_2Or_14__invert__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__str__", 0); - __Pyx_TraceCall("__str__", __pyx_f[0], 505, 0, __PYX_ERR(0, 505, __pyx_L1_error)); + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[98])) + __Pyx_RefNannySetupContext("__invert__", 0); + __Pyx_TraceStartFunc("__invert__", __pyx_f[0], 525, 0, 0, 0, __PYX_ERR(0, 525, __pyx_L1_error)); - /* "hunter/_predicates.pyx":506 + /* "hunter/_predicates.pyx":526 * - * def __str__(self): - * return 'Not(%s)' % self.predicate # <<<<<<<<<<<<<< + * def __invert__(self): + * return Not(self) # <<<<<<<<<<<<<< * - * def __repr__(self): - */ - __Pyx_TraceLine(506,0,__PYX_ERR(0, 506, __pyx_L1_error)) + * cdef inline fast_Or_call(Or self, Event event): +*/ + __Pyx_TraceLine(526,1,0,__PYX_ERR(0, 526, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Not_s, __pyx_v_self->predicate); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 506, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; + __pyx_t_2 = NULL; + __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Not); + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Not); + __pyx_t_4 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, ((PyObject *)__pyx_v_self)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 526, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_1); + } + __pyx_r = ((PyObject *)__pyx_t_1); __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 526, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_predicates.pyx":505 - * self.predicate = predicate + /* "hunter/_predicates.pyx":525 + * return And(self, other) * - * def __str__(self): # <<<<<<<<<<<<<< - * return 'Not(%s)' % self.predicate + * def __invert__(self): # <<<<<<<<<<<<<< + * return Not(self) * - */ +*/ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.Not.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 525, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Or.__invert__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":508 - * return 'Not(%s)' % self.predicate +/* "hunter/_predicates.pxd":31 + * cdef class Or: + * cdef: + * readonly tuple predicates # <<<<<<<<<<<<<< * - * def __repr__(self): # <<<<<<<<<<<<<< - * return '' % self.predicate * - */ +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_3Not_5__repr__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_3Not_5__repr__(PyObject *__pyx_v_self) { +static PyObject *__pyx_pw_6hunter_11_predicates_2Or_10predicates_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_2Or_10predicates_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_3Not_4__repr__(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_2Or_10predicates___get__(((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_3Not_4__repr__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self) { +static PyObject *__pyx_pf_6hunter_11_predicates_2Or_10predicates___get__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__repr__", 0); - __Pyx_TraceCall("__repr__", __pyx_f[0], 508, 0, __PYX_ERR(0, 508, __pyx_L1_error)); - - /* "hunter/_predicates.pyx":509 - * - * def __repr__(self): - * return '' % self.predicate # <<<<<<<<<<<<<< - * - * def __eq__(self, other): - */ - __Pyx_TraceLine(509,0,__PYX_ERR(0, 509, __pyx_L1_error)) + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[99])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 31, 0, 0, 0, __PYX_ERR(2, 31, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyString_FormatSafe(__pyx_kp_s_hunter__predicates_Not_predicat, __pyx_v_self->predicate); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 509, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; + __Pyx_INCREF(__pyx_v_self->predicates); + __pyx_r = __pyx_v_self->predicates; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 31, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_predicates.pyx":508 - * return 'Not(%s)' % self.predicate - * - * def __repr__(self): # <<<<<<<<<<<<<< - * return '' % self.predicate - * - */ - /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.Not.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 31, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Or.predicates.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":511 - * return '' % self.predicate - * - * def __eq__(self, other): # <<<<<<<<<<<<<< - * return ( - * isinstance(other, Not) - */ +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_3Not_7__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_3Not_7__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { +static PyObject *__pyx_pw_6hunter_11_predicates_2Or_17__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_11_predicates_2Or_17__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_2Or_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_11_predicates_2Or_17__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_3Not_6__eq__(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_6hunter_11_predicates_2Or_16__reduce_cython__(((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_3Not_6__eq__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self, PyObject *__pyx_v_other) { +static PyObject *__pyx_pf_6hunter_11_predicates_2Or_16__reduce_cython__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; - __Pyx_RefNannySetupContext("__eq__", 0); - __Pyx_TraceCall("__eq__", __pyx_f[0], 511, 0, __PYX_ERR(0, 511, __pyx_L1_error)); + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[100])) + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + __Pyx_TraceStartFunc("__reduce_cython__", __pyx_f[1], 1, 0, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); - /* "hunter/_predicates.pyx":512 - * - * def __eq__(self, other): - * return ( # <<<<<<<<<<<<<< - * isinstance(other, Not) - * and self.predicate == ( other).predicate - */ - __Pyx_TraceLine(512,0,__PYX_ERR(0, 512, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self.predicates,) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: +*/ + __Pyx_TraceLine(5,2,0,__PYX_ERR(1, 5, __pyx_L1_error)) + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_self->predicates); + __Pyx_GIVEREF(__pyx_v_self->predicates); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->predicates) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; - /* "hunter/_predicates.pyx":513 - * def __eq__(self, other): - * return ( - * isinstance(other, Not) # <<<<<<<<<<<<<< - * and self.predicate == ( other).predicate - * ) - */ - __Pyx_TraceLine(513,0,__PYX_ERR(0, 513, __pyx_L1_error)) - __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_other, __pyx_ptype_6hunter_11_predicates_Not); + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.predicates,) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) +*/ + __Pyx_TraceLine(6,6,0,__PYX_ERR(1, 6, __pyx_L1_error)) + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self.predicates,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + __Pyx_TraceLine(7,13,0,__PYX_ERR(1, 7, __pyx_L1_error)) + __pyx_t_2 = (__pyx_v__dict != Py_None); if (__pyx_t_2) { - } else { - __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 513, __pyx_L1_error) + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: +*/ + __Pyx_TraceLine(8,15,0,__PYX_ERR(1, 8, __pyx_L1_error)) + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict) != (0)) __PYX_ERR(1, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __pyx_t_3; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); __pyx_t_3 = 0; - goto __pyx_L3_bool_binop_done; - } - - /* "hunter/_predicates.pyx":514 - * return ( - * isinstance(other, Not) - * and self.predicate == ( other).predicate # <<<<<<<<<<<<<< - * ) - * - */ - __Pyx_TraceLine(514,0,__PYX_ERR(0, 514, __pyx_L1_error)) - __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->predicate, ((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_other)->predicate, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 514, __pyx_L1_error) - __Pyx_INCREF(__pyx_t_3); - __pyx_t_1 = __pyx_t_3; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_L3_bool_binop_done:; - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - /* "hunter/_predicates.pyx":511 - * return '' % self.predicate - * - * def __eq__(self, other): # <<<<<<<<<<<<<< - * return ( - * isinstance(other, Not) - */ + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self.predicates is not None +*/ + __Pyx_TraceLine(9,17,0,__PYX_ERR(1, 9, __pyx_L1_error)) + __pyx_v_use_setstate = 1; - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("hunter._predicates.Not.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "(tree fragment)":7 + * state = (self.predicates,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + goto __pyx_L3; + } -/* "hunter/_predicates.pyx":517 - * ) - * - * def __hash__(self): # <<<<<<<<<<<<<< - * return hash(('Not', self.predicate)) - * - */ + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self.predicates is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Or, (type(self), 0x8e21672, None), state +*/ + __Pyx_TraceLine(11,21,0,__PYX_ERR(1, 11, __pyx_L1_error)) + /*else*/ { + __pyx_t_2 = (__pyx_v_self->predicates != ((PyObject*)Py_None)); + __pyx_v_use_setstate = __pyx_t_2; + } + __pyx_L3:; -/* Python wrapper */ -static Py_hash_t __pyx_pw_6hunter_11_predicates_3Not_9__hash__(PyObject *__pyx_v_self); /*proto*/ -static Py_hash_t __pyx_pw_6hunter_11_predicates_3Not_9__hash__(PyObject *__pyx_v_self) { - Py_hash_t __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__hash__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_3Not_8__hash__(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self)); + /* "(tree fragment)":12 + * else: + * use_setstate = self.predicates is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Or, (type(self), 0x8e21672, None), state + * else: +*/ + __Pyx_TraceLine(12,24,0,__PYX_ERR(1, 12, __pyx_L1_error)) + if (__pyx_v_use_setstate) { - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "(tree fragment)":13 + * use_setstate = self.predicates is not None + * if use_setstate: + * return __pyx_unpickle_Or, (type(self), 0x8e21672, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Or, (type(self), 0x8e21672, state) +*/ + __Pyx_TraceLine(13,25,0,__PYX_ERR(1, 13, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Or); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_149034610); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_149034610); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_mstate_global->__pyx_int_149034610) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + __Pyx_TraceReturnValue(__pyx_r, 25, 0, __PYX_ERR(1, 13, __pyx_L1_error)); + goto __pyx_L0; -static Py_hash_t __pyx_pf_6hunter_11_predicates_3Not_8__hash__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self) { - Py_hash_t __pyx_r; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - Py_hash_t __pyx_t_2; - __Pyx_RefNannySetupContext("__hash__", 0); - __Pyx_TraceCall("__hash__", __pyx_f[0], 517, 0, __PYX_ERR(0, 517, __pyx_L1_error)); + /* "(tree fragment)":12 + * else: + * use_setstate = self.predicates is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Or, (type(self), 0x8e21672, None), state + * else: +*/ + } - /* "hunter/_predicates.pyx":518 - * - * def __hash__(self): - * return hash(('Not', self.predicate)) # <<<<<<<<<<<<<< - * - * def __call__(self, Event event): - */ - __Pyx_TraceLine(518,0,__PYX_ERR(0, 518, __pyx_L1_error)) - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 518, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_n_s_Not); - __Pyx_GIVEREF(__pyx_n_s_Not); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_Not); - __Pyx_INCREF(__pyx_v_self->predicate); - __Pyx_GIVEREF(__pyx_v_self->predicate); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->predicate); - __pyx_t_2 = PyObject_Hash(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_hash_t)-1))) __PYX_ERR(0, 518, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_2; - goto __pyx_L0; + /* "(tree fragment)":15 + * return __pyx_unpickle_Or, (type(self), 0x8e21672, None), state + * else: + * return __pyx_unpickle_Or, (type(self), 0x8e21672, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Or__set_state(self, __pyx_state) +*/ + __Pyx_TraceLine(15,33,0,__PYX_ERR(1, 15, __pyx_L1_error)) + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Or); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_149034610); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_149034610); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_mstate_global->__pyx_int_149034610) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + __Pyx_TraceReturnValue(__pyx_r, 33, 0, __PYX_ERR(1, 15, __pyx_L1_error)); + goto __pyx_L0; + } - /* "hunter/_predicates.pyx":517 - * ) - * - * def __hash__(self): # <<<<<<<<<<<<<< - * return hash(('Not', self.predicate)) - * - */ + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.Not.__hash__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Or.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; __pyx_L0:; - if (unlikely(__pyx_r == -1) && !PyErr_Occurred()) __pyx_r = -2; - __Pyx_TraceReturn(Py_None, 0); + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":520 - * return hash(('Not', self.predicate)) - * - * def __call__(self, Event event): # <<<<<<<<<<<<<< - * return fast_Not_call(self, event) - * - */ +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Or, (type(self), 0x8e21672, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Or__set_state(self, __pyx_state) +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_3Not_11__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_3Not_11__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event = 0; +static PyObject *__pyx_pw_6hunter_11_predicates_2Or_19__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_11_predicates_2Or_19__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_2Or_19__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_11_predicates_2Or_19__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__call__ (wrapper)", 0); + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_event,0}; - PyObject* values[1] = {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 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 16, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) 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_event)) != 0)) kw_args--; - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__call__") < 0)) __PYX_ERR(0, 520, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 16, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 16, __pyx_L3_error) } } - } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { + } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) } - __pyx_v_event = ((struct __pyx_obj_6hunter_6_event_Event *)values[0]); + __pyx_v___pyx_state = values[0]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__call__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 520, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - __Pyx_AddTraceback("hunter._predicates.Not.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("hunter._predicates.Or.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_event), __pyx_ptype_6hunter_6_event_Event, 1, "event", 0))) __PYX_ERR(0, 520, __pyx_L1_error) - __pyx_r = __pyx_pf_6hunter_11_predicates_3Not_10__call__(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self), __pyx_v_event); + __pyx_r = __pyx_pf_6hunter_11_predicates_2Or_18__setstate_cython__(((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ - goto __pyx_L0; - __pyx_L1_error:; - __pyx_r = NULL; - __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_3Not_10__call__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { +static PyObject *__pyx_pf_6hunter_11_predicates_2Or_18__setstate_cython__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__call__", 0); - __Pyx_TraceCall("__call__", __pyx_f[0], 520, 0, __PYX_ERR(0, 520, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[101])) + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + __Pyx_TraceStartFunc("__setstate_cython__", __pyx_f[1], 16, 0, 0, 0, __PYX_ERR(1, 16, __pyx_L1_error)); - /* "hunter/_predicates.pyx":521 - * - * def __call__(self, Event event): - * return fast_Not_call(self, event) # <<<<<<<<<<<<<< - * - * def __or__(self, other): - */ - __Pyx_TraceLine(521,0,__PYX_ERR(0, 521, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_f_6hunter_11_predicates_fast_Not_call(__pyx_v_self, __pyx_v_event); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 521, __pyx_L1_error) + /* "(tree fragment)":17 + * return __pyx_unpickle_Or, (type(self), 0x8e21672, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Or__set_state(self, __pyx_state) # <<<<<<<<<<<<<< +*/ + __Pyx_TraceLine(17,4,0,__PYX_ERR(1, 17, __pyx_L1_error)) + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_6hunter_11_predicates___pyx_unpickle_Or__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "hunter/_predicates.pyx":520 - * return hash(('Not', self.predicate)) - * - * def __call__(self, Event event): # <<<<<<<<<<<<<< - * return fast_Not_call(self, event) - * - */ + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Or, (type(self), 0x8e21672, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Or__set_state(self, __pyx_state) +*/ /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(1, 16, __pyx_L1_error)); + goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.Not.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 16, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Or.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":523 - * return fast_Not_call(self, event) +/* "hunter/_predicates.pyx":528 + * return Not(self) * - * def __or__(self, other): # <<<<<<<<<<<<<< - * if type(self) is Not and type(other) is Not: - * return Not(And(( self).predicate, ( other).predicate)) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_3Not_13__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_3Not_13__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__or__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_3Not_12__or__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + * cdef inline fast_Or_call(Or self, Event event): # <<<<<<<<<<<<<< + * for predicate in self.predicates: + * if fast_call(predicate, event): +*/ -static PyObject *__pyx_pf_6hunter_11_predicates_3Not_12__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_fast_Or_call(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { + PyObject *__pyx_v_predicate = NULL; PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - __Pyx_RefNannySetupContext("__or__", 0); - __Pyx_TraceCall("__or__", __pyx_f[0], 523, 0, __PYX_ERR(0, 523, __pyx_L1_error)); + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[102])) + __Pyx_RefNannySetupContext("fast_Or_call", 0); + __Pyx_TraceStartFunc("fast_Or_call", __pyx_f[0], 528, 0, 0, 0, __PYX_ERR(0, 528, __pyx_L1_error)); - /* "hunter/_predicates.pyx":524 + /* "hunter/_predicates.pyx":529 * - * def __or__(self, other): - * if type(self) is Not and type(other) is Not: # <<<<<<<<<<<<<< - * return Not(And(( self).predicate, ( other).predicate)) - * else: - */ - __Pyx_TraceLine(524,0,__PYX_ERR(0, 524, __pyx_L1_error)) - __pyx_t_2 = (((PyObject *)Py_TYPE(__pyx_v_self)) == ((PyObject *)__pyx_ptype_6hunter_11_predicates_Not)); - __pyx_t_3 = (__pyx_t_2 != 0); - if (__pyx_t_3) { - } else { - __pyx_t_1 = __pyx_t_3; - goto __pyx_L4_bool_binop_done; + * cdef inline fast_Or_call(Or self, Event event): + * for predicate in self.predicates: # <<<<<<<<<<<<<< + * if fast_call(predicate, event): + * return True +*/ + __Pyx_TraceLine(529,4,0,__PYX_ERR(0, 529, __pyx_L1_error)) + if (unlikely(__pyx_v_self->predicates == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 529, __pyx_L1_error) } - __pyx_t_3 = (((PyObject *)Py_TYPE(__pyx_v_other)) == ((PyObject *)__pyx_ptype_6hunter_11_predicates_Not)); - __pyx_t_2 = (__pyx_t_3 != 0); - __pyx_t_1 = __pyx_t_2; - __pyx_L4_bool_binop_done:; - if (__pyx_t_1) { + __pyx_t_1 = __pyx_v_self->predicates; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 529, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2)); + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); + #endif + ++__pyx_t_2; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 529, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_predicate, __pyx_t_3); + __pyx_t_3 = 0; + __Pyx_TraceLine(529,1,0,__PYX_ERR(0, 529, __pyx_L1_error)) - /* "hunter/_predicates.pyx":525 - * def __or__(self, other): - * if type(self) is Not and type(other) is Not: - * return Not(And(( self).predicate, ( other).predicate)) # <<<<<<<<<<<<<< - * else: - * return Or(self, other) - */ - __Pyx_TraceLine(525,0,__PYX_ERR(0, 525, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 525, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_INCREF(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self)->predicate); - __Pyx_GIVEREF(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self)->predicate); - PyTuple_SET_ITEM(__pyx_t_4, 0, ((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self)->predicate); - __Pyx_INCREF(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_other)->predicate); - __Pyx_GIVEREF(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_other)->predicate); - PyTuple_SET_ITEM(__pyx_t_4, 1, ((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_other)->predicate); - __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_And), __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 525, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_6hunter_11_predicates_Not), __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 525, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_r = __pyx_t_4; - __pyx_t_4 = 0; - goto __pyx_L0; + /* "hunter/_predicates.pyx":530 + * cdef inline fast_Or_call(Or self, Event event): + * for predicate in self.predicates: + * if fast_call(predicate, event): # <<<<<<<<<<<<<< + * return True + * else: +*/ + __Pyx_TraceLine(530,7,0,__PYX_ERR(0, 530, __pyx_L1_error)) + __pyx_t_3 = __pyx_f_6hunter_11_predicates_fast_call(__pyx_v_predicate, __pyx_v_event); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 530, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 530, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_4) { + + /* "hunter/_predicates.pyx":531 + * for predicate in self.predicates: + * if fast_call(predicate, event): + * return True # <<<<<<<<<<<<<< + * else: + * return False +*/ + __Pyx_TraceLine(531,10,0,__PYX_ERR(0, 531, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_True); + __pyx_r = Py_True; + __Pyx_TraceReturnValue(__pyx_r, 10, 0, __PYX_ERR(0, 531, __pyx_L1_error)); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + + /* "hunter/_predicates.pyx":530 + * cdef inline fast_Or_call(Or self, Event event): + * for predicate in self.predicates: + * if fast_call(predicate, event): # <<<<<<<<<<<<<< + * return True + * else: +*/ + } - /* "hunter/_predicates.pyx":524 + /* "hunter/_predicates.pyx":529 * - * def __or__(self, other): - * if type(self) is Not and type(other) is Not: # <<<<<<<<<<<<<< - * return Not(And(( self).predicate, ( other).predicate)) - * else: - */ + * cdef inline fast_Or_call(Or self, Event event): + * for predicate in self.predicates: # <<<<<<<<<<<<<< + * if fast_call(predicate, event): + * return True +*/ + __Pyx_TraceLine(529,1,0,__PYX_ERR(0, 529, __pyx_L1_error)) } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /*else*/ { - /* "hunter/_predicates.pyx":527 - * return Not(And(( self).predicate, ( other).predicate)) - * else: - * return Or(self, other) # <<<<<<<<<<<<<< + /* "hunter/_predicates.pyx":533 + * return True + * else: + * return False # <<<<<<<<<<<<<< * - * def __and__(self, other): - */ - __Pyx_TraceLine(527,0,__PYX_ERR(0, 527, __pyx_L1_error)) - /*else*/ { + * +*/ + __Pyx_TraceLine(533,12,0,__PYX_ERR(0, 533, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 527, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_INCREF(__pyx_v_self); - __Pyx_GIVEREF(__pyx_v_self); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_self); - __Pyx_INCREF(__pyx_v_other); - __Pyx_GIVEREF(__pyx_v_other); - PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_other); - __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_Or), __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 527, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + __Pyx_TraceReturnValue(__pyx_r, 12, 0, __PYX_ERR(0, 533, __pyx_L1_error)); goto __pyx_L0; } - /* "hunter/_predicates.pyx":523 - * return fast_Not_call(self, event) + /* "hunter/_predicates.pyx":528 + * return Not(self) * - * def __or__(self, other): # <<<<<<<<<<<<<< - * if type(self) is Not and type(other) is Not: - * return Not(And(( self).predicate, ( other).predicate)) - */ - - /* function exit code */ + * cdef inline fast_Or_call(Or self, Event event): # <<<<<<<<<<<<<< + * for predicate in self.predicates: + * if fast_call(predicate, event): +*/ + + /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("hunter._predicates.Not.__or__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 528, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.fast_Or_call", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; + __Pyx_XDECREF(__pyx_v_predicate); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":529 - * return Or(self, other) +/* "hunter/_predicates.pyx":540 + * `Not` predicate. + * """ + * def __init__(self, predicate): # <<<<<<<<<<<<<< + * self.predicate = predicate * - * def __and__(self, other): # <<<<<<<<<<<<<< - * if type(self) is Not and type(other) is Not: - * return Not(Or(( self).predicate, ( other).predicate)) - */ +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_3Not_15__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_3Not_15__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { - PyObject *__pyx_r = 0; +static int __pyx_pw_6hunter_11_predicates_3Not_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_6hunter_11_predicates_3Not_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_predicate = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__and__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_3Not_14__and__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_predicate,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 540, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 540, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__init__", 0) < 0) __PYX_ERR(0, 540, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, i); __PYX_ERR(0, 540, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 540, __pyx_L3_error) + } + __pyx_v_predicate = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 540, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("hunter._predicates.Not.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6hunter_11_predicates_3Not___init__(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self), __pyx_v_predicate); /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_3Not_14__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations +static int __pyx_pf_6hunter_11_predicates_3Not___init__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self, PyObject *__pyx_v_predicate) { + int __pyx_r; + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - __Pyx_RefNannySetupContext("__and__", 0); - __Pyx_TraceCall("__and__", __pyx_f[0], 529, 0, __PYX_ERR(0, 529, __pyx_L1_error)); - - /* "hunter/_predicates.pyx":530 - * - * def __and__(self, other): - * if type(self) is Not and type(other) is Not: # <<<<<<<<<<<<<< - * return Not(Or(( self).predicate, ( other).predicate)) - * else: - */ - __Pyx_TraceLine(530,0,__PYX_ERR(0, 530, __pyx_L1_error)) - __pyx_t_2 = (((PyObject *)Py_TYPE(__pyx_v_self)) == ((PyObject *)__pyx_ptype_6hunter_11_predicates_Not)); - __pyx_t_3 = (__pyx_t_2 != 0); - if (__pyx_t_3) { - } else { - __pyx_t_1 = __pyx_t_3; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_3 = (((PyObject *)Py_TYPE(__pyx_v_other)) == ((PyObject *)__pyx_ptype_6hunter_11_predicates_Not)); - __pyx_t_2 = (__pyx_t_3 != 0); - __pyx_t_1 = __pyx_t_2; - __pyx_L4_bool_binop_done:; - if (__pyx_t_1) { - - /* "hunter/_predicates.pyx":531 - * def __and__(self, other): - * if type(self) is Not and type(other) is Not: - * return Not(Or(( self).predicate, ( other).predicate)) # <<<<<<<<<<<<<< - * else: - * return And(self, other) - */ - __Pyx_TraceLine(531,0,__PYX_ERR(0, 531, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 531, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_INCREF(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self)->predicate); - __Pyx_GIVEREF(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self)->predicate); - PyTuple_SET_ITEM(__pyx_t_4, 0, ((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self)->predicate); - __Pyx_INCREF(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_other)->predicate); - __Pyx_GIVEREF(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_other)->predicate); - PyTuple_SET_ITEM(__pyx_t_4, 1, ((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_other)->predicate); - __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_Or), __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 531, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_6hunter_11_predicates_Not), __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 531, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_r = __pyx_t_4; - __pyx_t_4 = 0; - goto __pyx_L0; - - /* "hunter/_predicates.pyx":530 - * - * def __and__(self, other): - * if type(self) is Not and type(other) is Not: # <<<<<<<<<<<<<< - * return Not(Or(( self).predicate, ( other).predicate)) - * else: - */ - } + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[103])) + __Pyx_RefNannySetupContext("__init__", 0); + __Pyx_TraceStartFunc("__init__", __pyx_f[0], 540, 0, 0, 0, __PYX_ERR(0, 540, __pyx_L1_error)); - /* "hunter/_predicates.pyx":533 - * return Not(Or(( self).predicate, ( other).predicate)) - * else: - * return And(self, other) # <<<<<<<<<<<<<< + /* "hunter/_predicates.pyx":541 + * """ + * def __init__(self, predicate): + * self.predicate = predicate # <<<<<<<<<<<<<< * - * def __invert__(self): - */ - __Pyx_TraceLine(533,0,__PYX_ERR(0, 533, __pyx_L1_error)) - /*else*/ { - __Pyx_XDECREF(__pyx_r); - __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 533, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_INCREF(__pyx_v_self); - __Pyx_GIVEREF(__pyx_v_self); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_self); - __Pyx_INCREF(__pyx_v_other); - __Pyx_GIVEREF(__pyx_v_other); - PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_other); - __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_And), __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 533, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; - goto __pyx_L0; - } + * def __str__(self): +*/ + __Pyx_TraceLine(541,1,0,__PYX_ERR(0, 541, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_predicate); + __Pyx_GIVEREF(__pyx_v_predicate); + __Pyx_GOTREF(__pyx_v_self->predicate); + __Pyx_DECREF(__pyx_v_self->predicate); + __pyx_v_self->predicate = __pyx_v_predicate; - /* "hunter/_predicates.pyx":529 - * return Or(self, other) + /* "hunter/_predicates.pyx":540 + * `Not` predicate. + * """ + * def __init__(self, predicate): # <<<<<<<<<<<<<< + * self.predicate = predicate * - * def __and__(self, other): # <<<<<<<<<<<<<< - * if type(self) is Not and type(other) is Not: - * return Not(Or(( self).predicate, ( other).predicate)) - */ +*/ /* function exit code */ + __pyx_r = 0; + __Pyx_TraceReturnCValue(__pyx_r, __Pyx_Owned_Py_None, 0, 0, __PYX_ERR(0, 540, __pyx_L1_error)); + goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("hunter._predicates.Not.__and__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 540, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Not.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":535 - * return And(self, other) +/* "hunter/_predicates.pyx":543 + * self.predicate = predicate * - * def __invert__(self): # <<<<<<<<<<<<<< - * return self.predicate + * def __str__(self): # <<<<<<<<<<<<<< + * return 'Not(%s)' % self.predicate * - */ +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_3Not_17__invert__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_3Not_17__invert__(PyObject *__pyx_v_self) { +static PyObject *__pyx_pw_6hunter_11_predicates_3Not_3__str__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_3Not_3__str__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__invert__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_3Not_16__invert__(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_3Not_2__str__(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_3Not_16__invert__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self) { +static PyObject *__pyx_pf_6hunter_11_predicates_3Not_2__str__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__invert__", 0); - __Pyx_TraceCall("__invert__", __pyx_f[0], 535, 0, __PYX_ERR(0, 535, __pyx_L1_error)); + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[104])) + __Pyx_RefNannySetupContext("__str__", 0); + __Pyx_TraceStartFunc("__str__", __pyx_f[0], 543, 0, 0, 0, __PYX_ERR(0, 543, __pyx_L1_error)); - /* "hunter/_predicates.pyx":536 + /* "hunter/_predicates.pyx":544 * - * def __invert__(self): - * return self.predicate # <<<<<<<<<<<<<< + * def __str__(self): + * return 'Not(%s)' % self.predicate # <<<<<<<<<<<<<< * - * cdef inline fast_Not_call(Not self, Event event): - */ - __Pyx_TraceLine(536,0,__PYX_ERR(0, 536, __pyx_L1_error)) + * def __repr__(self): +*/ + __Pyx_TraceLine(544,1,0,__PYX_ERR(0, 544, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->predicate); - __pyx_r = __pyx_v_self->predicate; + __pyx_t_1 = __Pyx_PyUnicode_FormatSafe(__pyx_mstate_global->__pyx_kp_u_Not_s, __pyx_v_self->predicate); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 544, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 544, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_predicates.pyx":535 - * return And(self, other) + /* "hunter/_predicates.pyx":543 + * self.predicate = predicate * - * def __invert__(self): # <<<<<<<<<<<<<< - * return self.predicate + * def __str__(self): # <<<<<<<<<<<<<< + * return 'Not(%s)' % self.predicate * - */ +*/ /* function exit code */ __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.Not.__invert__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 543, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Not.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pxd":34 - * cdef class Not: - * cdef: - * readonly object predicate # <<<<<<<<<<<<<< +/* "hunter/_predicates.pyx":546 + * return 'Not(%s)' % self.predicate * - * @cython.final - */ + * def __repr__(self): # <<<<<<<<<<<<<< + * return '' % self.predicate + * +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_3Not_9predicate_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_3Not_9predicate_1__get__(PyObject *__pyx_v_self) { +static PyObject *__pyx_pw_6hunter_11_predicates_3Not_5__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_3Not_5__repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_3Not_9predicate___get__(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_3Not_4__repr__(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_3Not_9predicate___get__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self) { +static PyObject *__pyx_pf_6hunter_11_predicates_3Not_4__repr__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 34, 0, __PYX_ERR(1, 34, __pyx_L1_error)); + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[105])) + __Pyx_RefNannySetupContext("__repr__", 0); + __Pyx_TraceStartFunc("__repr__", __pyx_f[0], 546, 0, 0, 0, __PYX_ERR(0, 546, __pyx_L1_error)); + + /* "hunter/_predicates.pyx":547 + * + * def __repr__(self): + * return '' % self.predicate # <<<<<<<<<<<<<< + * + * def __eq__(self, other): +*/ + __Pyx_TraceLine(547,1,0,__PYX_ERR(0, 547, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->predicate); - __pyx_r = __pyx_v_self->predicate; + __pyx_t_1 = __Pyx_PyUnicode_FormatSafe(__pyx_mstate_global->__pyx_kp_u_hunter__predicates_Not_predicat, __pyx_v_self->predicate); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 547, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 547, __pyx_L1_error)); goto __pyx_L0; + /* "hunter/_predicates.pyx":546 + * return 'Not(%s)' % self.predicate + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return '' % self.predicate + * +*/ + /* function exit code */ __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.Not.predicate.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 546, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Not.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict - */ +/* "hunter/_predicates.pyx":549 + * return '' % self.predicate + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return ( + * isinstance(other, Not) +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_3Not_19__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_3Not_19__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_6hunter_11_predicates_3Not_7__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_3Not_7__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_3Not_18__reduce_cython__(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_3Not_6__eq__(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self), ((PyObject *)__pyx_v_other)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_3Not_18__reduce_cython__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self) { - PyObject *__pyx_v_state = 0; - PyObject *__pyx_v__dict = 0; - int __pyx_v_use_setstate; +static PyObject *__pyx_pf_6hunter_11_predicates_3Not_6__eq__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self, PyObject *__pyx_v_other) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; - int __pyx_t_3; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - __Pyx_RefNannySetupContext("__reduce_cython__", 0); - __Pyx_TraceCall("__reduce_cython__", __pyx_f[2], 1, 0, __PYX_ERR(2, 1, __pyx_L1_error)); - - /* "(tree fragment)":5 - * cdef object _dict - * cdef bint use_setstate - * state = (self.predicate,) # <<<<<<<<<<<<<< - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: - */ - __Pyx_TraceLine(5,0,__PYX_ERR(2, 5, __pyx_L1_error)) - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v_self->predicate); - __Pyx_GIVEREF(__pyx_v_self->predicate); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->predicate); - __pyx_v_state = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - - /* "(tree fragment)":6 - * cdef bint use_setstate - * state = (self.predicate,) - * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< - * if _dict is not None: - * state += (_dict,) - */ - __Pyx_TraceLine(6,0,__PYX_ERR(2, 6, __pyx_L1_error)) - __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v__dict = __pyx_t_1; - __pyx_t_1 = 0; - - /* "(tree fragment)":7 - * state = (self.predicate,) - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: # <<<<<<<<<<<<<< - * state += (_dict,) - * use_setstate = True - */ - __Pyx_TraceLine(7,0,__PYX_ERR(2, 7, __pyx_L1_error)) - __pyx_t_2 = (__pyx_v__dict != Py_None); - __pyx_t_3 = (__pyx_t_2 != 0); - if (__pyx_t_3) { - - /* "(tree fragment)":8 - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: - * state += (_dict,) # <<<<<<<<<<<<<< - * use_setstate = True - * else: - */ - __Pyx_TraceLine(8,0,__PYX_ERR(2, 8, __pyx_L1_error)) - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v__dict); - __Pyx_GIVEREF(__pyx_v__dict); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict); - __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4)); - __pyx_t_4 = 0; - - /* "(tree fragment)":9 - * if _dict is not None: - * state += (_dict,) - * use_setstate = True # <<<<<<<<<<<<<< - * else: - * use_setstate = self.predicate is not None - */ - __Pyx_TraceLine(9,0,__PYX_ERR(2, 9, __pyx_L1_error)) - __pyx_v_use_setstate = 1; - - /* "(tree fragment)":7 - * state = (self.predicate,) - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: # <<<<<<<<<<<<<< - * state += (_dict,) - * use_setstate = True - */ - goto __pyx_L3; - } - - /* "(tree fragment)":11 - * use_setstate = True - * else: - * use_setstate = self.predicate is not None # <<<<<<<<<<<<<< - * if use_setstate: - * return __pyx_unpickle_Not, (type(self), 0xf670ef6, None), state - */ - __Pyx_TraceLine(11,0,__PYX_ERR(2, 11, __pyx_L1_error)) - /*else*/ { - __pyx_t_3 = (__pyx_v_self->predicate != Py_None); - __pyx_v_use_setstate = __pyx_t_3; - } - __pyx_L3:; - - /* "(tree fragment)":12 - * else: - * use_setstate = self.predicate is not None - * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_Not, (type(self), 0xf670ef6, None), state - * else: - */ - __Pyx_TraceLine(12,0,__PYX_ERR(2, 12, __pyx_L1_error)) - __pyx_t_3 = (__pyx_v_use_setstate != 0); - if (__pyx_t_3) { + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[106])) + __Pyx_RefNannySetupContext("__eq__", 0); + __Pyx_TraceStartFunc("__eq__", __pyx_f[0], 549, 0, 0, 0, __PYX_ERR(0, 549, __pyx_L1_error)); - /* "(tree fragment)":13 - * use_setstate = self.predicate is not None - * if use_setstate: - * return __pyx_unpickle_Not, (type(self), 0xf670ef6, None), state # <<<<<<<<<<<<<< - * else: - * return __pyx_unpickle_Not, (type(self), 0xf670ef6, state) - */ - __Pyx_TraceLine(13,0,__PYX_ERR(2, 13, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Not); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_INCREF(__pyx_int_258412278); - __Pyx_GIVEREF(__pyx_int_258412278); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_258412278); - __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(Py_None); - PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None); - __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1); - __Pyx_INCREF(__pyx_v_state); - __Pyx_GIVEREF(__pyx_v_state); - PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state); - __pyx_t_4 = 0; - __pyx_t_1 = 0; - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; - goto __pyx_L0; + /* "hunter/_predicates.pyx":550 + * + * def __eq__(self, other): + * return ( # <<<<<<<<<<<<<< + * isinstance(other, Not) + * and self.predicate == ( other).predicate +*/ + __Pyx_TraceLine(550,1,0,__PYX_ERR(0, 550, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); - /* "(tree fragment)":12 - * else: - * use_setstate = self.predicate is not None - * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_Not, (type(self), 0xf670ef6, None), state - * else: - */ + /* "hunter/_predicates.pyx":551 + * def __eq__(self, other): + * return ( + * isinstance(other, Not) # <<<<<<<<<<<<<< + * and self.predicate == ( other).predicate + * ) +*/ + __Pyx_TraceLine(551,5,0,__PYX_ERR(0, 551, __pyx_L1_error)) + __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_other, __pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Not); + if (__pyx_t_2) { + } else { + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 551, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L3_bool_binop_done; } - /* "(tree fragment)":15 - * return __pyx_unpickle_Not, (type(self), 0xf670ef6, None), state - * else: - * return __pyx_unpickle_Not, (type(self), 0xf670ef6, state) # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_Not__set_state(self, __pyx_state) - */ - __Pyx_TraceLine(15,0,__PYX_ERR(2, 15, __pyx_L1_error)) - /*else*/ { - __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_Not); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_INCREF(__pyx_int_258412278); - __Pyx_GIVEREF(__pyx_int_258412278); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_258412278); - __Pyx_INCREF(__pyx_v_state); - __Pyx_GIVEREF(__pyx_v_state); - PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state); - __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_5); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1); - __pyx_t_5 = 0; - __pyx_t_1 = 0; - __pyx_r = __pyx_t_4; - __pyx_t_4 = 0; - goto __pyx_L0; - } + /* "hunter/_predicates.pyx":552 + * return ( + * isinstance(other, Not) + * and self.predicate == ( other).predicate # <<<<<<<<<<<<<< + * ) + * +*/ + __Pyx_TraceLine(552,12,0,__PYX_ERR(0, 552, __pyx_L1_error)) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->predicate, ((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_other)->predicate, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 552, __pyx_L1_error) + __Pyx_INCREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_L3_bool_binop_done:; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 550, __pyx_L1_error)); + goto __pyx_L0; - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict - */ + /* "hunter/_predicates.pyx":549 + * return '' % self.predicate + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return ( + * isinstance(other, Not) +*/ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("hunter._predicates.Not.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 549, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Not.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF(__pyx_v_state); - __Pyx_XDECREF(__pyx_v__dict); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "(tree fragment)":16 - * else: - * return __pyx_unpickle_Not, (type(self), 0xf670ef6, state) - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle_Not__set_state(self, __pyx_state) - */ +/* "hunter/_predicates.pyx":555 + * ) + * + * def __call__(self, Event event): # <<<<<<<<<<<<<< + * return fast_Not_call(self, event) + * +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_3Not_21__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_3Not_21__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_6hunter_11_predicates_3Not_9__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_3Not_9__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_3Not_20__setstate_cython__(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + __Pyx_RefNannySetupContext("__call__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_event,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 555, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 555, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__call__", 0) < 0) __PYX_ERR(0, 555, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__call__", 1, 1, 1, i); __PYX_ERR(0, 555, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 555, __pyx_L3_error) + } + __pyx_v_event = ((struct __pyx_obj_6hunter_6_event_Event *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__call__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 555, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("hunter._predicates.Not.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_event), __pyx_mstate_global->__pyx_ptype_6hunter_6_event_Event, 1, "event", 0))) __PYX_ERR(0, 555, __pyx_L1_error) + __pyx_r = __pyx_pf_6hunter_11_predicates_3Not_8__call__(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self), __pyx_v_event); /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_3Not_20__setstate_cython__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pf_6hunter_11_predicates_3Not_8__call__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__setstate_cython__", 0); - __Pyx_TraceCall("__setstate_cython__", __pyx_f[2], 16, 0, __PYX_ERR(2, 16, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[107])) + __Pyx_RefNannySetupContext("__call__", 0); + __Pyx_TraceStartFunc("__call__", __pyx_f[0], 555, 0, 0, 0, __PYX_ERR(0, 555, __pyx_L1_error)); - /* "(tree fragment)":17 - * return __pyx_unpickle_Not, (type(self), 0xf670ef6, state) - * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_Not__set_state(self, __pyx_state) # <<<<<<<<<<<<<< - */ - __Pyx_TraceLine(17,0,__PYX_ERR(2, 17, __pyx_L1_error)) - if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(2, 17, __pyx_L1_error) - __pyx_t_1 = __pyx_f_6hunter_11_predicates___pyx_unpickle_Not__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 17, __pyx_L1_error) + /* "hunter/_predicates.pyx":556 + * + * def __call__(self, Event event): + * return fast_Not_call(self, event) # <<<<<<<<<<<<<< + * + * def __or__(self, other): +*/ + __Pyx_TraceLine(556,1,0,__PYX_ERR(0, 556, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6hunter_11_predicates_fast_Not_call(__pyx_v_self, __pyx_v_event); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 556, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 556, __pyx_L1_error)); + goto __pyx_L0; - /* "(tree fragment)":16 - * else: - * return __pyx_unpickle_Not, (type(self), 0xf670ef6, state) - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle_Not__set_state(self, __pyx_state) - */ + /* "hunter/_predicates.pyx":555 + * ) + * + * def __call__(self, Event event): # <<<<<<<<<<<<<< + * return fast_Not_call(self, event) + * +*/ /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.Not.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 555, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Not.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":538 - * return self.predicate - * - * cdef inline fast_Not_call(Not self, Event event): # <<<<<<<<<<<<<< - * return not fast_call(self.predicate, event) +/* "hunter/_predicates.pyx":558 + * return fast_Not_call(self, event) * - */ + * def __or__(self, other): # <<<<<<<<<<<<<< + * if type(self) is Not and type(other) is Not: + * return Not(And(( self).predicate, ( other).predicate)) +*/ -static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_fast_Not_call(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_3Not_11__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_3Not_11__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__or__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_3Not_10__or__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_11_predicates_3Not_10__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - int __pyx_t_3; - __Pyx_RefNannySetupContext("fast_Not_call", 0); - __Pyx_TraceCall("fast_Not_call", __pyx_f[0], 538, 0, __PYX_ERR(0, 538, __pyx_L1_error)); + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + size_t __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[108])) + __Pyx_RefNannySetupContext("__or__", 0); + __Pyx_TraceStartFunc("__or__", __pyx_f[0], 558, 0, 0, 0, __PYX_ERR(0, 558, __pyx_L1_error)); - /* "hunter/_predicates.pyx":539 - * - * cdef inline fast_Not_call(Not self, Event event): - * return not fast_call(self.predicate, event) # <<<<<<<<<<<<<< + /* "hunter/_predicates.pyx":559 * + * def __or__(self, other): + * if type(self) is Not and type(other) is Not: # <<<<<<<<<<<<<< + * return Not(And(( self).predicate, ( other).predicate)) + * else: +*/ + __Pyx_TraceLine(559,6,0,__PYX_ERR(0, 559, __pyx_L1_error)) + __pyx_t_2 = (((PyObject *)Py_TYPE(__pyx_v_self)) == ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Not)); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = (((PyObject *)Py_TYPE(__pyx_v_other)) == ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Not)); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "hunter/_predicates.pyx":560 + * def __or__(self, other): + * if type(self) is Not and type(other) is Not: + * return Not(And(( self).predicate, ( other).predicate)) # <<<<<<<<<<<<<< + * else: + * return Or(self, other) +*/ + __Pyx_TraceLine(560,13,0,__PYX_ERR(0, 560, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = NULL; + __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Not); + __pyx_t_5 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Not); + __pyx_t_7 = NULL; + __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_And); + __pyx_t_8 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_And); + __pyx_t_9 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_7, ((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self)->predicate, ((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_other)->predicate}; + __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 560, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_6); + } + __pyx_t_9 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, ((PyObject *)__pyx_t_6)}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF((PyObject *)__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 560, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_3); + } + __pyx_r = ((PyObject *)__pyx_t_3); + __pyx_t_3 = 0; + __Pyx_TraceReturnValue(__pyx_r, 13, 0, __PYX_ERR(0, 560, __pyx_L1_error)); + goto __pyx_L0; + + /* "hunter/_predicates.pyx":559 * - */ - __Pyx_TraceLine(539,0,__PYX_ERR(0, 539, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_v_self->predicate; - __Pyx_INCREF(__pyx_t_1); - __pyx_t_2 = __pyx_f_6hunter_11_predicates_fast_call(__pyx_t_1, __pyx_v_event); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 539, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 539, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyBool_FromLong((!__pyx_t_3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 539, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; + * def __or__(self, other): + * if type(self) is Not and type(other) is Not: # <<<<<<<<<<<<<< + * return Not(And(( self).predicate, ( other).predicate)) + * else: +*/ + } - /* "hunter/_predicates.pyx":538 - * return self.predicate + /* "hunter/_predicates.pyx":562 + * return Not(And(( self).predicate, ( other).predicate)) + * else: + * return Or(self, other) # <<<<<<<<<<<<<< * - * cdef inline fast_Not_call(Not self, Event event): # <<<<<<<<<<<<<< - * return not fast_call(self.predicate, event) + * def __and__(self, other): +*/ + __Pyx_TraceLine(562,24,0,__PYX_ERR(0, 562, __pyx_L1_error)) + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __pyx_t_5 = NULL; + __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Or); + __pyx_t_6 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Or); + __pyx_t_9 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_v_self, __pyx_v_other}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 562, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_3); + } + __pyx_r = ((PyObject *)__pyx_t_3); + __pyx_t_3 = 0; + __Pyx_TraceReturnValue(__pyx_r, 24, 0, __PYX_ERR(0, 562, __pyx_L1_error)); + goto __pyx_L0; + } + + /* "hunter/_predicates.pyx":558 + * return fast_Not_call(self, event) * - */ + * def __or__(self, other): # <<<<<<<<<<<<<< + * if type(self) is Not and type(other) is Not: + * return Not(And(( self).predicate, ( other).predicate)) +*/ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("hunter._predicates.fast_Not_call", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 558, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Not.__or__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":542 - * +/* "hunter/_predicates.pyx":564 + * return Or(self, other) * - * cdef inline fast_call(callable, Event event): # <<<<<<<<<<<<<< - * if type(callable) is Query: - * return fast_Query_call( callable, event) - */ + * def __and__(self, other): # <<<<<<<<<<<<<< + * if type(self) is Not and type(other) is Not: + * return Not(Or(( self).predicate, ( other).predicate)) +*/ -static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_fast_call(PyObject *__pyx_v_callable, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_3Not_13__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_3Not_13__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__and__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_3Not_12__and__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_11_predicates_3Not_12__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; - __Pyx_RefNannySetupContext("fast_call", 0); - __Pyx_TraceCall("fast_call", __pyx_f[0], 542, 0, __PYX_ERR(0, 542, __pyx_L1_error)); + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + size_t __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[109])) + __Pyx_RefNannySetupContext("__and__", 0); + __Pyx_TraceStartFunc("__and__", __pyx_f[0], 564, 0, 0, 0, __PYX_ERR(0, 564, __pyx_L1_error)); - /* "hunter/_predicates.pyx":543 + /* "hunter/_predicates.pyx":565 * - * cdef inline fast_call(callable, Event event): - * if type(callable) is Query: # <<<<<<<<<<<<<< - * return fast_Query_call( callable, event) - * elif type(callable) is Or: - */ - __Pyx_TraceLine(543,0,__PYX_ERR(0, 543, __pyx_L1_error)) - __pyx_t_1 = (((PyObject *)Py_TYPE(__pyx_v_callable)) == ((PyObject *)__pyx_ptype_6hunter_11_predicates_Query)); - __pyx_t_2 = (__pyx_t_1 != 0); + * def __and__(self, other): + * if type(self) is Not and type(other) is Not: # <<<<<<<<<<<<<< + * return Not(Or(( self).predicate, ( other).predicate)) + * else: +*/ + __Pyx_TraceLine(565,6,0,__PYX_ERR(0, 565, __pyx_L1_error)) + __pyx_t_2 = (((PyObject *)Py_TYPE(__pyx_v_self)) == ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Not)); if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = (((PyObject *)Py_TYPE(__pyx_v_other)) == ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Not)); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { - /* "hunter/_predicates.pyx":544 - * cdef inline fast_call(callable, Event event): - * if type(callable) is Query: - * return fast_Query_call( callable, event) # <<<<<<<<<<<<<< - * elif type(callable) is Or: - * return fast_Or_call( callable, event) - */ - __Pyx_TraceLine(544,0,__PYX_ERR(0, 544, __pyx_L1_error)) + /* "hunter/_predicates.pyx":566 + * def __and__(self, other): + * if type(self) is Not and type(other) is Not: + * return Not(Or(( self).predicate, ( other).predicate)) # <<<<<<<<<<<<<< + * else: + * return And(self, other) +*/ + __Pyx_TraceLine(566,13,0,__PYX_ERR(0, 566, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __pyx_f_6hunter_11_predicates_fast_Query_call(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_callable), __pyx_v_event); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 544, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_r = __pyx_t_3; + __pyx_t_4 = NULL; + __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Not); + __pyx_t_5 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Not); + __pyx_t_7 = NULL; + __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Or); + __pyx_t_8 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Or); + __pyx_t_9 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_7, ((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self)->predicate, ((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_other)->predicate}; + __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 566, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_6); + } + __pyx_t_9 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, ((PyObject *)__pyx_t_6)}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF((PyObject *)__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 566, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_3); + } + __pyx_r = ((PyObject *)__pyx_t_3); __pyx_t_3 = 0; + __Pyx_TraceReturnValue(__pyx_r, 13, 0, __PYX_ERR(0, 566, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_predicates.pyx":543 + /* "hunter/_predicates.pyx":565 * - * cdef inline fast_call(callable, Event event): - * if type(callable) is Query: # <<<<<<<<<<<<<< - * return fast_Query_call( callable, event) - * elif type(callable) is Or: - */ + * def __and__(self, other): + * if type(self) is Not and type(other) is Not: # <<<<<<<<<<<<<< + * return Not(Or(( self).predicate, ( other).predicate)) + * else: +*/ } - /* "hunter/_predicates.pyx":545 - * if type(callable) is Query: - * return fast_Query_call( callable, event) - * elif type(callable) is Or: # <<<<<<<<<<<<<< - * return fast_Or_call( callable, event) - * elif type(callable) is And: - */ - __Pyx_TraceLine(545,0,__PYX_ERR(0, 545, __pyx_L1_error)) - __pyx_t_2 = (((PyObject *)Py_TYPE(__pyx_v_callable)) == ((PyObject *)__pyx_ptype_6hunter_11_predicates_Or)); - __pyx_t_1 = (__pyx_t_2 != 0); - if (__pyx_t_1) { - - /* "hunter/_predicates.pyx":546 - * return fast_Query_call( callable, event) - * elif type(callable) is Or: - * return fast_Or_call( callable, event) # <<<<<<<<<<<<<< - * elif type(callable) is And: - * return fast_And_call( callable, event) - */ - __Pyx_TraceLine(546,0,__PYX_ERR(0, 546, __pyx_L1_error)) + /* "hunter/_predicates.pyx":568 + * return Not(Or(( self).predicate, ( other).predicate)) + * else: + * return And(self, other) # <<<<<<<<<<<<<< + * + * def __invert__(self): +*/ + __Pyx_TraceLine(568,24,0,__PYX_ERR(0, 568, __pyx_L1_error)) + /*else*/ { __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __pyx_f_6hunter_11_predicates_fast_Or_call(((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_callable), __pyx_v_event); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 546, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_r = __pyx_t_3; + __pyx_t_5 = NULL; + __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_And); + __pyx_t_6 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_And); + __pyx_t_9 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_v_self, __pyx_v_other}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 568, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_3); + } + __pyx_r = ((PyObject *)__pyx_t_3); __pyx_t_3 = 0; + __Pyx_TraceReturnValue(__pyx_r, 24, 0, __PYX_ERR(0, 568, __pyx_L1_error)); goto __pyx_L0; - - /* "hunter/_predicates.pyx":545 - * if type(callable) is Query: - * return fast_Query_call( callable, event) - * elif type(callable) is Or: # <<<<<<<<<<<<<< - * return fast_Or_call( callable, event) - * elif type(callable) is And: - */ } - /* "hunter/_predicates.pyx":547 - * elif type(callable) is Or: - * return fast_Or_call( callable, event) - * elif type(callable) is And: # <<<<<<<<<<<<<< - * return fast_And_call( callable, event) - * elif type(callable) is Not: - */ - __Pyx_TraceLine(547,0,__PYX_ERR(0, 547, __pyx_L1_error)) - __pyx_t_1 = (((PyObject *)Py_TYPE(__pyx_v_callable)) == ((PyObject *)__pyx_ptype_6hunter_11_predicates_And)); - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { - - /* "hunter/_predicates.pyx":548 - * return fast_Or_call( callable, event) - * elif type(callable) is And: - * return fast_And_call( callable, event) # <<<<<<<<<<<<<< - * elif type(callable) is Not: - * return fast_Not_call( callable, event) - */ - __Pyx_TraceLine(548,0,__PYX_ERR(0, 548, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __pyx_f_6hunter_11_predicates_fast_And_call(((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v_callable), __pyx_v_event); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 548, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_r = __pyx_t_3; - __pyx_t_3 = 0; - goto __pyx_L0; + /* "hunter/_predicates.pyx":564 + * return Or(self, other) + * + * def __and__(self, other): # <<<<<<<<<<<<<< + * if type(self) is Not and type(other) is Not: + * return Not(Or(( self).predicate, ( other).predicate)) +*/ - /* "hunter/_predicates.pyx":547 - * elif type(callable) is Or: - * return fast_Or_call( callable, event) - * elif type(callable) is And: # <<<<<<<<<<<<<< - * return fast_And_call( callable, event) - * elif type(callable) is Not: - */ - } - - /* "hunter/_predicates.pyx":549 - * elif type(callable) is And: - * return fast_And_call( callable, event) - * elif type(callable) is Not: # <<<<<<<<<<<<<< - * return fast_Not_call( callable, event) - * elif type(callable) is When: - */ - __Pyx_TraceLine(549,0,__PYX_ERR(0, 549, __pyx_L1_error)) - __pyx_t_2 = (((PyObject *)Py_TYPE(__pyx_v_callable)) == ((PyObject *)__pyx_ptype_6hunter_11_predicates_Not)); - __pyx_t_1 = (__pyx_t_2 != 0); - if (__pyx_t_1) { - - /* "hunter/_predicates.pyx":550 - * return fast_And_call( callable, event) - * elif type(callable) is Not: - * return fast_Not_call( callable, event) # <<<<<<<<<<<<<< - * elif type(callable) is When: - * return fast_When_call( callable, event) - */ - __Pyx_TraceLine(550,0,__PYX_ERR(0, 550, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __pyx_f_6hunter_11_predicates_fast_Not_call(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_callable), __pyx_v_event); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 550, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_r = __pyx_t_3; - __pyx_t_3 = 0; - goto __pyx_L0; - - /* "hunter/_predicates.pyx":549 - * elif type(callable) is And: - * return fast_And_call( callable, event) - * elif type(callable) is Not: # <<<<<<<<<<<<<< - * return fast_Not_call( callable, event) - * elif type(callable) is When: - */ - } - - /* "hunter/_predicates.pyx":551 - * elif type(callable) is Not: - * return fast_Not_call( callable, event) - * elif type(callable) is When: # <<<<<<<<<<<<<< - * return fast_When_call( callable, event) - * elif type(callable) is From: - */ - __Pyx_TraceLine(551,0,__PYX_ERR(0, 551, __pyx_L1_error)) - __pyx_t_1 = (((PyObject *)Py_TYPE(__pyx_v_callable)) == ((PyObject *)__pyx_ptype_6hunter_11_predicates_When)); - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { - - /* "hunter/_predicates.pyx":552 - * return fast_Not_call( callable, event) - * elif type(callable) is When: - * return fast_When_call( callable, event) # <<<<<<<<<<<<<< - * elif type(callable) is From: - * return fast_From_call( callable, event) - */ - __Pyx_TraceLine(552,0,__PYX_ERR(0, 552, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __pyx_f_6hunter_11_predicates_fast_When_call(((struct __pyx_obj_6hunter_11_predicates_When *)__pyx_v_callable), __pyx_v_event); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 552, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_r = __pyx_t_3; - __pyx_t_3 = 0; - goto __pyx_L0; + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 564, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Not.__and__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":551 - * elif type(callable) is Not: - * return fast_Not_call( callable, event) - * elif type(callable) is When: # <<<<<<<<<<<<<< - * return fast_When_call( callable, event) - * elif type(callable) is From: - */ - } +/* "hunter/_predicates.pyx":570 + * return And(self, other) + * + * def __invert__(self): # <<<<<<<<<<<<<< + * return self.predicate + * +*/ - /* "hunter/_predicates.pyx":553 - * elif type(callable) is When: - * return fast_When_call( callable, event) - * elif type(callable) is From: # <<<<<<<<<<<<<< - * return fast_From_call( callable, event) - * else: - */ - __Pyx_TraceLine(553,0,__PYX_ERR(0, 553, __pyx_L1_error)) - __pyx_t_2 = (((PyObject *)Py_TYPE(__pyx_v_callable)) == ((PyObject *)__pyx_ptype_6hunter_11_predicates_From)); - __pyx_t_1 = (__pyx_t_2 != 0); - if (__pyx_t_1) { +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_3Not_15__invert__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_3Not_15__invert__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__invert__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_3Not_14__invert__(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self)); - /* "hunter/_predicates.pyx":554 - * return fast_When_call( callable, event) - * elif type(callable) is From: - * return fast_From_call( callable, event) # <<<<<<<<<<<<<< - * else: - * return callable(event) - */ - __Pyx_TraceLine(554,0,__PYX_ERR(0, 554, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __pyx_f_6hunter_11_predicates_fast_From_call(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_callable), __pyx_v_event); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 554, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_r = __pyx_t_3; - __pyx_t_3 = 0; - goto __pyx_L0; + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":553 - * elif type(callable) is When: - * return fast_When_call( callable, event) - * elif type(callable) is From: # <<<<<<<<<<<<<< - * return fast_From_call( callable, event) - * else: - */ - } +static PyObject *__pyx_pf_6hunter_11_predicates_3Not_14__invert__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[110])) + __Pyx_RefNannySetupContext("__invert__", 0); + __Pyx_TraceStartFunc("__invert__", __pyx_f[0], 570, 0, 0, 0, __PYX_ERR(0, 570, __pyx_L1_error)); - /* "hunter/_predicates.pyx":556 - * return fast_From_call( callable, event) - * else: - * return callable(event) # <<<<<<<<<<<<<< - */ - __Pyx_TraceLine(556,0,__PYX_ERR(0, 556, __pyx_L1_error)) - /*else*/ { - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_callable); - __pyx_t_4 = __pyx_v_callable; __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - } - } - __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, ((PyObject *)__pyx_v_event)) : __Pyx_PyObject_CallOneArg(__pyx_t_4, ((PyObject *)__pyx_v_event)); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 556, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_r = __pyx_t_3; - __pyx_t_3 = 0; - goto __pyx_L0; - } + /* "hunter/_predicates.pyx":571 + * + * def __invert__(self): + * return self.predicate # <<<<<<<<<<<<<< + * + * cdef inline fast_Not_call(Not self, Event event): +*/ + __Pyx_TraceLine(571,1,0,__PYX_ERR(0, 571, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->predicate); + __pyx_r = __pyx_v_self->predicate; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 571, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_predicates.pyx":542 + /* "hunter/_predicates.pyx":570 + * return And(self, other) * + * def __invert__(self): # <<<<<<<<<<<<<< + * return self.predicate * - * cdef inline fast_call(callable, Event event): # <<<<<<<<<<<<<< - * if type(callable) is Query: - * return fast_Query_call( callable, event) - */ +*/ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("hunter._predicates.fast_call", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 570, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Not.__invert__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "(tree fragment)":1 - * def __pyx_unpickle_Query(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ +/* "hunter/_predicates.pxd":37 + * cdef class Not: + * cdef: + * readonly object predicate # <<<<<<<<<<<<<< + * + * +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_1__pyx_unpickle_Query(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static PyMethodDef __pyx_mdef_6hunter_11_predicates_1__pyx_unpickle_Query = {"__pyx_unpickle_Query", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6hunter_11_predicates_1__pyx_unpickle_Query, METH_VARARGS|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6hunter_11_predicates_1__pyx_unpickle_Query(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v___pyx_type = 0; - long __pyx_v___pyx_checksum; - PyObject *__pyx_v___pyx_state = 0; +static PyObject *__pyx_pw_6hunter_11_predicates_3Not_9predicate_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_3Not_9predicate_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__pyx_unpickle_Query (wrapper)", 0); - { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; - PyObject* values[3] = {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 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_pyx_type)) != 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_pyx_checksum)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Query", 1, 3, 3, 1); __PYX_ERR(2, 1, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Query", 1, 3, 3, 2); __PYX_ERR(2, 1, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_Query") < 0)) __PYX_ERR(2, 1, __pyx_L3_error) - } - } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { - 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); - } - __pyx_v___pyx_type = values[0]; - __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(2, 1, __pyx_L3_error) - __pyx_v___pyx_state = values[2]; - } - goto __pyx_L4_argument_unpacking_done; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Query", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1, __pyx_L3_error) - __pyx_L3_error:; - __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_Query", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6hunter_11_predicates___pyx_unpickle_Query(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_3Not_9predicate___get__(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates___pyx_unpickle_Query(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_v___pyx_PickleError = 0; - PyObject *__pyx_v___pyx_result = 0; +static PyObject *__pyx_pf_6hunter_11_predicates_3Not_9predicate___get__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - int __pyx_t_6; - __Pyx_TraceFrameInit(__pyx_codeobj__6) - __Pyx_RefNannySetupContext("__pyx_unpickle_Query", 0); - __Pyx_TraceCall("__pyx_unpickle_Query", __pyx_f[2], 1, 0, __PYX_ERR(2, 1, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[111])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 37, 0, 0, 0, __PYX_ERR(2, 37, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->predicate); + __pyx_r = __pyx_v_self->predicate; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 37, __pyx_L1_error)); + goto __pyx_L0; - /* "(tree fragment)":4 - * cdef object __pyx_PickleError - * cdef object __pyx_result - * if __pyx_checksum != 0x4eca0a2: # <<<<<<<<<<<<<< - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0x4eca0a2 = (query_contains, query_endswith, query_eq, query_gt, query_gte, query_in, query_lt, query_lte, query_regex, query_startswith))" % __pyx_checksum) - */ - __Pyx_TraceLine(4,0,__PYX_ERR(2, 4, __pyx_L1_error)) - __pyx_t_1 = ((__pyx_v___pyx_checksum != 0x4eca0a2) != 0); - if (__pyx_t_1) { + /* function exit code */ + __pyx_L1_error:; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 37, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Not.predicate.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "(tree fragment)":5 - * cdef object __pyx_result - * if __pyx_checksum != 0x4eca0a2: - * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< - * raise __pyx_PickleError("Incompatible checksums (%s vs 0x4eca0a2 = (query_contains, query_endswith, query_eq, query_gt, query_gte, query_in, query_lt, query_lte, query_regex, query_startswith))" % __pyx_checksum) - * __pyx_result = Query.__new__(__pyx_type) - */ - __Pyx_TraceLine(5,0,__PYX_ERR(2, 5, __pyx_L1_error)) - __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_n_s_PickleError); - __Pyx_GIVEREF(__pyx_n_s_PickleError); - PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_PickleError); - __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_t_2); - __pyx_v___pyx_PickleError = __pyx_t_2; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ - /* "(tree fragment)":6 - * if __pyx_checksum != 0x4eca0a2: - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0x4eca0a2 = (query_contains, query_endswith, query_eq, query_gt, query_gte, query_in, query_lt, query_lte, query_regex, query_startswith))" % __pyx_checksum) # <<<<<<<<<<<<<< - * __pyx_result = Query.__new__(__pyx_type) - * if __pyx_state is not None: - */ - __Pyx_TraceLine(6,0,__PYX_ERR(2, 6, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_s_vs_0x4e, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_INCREF(__pyx_v___pyx_PickleError); - __pyx_t_2 = __pyx_v___pyx_PickleError; __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - } - } - __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(2, 6, __pyx_L1_error) +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_3Not_17__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_11_predicates_3Not_17__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_3Not_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_11_predicates_3Not_17__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_6hunter_11_predicates_3Not_16__reduce_cython__(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self)); - /* "(tree fragment)":4 - * cdef object __pyx_PickleError - * cdef object __pyx_result - * if __pyx_checksum != 0x4eca0a2: # <<<<<<<<<<<<<< - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0x4eca0a2 = (query_contains, query_endswith, query_eq, query_gt, query_gte, query_in, query_lt, query_lte, query_regex, query_startswith))" % __pyx_checksum) - */ - } + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_11_predicates_3Not_16__reduce_cython__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[112])) + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + __Pyx_TraceStartFunc("__reduce_cython__", __pyx_f[1], 1, 0, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self.predicate,) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: +*/ + __Pyx_TraceLine(5,2,0,__PYX_ERR(1, 5, __pyx_L1_error)) + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_self->predicate); + __Pyx_GIVEREF(__pyx_v_self->predicate); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->predicate) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.predicate,) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) +*/ + __Pyx_TraceLine(6,6,0,__PYX_ERR(1, 6, __pyx_L1_error)) + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; /* "(tree fragment)":7 - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0x4eca0a2 = (query_contains, query_endswith, query_eq, query_gt, query_gte, query_in, query_lt, query_lte, query_regex, query_startswith))" % __pyx_checksum) - * __pyx_result = Query.__new__(__pyx_type) # <<<<<<<<<<<<<< - * if __pyx_state is not None: - * __pyx_unpickle_Query__set_state( __pyx_result, __pyx_state) - */ - __Pyx_TraceLine(7,0,__PYX_ERR(2, 7, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_6hunter_11_predicates_Query), __pyx_n_s_new); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - } - } - __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v___pyx_type); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v___pyx_result = __pyx_t_3; - __pyx_t_3 = 0; + * state = (self.predicate,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + __Pyx_TraceLine(7,13,0,__PYX_ERR(1, 7, __pyx_L1_error)) + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { - /* "(tree fragment)":8 - * raise __pyx_PickleError("Incompatible checksums (%s vs 0x4eca0a2 = (query_contains, query_endswith, query_eq, query_gt, query_gte, query_in, query_lt, query_lte, query_regex, query_startswith))" % __pyx_checksum) - * __pyx_result = Query.__new__(__pyx_type) - * if __pyx_state is not None: # <<<<<<<<<<<<<< - * __pyx_unpickle_Query__set_state( __pyx_result, __pyx_state) - * return __pyx_result - */ - __Pyx_TraceLine(8,0,__PYX_ERR(2, 8, __pyx_L1_error)) - __pyx_t_1 = (__pyx_v___pyx_state != Py_None); - __pyx_t_6 = (__pyx_t_1 != 0); - if (__pyx_t_6) { + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: +*/ + __Pyx_TraceLine(8,15,0,__PYX_ERR(1, 8, __pyx_L1_error)) + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict) != (0)) __PYX_ERR(1, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; /* "(tree fragment)":9 - * __pyx_result = Query.__new__(__pyx_type) - * if __pyx_state is not None: - * __pyx_unpickle_Query__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< - * return __pyx_result - * cdef __pyx_unpickle_Query__set_state(Query __pyx_result, tuple __pyx_state): - */ - __Pyx_TraceLine(9,0,__PYX_ERR(2, 9, __pyx_L1_error)) - if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(2, 9, __pyx_L1_error) - __pyx_t_3 = __pyx_f_6hunter_11_predicates___pyx_unpickle_Query__set_state(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 9, __pyx_L1_error) + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self.predicate is not None +*/ + __Pyx_TraceLine(9,17,0,__PYX_ERR(1, 9, __pyx_L1_error)) + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self.predicate,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self.predicate is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Not, (type(self), 0x23761c9, None), state +*/ + __Pyx_TraceLine(11,21,0,__PYX_ERR(1, 11, __pyx_L1_error)) + /*else*/ { + __pyx_t_2 = (__pyx_v_self->predicate != Py_None); + __pyx_v_use_setstate = __pyx_t_2; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.predicate is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Not, (type(self), 0x23761c9, None), state + * else: +*/ + __Pyx_TraceLine(12,24,0,__PYX_ERR(1, 12, __pyx_L1_error)) + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self.predicate is not None + * if use_setstate: + * return __pyx_unpickle_Not, (type(self), 0x23761c9, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Not, (type(self), 0x23761c9, state) +*/ + __Pyx_TraceLine(13,25,0,__PYX_ERR(1, 13, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Not); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_37183945); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_37183945); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_mstate_global->__pyx_int_37183945) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + __Pyx_TraceReturnValue(__pyx_r, 25, 0, __PYX_ERR(1, 13, __pyx_L1_error)); + goto __pyx_L0; - /* "(tree fragment)":8 - * raise __pyx_PickleError("Incompatible checksums (%s vs 0x4eca0a2 = (query_contains, query_endswith, query_eq, query_gt, query_gte, query_in, query_lt, query_lte, query_regex, query_startswith))" % __pyx_checksum) - * __pyx_result = Query.__new__(__pyx_type) - * if __pyx_state is not None: # <<<<<<<<<<<<<< - * __pyx_unpickle_Query__set_state( __pyx_result, __pyx_state) - * return __pyx_result - */ + /* "(tree fragment)":12 + * else: + * use_setstate = self.predicate is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Not, (type(self), 0x23761c9, None), state + * else: +*/ } - /* "(tree fragment)":10 - * if __pyx_state is not None: - * __pyx_unpickle_Query__set_state( __pyx_result, __pyx_state) - * return __pyx_result # <<<<<<<<<<<<<< - * cdef __pyx_unpickle_Query__set_state(Query __pyx_result, tuple __pyx_state): - * __pyx_result.query_contains = __pyx_state[0]; __pyx_result.query_endswith = __pyx_state[1]; __pyx_result.query_eq = __pyx_state[2]; __pyx_result.query_gt = __pyx_state[3]; __pyx_result.query_gte = __pyx_state[4]; __pyx_result.query_in = __pyx_state[5]; __pyx_result.query_lt = __pyx_state[6]; __pyx_result.query_lte = __pyx_state[7]; __pyx_result.query_regex = __pyx_state[8]; __pyx_result.query_startswith = __pyx_state[9] - */ - __Pyx_TraceLine(10,0,__PYX_ERR(2, 10, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v___pyx_result); - __pyx_r = __pyx_v___pyx_result; - goto __pyx_L0; + /* "(tree fragment)":15 + * return __pyx_unpickle_Not, (type(self), 0x23761c9, None), state + * else: + * return __pyx_unpickle_Not, (type(self), 0x23761c9, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Not__set_state(self, __pyx_state) +*/ + __Pyx_TraceLine(15,33,0,__PYX_ERR(1, 15, __pyx_L1_error)) + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Not); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_37183945); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_37183945); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_mstate_global->__pyx_int_37183945) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + __Pyx_TraceReturnValue(__pyx_r, 33, 0, __PYX_ERR(1, 15, __pyx_L1_error)); + goto __pyx_L0; + } /* "(tree fragment)":1 - * def __pyx_unpickle_Query(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_Query", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Not.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF(__pyx_v___pyx_PickleError); - __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "(tree fragment)":11 - * __pyx_unpickle_Query__set_state( __pyx_result, __pyx_state) - * return __pyx_result - * cdef __pyx_unpickle_Query__set_state(Query __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< - * __pyx_result.query_contains = __pyx_state[0]; __pyx_result.query_endswith = __pyx_state[1]; __pyx_result.query_eq = __pyx_state[2]; __pyx_result.query_gt = __pyx_state[3]; __pyx_result.query_gte = __pyx_state[4]; __pyx_result.query_in = __pyx_state[5]; __pyx_result.query_lt = __pyx_state[6]; __pyx_result.query_lte = __pyx_state[7]; __pyx_result.query_regex = __pyx_state[8]; __pyx_result.query_startswith = __pyx_state[9] - * if len(__pyx_state) > 10 and hasattr(__pyx_result, '__dict__'): - */ - -static PyObject *__pyx_f_6hunter_11_predicates___pyx_unpickle_Query__set_state(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_t_2; - Py_ssize_t __pyx_t_3; - int __pyx_t_4; - int __pyx_t_5; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - __Pyx_RefNannySetupContext("__pyx_unpickle_Query__set_state", 0); - __Pyx_TraceCall("__pyx_unpickle_Query__set_state", __pyx_f[2], 11, 0, __PYX_ERR(2, 11, __pyx_L1_error)); - - /* "(tree fragment)":12 - * return __pyx_result - * cdef __pyx_unpickle_Query__set_state(Query __pyx_result, tuple __pyx_state): - * __pyx_result.query_contains = __pyx_state[0]; __pyx_result.query_endswith = __pyx_state[1]; __pyx_result.query_eq = __pyx_state[2]; __pyx_result.query_gt = __pyx_state[3]; __pyx_result.query_gte = __pyx_state[4]; __pyx_result.query_in = __pyx_state[5]; __pyx_result.query_lt = __pyx_state[6]; __pyx_result.query_lte = __pyx_state[7]; __pyx_result.query_regex = __pyx_state[8]; __pyx_result.query_startswith = __pyx_state[9] # <<<<<<<<<<<<<< - * if len(__pyx_state) > 10 and hasattr(__pyx_result, '__dict__'): - * __pyx_result.__dict__.update(__pyx_state[10]) - */ - __Pyx_TraceLine(12,0,__PYX_ERR(2, 12, __pyx_L1_error)) - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->query_contains); - __Pyx_DECREF(__pyx_v___pyx_result->query_contains); - __pyx_v___pyx_result->query_contains = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->query_endswith); - __Pyx_DECREF(__pyx_v___pyx_result->query_endswith); - __pyx_v___pyx_result->query_endswith = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->query_eq); - __Pyx_DECREF(__pyx_v___pyx_result->query_eq); - __pyx_v___pyx_result->query_eq = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->query_gt); - __Pyx_DECREF(__pyx_v___pyx_result->query_gt); - __pyx_v___pyx_result->query_gt = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 4, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->query_gte); - __Pyx_DECREF(__pyx_v___pyx_result->query_gte); - __pyx_v___pyx_result->query_gte = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 5, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->query_in); - __Pyx_DECREF(__pyx_v___pyx_result->query_in); - __pyx_v___pyx_result->query_in = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 6, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->query_lt); - __Pyx_DECREF(__pyx_v___pyx_result->query_lt); - __pyx_v___pyx_result->query_lt = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 7, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->query_lte); - __Pyx_DECREF(__pyx_v___pyx_result->query_lte); - __pyx_v___pyx_result->query_lte = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 8, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->query_regex); - __Pyx_DECREF(__pyx_v___pyx_result->query_regex); - __pyx_v___pyx_result->query_regex = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 9, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->query_startswith); - __Pyx_DECREF(__pyx_v___pyx_result->query_startswith); - __pyx_v___pyx_result->query_startswith = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - - /* "(tree fragment)":13 - * cdef __pyx_unpickle_Query__set_state(Query __pyx_result, tuple __pyx_state): - * __pyx_result.query_contains = __pyx_state[0]; __pyx_result.query_endswith = __pyx_state[1]; __pyx_result.query_eq = __pyx_state[2]; __pyx_result.query_gt = __pyx_state[3]; __pyx_result.query_gte = __pyx_state[4]; __pyx_result.query_in = __pyx_state[5]; __pyx_result.query_lt = __pyx_state[6]; __pyx_result.query_lte = __pyx_state[7]; __pyx_result.query_regex = __pyx_state[8]; __pyx_result.query_startswith = __pyx_state[9] - * if len(__pyx_state) > 10 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< - * __pyx_result.__dict__.update(__pyx_state[10]) - */ - __Pyx_TraceLine(13,0,__PYX_ERR(2, 13, __pyx_L1_error)) - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(2, 13, __pyx_L1_error) - } - __pyx_t_3 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(2, 13, __pyx_L1_error) - __pyx_t_4 = ((__pyx_t_3 > 10) != 0); - if (__pyx_t_4) { - } else { - __pyx_t_2 = __pyx_t_4; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(2, 13, __pyx_L1_error) - __pyx_t_5 = (__pyx_t_4 != 0); - __pyx_t_2 = __pyx_t_5; - __pyx_L4_bool_binop_done:; - if (__pyx_t_2) { - - /* "(tree fragment)":14 - * __pyx_result.query_contains = __pyx_state[0]; __pyx_result.query_endswith = __pyx_state[1]; __pyx_result.query_eq = __pyx_state[2]; __pyx_result.query_gt = __pyx_state[3]; __pyx_result.query_gte = __pyx_state[4]; __pyx_result.query_in = __pyx_state[5]; __pyx_result.query_lt = __pyx_state[6]; __pyx_result.query_lte = __pyx_state[7]; __pyx_result.query_regex = __pyx_state[8]; __pyx_result.query_startswith = __pyx_state[9] - * if len(__pyx_state) > 10 and hasattr(__pyx_result, '__dict__'): - * __pyx_result.__dict__.update(__pyx_state[10]) # <<<<<<<<<<<<<< - */ - __Pyx_TraceLine(14,0,__PYX_ERR(2, 14, __pyx_L1_error)) - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_update); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 14, __pyx_L1_error) - } - __pyx_t_6 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 10, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); - if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); - __Pyx_INCREF(__pyx_t_8); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_7, function); - } - } - __pyx_t_1 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "(tree fragment)":13 - * cdef __pyx_unpickle_Query__set_state(Query __pyx_result, tuple __pyx_state): - * __pyx_result.query_contains = __pyx_state[0]; __pyx_result.query_endswith = __pyx_state[1]; __pyx_result.query_eq = __pyx_state[2]; __pyx_result.query_gt = __pyx_state[3]; __pyx_result.query_gte = __pyx_state[4]; __pyx_result.query_in = __pyx_state[5]; __pyx_result.query_lt = __pyx_state[6]; __pyx_result.query_lte = __pyx_state[7]; __pyx_result.query_regex = __pyx_state[8]; __pyx_result.query_startswith = __pyx_state[9] - * if len(__pyx_state) > 10 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< - * __pyx_result.__dict__.update(__pyx_state[10]) - */ - } - - /* "(tree fragment)":11 - * __pyx_unpickle_Query__set_state( __pyx_result, __pyx_state) - * return __pyx_result - * cdef __pyx_unpickle_Query__set_state(Query __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< - * __pyx_result.query_contains = __pyx_state[0]; __pyx_result.query_endswith = __pyx_state[1]; __pyx_result.query_eq = __pyx_state[2]; __pyx_result.query_gt = __pyx_state[3]; __pyx_result.query_gte = __pyx_state[4]; __pyx_result.query_in = __pyx_state[5]; __pyx_result.query_lt = __pyx_state[6]; __pyx_result.query_lte = __pyx_state[7]; __pyx_result.query_regex = __pyx_state[8]; __pyx_result.query_startswith = __pyx_state[9] - * if len(__pyx_state) > 10 and hasattr(__pyx_result, '__dict__'): - */ - - /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_Query__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "(tree fragment)":1 - * def __pyx_unpickle_When(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Not, (type(self), 0x23761c9, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Not__set_state(self, __pyx_state) +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_3__pyx_unpickle_When(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static PyMethodDef __pyx_mdef_6hunter_11_predicates_3__pyx_unpickle_When = {"__pyx_unpickle_When", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6hunter_11_predicates_3__pyx_unpickle_When, METH_VARARGS|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6hunter_11_predicates_3__pyx_unpickle_When(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v___pyx_type = 0; - long __pyx_v___pyx_checksum; +static PyObject *__pyx_pw_6hunter_11_predicates_3Not_19__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_11_predicates_3Not_19__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_3Not_19__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_11_predicates_3Not_19__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__pyx_unpickle_When (wrapper)", 0); + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; - PyObject* values[3] = {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 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); + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 16, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) 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_pyx_type)) != 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_pyx_checksum)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_When", 1, 3, 3, 1); __PYX_ERR(2, 1, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_When", 1, 3, 3, 2); __PYX_ERR(2, 1, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_When") < 0)) __PYX_ERR(2, 1, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 16, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 16, __pyx_L3_error) } } - } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { + } else if (unlikely(__pyx_nargs != 1)) { 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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) } - __pyx_v___pyx_type = values[0]; - __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(2, 1, __pyx_L3_error) - __pyx_v___pyx_state = values[2]; + __pyx_v___pyx_state = values[0]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_When", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_When", __pyx_clineno, __pyx_lineno, __pyx_filename); + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("hunter._predicates.Not.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6hunter_11_predicates_2__pyx_unpickle_When(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + __pyx_r = __pyx_pf_6hunter_11_predicates_3Not_18__setstate_cython__(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_2__pyx_unpickle_When(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_v___pyx_PickleError = 0; - PyObject *__pyx_v___pyx_result = 0; +static PyObject *__pyx_pf_6hunter_11_predicates_3Not_18__setstate_cython__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - int __pyx_t_6; - __Pyx_TraceFrameInit(__pyx_codeobj__7) - __Pyx_RefNannySetupContext("__pyx_unpickle_When", 0); - __Pyx_TraceCall("__pyx_unpickle_When", __pyx_f[2], 1, 0, __PYX_ERR(2, 1, __pyx_L1_error)); + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[113])) + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + __Pyx_TraceStartFunc("__setstate_cython__", __pyx_f[1], 16, 0, 0, 0, __PYX_ERR(1, 16, __pyx_L1_error)); - /* "(tree fragment)":4 - * cdef object __pyx_PickleError - * cdef object __pyx_result - * if __pyx_checksum != 0xb55b71c: # <<<<<<<<<<<<<< - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xb55b71c = (actions, condition))" % __pyx_checksum) - */ - __Pyx_TraceLine(4,0,__PYX_ERR(2, 4, __pyx_L1_error)) - __pyx_t_1 = ((__pyx_v___pyx_checksum != 0xb55b71c) != 0); - if (__pyx_t_1) { + /* "(tree fragment)":17 + * return __pyx_unpickle_Not, (type(self), 0x23761c9, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Not__set_state(self, __pyx_state) # <<<<<<<<<<<<<< +*/ + __Pyx_TraceLine(17,4,0,__PYX_ERR(1, 17, __pyx_L1_error)) + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_6hunter_11_predicates___pyx_unpickle_Not__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "(tree fragment)":5 - * cdef object __pyx_result - * if __pyx_checksum != 0xb55b71c: - * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xb55b71c = (actions, condition))" % __pyx_checksum) - * __pyx_result = When.__new__(__pyx_type) - */ - __Pyx_TraceLine(5,0,__PYX_ERR(2, 5, __pyx_L1_error)) - __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_n_s_PickleError); - __Pyx_GIVEREF(__pyx_n_s_PickleError); - PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_PickleError); - __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_t_2); - __pyx_v___pyx_PickleError = __pyx_t_2; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "(tree fragment)":6 - * if __pyx_checksum != 0xb55b71c: - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xb55b71c = (actions, condition))" % __pyx_checksum) # <<<<<<<<<<<<<< - * __pyx_result = When.__new__(__pyx_type) - * if __pyx_state is not None: - */ - __Pyx_TraceLine(6,0,__PYX_ERR(2, 6, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_s_vs_0xb5, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_INCREF(__pyx_v___pyx_PickleError); - __pyx_t_2 = __pyx_v___pyx_PickleError; __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - } - } - __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(2, 6, __pyx_L1_error) - - /* "(tree fragment)":4 - * cdef object __pyx_PickleError - * cdef object __pyx_result - * if __pyx_checksum != 0xb55b71c: # <<<<<<<<<<<<<< - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xb55b71c = (actions, condition))" % __pyx_checksum) - */ - } - - /* "(tree fragment)":7 - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xb55b71c = (actions, condition))" % __pyx_checksum) - * __pyx_result = When.__new__(__pyx_type) # <<<<<<<<<<<<<< - * if __pyx_state is not None: - * __pyx_unpickle_When__set_state( __pyx_result, __pyx_state) - */ - __Pyx_TraceLine(7,0,__PYX_ERR(2, 7, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_6hunter_11_predicates_When), __pyx_n_s_new); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - } - } - __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v___pyx_type); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v___pyx_result = __pyx_t_3; - __pyx_t_3 = 0; - - /* "(tree fragment)":8 - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xb55b71c = (actions, condition))" % __pyx_checksum) - * __pyx_result = When.__new__(__pyx_type) - * if __pyx_state is not None: # <<<<<<<<<<<<<< - * __pyx_unpickle_When__set_state( __pyx_result, __pyx_state) - * return __pyx_result - */ - __Pyx_TraceLine(8,0,__PYX_ERR(2, 8, __pyx_L1_error)) - __pyx_t_1 = (__pyx_v___pyx_state != Py_None); - __pyx_t_6 = (__pyx_t_1 != 0); - if (__pyx_t_6) { - - /* "(tree fragment)":9 - * __pyx_result = When.__new__(__pyx_type) - * if __pyx_state is not None: - * __pyx_unpickle_When__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< - * return __pyx_result - * cdef __pyx_unpickle_When__set_state(When __pyx_result, tuple __pyx_state): - */ - __Pyx_TraceLine(9,0,__PYX_ERR(2, 9, __pyx_L1_error)) - if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(2, 9, __pyx_L1_error) - __pyx_t_3 = __pyx_f_6hunter_11_predicates___pyx_unpickle_When__set_state(((struct __pyx_obj_6hunter_11_predicates_When *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "(tree fragment)":8 - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xb55b71c = (actions, condition))" % __pyx_checksum) - * __pyx_result = When.__new__(__pyx_type) - * if __pyx_state is not None: # <<<<<<<<<<<<<< - * __pyx_unpickle_When__set_state( __pyx_result, __pyx_state) - * return __pyx_result - */ - } - - /* "(tree fragment)":10 - * if __pyx_state is not None: - * __pyx_unpickle_When__set_state( __pyx_result, __pyx_state) - * return __pyx_result # <<<<<<<<<<<<<< - * cdef __pyx_unpickle_When__set_state(When __pyx_result, tuple __pyx_state): - * __pyx_result.actions = __pyx_state[0]; __pyx_result.condition = __pyx_state[1] - */ - __Pyx_TraceLine(10,0,__PYX_ERR(2, 10, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v___pyx_result); - __pyx_r = __pyx_v___pyx_result; - goto __pyx_L0; - - /* "(tree fragment)":1 - * def __pyx_unpickle_When(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Not, (type(self), 0x23761c9, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Not__set_state(self, __pyx_state) +*/ /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(1, 16, __pyx_L1_error)); + goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_When", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 16, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Not.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF(__pyx_v___pyx_PickleError); - __Pyx_XDECREF(__pyx_v___pyx_result); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "(tree fragment)":11 - * __pyx_unpickle_When__set_state( __pyx_result, __pyx_state) - * return __pyx_result - * cdef __pyx_unpickle_When__set_state(When __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< - * __pyx_result.actions = __pyx_state[0]; __pyx_result.condition = __pyx_state[1] - * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): - */ +/* "hunter/_predicates.pyx":573 + * return self.predicate + * + * cdef inline fast_Not_call(Not self, Event event): # <<<<<<<<<<<<<< + * return not fast_call(self.predicate, event) + * +*/ -static PyObject *__pyx_f_6hunter_11_predicates___pyx_unpickle_When__set_state(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_fast_Not_call(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - int __pyx_t_2; - Py_ssize_t __pyx_t_3; - int __pyx_t_4; - int __pyx_t_5; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - __Pyx_RefNannySetupContext("__pyx_unpickle_When__set_state", 0); - __Pyx_TraceCall("__pyx_unpickle_When__set_state", __pyx_f[2], 11, 0, __PYX_ERR(2, 11, __pyx_L1_error)); - - /* "(tree fragment)":12 - * return __pyx_result - * cdef __pyx_unpickle_When__set_state(When __pyx_result, tuple __pyx_state): - * __pyx_result.actions = __pyx_state[0]; __pyx_result.condition = __pyx_state[1] # <<<<<<<<<<<<<< - * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): - * __pyx_result.__dict__.update(__pyx_state[2]) - */ - __Pyx_TraceLine(12,0,__PYX_ERR(2, 12, __pyx_L1_error)) - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->actions); - __Pyx_DECREF(__pyx_v___pyx_result->actions); - __pyx_v___pyx_result->actions = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->condition); - __Pyx_DECREF(__pyx_v___pyx_result->condition); - __pyx_v___pyx_result->condition = __pyx_t_1; - __pyx_t_1 = 0; - - /* "(tree fragment)":13 - * cdef __pyx_unpickle_When__set_state(When __pyx_result, tuple __pyx_state): - * __pyx_result.actions = __pyx_state[0]; __pyx_result.condition = __pyx_state[1] - * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< - * __pyx_result.__dict__.update(__pyx_state[2]) - */ - __Pyx_TraceLine(13,0,__PYX_ERR(2, 13, __pyx_L1_error)) - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(2, 13, __pyx_L1_error) - } - __pyx_t_3 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(2, 13, __pyx_L1_error) - __pyx_t_4 = ((__pyx_t_3 > 2) != 0); - if (__pyx_t_4) { - } else { - __pyx_t_2 = __pyx_t_4; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(2, 13, __pyx_L1_error) - __pyx_t_5 = (__pyx_t_4 != 0); - __pyx_t_2 = __pyx_t_5; - __pyx_L4_bool_binop_done:; - if (__pyx_t_2) { - - /* "(tree fragment)":14 - * __pyx_result.actions = __pyx_state[0]; __pyx_result.condition = __pyx_state[1] - * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): - * __pyx_result.__dict__.update(__pyx_state[2]) # <<<<<<<<<<<<<< - */ - __Pyx_TraceLine(14,0,__PYX_ERR(2, 14, __pyx_L1_error)) - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_update); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 14, __pyx_L1_error) - } - __pyx_t_6 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); - if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); - __Pyx_INCREF(__pyx_t_8); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_7, function); - } - } - __pyx_t_1 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[114])) + __Pyx_RefNannySetupContext("fast_Not_call", 0); + __Pyx_TraceStartFunc("fast_Not_call", __pyx_f[0], 573, 0, 0, 0, __PYX_ERR(0, 573, __pyx_L1_error)); - /* "(tree fragment)":13 - * cdef __pyx_unpickle_When__set_state(When __pyx_result, tuple __pyx_state): - * __pyx_result.actions = __pyx_state[0]; __pyx_result.condition = __pyx_state[1] - * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< - * __pyx_result.__dict__.update(__pyx_state[2]) - */ - } + /* "hunter/_predicates.pyx":574 + * + * cdef inline fast_Not_call(Not self, Event event): + * return not fast_call(self.predicate, event) # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_TraceLine(574,1,0,__PYX_ERR(0, 574, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_v_self->predicate; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = __pyx_f_6hunter_11_predicates_fast_call(__pyx_t_1, __pyx_v_event); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 574, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyBool_FromLong((!__pyx_t_3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 574, __pyx_L1_error)); + goto __pyx_L0; - /* "(tree fragment)":11 - * __pyx_unpickle_When__set_state( __pyx_result, __pyx_state) - * return __pyx_result - * cdef __pyx_unpickle_When__set_state(When __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< - * __pyx_result.actions = __pyx_state[0]; __pyx_result.condition = __pyx_state[1] - * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): - */ + /* "hunter/_predicates.pyx":573 + * return self.predicate + * + * cdef inline fast_Not_call(Not self, Event event): # <<<<<<<<<<<<<< + * return not fast_call(self.predicate, event) + * +*/ /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_When__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 573, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.fast_Not_call", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "(tree fragment)":1 - * def __pyx_unpickle_From(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ +/* "hunter/_predicates.pyx":577 + * + * + * cdef inline fast_call(callable, Event event): # <<<<<<<<<<<<<< + * if type(callable) is Query: + * return fast_Query_call( callable, event) +*/ -/* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_5__pyx_unpickle_From(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static PyMethodDef __pyx_mdef_6hunter_11_predicates_5__pyx_unpickle_From = {"__pyx_unpickle_From", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6hunter_11_predicates_5__pyx_unpickle_From, METH_VARARGS|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6hunter_11_predicates_5__pyx_unpickle_From(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v___pyx_type = 0; - long __pyx_v___pyx_checksum; - PyObject *__pyx_v___pyx_state = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__pyx_unpickle_From (wrapper)", 0); - { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; - PyObject* values[3] = {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 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_pyx_type)) != 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_pyx_checksum)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_From", 1, 3, 3, 1); __PYX_ERR(2, 1, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_From", 1, 3, 3, 2); __PYX_ERR(2, 1, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_From") < 0)) __PYX_ERR(2, 1, __pyx_L3_error) - } - } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { - 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); - } - __pyx_v___pyx_type = values[0]; - __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(2, 1, __pyx_L3_error) - __pyx_v___pyx_state = values[2]; - } - goto __pyx_L4_argument_unpacking_done; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_From", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1, __pyx_L3_error) - __pyx_L3_error:; - __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_From", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6hunter_11_predicates_4__pyx_unpickle_From(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6hunter_11_predicates_4__pyx_unpickle_From(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_v___pyx_PickleError = 0; - PyObject *__pyx_v___pyx_result = 0; - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_fast_call(PyObject *__pyx_v_callable, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - int __pyx_t_6; - __Pyx_TraceFrameInit(__pyx_codeobj__8) - __Pyx_RefNannySetupContext("__pyx_unpickle_From", 0); - __Pyx_TraceCall("__pyx_unpickle_From", __pyx_f[2], 1, 0, __PYX_ERR(2, 1, __pyx_L1_error)); + size_t __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[115])) + __Pyx_RefNannySetupContext("fast_call", 0); + __Pyx_TraceStartFunc("fast_call", __pyx_f[0], 577, 0, 0, 0, __PYX_ERR(0, 577, __pyx_L1_error)); - /* "(tree fragment)":4 - * cdef object __pyx_PickleError - * cdef object __pyx_result - * if __pyx_checksum != 0x1acd5f7: # <<<<<<<<<<<<<< - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0x1acd5f7 = (condition, origin_calls, origin_depth, predicate, watermark))" % __pyx_checksum) - */ - __Pyx_TraceLine(4,0,__PYX_ERR(2, 4, __pyx_L1_error)) - __pyx_t_1 = ((__pyx_v___pyx_checksum != 0x1acd5f7) != 0); + /* "hunter/_predicates.pyx":578 + * + * cdef inline fast_call(callable, Event event): + * if type(callable) is Query: # <<<<<<<<<<<<<< + * return fast_Query_call( callable, event) + * elif type(callable) is Or: +*/ + __Pyx_TraceLine(578,6,0,__PYX_ERR(0, 578, __pyx_L1_error)) + __pyx_t_1 = (((PyObject *)Py_TYPE(__pyx_v_callable)) == ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Query)); if (__pyx_t_1) { - /* "(tree fragment)":5 - * cdef object __pyx_result - * if __pyx_checksum != 0x1acd5f7: - * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< - * raise __pyx_PickleError("Incompatible checksums (%s vs 0x1acd5f7 = (condition, origin_calls, origin_depth, predicate, watermark))" % __pyx_checksum) - * __pyx_result = From.__new__(__pyx_type) - */ - __Pyx_TraceLine(5,0,__PYX_ERR(2, 5, __pyx_L1_error)) - __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_n_s_PickleError); - __Pyx_GIVEREF(__pyx_n_s_PickleError); - PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_PickleError); - __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 5, __pyx_L1_error) + /* "hunter/_predicates.pyx":579 + * cdef inline fast_call(callable, Event event): + * if type(callable) is Query: + * return fast_Query_call( callable, event) # <<<<<<<<<<<<<< + * elif type(callable) is Or: + * return fast_Or_call( callable, event) +*/ + __Pyx_TraceLine(579,7,0,__PYX_ERR(0, 579, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_f_6hunter_11_predicates_fast_Query_call(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v_callable), __pyx_v_event); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 579, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_t_2); - __pyx_v___pyx_PickleError = __pyx_t_2; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_TraceReturnValue(__pyx_r, 7, 0, __PYX_ERR(0, 579, __pyx_L1_error)); + goto __pyx_L0; - /* "(tree fragment)":6 - * if __pyx_checksum != 0x1acd5f7: - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0x1acd5f7 = (condition, origin_calls, origin_depth, predicate, watermark))" % __pyx_checksum) # <<<<<<<<<<<<<< - * __pyx_result = From.__new__(__pyx_type) - * if __pyx_state is not None: - */ - __Pyx_TraceLine(6,0,__PYX_ERR(2, 6, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 6, __pyx_L1_error) + /* "hunter/_predicates.pyx":578 + * + * cdef inline fast_call(callable, Event event): + * if type(callable) is Query: # <<<<<<<<<<<<<< + * return fast_Query_call( callable, event) + * elif type(callable) is Or: +*/ + } + + /* "hunter/_predicates.pyx":580 + * if type(callable) is Query: + * return fast_Query_call( callable, event) + * elif type(callable) is Or: # <<<<<<<<<<<<<< + * return fast_Or_call( callable, event) + * elif type(callable) is And: +*/ + __Pyx_TraceLine(580,17,0,__PYX_ERR(0, 580, __pyx_L1_error)) + __pyx_t_1 = (((PyObject *)Py_TYPE(__pyx_v_callable)) == ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Or)); + if (__pyx_t_1) { + + /* "hunter/_predicates.pyx":581 + * return fast_Query_call( callable, event) + * elif type(callable) is Or: + * return fast_Or_call( callable, event) # <<<<<<<<<<<<<< + * elif type(callable) is And: + * return fast_And_call( callable, event) +*/ + __Pyx_TraceLine(581,18,0,__PYX_ERR(0, 581, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_f_6hunter_11_predicates_fast_Or_call(((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_callable), __pyx_v_event); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 581, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_s_vs_0x1a, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_INCREF(__pyx_v___pyx_PickleError); - __pyx_t_2 = __pyx_v___pyx_PickleError; __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - } - } - __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(2, 6, __pyx_L1_error) + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_TraceReturnValue(__pyx_r, 18, 0, __PYX_ERR(0, 581, __pyx_L1_error)); + goto __pyx_L0; - /* "(tree fragment)":4 - * cdef object __pyx_PickleError - * cdef object __pyx_result - * if __pyx_checksum != 0x1acd5f7: # <<<<<<<<<<<<<< - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0x1acd5f7 = (condition, origin_calls, origin_depth, predicate, watermark))" % __pyx_checksum) - */ + /* "hunter/_predicates.pyx":580 + * if type(callable) is Query: + * return fast_Query_call( callable, event) + * elif type(callable) is Or: # <<<<<<<<<<<<<< + * return fast_Or_call( callable, event) + * elif type(callable) is And: +*/ } - /* "(tree fragment)":7 - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0x1acd5f7 = (condition, origin_calls, origin_depth, predicate, watermark))" % __pyx_checksum) - * __pyx_result = From.__new__(__pyx_type) # <<<<<<<<<<<<<< - * if __pyx_state is not None: - * __pyx_unpickle_From__set_state( __pyx_result, __pyx_state) - */ - __Pyx_TraceLine(7,0,__PYX_ERR(2, 7, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_6hunter_11_predicates_From), __pyx_n_s_new); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - } - } - __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v___pyx_type); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v___pyx_result = __pyx_t_3; - __pyx_t_3 = 0; - - /* "(tree fragment)":8 - * raise __pyx_PickleError("Incompatible checksums (%s vs 0x1acd5f7 = (condition, origin_calls, origin_depth, predicate, watermark))" % __pyx_checksum) - * __pyx_result = From.__new__(__pyx_type) - * if __pyx_state is not None: # <<<<<<<<<<<<<< - * __pyx_unpickle_From__set_state( __pyx_result, __pyx_state) - * return __pyx_result - */ - __Pyx_TraceLine(8,0,__PYX_ERR(2, 8, __pyx_L1_error)) - __pyx_t_1 = (__pyx_v___pyx_state != Py_None); - __pyx_t_6 = (__pyx_t_1 != 0); - if (__pyx_t_6) { + /* "hunter/_predicates.pyx":582 + * elif type(callable) is Or: + * return fast_Or_call( callable, event) + * elif type(callable) is And: # <<<<<<<<<<<<<< + * return fast_And_call( callable, event) + * elif type(callable) is Not: +*/ + __Pyx_TraceLine(582,28,0,__PYX_ERR(0, 582, __pyx_L1_error)) + __pyx_t_1 = (((PyObject *)Py_TYPE(__pyx_v_callable)) == ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_And)); + if (__pyx_t_1) { - /* "(tree fragment)":9 - * __pyx_result = From.__new__(__pyx_type) - * if __pyx_state is not None: - * __pyx_unpickle_From__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< - * return __pyx_result - * cdef __pyx_unpickle_From__set_state(From __pyx_result, tuple __pyx_state): - */ - __Pyx_TraceLine(9,0,__PYX_ERR(2, 9, __pyx_L1_error)) - if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(2, 9, __pyx_L1_error) - __pyx_t_3 = __pyx_f_6hunter_11_predicates___pyx_unpickle_From__set_state(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + /* "hunter/_predicates.pyx":583 + * return fast_Or_call( callable, event) + * elif type(callable) is And: + * return fast_And_call( callable, event) # <<<<<<<<<<<<<< + * elif type(callable) is Not: + * return fast_Not_call( callable, event) +*/ + __Pyx_TraceLine(583,29,0,__PYX_ERR(0, 583, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_f_6hunter_11_predicates_fast_And_call(((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v_callable), __pyx_v_event); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_TraceReturnValue(__pyx_r, 29, 0, __PYX_ERR(0, 583, __pyx_L1_error)); + goto __pyx_L0; - /* "(tree fragment)":8 - * raise __pyx_PickleError("Incompatible checksums (%s vs 0x1acd5f7 = (condition, origin_calls, origin_depth, predicate, watermark))" % __pyx_checksum) - * __pyx_result = From.__new__(__pyx_type) - * if __pyx_state is not None: # <<<<<<<<<<<<<< - * __pyx_unpickle_From__set_state( __pyx_result, __pyx_state) - * return __pyx_result - */ + /* "hunter/_predicates.pyx":582 + * elif type(callable) is Or: + * return fast_Or_call( callable, event) + * elif type(callable) is And: # <<<<<<<<<<<<<< + * return fast_And_call( callable, event) + * elif type(callable) is Not: +*/ } - /* "(tree fragment)":10 - * if __pyx_state is not None: - * __pyx_unpickle_From__set_state( __pyx_result, __pyx_state) - * return __pyx_result # <<<<<<<<<<<<<< - * cdef __pyx_unpickle_From__set_state(From __pyx_result, tuple __pyx_state): - * __pyx_result.condition = __pyx_state[0]; __pyx_result.origin_calls = __pyx_state[1]; __pyx_result.origin_depth = __pyx_state[2]; __pyx_result.predicate = __pyx_state[3]; __pyx_result.watermark = __pyx_state[4] - */ - __Pyx_TraceLine(10,0,__PYX_ERR(2, 10, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v___pyx_result); - __pyx_r = __pyx_v___pyx_result; - goto __pyx_L0; + /* "hunter/_predicates.pyx":584 + * elif type(callable) is And: + * return fast_And_call( callable, event) + * elif type(callable) is Not: # <<<<<<<<<<<<<< + * return fast_Not_call( callable, event) + * elif type(callable) is When: +*/ + __Pyx_TraceLine(584,39,0,__PYX_ERR(0, 584, __pyx_L1_error)) + __pyx_t_1 = (((PyObject *)Py_TYPE(__pyx_v_callable)) == ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Not)); + if (__pyx_t_1) { - /* "(tree fragment)":1 - * def __pyx_unpickle_From(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ + /* "hunter/_predicates.pyx":585 + * return fast_And_call( callable, event) + * elif type(callable) is Not: + * return fast_Not_call( callable, event) # <<<<<<<<<<<<<< + * elif type(callable) is When: + * return fast_When_call( callable, event) +*/ + __Pyx_TraceLine(585,40,0,__PYX_ERR(0, 585, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_f_6hunter_11_predicates_fast_Not_call(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_callable), __pyx_v_event); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 585, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_TraceReturnValue(__pyx_r, 40, 0, __PYX_ERR(0, 585, __pyx_L1_error)); + goto __pyx_L0; - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_From", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v___pyx_PickleError); - __Pyx_XDECREF(__pyx_v___pyx_result); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":584 + * elif type(callable) is And: + * return fast_And_call( callable, event) + * elif type(callable) is Not: # <<<<<<<<<<<<<< + * return fast_Not_call( callable, event) + * elif type(callable) is When: +*/ + } -/* "(tree fragment)":11 - * __pyx_unpickle_From__set_state( __pyx_result, __pyx_state) - * return __pyx_result - * cdef __pyx_unpickle_From__set_state(From __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< - * __pyx_result.condition = __pyx_state[0]; __pyx_result.origin_calls = __pyx_state[1]; __pyx_result.origin_depth = __pyx_state[2]; __pyx_result.predicate = __pyx_state[3]; __pyx_result.watermark = __pyx_state[4] - * if len(__pyx_state) > 5 and hasattr(__pyx_result, '__dict__'): - */ + /* "hunter/_predicates.pyx":586 + * elif type(callable) is Not: + * return fast_Not_call( callable, event) + * elif type(callable) is When: # <<<<<<<<<<<<<< + * return fast_When_call( callable, event) + * elif type(callable) is From: +*/ + __Pyx_TraceLine(586,50,0,__PYX_ERR(0, 586, __pyx_L1_error)) + __pyx_t_1 = (((PyObject *)Py_TYPE(__pyx_v_callable)) == ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_When)); + if (__pyx_t_1) { -static PyObject *__pyx_f_6hunter_11_predicates___pyx_unpickle_From__set_state(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_t_2; - int __pyx_t_3; - Py_ssize_t __pyx_t_4; - int __pyx_t_5; - int __pyx_t_6; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - PyObject *__pyx_t_9 = NULL; - __Pyx_RefNannySetupContext("__pyx_unpickle_From__set_state", 0); - __Pyx_TraceCall("__pyx_unpickle_From__set_state", __pyx_f[2], 11, 0, __PYX_ERR(2, 11, __pyx_L1_error)); + /* "hunter/_predicates.pyx":587 + * return fast_Not_call( callable, event) + * elif type(callable) is When: + * return fast_When_call( callable, event) # <<<<<<<<<<<<<< + * elif type(callable) is From: + * return fast_From_call( callable, event) +*/ + __Pyx_TraceLine(587,51,0,__PYX_ERR(0, 587, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_f_6hunter_11_predicates_fast_When_call(((struct __pyx_obj_6hunter_11_predicates_When *)__pyx_v_callable), __pyx_v_event); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 587, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_TraceReturnValue(__pyx_r, 51, 0, __PYX_ERR(0, 587, __pyx_L1_error)); + goto __pyx_L0; - /* "(tree fragment)":12 - * return __pyx_result - * cdef __pyx_unpickle_From__set_state(From __pyx_result, tuple __pyx_state): - * __pyx_result.condition = __pyx_state[0]; __pyx_result.origin_calls = __pyx_state[1]; __pyx_result.origin_depth = __pyx_state[2]; __pyx_result.predicate = __pyx_state[3]; __pyx_result.watermark = __pyx_state[4] # <<<<<<<<<<<<<< - * if len(__pyx_state) > 5 and hasattr(__pyx_result, '__dict__'): - * __pyx_result.__dict__.update(__pyx_state[5]) - */ - __Pyx_TraceLine(12,0,__PYX_ERR(2, 12, __pyx_L1_error)) - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->condition); - __Pyx_DECREF(__pyx_v___pyx_result->condition); - __pyx_v___pyx_result->condition = __pyx_t_1; - __pyx_t_1 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v___pyx_result->origin_calls = __pyx_t_2; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v___pyx_result->origin_depth = __pyx_t_2; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->predicate); - __Pyx_DECREF(__pyx_v___pyx_result->predicate); - __pyx_v___pyx_result->predicate = __pyx_t_1; - __pyx_t_1 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) + /* "hunter/_predicates.pyx":586 + * elif type(callable) is Not: + * return fast_Not_call( callable, event) + * elif type(callable) is When: # <<<<<<<<<<<<<< + * return fast_When_call( callable, event) + * elif type(callable) is From: +*/ } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 4, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v___pyx_result->watermark = __pyx_t_2; - /* "(tree fragment)":13 - * cdef __pyx_unpickle_From__set_state(From __pyx_result, tuple __pyx_state): - * __pyx_result.condition = __pyx_state[0]; __pyx_result.origin_calls = __pyx_state[1]; __pyx_result.origin_depth = __pyx_state[2]; __pyx_result.predicate = __pyx_state[3]; __pyx_result.watermark = __pyx_state[4] - * if len(__pyx_state) > 5 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< - * __pyx_result.__dict__.update(__pyx_state[5]) - */ - __Pyx_TraceLine(13,0,__PYX_ERR(2, 13, __pyx_L1_error)) - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(2, 13, __pyx_L1_error) + /* "hunter/_predicates.pyx":588 + * elif type(callable) is When: + * return fast_When_call( callable, event) + * elif type(callable) is From: # <<<<<<<<<<<<<< + * return fast_From_call( callable, event) + * elif type(callable) is Backlog: +*/ + __Pyx_TraceLine(588,61,0,__PYX_ERR(0, 588, __pyx_L1_error)) + __pyx_t_1 = (((PyObject *)Py_TYPE(__pyx_v_callable)) == ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_From)); + if (__pyx_t_1) { + + /* "hunter/_predicates.pyx":589 + * return fast_When_call( callable, event) + * elif type(callable) is From: + * return fast_From_call( callable, event) # <<<<<<<<<<<<<< + * elif type(callable) is Backlog: + * return fast_Backlog_call( callable, event) +*/ + __Pyx_TraceLine(589,62,0,__PYX_ERR(0, 589, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_f_6hunter_11_predicates_fast_From_call(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_callable), __pyx_v_event); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 589, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_TraceReturnValue(__pyx_r, 62, 0, __PYX_ERR(0, 589, __pyx_L1_error)); + goto __pyx_L0; + + /* "hunter/_predicates.pyx":588 + * elif type(callable) is When: + * return fast_When_call( callable, event) + * elif type(callable) is From: # <<<<<<<<<<<<<< + * return fast_From_call( callable, event) + * elif type(callable) is Backlog: +*/ } - __pyx_t_4 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(2, 13, __pyx_L1_error) - __pyx_t_5 = ((__pyx_t_4 > 5) != 0); - if (__pyx_t_5) { - } else { - __pyx_t_3 = __pyx_t_5; - goto __pyx_L4_bool_binop_done; + + /* "hunter/_predicates.pyx":590 + * elif type(callable) is From: + * return fast_From_call( callable, event) + * elif type(callable) is Backlog: # <<<<<<<<<<<<<< + * return fast_Backlog_call( callable, event) + * else: +*/ + __Pyx_TraceLine(590,72,0,__PYX_ERR(0, 590, __pyx_L1_error)) + __pyx_t_1 = (((PyObject *)Py_TYPE(__pyx_v_callable)) == ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Backlog)); + if (__pyx_t_1) { + + /* "hunter/_predicates.pyx":591 + * return fast_From_call( callable, event) + * elif type(callable) is Backlog: + * return fast_Backlog_call( callable, event) # <<<<<<<<<<<<<< + * else: + * return callable(event) +*/ + __Pyx_TraceLine(591,73,0,__PYX_ERR(0, 591, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_f_6hunter_11_predicates_fast_Backlog_call(((struct __pyx_obj_6hunter_11_predicates_Backlog *)__pyx_v_callable), __pyx_v_event); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 591, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_TraceReturnValue(__pyx_r, 73, 0, __PYX_ERR(0, 591, __pyx_L1_error)); + goto __pyx_L0; + + /* "hunter/_predicates.pyx":590 + * elif type(callable) is From: + * return fast_From_call( callable, event) + * elif type(callable) is Backlog: # <<<<<<<<<<<<<< + * return fast_Backlog_call( callable, event) + * else: +*/ } - __pyx_t_5 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(2, 13, __pyx_L1_error) - __pyx_t_6 = (__pyx_t_5 != 0); - __pyx_t_3 = __pyx_t_6; - __pyx_L4_bool_binop_done:; - if (__pyx_t_3) { - /* "(tree fragment)":14 - * __pyx_result.condition = __pyx_state[0]; __pyx_result.origin_calls = __pyx_state[1]; __pyx_result.origin_depth = __pyx_state[2]; __pyx_result.predicate = __pyx_state[3]; __pyx_result.watermark = __pyx_state[4] - * if len(__pyx_state) > 5 and hasattr(__pyx_result, '__dict__'): - * __pyx_result.__dict__.update(__pyx_state[5]) # <<<<<<<<<<<<<< - */ - __Pyx_TraceLine(14,0,__PYX_ERR(2, 14, __pyx_L1_error)) - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_update); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 14, __pyx_L1_error) + /* "hunter/_predicates.pyx":593 + * return fast_Backlog_call( callable, event) + * else: + * return callable(event) # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_TraceLine(593,79,0,__PYX_ERR(0, 593, __pyx_L1_error)) + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = NULL; + __Pyx_INCREF(__pyx_v_callable); + __pyx_t_4 = __pyx_v_callable; + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_5 = 0; } - __pyx_t_7 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 5, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_9 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) { - __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); - if (likely(__pyx_t_9)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); - __Pyx_INCREF(__pyx_t_9); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_8, function); - } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, ((PyObject *)__pyx_v_event)}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 593, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); } - __pyx_t_1 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_9, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); - __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "(tree fragment)":13 - * cdef __pyx_unpickle_From__set_state(From __pyx_result, tuple __pyx_state): - * __pyx_result.condition = __pyx_state[0]; __pyx_result.origin_calls = __pyx_state[1]; __pyx_result.origin_depth = __pyx_state[2]; __pyx_result.predicate = __pyx_state[3]; __pyx_result.watermark = __pyx_state[4] - * if len(__pyx_state) > 5 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< - * __pyx_result.__dict__.update(__pyx_state[5]) - */ + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_TraceReturnValue(__pyx_r, 79, 0, __PYX_ERR(0, 593, __pyx_L1_error)); + goto __pyx_L0; } - /* "(tree fragment)":11 - * __pyx_unpickle_From__set_state( __pyx_result, __pyx_state) - * return __pyx_result - * cdef __pyx_unpickle_From__set_state(From __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< - * __pyx_result.condition = __pyx_state[0]; __pyx_result.origin_calls = __pyx_state[1]; __pyx_result.origin_depth = __pyx_state[2]; __pyx_result.predicate = __pyx_state[3]; __pyx_result.watermark = __pyx_state[4] - * if len(__pyx_state) > 5 and hasattr(__pyx_result, '__dict__'): - */ + /* "hunter/_predicates.pyx":577 + * + * + * cdef inline fast_call(callable, Event event): # <<<<<<<<<<<<<< + * if type(callable) is Query: + * return fast_Query_call( callable, event) +*/ /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_XDECREF(__pyx_t_9); - __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_From__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 577, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.fast_call", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "(tree fragment)":1 - * def __pyx_unpickle_And(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ +/* "hunter/_predicates.pyx":598 + * @cython.final + * cdef class Backlog: + * def __init__(self, condition, size=100, stack=10, vars=False, strip=True, action=None, filter=None): # <<<<<<<<<<<<<< + * self.action = action() if isclass(action) and issubclass(action, Action) else action + * if not isinstance(self.action, ColorStreamAction): +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_7__pyx_unpickle_And(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static PyMethodDef __pyx_mdef_6hunter_11_predicates_7__pyx_unpickle_And = {"__pyx_unpickle_And", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6hunter_11_predicates_7__pyx_unpickle_And, METH_VARARGS|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6hunter_11_predicates_7__pyx_unpickle_And(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v___pyx_type = 0; - long __pyx_v___pyx_checksum; - PyObject *__pyx_v___pyx_state = 0; - PyObject *__pyx_r = 0; +static int __pyx_pw_6hunter_11_predicates_7Backlog_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_6hunter_11_predicates_7Backlog_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_condition = 0; + PyObject *__pyx_v_size = 0; + PyObject *__pyx_v_stack = 0; + PyObject *__pyx_v_vars = 0; + PyObject *__pyx_v_strip = 0; + PyObject *__pyx_v_action = 0; + PyObject *__pyx_v_filter = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[7] = {0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__pyx_unpickle_And (wrapper)", 0); + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; - PyObject* values[3] = {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 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_condition,&__pyx_mstate_global->__pyx_n_u_size,&__pyx_mstate_global->__pyx_n_u_stack,&__pyx_mstate_global->__pyx_n_u_vars,&__pyx_mstate_global->__pyx_n_u_strip,&__pyx_mstate_global->__pyx_n_u_action,&__pyx_mstate_global->__pyx_n_u_filter,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 598, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 7: + values[6] = __Pyx_ArgRef_VARARGS(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 598, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_VARARGS(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 598, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 5: + values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 598, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 4: + values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 598, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 3: + values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 598, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 598, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 598, __pyx_L3_error) 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_pyx_type)) != 0)) kw_args--; - else goto __pyx_L5_argtuple_error; + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__init__", 0) < 0) __PYX_ERR(0, 598, __pyx_L3_error) + if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_100)); + if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_10)); + if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)Py_False)); + if (!values[4]) values[4] = __Pyx_NewRef(((PyObject *)Py_True)); + if (!values[5]) values[5] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[6]) values[6] = __Pyx_NewRef(((PyObject *)Py_None)); + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 7, i); __PYX_ERR(0, 598, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 7: + values[6] = __Pyx_ArgRef_VARARGS(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 598, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_checksum)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_And", 1, 3, 3, 1); __PYX_ERR(2, 1, __pyx_L3_error) - } + case 6: + values[5] = __Pyx_ArgRef_VARARGS(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 598, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 5: + values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 598, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 598, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 598, __pyx_L3_error) CYTHON_FALLTHROUGH; case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_And", 1, 3, 3, 2); __PYX_ERR(2, 1, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_And") < 0)) __PYX_ERR(2, 1, __pyx_L3_error) + values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 598, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 598, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; } - } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { - 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); + if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_100)); + if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_10)); + if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)Py_False)); + if (!values[4]) values[4] = __Pyx_NewRef(((PyObject *)Py_True)); + if (!values[5]) values[5] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[6]) values[6] = __Pyx_NewRef(((PyObject *)Py_None)); } - __pyx_v___pyx_type = values[0]; - __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(2, 1, __pyx_L3_error) - __pyx_v___pyx_state = values[2]; - } - goto __pyx_L4_argument_unpacking_done; + __pyx_v_condition = values[0]; + __pyx_v_size = values[1]; + __pyx_v_stack = values[2]; + __pyx_v_vars = values[3]; + __pyx_v_strip = values[4]; + __pyx_v_action = values[5]; + __pyx_v_filter = values[6]; + } + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_And", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 7, __pyx_nargs); __PYX_ERR(0, 598, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_And", __pyx_clineno, __pyx_lineno, __pyx_filename); + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("hunter._predicates.Backlog.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); - return NULL; + return -1; __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6hunter_11_predicates_6__pyx_unpickle_And(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + __pyx_r = __pyx_pf_6hunter_11_predicates_7Backlog___init__(((struct __pyx_obj_6hunter_11_predicates_Backlog *)__pyx_v_self), __pyx_v_condition, __pyx_v_size, __pyx_v_stack, __pyx_v_vars, __pyx_v_strip, __pyx_v_action, __pyx_v_filter); /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_6__pyx_unpickle_And(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_v___pyx_PickleError = 0; - PyObject *__pyx_v___pyx_result = 0; - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations +static int __pyx_pf_6hunter_11_predicates_7Backlog___init__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self, PyObject *__pyx_v_condition, PyObject *__pyx_v_size, PyObject *__pyx_v_stack, PyObject *__pyx_v_vars, PyObject *__pyx_v_strip, PyObject *__pyx_v_action, PyObject *__pyx_v_filter) { + int __pyx_r; + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; - int __pyx_t_6; - __Pyx_TraceFrameInit(__pyx_codeobj__9) - __Pyx_RefNannySetupContext("__pyx_unpickle_And", 0); - __Pyx_TraceCall("__pyx_unpickle_And", __pyx_f[2], 1, 0, __PYX_ERR(2, 1, __pyx_L1_error)); - - /* "(tree fragment)":4 - * cdef object __pyx_PickleError - * cdef object __pyx_result - * if __pyx_checksum != 0xaa8cbda: # <<<<<<<<<<<<<< - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xaa8cbda = (predicates))" % __pyx_checksum) - */ - __Pyx_TraceLine(4,0,__PYX_ERR(2, 4, __pyx_L1_error)) - __pyx_t_1 = ((__pyx_v___pyx_checksum != 0xaa8cbda) != 0); - if (__pyx_t_1) { - - /* "(tree fragment)":5 - * cdef object __pyx_result - * if __pyx_checksum != 0xaa8cbda: - * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xaa8cbda = (predicates))" % __pyx_checksum) - * __pyx_result = And.__new__(__pyx_type) - */ - __Pyx_TraceLine(5,0,__PYX_ERR(2, 5, __pyx_L1_error)) - __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_n_s_PickleError); - __Pyx_GIVEREF(__pyx_n_s_PickleError); - PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_PickleError); - __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 5, __pyx_L1_error) + size_t __pyx_t_6; + int __pyx_t_7; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[116])) + __Pyx_RefNannySetupContext("__init__", 0); + __Pyx_TraceStartFunc("__init__", __pyx_f[0], 598, 0, 0, 0, __PYX_ERR(0, 598, __pyx_L1_error)); + + /* "hunter/_predicates.pyx":599 + * cdef class Backlog: + * def __init__(self, condition, size=100, stack=10, vars=False, strip=True, action=None, filter=None): + * self.action = action() if isclass(action) and issubclass(action, Action) else action # <<<<<<<<<<<<<< + * if not isinstance(self.action, ColorStreamAction): + * raise TypeError("Action %r must be a ColorStreamAction." % self.action) +*/ + __Pyx_TraceLine(599,12,0,__PYX_ERR(0, 599, __pyx_L1_error)) + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_isclass); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 599, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_action}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 599, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_t_2); - __pyx_v___pyx_PickleError = __pyx_t_2; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "(tree fragment)":6 - * if __pyx_checksum != 0xaa8cbda: - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xaa8cbda = (predicates))" % __pyx_checksum) # <<<<<<<<<<<<<< - * __pyx_result = And.__new__(__pyx_type) - * if __pyx_state is not None: - */ - __Pyx_TraceLine(6,0,__PYX_ERR(2, 6, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_s_vs_0xaa, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_INCREF(__pyx_v___pyx_PickleError); - __pyx_t_2 = __pyx_v___pyx_PickleError; __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - } + } + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 599, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_7) { + } else { + __pyx_t_2 = __pyx_t_7; + goto __pyx_L3_bool_binop_done; + } + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_Action); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 599, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = PyObject_IsSubclass(__pyx_v_action, __pyx_t_3); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 599, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __pyx_t_7; + __pyx_L3_bool_binop_done:; + if (__pyx_t_2) { + __pyx_t_5 = NULL; + __Pyx_INCREF(__pyx_v_action); + __pyx_t_4 = __pyx_v_action; + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_6 = 0; } - __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(2, 6, __pyx_L1_error) - - /* "(tree fragment)":4 - * cdef object __pyx_PickleError - * cdef object __pyx_result - * if __pyx_checksum != 0xaa8cbda: # <<<<<<<<<<<<<< - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xaa8cbda = (predicates))" % __pyx_checksum) - */ + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 599, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = 0; + } else { + __Pyx_INCREF(__pyx_v_action); + __pyx_t_1 = __pyx_v_action; } + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->action); + __Pyx_DECREF(__pyx_v_self->action); + __pyx_v_self->action = __pyx_t_1; + __pyx_t_1 = 0; - /* "(tree fragment)":7 - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xaa8cbda = (predicates))" % __pyx_checksum) - * __pyx_result = And.__new__(__pyx_type) # <<<<<<<<<<<<<< - * if __pyx_state is not None: - * __pyx_unpickle_And__set_state( __pyx_result, __pyx_state) - */ - __Pyx_TraceLine(7,0,__PYX_ERR(2, 7, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_6hunter_11_predicates_And), __pyx_n_s_new); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - } - } - __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v___pyx_type); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 7, __pyx_L1_error) + /* "hunter/_predicates.pyx":600 + * def __init__(self, condition, size=100, stack=10, vars=False, strip=True, action=None, filter=None): + * self.action = action() if isclass(action) and issubclass(action, Action) else action + * if not isinstance(self.action, ColorStreamAction): # <<<<<<<<<<<<<< + * raise TypeError("Action %r must be a ColorStreamAction." % self.action) + * self.condition = condition +*/ + __Pyx_TraceLine(600,25,0,__PYX_ERR(0, 600, __pyx_L1_error)) + __pyx_t_1 = __pyx_v_self->action; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_ColorStreamAction); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 600, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v___pyx_result = __pyx_t_3; - __pyx_t_3 = 0; - - /* "(tree fragment)":8 - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xaa8cbda = (predicates))" % __pyx_checksum) - * __pyx_result = And.__new__(__pyx_type) - * if __pyx_state is not None: # <<<<<<<<<<<<<< - * __pyx_unpickle_And__set_state( __pyx_result, __pyx_state) - * return __pyx_result - */ - __Pyx_TraceLine(8,0,__PYX_ERR(2, 8, __pyx_L1_error)) - __pyx_t_1 = (__pyx_v___pyx_state != Py_None); - __pyx_t_6 = (__pyx_t_1 != 0); - if (__pyx_t_6) { + __pyx_t_2 = PyObject_IsInstance(__pyx_t_1, __pyx_t_3); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 600, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = (!__pyx_t_2); + if (unlikely(__pyx_t_7)) { - /* "(tree fragment)":9 - * __pyx_result = And.__new__(__pyx_type) - * if __pyx_state is not None: - * __pyx_unpickle_And__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< - * return __pyx_result - * cdef __pyx_unpickle_And__set_state(And __pyx_result, tuple __pyx_state): - */ - __Pyx_TraceLine(9,0,__PYX_ERR(2, 9, __pyx_L1_error)) - if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(2, 9, __pyx_L1_error) - __pyx_t_3 = __pyx_f_6hunter_11_predicates___pyx_unpickle_And__set_state(((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + /* "hunter/_predicates.pyx":601 + * self.action = action() if isclass(action) and issubclass(action, Action) else action + * if not isinstance(self.action, ColorStreamAction): + * raise TypeError("Action %r must be a ColorStreamAction." % self.action) # <<<<<<<<<<<<<< + * self.condition = condition + * self.queue = deque(maxlen=size) +*/ + __Pyx_TraceLine(601,29,0,__PYX_ERR(0, 601, __pyx_L1_error)) + __pyx_t_1 = NULL; + __Pyx_INCREF(__pyx_builtin_TypeError); + __pyx_t_4 = __pyx_builtin_TypeError; + __pyx_t_5 = __Pyx_PyUnicode_FormatSafe(__pyx_mstate_global->__pyx_kp_u_Action_r_must_be_a_ColorStreamAc, __pyx_v_self->action); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 601, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 601, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 601, __pyx_L1_error) - /* "(tree fragment)":8 - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xaa8cbda = (predicates))" % __pyx_checksum) - * __pyx_result = And.__new__(__pyx_type) - * if __pyx_state is not None: # <<<<<<<<<<<<<< - * __pyx_unpickle_And__set_state( __pyx_result, __pyx_state) - * return __pyx_result - */ + /* "hunter/_predicates.pyx":600 + * def __init__(self, condition, size=100, stack=10, vars=False, strip=True, action=None, filter=None): + * self.action = action() if isclass(action) and issubclass(action, Action) else action + * if not isinstance(self.action, ColorStreamAction): # <<<<<<<<<<<<<< + * raise TypeError("Action %r must be a ColorStreamAction." % self.action) + * self.condition = condition +*/ } - /* "(tree fragment)":10 - * if __pyx_state is not None: - * __pyx_unpickle_And__set_state( __pyx_result, __pyx_state) - * return __pyx_result # <<<<<<<<<<<<<< - * cdef __pyx_unpickle_And__set_state(And __pyx_result, tuple __pyx_state): - * __pyx_result.predicates = __pyx_state[0] - */ - __Pyx_TraceLine(10,0,__PYX_ERR(2, 10, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v___pyx_result); - __pyx_r = __pyx_v___pyx_result; - goto __pyx_L0; - - /* "(tree fragment)":1 - * def __pyx_unpickle_And(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_And", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v___pyx_PickleError); - __Pyx_XDECREF(__pyx_v___pyx_result); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "(tree fragment)":11 - * __pyx_unpickle_And__set_state( __pyx_result, __pyx_state) - * return __pyx_result - * cdef __pyx_unpickle_And__set_state(And __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< - * __pyx_result.predicates = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): - */ - -static PyObject *__pyx_f_6hunter_11_predicates___pyx_unpickle_And__set_state(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_t_2; - Py_ssize_t __pyx_t_3; - int __pyx_t_4; - int __pyx_t_5; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - __Pyx_RefNannySetupContext("__pyx_unpickle_And__set_state", 0); - __Pyx_TraceCall("__pyx_unpickle_And__set_state", __pyx_f[2], 11, 0, __PYX_ERR(2, 11, __pyx_L1_error)); - - /* "(tree fragment)":12 - * return __pyx_result - * cdef __pyx_unpickle_And__set_state(And __pyx_result, tuple __pyx_state): - * __pyx_result.predicates = __pyx_state[0] # <<<<<<<<<<<<<< - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): - * __pyx_result.__dict__.update(__pyx_state[1]) - */ - __Pyx_TraceLine(12,0,__PYX_ERR(2, 12, __pyx_L1_error)) - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->predicates); - __Pyx_DECREF(__pyx_v___pyx_result->predicates); - __pyx_v___pyx_result->predicates = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; + /* "hunter/_predicates.pyx":602 + * if not isinstance(self.action, ColorStreamAction): + * raise TypeError("Action %r must be a ColorStreamAction." % self.action) + * self.condition = condition # <<<<<<<<<<<<<< + * self.queue = deque(maxlen=size) + * self.size = size +*/ + __Pyx_TraceLine(602,34,0,__PYX_ERR(0, 602, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_condition); + __Pyx_GIVEREF(__pyx_v_condition); + __Pyx_GOTREF(__pyx_v_self->condition); + __Pyx_DECREF(__pyx_v_self->condition); + __pyx_v_self->condition = __pyx_v_condition; - /* "(tree fragment)":13 - * cdef __pyx_unpickle_And__set_state(And __pyx_result, tuple __pyx_state): - * __pyx_result.predicates = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< - * __pyx_result.__dict__.update(__pyx_state[1]) - */ - __Pyx_TraceLine(13,0,__PYX_ERR(2, 13, __pyx_L1_error)) - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(2, 13, __pyx_L1_error) - } - __pyx_t_3 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(2, 13, __pyx_L1_error) - __pyx_t_4 = ((__pyx_t_3 > 1) != 0); - if (__pyx_t_4) { - } else { - __pyx_t_2 = __pyx_t_4; - goto __pyx_L4_bool_binop_done; + /* "hunter/_predicates.pyx":603 + * raise TypeError("Action %r must be a ColorStreamAction." % self.action) + * self.condition = condition + * self.queue = deque(maxlen=size) # <<<<<<<<<<<<<< + * self.size = size + * self.stack = stack +*/ + __Pyx_TraceLine(603,40,0,__PYX_ERR(0, 603, __pyx_L1_error)) + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_deque); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 603, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_6 = 0; } - __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(2, 13, __pyx_L1_error) - __pyx_t_5 = (__pyx_t_4 != 0); - __pyx_t_2 = __pyx_t_5; - __pyx_L4_bool_binop_done:; - if (__pyx_t_2) { - - /* "(tree fragment)":14 - * __pyx_result.predicates = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): - * __pyx_result.__dict__.update(__pyx_state[1]) # <<<<<<<<<<<<<< - */ - __Pyx_TraceLine(14,0,__PYX_ERR(2, 14, __pyx_L1_error)) - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_update); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 14, __pyx_L1_error) - } - __pyx_t_6 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); - if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); - __Pyx_INCREF(__pyx_t_8); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_7, function); - } - } - __pyx_t_1 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 14, __pyx_L1_error) + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_4, NULL}; + __pyx_t_1 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 603, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_maxlen, __pyx_v_size, __pyx_t_1, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 603, __pyx_L1_error) + __pyx_t_3 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_5, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 603, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_self->queue); + __Pyx_DECREF(__pyx_v_self->queue); + __pyx_v_self->queue = __pyx_t_3; + __pyx_t_3 = 0; - /* "(tree fragment)":13 - * cdef __pyx_unpickle_And__set_state(And __pyx_result, tuple __pyx_state): - * __pyx_result.predicates = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< - * __pyx_result.__dict__.update(__pyx_state[1]) - */ + /* "hunter/_predicates.pyx":604 + * self.condition = condition + * self.queue = deque(maxlen=size) + * self.size = size # <<<<<<<<<<<<<< + * self.stack = stack + * self.strip = strip +*/ + __Pyx_TraceLine(604,45,0,__PYX_ERR(0, 604, __pyx_L1_error)) + __pyx_t_8 = __Pyx_PyLong_As_int(__pyx_v_size); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 604, __pyx_L1_error) + __pyx_v_self->size = __pyx_t_8; + + /* "hunter/_predicates.pyx":605 + * self.queue = deque(maxlen=size) + * self.size = size + * self.stack = stack # <<<<<<<<<<<<<< + * self.strip = strip + * self.vars = vars +*/ + __Pyx_TraceLine(605,48,0,__PYX_ERR(0, 605, __pyx_L1_error)) + __pyx_t_8 = __Pyx_PyLong_As_int(__pyx_v_stack); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 605, __pyx_L1_error) + __pyx_v_self->stack = __pyx_t_8; + + /* "hunter/_predicates.pyx":606 + * self.size = size + * self.stack = stack + * self.strip = strip # <<<<<<<<<<<<<< + * self.vars = vars + * self._try_repr = self.action.try_repr if self.vars else None +*/ + __Pyx_TraceLine(606,51,0,__PYX_ERR(0, 606, __pyx_L1_error)) + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_strip); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 606, __pyx_L1_error) + __pyx_v_self->strip = __pyx_t_7; + + /* "hunter/_predicates.pyx":607 + * self.stack = stack + * self.strip = strip + * self.vars = vars # <<<<<<<<<<<<<< + * self._try_repr = self.action.try_repr if self.vars else None + * self._filter = filter +*/ + __Pyx_TraceLine(607,54,0,__PYX_ERR(0, 607, __pyx_L1_error)) + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_vars); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 607, __pyx_L1_error) + __pyx_v_self->vars = __pyx_t_7; + + /* "hunter/_predicates.pyx":608 + * self.strip = strip + * self.vars = vars + * self._try_repr = self.action.try_repr if self.vars else None # <<<<<<<<<<<<<< + * self._filter = filter + * +*/ + __Pyx_TraceLine(608,61,0,__PYX_ERR(0, 608, __pyx_L1_error)) + if (__pyx_v_self->vars) { + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->action, __pyx_mstate_global->__pyx_n_u_try_repr); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 608, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = __pyx_t_5; + __pyx_t_5 = 0; + } else { + __Pyx_INCREF(Py_None); + __pyx_t_3 = Py_None; } + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_self->_try_repr); + __Pyx_DECREF(__pyx_v_self->_try_repr); + __pyx_v_self->_try_repr = __pyx_t_3; + __pyx_t_3 = 0; - /* "(tree fragment)":11 - * __pyx_unpickle_And__set_state( __pyx_result, __pyx_state) - * return __pyx_result - * cdef __pyx_unpickle_And__set_state(And __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< - * __pyx_result.predicates = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): - */ + /* "hunter/_predicates.pyx":609 + * self.vars = vars + * self._try_repr = self.action.try_repr if self.vars else None + * self._filter = filter # <<<<<<<<<<<<<< + * + * def __call__(self, event): +*/ + __Pyx_TraceLine(609,63,0,__PYX_ERR(0, 609, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_filter); + __Pyx_GIVEREF(__pyx_v_filter); + __Pyx_GOTREF(__pyx_v_self->_filter); + __Pyx_DECREF(__pyx_v_self->_filter); + __pyx_v_self->_filter = __pyx_v_filter; + + /* "hunter/_predicates.pyx":598 + * @cython.final + * cdef class Backlog: + * def __init__(self, condition, size=100, stack=10, vars=False, strip=True, action=None, filter=None): # <<<<<<<<<<<<<< + * self.action = action() if isclass(action) and issubclass(action, Action) else action + * if not isinstance(self.action, ColorStreamAction): +*/ /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __pyx_r = 0; + __Pyx_TraceReturnCValue(__pyx_r, __Pyx_Owned_Py_None, 0, 0, __PYX_ERR(0, 598, __pyx_L1_error)); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_And__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 598, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Backlog.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "(tree fragment)":1 - * def __pyx_unpickle_Or(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ +/* "hunter/_predicates.pyx":611 + * self._filter = filter + * + * def __call__(self, event): # <<<<<<<<<<<<<< + * return fast_Backlog_call(self, event) + * +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_9__pyx_unpickle_Or(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static PyMethodDef __pyx_mdef_6hunter_11_predicates_9__pyx_unpickle_Or = {"__pyx_unpickle_Or", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6hunter_11_predicates_9__pyx_unpickle_Or, METH_VARARGS|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6hunter_11_predicates_9__pyx_unpickle_Or(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v___pyx_type = 0; - long __pyx_v___pyx_checksum; - PyObject *__pyx_v___pyx_state = 0; +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_3__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_3__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_event = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__pyx_unpickle_Or (wrapper)", 0); + __Pyx_RefNannySetupContext("__call__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; - PyObject* values[3] = {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 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); + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_event,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 611, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 611, __pyx_L3_error) 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_pyx_type)) != 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_pyx_checksum)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Or", 1, 3, 3, 1); __PYX_ERR(2, 1, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Or", 1, 3, 3, 2); __PYX_ERR(2, 1, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_Or") < 0)) __PYX_ERR(2, 1, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__call__", 0) < 0) __PYX_ERR(0, 611, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__call__", 1, 1, 1, i); __PYX_ERR(0, 611, __pyx_L3_error) } } - } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { + } else if (unlikely(__pyx_nargs != 1)) { 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[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 611, __pyx_L3_error) } - __pyx_v___pyx_type = values[0]; - __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(2, 1, __pyx_L3_error) - __pyx_v___pyx_state = values[2]; + __pyx_v_event = values[0]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Or", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__call__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 611, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_Or", __pyx_clineno, __pyx_lineno, __pyx_filename); + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("hunter._predicates.Backlog.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6hunter_11_predicates_8__pyx_unpickle_Or(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + __pyx_r = __pyx_pf_6hunter_11_predicates_7Backlog_2__call__(((struct __pyx_obj_6hunter_11_predicates_Backlog *)__pyx_v_self), __pyx_v_event); /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_8__pyx_unpickle_Or(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_v___pyx_PickleError = 0; - PyObject *__pyx_v___pyx_result = 0; +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_2__call__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self, PyObject *__pyx_v_event) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - int __pyx_t_6; - __Pyx_TraceFrameInit(__pyx_codeobj__10) - __Pyx_RefNannySetupContext("__pyx_unpickle_Or", 0); - __Pyx_TraceCall("__pyx_unpickle_Or", __pyx_f[2], 1, 0, __PYX_ERR(2, 1, __pyx_L1_error)); - - /* "(tree fragment)":4 - * cdef object __pyx_PickleError - * cdef object __pyx_result - * if __pyx_checksum != 0xaa8cbda: # <<<<<<<<<<<<<< - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xaa8cbda = (predicates))" % __pyx_checksum) - */ - __Pyx_TraceLine(4,0,__PYX_ERR(2, 4, __pyx_L1_error)) - __pyx_t_1 = ((__pyx_v___pyx_checksum != 0xaa8cbda) != 0); - if (__pyx_t_1) { + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[117])) + __Pyx_RefNannySetupContext("__call__", 0); + __Pyx_TraceStartFunc("__call__", __pyx_f[0], 611, 0, 0, 0, __PYX_ERR(0, 611, __pyx_L1_error)); - /* "(tree fragment)":5 - * cdef object __pyx_result - * if __pyx_checksum != 0xaa8cbda: - * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xaa8cbda = (predicates))" % __pyx_checksum) - * __pyx_result = Or.__new__(__pyx_type) - */ - __Pyx_TraceLine(5,0,__PYX_ERR(2, 5, __pyx_L1_error)) - __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_n_s_PickleError); - __Pyx_GIVEREF(__pyx_n_s_PickleError); - PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_PickleError); - __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_t_2); - __pyx_v___pyx_PickleError = __pyx_t_2; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + /* "hunter/_predicates.pyx":612 + * + * def __call__(self, event): + * return fast_Backlog_call(self, event) # <<<<<<<<<<<<<< + * + * def __str__(self): +*/ + __Pyx_TraceLine(612,1,0,__PYX_ERR(0, 612, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + if (!(likely(((__pyx_v_event) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_event, __pyx_mstate_global->__pyx_ptype_6hunter_6_event_Event))))) __PYX_ERR(0, 612, __pyx_L1_error) + __pyx_t_1 = __pyx_f_6hunter_11_predicates_fast_Backlog_call(__pyx_v_self, ((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_event)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 612, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 612, __pyx_L1_error)); + goto __pyx_L0; - /* "(tree fragment)":6 - * if __pyx_checksum != 0xaa8cbda: - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xaa8cbda = (predicates))" % __pyx_checksum) # <<<<<<<<<<<<<< - * __pyx_result = Or.__new__(__pyx_type) - * if __pyx_state is not None: - */ - __Pyx_TraceLine(6,0,__PYX_ERR(2, 6, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_s_vs_0xaa, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_INCREF(__pyx_v___pyx_PickleError); - __pyx_t_2 = __pyx_v___pyx_PickleError; __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - } - } - __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(2, 6, __pyx_L1_error) + /* "hunter/_predicates.pyx":611 + * self._filter = filter + * + * def __call__(self, event): # <<<<<<<<<<<<<< + * return fast_Backlog_call(self, event) + * +*/ - /* "(tree fragment)":4 - * cdef object __pyx_PickleError - * cdef object __pyx_result - * if __pyx_checksum != 0xaa8cbda: # <<<<<<<<<<<<<< - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xaa8cbda = (predicates))" % __pyx_checksum) - */ - } + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 611, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Backlog.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "(tree fragment)":7 - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xaa8cbda = (predicates))" % __pyx_checksum) - * __pyx_result = Or.__new__(__pyx_type) # <<<<<<<<<<<<<< - * if __pyx_state is not None: - * __pyx_unpickle_Or__set_state( __pyx_result, __pyx_state) - */ - __Pyx_TraceLine(7,0,__PYX_ERR(2, 7, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_6hunter_11_predicates_Or), __pyx_n_s_new); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - } - } - __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v___pyx_type); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v___pyx_result = __pyx_t_3; - __pyx_t_3 = 0; +/* "hunter/_predicates.pyx":614 + * return fast_Backlog_call(self, event) + * + * def __str__(self): # <<<<<<<<<<<<<< + * return 'Backlog(%s, size=%s, stack=%s, vars=%s, action=%s, filter=%s)' % ( + * self.condition, self.size, self.stack, self.vars, self.action, self._filter +*/ - /* "(tree fragment)":8 - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xaa8cbda = (predicates))" % __pyx_checksum) - * __pyx_result = Or.__new__(__pyx_type) - * if __pyx_state is not None: # <<<<<<<<<<<<<< - * __pyx_unpickle_Or__set_state( __pyx_result, __pyx_state) - * return __pyx_result - */ - __Pyx_TraceLine(8,0,__PYX_ERR(2, 8, __pyx_L1_error)) - __pyx_t_1 = (__pyx_v___pyx_state != Py_None); - __pyx_t_6 = (__pyx_t_1 != 0); - if (__pyx_t_6) { +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_5__str__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_5__str__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_7Backlog_4__str__(((struct __pyx_obj_6hunter_11_predicates_Backlog *)__pyx_v_self)); - /* "(tree fragment)":9 - * __pyx_result = Or.__new__(__pyx_type) - * if __pyx_state is not None: - * __pyx_unpickle_Or__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< - * return __pyx_result - * cdef __pyx_unpickle_Or__set_state(Or __pyx_result, tuple __pyx_state): - */ - __Pyx_TraceLine(9,0,__PYX_ERR(2, 9, __pyx_L1_error)) - if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(2, 9, __pyx_L1_error) - __pyx_t_3 = __pyx_f_6hunter_11_predicates___pyx_unpickle_Or__set_state(((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "(tree fragment)":8 - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xaa8cbda = (predicates))" % __pyx_checksum) - * __pyx_result = Or.__new__(__pyx_type) - * if __pyx_state is not None: # <<<<<<<<<<<<<< - * __pyx_unpickle_Or__set_state( __pyx_result, __pyx_state) - * return __pyx_result - */ - } +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_4__str__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7[13]; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[118])) + __Pyx_RefNannySetupContext("__str__", 0); + __Pyx_TraceStartFunc("__str__", __pyx_f[0], 614, 0, 0, 0, __PYX_ERR(0, 614, __pyx_L1_error)); - /* "(tree fragment)":10 - * if __pyx_state is not None: - * __pyx_unpickle_Or__set_state( __pyx_result, __pyx_state) - * return __pyx_result # <<<<<<<<<<<<<< - * cdef __pyx_unpickle_Or__set_state(Or __pyx_result, tuple __pyx_state): - * __pyx_result.predicates = __pyx_state[0] - */ - __Pyx_TraceLine(10,0,__PYX_ERR(2, 10, __pyx_L1_error)) + /* "hunter/_predicates.pyx":615 + * + * def __str__(self): + * return 'Backlog(%s, size=%s, stack=%s, vars=%s, action=%s, filter=%s)' % ( # <<<<<<<<<<<<<< + * self.condition, self.size, self.stack, self.vars, self.action, self._filter + * ) +*/ + __Pyx_TraceLine(615,1,0,__PYX_ERR(0, 615, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v___pyx_result); - __pyx_r = __pyx_v___pyx_result; + + /* "hunter/_predicates.pyx":616 + * def __str__(self): + * return 'Backlog(%s, size=%s, stack=%s, vars=%s, action=%s, filter=%s)' % ( + * self.condition, self.size, self.stack, self.vars, self.action, self._filter # <<<<<<<<<<<<<< + * ) + * +*/ + __Pyx_TraceLine(616,4,0,__PYX_ERR(0, 616, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_self->condition), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyUnicode_From_int(__pyx_v_self->size, 0, ' ', 'd'); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyUnicode_From_int(__pyx_v_self->stack, 0, ' ', 'd'); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyUnicode_FromBInt_bint(__pyx_v_self->vars); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_self->action), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_self->_filter), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7[0] = __pyx_mstate_global->__pyx_kp_u_Backlog; + __pyx_t_7[1] = __pyx_t_1; + __pyx_t_7[2] = __pyx_mstate_global->__pyx_kp_u_size_2; + __pyx_t_7[3] = __pyx_t_2; + __pyx_t_7[4] = __pyx_mstate_global->__pyx_kp_u_stack_2; + __pyx_t_7[5] = __pyx_t_3; + __pyx_t_7[6] = __pyx_mstate_global->__pyx_kp_u_vars_2; + __pyx_t_7[7] = __pyx_t_4; + __pyx_t_7[8] = __pyx_mstate_global->__pyx_kp_u_action_2; + __pyx_t_7[9] = __pyx_t_5; + __pyx_t_7[10] = __pyx_mstate_global->__pyx_kp_u_filter_2; + __pyx_t_7[11] = __pyx_t_6; + __pyx_t_7[12] = __pyx_mstate_global->__pyx_kp_u__7; + + /* "hunter/_predicates.pyx":615 + * + * def __str__(self): + * return 'Backlog(%s, size=%s, stack=%s, vars=%s, action=%s, filter=%s)' % ( # <<<<<<<<<<<<<< + * self.condition, self.size, self.stack, self.vars, self.action, self._filter + * ) +*/ + __Pyx_TraceLine(615,2,0,__PYX_ERR(0, 615, __pyx_L1_error)) + __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_7, 13, 8 * 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1) + 7 * 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4) + 9 * 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6)); + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 615, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_r = __pyx_t_8; + __pyx_t_8 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 615, __pyx_L1_error)); goto __pyx_L0; - /* "(tree fragment)":1 - * def __pyx_unpickle_Or(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ + /* "hunter/_predicates.pyx":614 + * return fast_Backlog_call(self, event) + * + * def __str__(self): # <<<<<<<<<<<<<< + * return 'Backlog(%s, size=%s, stack=%s, vars=%s, action=%s, filter=%s)' % ( + * self.condition, self.size, self.stack, self.vars, self.action, self._filter +*/ /* function exit code */ __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_Or", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 614, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Backlog.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF(__pyx_v___pyx_PickleError); - __Pyx_XDECREF(__pyx_v___pyx_result); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "(tree fragment)":11 - * __pyx_unpickle_Or__set_state( __pyx_result, __pyx_state) - * return __pyx_result - * cdef __pyx_unpickle_Or__set_state(Or __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< - * __pyx_result.predicates = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): - */ +/* "hunter/_predicates.pyx":619 + * ) + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return '' % ( + * self.condition, self.size, self.stack, self.vars, self.action, self._filter +*/ -static PyObject *__pyx_f_6hunter_11_predicates___pyx_unpickle_Or__set_state(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_7__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_7__repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_7Backlog_6__repr__(((struct __pyx_obj_6hunter_11_predicates_Backlog *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_6__repr__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - int __pyx_t_2; - Py_ssize_t __pyx_t_3; - int __pyx_t_4; - int __pyx_t_5; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_7[13]; PyObject *__pyx_t_8 = NULL; - __Pyx_RefNannySetupContext("__pyx_unpickle_Or__set_state", 0); - __Pyx_TraceCall("__pyx_unpickle_Or__set_state", __pyx_f[2], 11, 0, __PYX_ERR(2, 11, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[119])) + __Pyx_RefNannySetupContext("__repr__", 0); + __Pyx_TraceStartFunc("__repr__", __pyx_f[0], 619, 0, 0, 0, __PYX_ERR(0, 619, __pyx_L1_error)); - /* "(tree fragment)":12 - * return __pyx_result - * cdef __pyx_unpickle_Or__set_state(Or __pyx_result, tuple __pyx_state): - * __pyx_result.predicates = __pyx_state[0] # <<<<<<<<<<<<<< - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): - * __pyx_result.__dict__.update(__pyx_state[1]) - */ - __Pyx_TraceLine(12,0,__PYX_ERR(2, 12, __pyx_L1_error)) - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->predicates); - __Pyx_DECREF(__pyx_v___pyx_result->predicates); - __pyx_v___pyx_result->predicates = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; + /* "hunter/_predicates.pyx":620 + * + * def __repr__(self): + * return '' % ( # <<<<<<<<<<<<<< + * self.condition, self.size, self.stack, self.vars, self.action, self._filter + * ) +*/ + __Pyx_TraceLine(620,1,0,__PYX_ERR(0, 620, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); - /* "(tree fragment)":13 - * cdef __pyx_unpickle_Or__set_state(Or __pyx_result, tuple __pyx_state): - * __pyx_result.predicates = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< - * __pyx_result.__dict__.update(__pyx_state[1]) - */ - __Pyx_TraceLine(13,0,__PYX_ERR(2, 13, __pyx_L1_error)) - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(2, 13, __pyx_L1_error) - } - __pyx_t_3 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(2, 13, __pyx_L1_error) - __pyx_t_4 = ((__pyx_t_3 > 1) != 0); - if (__pyx_t_4) { - } else { - __pyx_t_2 = __pyx_t_4; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(2, 13, __pyx_L1_error) - __pyx_t_5 = (__pyx_t_4 != 0); - __pyx_t_2 = __pyx_t_5; - __pyx_L4_bool_binop_done:; - if (__pyx_t_2) { - - /* "(tree fragment)":14 - * __pyx_result.predicates = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): - * __pyx_result.__dict__.update(__pyx_state[1]) # <<<<<<<<<<<<<< - */ - __Pyx_TraceLine(14,0,__PYX_ERR(2, 14, __pyx_L1_error)) - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_update); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 14, __pyx_L1_error) - } - __pyx_t_6 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); - if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); - __Pyx_INCREF(__pyx_t_8); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_7, function); - } - } - __pyx_t_1 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "(tree fragment)":13 - * cdef __pyx_unpickle_Or__set_state(Or __pyx_result, tuple __pyx_state): - * __pyx_result.predicates = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< - * __pyx_result.__dict__.update(__pyx_state[1]) - */ - } + /* "hunter/_predicates.pyx":621 + * def __repr__(self): + * return '' % ( + * self.condition, self.size, self.stack, self.vars, self.action, self._filter # <<<<<<<<<<<<<< + * ) + * +*/ + __Pyx_TraceLine(621,4,0,__PYX_ERR(0, 621, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_self->condition), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 621, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyUnicode_From_int(__pyx_v_self->size, 0, ' ', 'd'); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 621, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyUnicode_From_int(__pyx_v_self->stack, 0, ' ', 'd'); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 621, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyUnicode_FromBInt_bint(__pyx_v_self->vars); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 621, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_self->action), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 621, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_self->_filter), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 621, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7[0] = __pyx_mstate_global->__pyx_kp_u_hunter_predicates_Backlog_condi; + __pyx_t_7[1] = __pyx_t_1; + __pyx_t_7[2] = __pyx_mstate_global->__pyx_kp_u_size_2; + __pyx_t_7[3] = __pyx_t_2; + __pyx_t_7[4] = __pyx_mstate_global->__pyx_kp_u_stack_2; + __pyx_t_7[5] = __pyx_t_3; + __pyx_t_7[6] = __pyx_mstate_global->__pyx_kp_u_vars_2; + __pyx_t_7[7] = __pyx_t_4; + __pyx_t_7[8] = __pyx_mstate_global->__pyx_kp_u_action_2; + __pyx_t_7[9] = __pyx_t_5; + __pyx_t_7[10] = __pyx_mstate_global->__pyx_kp_u_filter_2; + __pyx_t_7[11] = __pyx_t_6; + __pyx_t_7[12] = __pyx_mstate_global->__pyx_kp_u__8; + + /* "hunter/_predicates.pyx":620 + * + * def __repr__(self): + * return '' % ( # <<<<<<<<<<<<<< + * self.condition, self.size, self.stack, self.vars, self.action, self._filter + * ) +*/ + __Pyx_TraceLine(620,2,0,__PYX_ERR(0, 620, __pyx_L1_error)) + __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_7, 13, 38 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1) + 7 * 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2) + 8 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4) + 9 * 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6)); + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 620, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_r = __pyx_t_8; + __pyx_t_8 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 620, __pyx_L1_error)); + goto __pyx_L0; - /* "(tree fragment)":11 - * __pyx_unpickle_Or__set_state( __pyx_result, __pyx_state) - * return __pyx_result - * cdef __pyx_unpickle_Or__set_state(Or __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< - * __pyx_result.predicates = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): - */ + /* "hunter/_predicates.pyx":619 + * ) + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return '' % ( + * self.condition, self.size, self.stack, self.vars, self.action, self._filter +*/ /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_Or__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 619, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Backlog.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "(tree fragment)":1 - * def __pyx_unpickle_Not(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ +/* "hunter/_predicates.pyx":624 + * ) + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return ( + * isinstance(other, Backlog) and +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_11_predicates_11__pyx_unpickle_Not(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static PyMethodDef __pyx_mdef_6hunter_11_predicates_11__pyx_unpickle_Not = {"__pyx_unpickle_Not", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6hunter_11_predicates_11__pyx_unpickle_Not, METH_VARARGS|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6hunter_11_predicates_11__pyx_unpickle_Not(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v___pyx_type = 0; - long __pyx_v___pyx_checksum; - PyObject *__pyx_v___pyx_state = 0; +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_9__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_9__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__pyx_unpickle_Not (wrapper)", 0); - { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; - PyObject* values[3] = {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 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_pyx_type)) != 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_pyx_checksum)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Not", 1, 3, 3, 1); __PYX_ERR(2, 1, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Not", 1, 3, 3, 2); __PYX_ERR(2, 1, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_Not") < 0)) __PYX_ERR(2, 1, __pyx_L3_error) - } - } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { - 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); - } - __pyx_v___pyx_type = values[0]; - __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(2, 1, __pyx_L3_error) - __pyx_v___pyx_state = values[2]; - } - goto __pyx_L4_argument_unpacking_done; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Not", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1, __pyx_L3_error) - __pyx_L3_error:; - __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_Not", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6hunter_11_predicates_10__pyx_unpickle_Not(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_7Backlog_8__eq__(((struct __pyx_obj_6hunter_11_predicates_Backlog *)__pyx_v_self), ((PyObject *)__pyx_v_other)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_10__pyx_unpickle_Not(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_v___pyx_PickleError = 0; - PyObject *__pyx_v___pyx_result = 0; +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_8__eq__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self, PyObject *__pyx_v_other) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - int __pyx_t_6; - __Pyx_TraceFrameInit(__pyx_codeobj__11) - __Pyx_RefNannySetupContext("__pyx_unpickle_Not", 0); - __Pyx_TraceCall("__pyx_unpickle_Not", __pyx_f[2], 1, 0, __PYX_ERR(2, 1, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[120])) + __Pyx_RefNannySetupContext("__eq__", 0); + __Pyx_TraceStartFunc("__eq__", __pyx_f[0], 624, 0, 0, 0, __PYX_ERR(0, 624, __pyx_L1_error)); - /* "(tree fragment)":4 - * cdef object __pyx_PickleError - * cdef object __pyx_result - * if __pyx_checksum != 0xf670ef6: # <<<<<<<<<<<<<< - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xf670ef6 = (predicate))" % __pyx_checksum) - */ - __Pyx_TraceLine(4,0,__PYX_ERR(2, 4, __pyx_L1_error)) - __pyx_t_1 = ((__pyx_v___pyx_checksum != 0xf670ef6) != 0); - if (__pyx_t_1) { + /* "hunter/_predicates.pyx":625 + * + * def __eq__(self, other): + * return ( # <<<<<<<<<<<<<< + * isinstance(other, Backlog) and + * self.condition == ( other).condition and +*/ + __Pyx_TraceLine(625,1,0,__PYX_ERR(0, 625, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); - /* "(tree fragment)":5 - * cdef object __pyx_result - * if __pyx_checksum != 0xf670ef6: - * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xf670ef6 = (predicate))" % __pyx_checksum) - * __pyx_result = Not.__new__(__pyx_type) - */ - __Pyx_TraceLine(5,0,__PYX_ERR(2, 5, __pyx_L1_error)) - __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_n_s_PickleError); - __Pyx_GIVEREF(__pyx_n_s_PickleError); - PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_PickleError); - __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 5, __pyx_L1_error) + /* "hunter/_predicates.pyx":626 + * def __eq__(self, other): + * return ( + * isinstance(other, Backlog) and # <<<<<<<<<<<<<< + * self.condition == ( other).condition and + * self.size == ( other).size and +*/ + __Pyx_TraceLine(626,5,0,__PYX_ERR(0, 626, __pyx_L1_error)) + __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_other, __pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Backlog); + if (__pyx_t_2) { + } else { + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 626, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_t_2); - __pyx_v___pyx_PickleError = __pyx_t_2; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L3_bool_binop_done; + } - /* "(tree fragment)":6 - * if __pyx_checksum != 0xf670ef6: - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xf670ef6 = (predicate))" % __pyx_checksum) # <<<<<<<<<<<<<< - * __pyx_result = Not.__new__(__pyx_type) - * if __pyx_state is not None: - */ - __Pyx_TraceLine(6,0,__PYX_ERR(2, 6, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_s_vs_0xf6, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_INCREF(__pyx_v___pyx_PickleError); - __pyx_t_2 = __pyx_v___pyx_PickleError; __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - } - } - __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); + /* "hunter/_predicates.pyx":627 + * return ( + * isinstance(other, Backlog) and + * self.condition == ( other).condition and # <<<<<<<<<<<<<< + * self.size == ( other).size and + * self.stack == ( other).stack and +*/ + __Pyx_TraceLine(627,12,0,__PYX_ERR(0, 627, __pyx_L1_error)) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->condition, ((struct __pyx_obj_6hunter_11_predicates_Backlog *)__pyx_v_other)->condition, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 627, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 627, __pyx_L1_error) + if (__pyx_t_2) { __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(2, 6, __pyx_L1_error) - - /* "(tree fragment)":4 - * cdef object __pyx_PickleError - * cdef object __pyx_result - * if __pyx_checksum != 0xf670ef6: # <<<<<<<<<<<<<< - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xf670ef6 = (predicate))" % __pyx_checksum) - */ + } else { + __Pyx_INCREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L3_bool_binop_done; } - /* "(tree fragment)":7 - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xf670ef6 = (predicate))" % __pyx_checksum) - * __pyx_result = Not.__new__(__pyx_type) # <<<<<<<<<<<<<< - * if __pyx_state is not None: - * __pyx_unpickle_Not__set_state( __pyx_result, __pyx_state) - */ - __Pyx_TraceLine(7,0,__PYX_ERR(2, 7, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_6hunter_11_predicates_Not), __pyx_n_s_new); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - } - } - __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v___pyx_type); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v___pyx_result = __pyx_t_3; - __pyx_t_3 = 0; - - /* "(tree fragment)":8 - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xf670ef6 = (predicate))" % __pyx_checksum) - * __pyx_result = Not.__new__(__pyx_type) - * if __pyx_state is not None: # <<<<<<<<<<<<<< - * __pyx_unpickle_Not__set_state( __pyx_result, __pyx_state) - * return __pyx_result - */ - __Pyx_TraceLine(8,0,__PYX_ERR(2, 8, __pyx_L1_error)) - __pyx_t_1 = (__pyx_v___pyx_state != Py_None); - __pyx_t_6 = (__pyx_t_1 != 0); - if (__pyx_t_6) { + /* "hunter/_predicates.pyx":628 + * isinstance(other, Backlog) and + * self.condition == ( other).condition and + * self.size == ( other).size and # <<<<<<<<<<<<<< + * self.stack == ( other).stack and + * self.vars == ( other).vars and +*/ + __Pyx_TraceLine(628,16,0,__PYX_ERR(0, 628, __pyx_L1_error)) + __pyx_t_2 = (__pyx_v_self->size == ((struct __pyx_obj_6hunter_11_predicates_Backlog *)__pyx_v_other)->size); + if (__pyx_t_2) { + } else { + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 628, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L3_bool_binop_done; + } - /* "(tree fragment)":9 - * __pyx_result = Not.__new__(__pyx_type) - * if __pyx_state is not None: - * __pyx_unpickle_Not__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< - * return __pyx_result - * cdef __pyx_unpickle_Not__set_state(Not __pyx_result, tuple __pyx_state): - */ - __Pyx_TraceLine(9,0,__PYX_ERR(2, 9, __pyx_L1_error)) - if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(2, 9, __pyx_L1_error) - __pyx_t_3 = __pyx_f_6hunter_11_predicates___pyx_unpickle_Not__set_state(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 9, __pyx_L1_error) + /* "hunter/_predicates.pyx":629 + * self.condition == ( other).condition and + * self.size == ( other).size and + * self.stack == ( other).stack and # <<<<<<<<<<<<<< + * self.vars == ( other).vars and + * self.action == ( other).action +*/ + __Pyx_TraceLine(629,23,0,__PYX_ERR(0, 629, __pyx_L1_error)) + __pyx_t_2 = (__pyx_v_self->stack == ((struct __pyx_obj_6hunter_11_predicates_Backlog *)__pyx_v_other)->stack); + if (__pyx_t_2) { + } else { + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 629, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L3_bool_binop_done; + } - /* "(tree fragment)":8 - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xf670ef6 = (predicate))" % __pyx_checksum) - * __pyx_result = Not.__new__(__pyx_type) - * if __pyx_state is not None: # <<<<<<<<<<<<<< - * __pyx_unpickle_Not__set_state( __pyx_result, __pyx_state) - * return __pyx_result - */ + /* "hunter/_predicates.pyx":630 + * self.size == ( other).size and + * self.stack == ( other).stack and + * self.vars == ( other).vars and # <<<<<<<<<<<<<< + * self.action == ( other).action + * ) +*/ + __Pyx_TraceLine(630,30,0,__PYX_ERR(0, 630, __pyx_L1_error)) + __pyx_t_2 = (__pyx_v_self->vars == ((struct __pyx_obj_6hunter_11_predicates_Backlog *)__pyx_v_other)->vars); + if (__pyx_t_2) { + } else { + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 630, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L3_bool_binop_done; } - /* "(tree fragment)":10 - * if __pyx_state is not None: - * __pyx_unpickle_Not__set_state( __pyx_result, __pyx_state) - * return __pyx_result # <<<<<<<<<<<<<< - * cdef __pyx_unpickle_Not__set_state(Not __pyx_result, tuple __pyx_state): - * __pyx_result.predicate = __pyx_state[0] - */ - __Pyx_TraceLine(10,0,__PYX_ERR(2, 10, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v___pyx_result); - __pyx_r = __pyx_v___pyx_result; + /* "hunter/_predicates.pyx":631 + * self.stack == ( other).stack and + * self.vars == ( other).vars and + * self.action == ( other).action # <<<<<<<<<<<<<< + * ) + * +*/ + __Pyx_TraceLine(631,40,0,__PYX_ERR(0, 631, __pyx_L1_error)) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->action, ((struct __pyx_obj_6hunter_11_predicates_Backlog *)__pyx_v_other)->action, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 631, __pyx_L1_error) + __Pyx_INCREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_L3_bool_binop_done:; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 625, __pyx_L1_error)); goto __pyx_L0; - /* "(tree fragment)":1 - * def __pyx_unpickle_Not(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ + /* "hunter/_predicates.pyx":624 + * ) + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return ( + * isinstance(other, Backlog) and +*/ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_Not", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 624, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Backlog.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF(__pyx_v___pyx_PickleError); - __Pyx_XDECREF(__pyx_v___pyx_result); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "(tree fragment)":11 - * __pyx_unpickle_Not__set_state( __pyx_result, __pyx_state) - * return __pyx_result - * cdef __pyx_unpickle_Not__set_state(Not __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< - * __pyx_result.predicate = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): - */ +/* "hunter/_predicates.pyx":634 + * ) + * + * def __or__(self, other): # <<<<<<<<<<<<<< + * return Or(self, other) + * +*/ -static PyObject *__pyx_f_6hunter_11_predicates___pyx_unpickle_Not__set_state(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_11__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_11__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__or__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_7Backlog_10__or__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_10__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - int __pyx_t_2; - Py_ssize_t __pyx_t_3; - int __pyx_t_4; - int __pyx_t_5; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - __Pyx_RefNannySetupContext("__pyx_unpickle_Not__set_state", 0); - __Pyx_TraceCall("__pyx_unpickle_Not__set_state", __pyx_f[2], 11, 0, __PYX_ERR(2, 11, __pyx_L1_error)); + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[121])) + __Pyx_RefNannySetupContext("__or__", 0); + __Pyx_TraceStartFunc("__or__", __pyx_f[0], 634, 0, 0, 0, __PYX_ERR(0, 634, __pyx_L1_error)); - /* "(tree fragment)":12 - * return __pyx_result - * cdef __pyx_unpickle_Not__set_state(Not __pyx_result, tuple __pyx_state): - * __pyx_result.predicate = __pyx_state[0] # <<<<<<<<<<<<<< - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): - * __pyx_result.__dict__.update(__pyx_state[1]) - */ - __Pyx_TraceLine(12,0,__PYX_ERR(2, 12, __pyx_L1_error)) - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 12, __pyx_L1_error) + /* "hunter/_predicates.pyx":635 + * + * def __or__(self, other): + * return Or(self, other) # <<<<<<<<<<<<<< + * + * def __and__(self, other): +*/ + __Pyx_TraceLine(635,1,0,__PYX_ERR(0, 635, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = NULL; + __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Or); + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Or); + __pyx_t_4 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_v_self, __pyx_v_other}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 635, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_1); } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->predicate); - __Pyx_DECREF(__pyx_v___pyx_result->predicate); - __pyx_v___pyx_result->predicate = __pyx_t_1; + __pyx_r = ((PyObject *)__pyx_t_1); __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 635, __pyx_L1_error)); + goto __pyx_L0; - /* "(tree fragment)":13 - * cdef __pyx_unpickle_Not__set_state(Not __pyx_result, tuple __pyx_state): - * __pyx_result.predicate = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< - * __pyx_result.__dict__.update(__pyx_state[1]) - */ - __Pyx_TraceLine(13,0,__PYX_ERR(2, 13, __pyx_L1_error)) - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(2, 13, __pyx_L1_error) - } - __pyx_t_3 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(2, 13, __pyx_L1_error) - __pyx_t_4 = ((__pyx_t_3 > 1) != 0); - if (__pyx_t_4) { - } else { - __pyx_t_2 = __pyx_t_4; - goto __pyx_L4_bool_binop_done; + /* "hunter/_predicates.pyx":634 + * ) + * + * def __or__(self, other): # <<<<<<<<<<<<<< + * return Or(self, other) + * +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 634, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Backlog.__or__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/_predicates.pyx":637 + * return Or(self, other) + * + * def __and__(self, other): # <<<<<<<<<<<<<< + * return And(self, other) + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_13__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_13__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__and__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_7Backlog_12__and__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_12__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[122])) + __Pyx_RefNannySetupContext("__and__", 0); + __Pyx_TraceStartFunc("__and__", __pyx_f[0], 637, 0, 0, 0, __PYX_ERR(0, 637, __pyx_L1_error)); + + /* "hunter/_predicates.pyx":638 + * + * def __and__(self, other): + * return And(self, other) # <<<<<<<<<<<<<< + * + * def __invert__(self): +*/ + __Pyx_TraceLine(638,1,0,__PYX_ERR(0, 638, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = NULL; + __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_And); + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_And); + __pyx_t_4 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_v_self, __pyx_v_other}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 638, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_1); } - __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(2, 13, __pyx_L1_error) - __pyx_t_5 = (__pyx_t_4 != 0); - __pyx_t_2 = __pyx_t_5; - __pyx_L4_bool_binop_done:; - if (__pyx_t_2) { + __pyx_r = ((PyObject *)__pyx_t_1); + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 638, __pyx_L1_error)); + goto __pyx_L0; - /* "(tree fragment)":14 - * __pyx_result.predicate = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): - * __pyx_result.__dict__.update(__pyx_state[1]) # <<<<<<<<<<<<<< - */ - __Pyx_TraceLine(14,0,__PYX_ERR(2, 14, __pyx_L1_error)) - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_update); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + /* "hunter/_predicates.pyx":637 + * return Or(self, other) + * + * def __and__(self, other): # <<<<<<<<<<<<<< + * return And(self, other) + * +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 637, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Backlog.__and__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/_predicates.pyx":640 + * return And(self, other) + * + * def __invert__(self): # <<<<<<<<<<<<<< + * return Backlog(Not(self.condition), size=self.size, stack=self.stack, vars=self.vars, action=self.action, filter=self._filter) + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_15__invert__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_15__invert__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__invert__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_7Backlog_14__invert__(((struct __pyx_obj_6hunter_11_predicates_Backlog *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_14__invert__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + size_t __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[123])) + __Pyx_RefNannySetupContext("__invert__", 0); + __Pyx_TraceStartFunc("__invert__", __pyx_f[0], 640, 0, 0, 0, __PYX_ERR(0, 640, __pyx_L1_error)); + + /* "hunter/_predicates.pyx":641 + * + * def __invert__(self): + * return Backlog(Not(self.condition), size=self.size, stack=self.stack, vars=self.vars, action=self.action, filter=self._filter) # <<<<<<<<<<<<<< + * + * def filter(self, *predicates, **kwargs): +*/ + __Pyx_TraceLine(641,1,0,__PYX_ERR(0, 641, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = NULL; + __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Backlog); + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Backlog); + __pyx_t_5 = NULL; + __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Not); + __pyx_t_6 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Not); + __pyx_t_7 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_self->condition}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(2, 14, __pyx_L1_error) - } - __pyx_t_6 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); - if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); - __Pyx_INCREF(__pyx_t_8); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_7, function); - } - } - __pyx_t_1 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 641, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_self->size); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 641, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_self->stack); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 641, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = __Pyx_PyBool_FromLong(__pyx_v_self->vars); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 641, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = 1; + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 5 : 0)] = {__pyx_t_2, ((PyObject *)__pyx_t_4)}; + __pyx_t_9 = __Pyx_MakeVectorcallBuilderKwds(5); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 641, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_size, __pyx_t_6, __pyx_t_9, __pyx_callargs+2, 0) < 0) __PYX_ERR(0, 641, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_stack, __pyx_t_5, __pyx_t_9, __pyx_callargs+2, 1) < 0) __PYX_ERR(0, 641, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_vars, __pyx_t_8, __pyx_t_9, __pyx_callargs+2, 2) < 0) __PYX_ERR(0, 641, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_action, __pyx_v_self->action, __pyx_t_9, __pyx_callargs+2, 3) < 0) __PYX_ERR(0, 641, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_filter, __pyx_v_self->_filter, __pyx_t_9, __pyx_callargs+2, 4) < 0) __PYX_ERR(0, 641, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_3, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_9); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF((PyObject *)__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "(tree fragment)":13 - * cdef __pyx_unpickle_Not__set_state(Not __pyx_result, tuple __pyx_state): - * __pyx_result.predicate = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< - * __pyx_result.__dict__.update(__pyx_state[1]) - */ + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 641, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_1); } + __pyx_r = ((PyObject *)__pyx_t_1); + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 641, __pyx_L1_error)); + goto __pyx_L0; - /* "(tree fragment)":11 - * __pyx_unpickle_Not__set_state( __pyx_result, __pyx_state) - * return __pyx_result - * cdef __pyx_unpickle_Not__set_state(Not __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< - * __pyx_result.predicate = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): - */ + /* "hunter/_predicates.pyx":640 + * return And(self, other) + * + * def __invert__(self): # <<<<<<<<<<<<<< + * return Backlog(Not(self.condition), size=self.size, stack=self.stack, vars=self.vars, action=self.action, filter=self._filter) + * +*/ /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_Not__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; + __Pyx_XDECREF(__pyx_t_9); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 640, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Backlog.__invert__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_tp_new_6hunter_11_predicates_Query(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { - struct __pyx_obj_6hunter_11_predicates_Query *p; - PyObject *o; - o = (*t->tp_alloc)(t, 0); - if (unlikely(!o)) return 0; - p = ((struct __pyx_obj_6hunter_11_predicates_Query *)o); - p->query_contains = ((PyObject*)Py_None); Py_INCREF(Py_None); - p->query_endswith = ((PyObject*)Py_None); Py_INCREF(Py_None); - p->query_eq = ((PyObject*)Py_None); Py_INCREF(Py_None); - p->query_gt = ((PyObject*)Py_None); Py_INCREF(Py_None); - p->query_gte = ((PyObject*)Py_None); Py_INCREF(Py_None); - p->query_in = ((PyObject*)Py_None); Py_INCREF(Py_None); - p->query_lt = ((PyObject*)Py_None); Py_INCREF(Py_None); - p->query_lte = ((PyObject*)Py_None); Py_INCREF(Py_None); - p->query_regex = ((PyObject*)Py_None); Py_INCREF(Py_None); - p->query_startswith = ((PyObject*)Py_None); Py_INCREF(Py_None); - return o; -} - -static void __pyx_tp_dealloc_6hunter_11_predicates_Query(PyObject *o) { - struct __pyx_obj_6hunter_11_predicates_Query *p = (struct __pyx_obj_6hunter_11_predicates_Query *)o; - PyObject_GC_UnTrack(o); - Py_CLEAR(p->query_contains); - Py_CLEAR(p->query_endswith); - Py_CLEAR(p->query_eq); - Py_CLEAR(p->query_gt); - Py_CLEAR(p->query_gte); - Py_CLEAR(p->query_in); - Py_CLEAR(p->query_lt); - Py_CLEAR(p->query_lte); - Py_CLEAR(p->query_regex); - Py_CLEAR(p->query_startswith); - (*Py_TYPE(o)->tp_free)(o); -} +/* "hunter/_predicates.pyx":643 + * return Backlog(Not(self.condition), size=self.size, stack=self.stack, vars=self.vars, action=self.action, filter=self._filter) + * + * def filter(self, *predicates, **kwargs): # <<<<<<<<<<<<<< + * from hunter import _merge + * +*/ -static int __pyx_tp_traverse_6hunter_11_predicates_Query(PyObject *o, visitproc v, void *a) { - int e; - struct __pyx_obj_6hunter_11_predicates_Query *p = (struct __pyx_obj_6hunter_11_predicates_Query *)o; - if (p->query_contains) { - e = (*v)(p->query_contains, a); if (e) return e; - } - if (p->query_endswith) { - e = (*v)(p->query_endswith, a); if (e) return e; - } - if (p->query_eq) { - e = (*v)(p->query_eq, a); if (e) return e; - } - if (p->query_gt) { - e = (*v)(p->query_gt, a); if (e) return e; - } - if (p->query_gte) { - e = (*v)(p->query_gte, a); if (e) return e; - } - if (p->query_in) { - e = (*v)(p->query_in, a); if (e) return e; - } - if (p->query_lt) { - e = (*v)(p->query_lt, a); if (e) return e; - } - if (p->query_lte) { - e = (*v)(p->query_lte, a); if (e) return e; - } - if (p->query_regex) { - e = (*v)(p->query_regex, a); if (e) return e; - } - if (p->query_startswith) { - e = (*v)(p->query_startswith, a); if (e) return e; +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_17filter(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_11_predicates_7Backlog_17filter = {"filter", (PyCFunction)(void(*)(void))(PyCFunctionWithKeywords)__pyx_pw_6hunter_11_predicates_7Backlog_17filter, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_17filter(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_predicates = 0; + PyObject *__pyx_v_kwargs = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("filter (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (__pyx_kwds_len > 0) { + if (unlikely(__Pyx_CheckKeywordStrings("filter", __pyx_kwds) == -1)) return NULL; + __pyx_v_kwargs = __Pyx_KwargsAsDict_VARARGS(__pyx_kwds, __pyx_kwvalues); + if (unlikely(!__pyx_v_kwargs)) return NULL; + __Pyx_GOTREF(__pyx_v_kwargs); + } else { + __pyx_v_kwargs = PyDict_New(); + if (unlikely(!__pyx_v_kwargs)) return NULL; + __Pyx_GOTREF(__pyx_v_kwargs); } - return 0; -} + __Pyx_INCREF(__pyx_args); + __pyx_v_predicates = __pyx_args; + __pyx_r = __pyx_pf_6hunter_11_predicates_7Backlog_16filter(((struct __pyx_obj_6hunter_11_predicates_Backlog *)__pyx_v_self), __pyx_v_predicates, __pyx_v_kwargs); -static int __pyx_tp_clear_6hunter_11_predicates_Query(PyObject *o) { - PyObject* tmp; - struct __pyx_obj_6hunter_11_predicates_Query *p = (struct __pyx_obj_6hunter_11_predicates_Query *)o; - tmp = ((PyObject*)p->query_contains); - p->query_contains = ((PyObject*)Py_None); Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->query_endswith); - p->query_endswith = ((PyObject*)Py_None); Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->query_eq); - p->query_eq = ((PyObject*)Py_None); Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->query_gt); - p->query_gt = ((PyObject*)Py_None); Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->query_gte); - p->query_gte = ((PyObject*)Py_None); Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->query_in); - p->query_in = ((PyObject*)Py_None); Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->query_lt); - p->query_lt = ((PyObject*)Py_None); Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->query_lte); - p->query_lte = ((PyObject*)Py_None); Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->query_regex); - p->query_regex = ((PyObject*)Py_None); Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->query_startswith); - p->query_startswith = ((PyObject*)Py_None); Py_INCREF(Py_None); - Py_XDECREF(tmp); - return 0; + /* function exit code */ + __Pyx_DECREF(__pyx_v_predicates); + __Pyx_DECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -static PyObject *__pyx_tp_richcompare_6hunter_11_predicates_Query(PyObject *o1, PyObject *o2, int op) { - switch (op) { - case Py_EQ: { - return __pyx_pw_6hunter_11_predicates_5Query_7__eq__(o1, o2); - } - case Py_NE: { - PyObject *ret; - ret = __pyx_pw_6hunter_11_predicates_5Query_7__eq__(o1, o2); - if (likely(ret && ret != Py_NotImplemented)) { - int b = __Pyx_PyObject_IsTrue(ret); Py_DECREF(ret); - if (unlikely(b < 0)) return NULL; - ret = (b) ? Py_False : Py_True; - Py_INCREF(ret); - } - return ret; - } - default: { - return __Pyx_NewRef(Py_NotImplemented); - } - } -} +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_16filter(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self, PyObject *__pyx_v_predicates, PyObject *__pyx_v_kwargs) { + PyObject *__pyx_v__merge = NULL; + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + size_t __pyx_t_10; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[124])) + __Pyx_RefNannySetupContext("filter", 0); + __Pyx_TraceStartFunc("filter", __pyx_f[0], 643, 0, 0, 0, __PYX_ERR(0, 643, __pyx_L1_error)); + __Pyx_INCREF(__pyx_v_predicates); -static PyObject *__pyx_getprop_6hunter_11_predicates_5Query_query_contains(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_11_predicates_5Query_14query_contains_1__get__(o); -} + /* "hunter/_predicates.pyx":644 + * + * def filter(self, *predicates, **kwargs): + * from hunter import _merge # <<<<<<<<<<<<<< + * + * if self._filter is not None: +*/ + __Pyx_TraceLine(644,3,0,__PYX_ERR(0, 644, __pyx_L1_error)) + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 644, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_merge); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_merge); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_mstate_global->__pyx_n_u_merge) != (0)) __PYX_ERR(0, 644, __pyx_L1_error); + __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_hunter, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 644, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_merge); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 644, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v__merge = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; -static PyObject *__pyx_getprop_6hunter_11_predicates_5Query_query_endswith(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_11_predicates_5Query_14query_endswith_1__get__(o); -} + /* "hunter/_predicates.pyx":646 + * from hunter import _merge + * + * if self._filter is not None: # <<<<<<<<<<<<<< + * predicates = (self._filter, *predicates) + * +*/ + __Pyx_TraceLine(646,8,0,__PYX_ERR(0, 646, __pyx_L1_error)) + __pyx_t_3 = (__pyx_v_self->_filter != Py_None); + if (__pyx_t_3) { -static PyObject *__pyx_getprop_6hunter_11_predicates_5Query_query_eq(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_11_predicates_5Query_8query_eq_1__get__(o); -} + /* "hunter/_predicates.pyx":647 + * + * if self._filter is not None: + * predicates = (self._filter, *predicates) # <<<<<<<<<<<<<< + * + * return Backlog( +*/ + __Pyx_TraceLine(647,11,0,__PYX_ERR(0, 647, __pyx_L1_error)) + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 647, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_self->_filter); + __Pyx_GIVEREF(__pyx_v_self->_filter); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->_filter) != (0)) __PYX_ERR(0, 647, __pyx_L1_error); + __pyx_t_2 = __pyx_t_1; + __pyx_t_1 = 0; + if (__Pyx_PyList_Extend(__pyx_t_2, __pyx_v_predicates) < 0) __PYX_ERR(0, 647, __pyx_L1_error) + { + PyObject *__pyx_temp = PyList_AsTuple(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); + __pyx_t_2 = __pyx_temp; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 647, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_DECREF_SET(__pyx_v_predicates, ((PyObject*)__pyx_t_2)); + __pyx_t_2 = 0; -static PyObject *__pyx_getprop_6hunter_11_predicates_5Query_query_gt(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_11_predicates_5Query_8query_gt_1__get__(o); -} + /* "hunter/_predicates.pyx":646 + * from hunter import _merge + * + * if self._filter is not None: # <<<<<<<<<<<<<< + * predicates = (self._filter, *predicates) + * +*/ + } -static PyObject *__pyx_getprop_6hunter_11_predicates_5Query_query_gte(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_11_predicates_5Query_9query_gte_1__get__(o); -} + /* "hunter/_predicates.pyx":649 + * predicates = (self._filter, *predicates) + * + * return Backlog( # <<<<<<<<<<<<<< + * self.condition, + * size=self.size, stack=self.stack, vars=self.vars, action=self.action, +*/ + __Pyx_TraceLine(649,13,0,__PYX_ERR(0, 649, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = NULL; + __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Backlog); + __pyx_t_4 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Backlog); -static PyObject *__pyx_getprop_6hunter_11_predicates_5Query_query_in(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_11_predicates_5Query_8query_in_1__get__(o); -} + /* "hunter/_predicates.pyx":651 + * return Backlog( + * self.condition, + * size=self.size, stack=self.stack, vars=self.vars, action=self.action, # <<<<<<<<<<<<<< + * filter=_merge(*predicates, **kwargs) + * ) +*/ + __Pyx_TraceLine(651,20,0,__PYX_ERR(0, 651, __pyx_L1_error)) + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_self->size); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 651, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_self->stack); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 651, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_self->vars); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 651, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); -static PyObject *__pyx_getprop_6hunter_11_predicates_5Query_query_lt(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_11_predicates_5Query_8query_lt_1__get__(o); -} + /* "hunter/_predicates.pyx":652 + * self.condition, + * size=self.size, stack=self.stack, vars=self.vars, action=self.action, + * filter=_merge(*predicates, **kwargs) # <<<<<<<<<<<<<< + * ) + * +*/ + __Pyx_TraceLine(652,34,0,__PYX_ERR(0, 652, __pyx_L1_error)) + __pyx_t_8 = PyDict_Copy(__pyx_v_kwargs); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 652, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_v__merge, __pyx_v_predicates, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 652, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_10 = 1; + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 5 : 0)] = {__pyx_t_1, __pyx_v_self->condition}; + __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(5); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 649, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_size, __pyx_t_5, __pyx_t_8, __pyx_callargs+2, 0) < 0) __PYX_ERR(0, 649, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_stack, __pyx_t_6, __pyx_t_8, __pyx_callargs+2, 1) < 0) __PYX_ERR(0, 649, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_vars, __pyx_t_7, __pyx_t_8, __pyx_callargs+2, 2) < 0) __PYX_ERR(0, 649, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_action, __pyx_v_self->action, __pyx_t_8, __pyx_callargs+2, 3) < 0) __PYX_ERR(0, 649, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_filter, __pyx_t_9, __pyx_t_8, __pyx_callargs+2, 4) < 0) __PYX_ERR(0, 649, __pyx_L1_error) + __pyx_t_2 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_4, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 649, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_2); + } + __pyx_r = ((PyObject *)__pyx_t_2); + __pyx_t_2 = 0; + __Pyx_TraceReturnValue(__pyx_r, 13, 0, __PYX_ERR(0, 649, __pyx_L1_error)); + goto __pyx_L0; -static PyObject *__pyx_getprop_6hunter_11_predicates_5Query_query_lte(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_11_predicates_5Query_9query_lte_1__get__(o); -} + /* "hunter/_predicates.pyx":643 + * return Backlog(Not(self.condition), size=self.size, stack=self.stack, vars=self.vars, action=self.action, filter=self._filter) + * + * def filter(self, *predicates, **kwargs): # <<<<<<<<<<<<<< + * from hunter import _merge + * +*/ -static PyObject *__pyx_getprop_6hunter_11_predicates_5Query_query_regex(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_11_predicates_5Query_11query_regex_1__get__(o); + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 643, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Backlog.filter", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_predicates); + __Pyx_XDECREF(__pyx_v__merge); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -static PyObject *__pyx_getprop_6hunter_11_predicates_5Query_query_startswith(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_11_predicates_5Query_16query_startswith_1__get__(o); -} +/* "hunter/_predicates.pxd":60 + * cdef class Backlog: + * cdef: + * readonly object condition # <<<<<<<<<<<<<< + * readonly int size + * readonly int stack +*/ -static PyMethodDef __pyx_methods_6hunter_11_predicates_Query[] = { - {"__reduce_cython__", (PyCFunction)__pyx_pw_6hunter_11_predicates_5Query_19__reduce_cython__, METH_NOARGS, 0}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_6hunter_11_predicates_5Query_21__setstate_cython__, METH_O, 0}, - {0, 0, 0, 0} -}; +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_9condition_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_9condition_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_7Backlog_9condition___get__(((struct __pyx_obj_6hunter_11_predicates_Backlog *)__pyx_v_self)); -static struct PyGetSetDef __pyx_getsets_6hunter_11_predicates_Query[] = { - {(char *)"query_contains", __pyx_getprop_6hunter_11_predicates_5Query_query_contains, 0, (char *)0, 0}, - {(char *)"query_endswith", __pyx_getprop_6hunter_11_predicates_5Query_query_endswith, 0, (char *)0, 0}, - {(char *)"query_eq", __pyx_getprop_6hunter_11_predicates_5Query_query_eq, 0, (char *)0, 0}, - {(char *)"query_gt", __pyx_getprop_6hunter_11_predicates_5Query_query_gt, 0, (char *)0, 0}, - {(char *)"query_gte", __pyx_getprop_6hunter_11_predicates_5Query_query_gte, 0, (char *)0, 0}, - {(char *)"query_in", __pyx_getprop_6hunter_11_predicates_5Query_query_in, 0, (char *)0, 0}, - {(char *)"query_lt", __pyx_getprop_6hunter_11_predicates_5Query_query_lt, 0, (char *)0, 0}, - {(char *)"query_lte", __pyx_getprop_6hunter_11_predicates_5Query_query_lte, 0, (char *)0, 0}, - {(char *)"query_regex", __pyx_getprop_6hunter_11_predicates_5Query_query_regex, 0, (char *)0, 0}, - {(char *)"query_startswith", __pyx_getprop_6hunter_11_predicates_5Query_query_startswith, 0, (char *)0, 0}, - {0, 0, 0, 0, 0} -}; + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} -static PyNumberMethods __pyx_tp_as_number_Query = { - 0, /*nb_add*/ - 0, /*nb_subtract*/ - 0, /*nb_multiply*/ - #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) - 0, /*nb_divide*/ - #endif - 0, /*nb_remainder*/ - 0, /*nb_divmod*/ - 0, /*nb_power*/ - 0, /*nb_negative*/ - 0, /*nb_positive*/ - 0, /*nb_absolute*/ - 0, /*nb_nonzero*/ - __pyx_pw_6hunter_11_predicates_5Query_17__invert__, /*nb_invert*/ - 0, /*nb_lshift*/ - 0, /*nb_rshift*/ - __pyx_pw_6hunter_11_predicates_5Query_15__and__, /*nb_and*/ - 0, /*nb_xor*/ - __pyx_pw_6hunter_11_predicates_5Query_13__or__, /*nb_or*/ - #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) - 0, /*nb_coerce*/ - #endif - 0, /*nb_int*/ - #if PY_MAJOR_VERSION < 3 - 0, /*nb_long*/ +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_9condition___get__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[125])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 60, 0, 0, 0, __PYX_ERR(2, 60, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->condition); + __pyx_r = __pyx_v_self->condition; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 60, __pyx_L1_error)); + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); #else - 0, /*reserved*/ - #endif - 0, /*nb_float*/ - #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) - 0, /*nb_oct*/ - #endif - #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) - 0, /*nb_hex*/ - #endif - 0, /*nb_inplace_add*/ - 0, /*nb_inplace_subtract*/ - 0, /*nb_inplace_multiply*/ - #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) - 0, /*nb_inplace_divide*/ - #endif - 0, /*nb_inplace_remainder*/ - 0, /*nb_inplace_power*/ - 0, /*nb_inplace_lshift*/ - 0, /*nb_inplace_rshift*/ - 0, /*nb_inplace_and*/ - 0, /*nb_inplace_xor*/ - 0, /*nb_inplace_or*/ - 0, /*nb_floor_divide*/ - 0, /*nb_true_divide*/ - 0, /*nb_inplace_floor_divide*/ - 0, /*nb_inplace_true_divide*/ - 0, /*nb_index*/ - #if PY_VERSION_HEX >= 0x03050000 - 0, /*nb_matrix_multiply*/ - #endif - #if PY_VERSION_HEX >= 0x03050000 - 0, /*nb_inplace_matrix_multiply*/ + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 60, __pyx_L1_error)); #endif -}; + __Pyx_AddTraceback("hunter._predicates.Backlog.condition.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} -static PyTypeObject __pyx_type_6hunter_11_predicates_Query = { - PyVarObject_HEAD_INIT(0, 0) - "hunter._predicates.Query", /*tp_name*/ - sizeof(struct __pyx_obj_6hunter_11_predicates_Query), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - __pyx_tp_dealloc_6hunter_11_predicates_Query, /*tp_dealloc*/ - #if PY_VERSION_HEX < 0x030800b4 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 - 0, /*tp_vectorcall_offset*/ - #endif - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - __pyx_pw_6hunter_11_predicates_5Query_5__repr__, /*tp_repr*/ - &__pyx_tp_as_number_Query, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - __pyx_pw_6hunter_11_predicates_5Query_9__hash__, /*tp_hash*/ - __pyx_pw_6hunter_11_predicates_5Query_11__call__, /*tp_call*/ - __pyx_pw_6hunter_11_predicates_5Query_3__str__, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - "\n A query class.\n\n See :class:`hunter.event.Event` for fields that can be filtered on.\n ", /*tp_doc*/ - __pyx_tp_traverse_6hunter_11_predicates_Query, /*tp_traverse*/ - __pyx_tp_clear_6hunter_11_predicates_Query, /*tp_clear*/ - __pyx_tp_richcompare_6hunter_11_predicates_Query, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - __pyx_methods_6hunter_11_predicates_Query, /*tp_methods*/ - 0, /*tp_members*/ - __pyx_getsets_6hunter_11_predicates_Query, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - __pyx_pw_6hunter_11_predicates_5Query_1__init__, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_6hunter_11_predicates_Query, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - 0, /*tp_finalize*/ - #endif - #if PY_VERSION_HEX >= 0x030800b1 - 0, /*tp_vectorcall*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 - 0, /*tp_print*/ - #endif -}; +/* "hunter/_predicates.pxd":61 + * cdef: + * readonly object condition + * readonly int size # <<<<<<<<<<<<<< + * readonly int stack + * readonly bint vars +*/ -static PyObject *__pyx_tp_new_6hunter_11_predicates_And(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { - struct __pyx_obj_6hunter_11_predicates_And *p; - PyObject *o; - o = (*t->tp_alloc)(t, 0); - if (unlikely(!o)) return 0; - p = ((struct __pyx_obj_6hunter_11_predicates_And *)o); - p->predicates = ((PyObject*)Py_None); Py_INCREF(Py_None); - return o; -} +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_4size_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_4size_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_7Backlog_4size___get__(((struct __pyx_obj_6hunter_11_predicates_Backlog *)__pyx_v_self)); -static void __pyx_tp_dealloc_6hunter_11_predicates_And(PyObject *o) { - struct __pyx_obj_6hunter_11_predicates_And *p = (struct __pyx_obj_6hunter_11_predicates_And *)o; - PyObject_GC_UnTrack(o); - Py_CLEAR(p->predicates); - (*Py_TYPE(o)->tp_free)(o); + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -static int __pyx_tp_traverse_6hunter_11_predicates_And(PyObject *o, visitproc v, void *a) { - int e; - struct __pyx_obj_6hunter_11_predicates_And *p = (struct __pyx_obj_6hunter_11_predicates_And *)o; - if (p->predicates) { - e = (*v)(p->predicates, a); if (e) return e; - } - return 0; -} +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_4size___get__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[126])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 61, 0, 0, 0, __PYX_ERR(2, 61, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->size); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 61, __pyx_L1_error)); + goto __pyx_L0; -static int __pyx_tp_clear_6hunter_11_predicates_And(PyObject *o) { - PyObject* tmp; - struct __pyx_obj_6hunter_11_predicates_And *p = (struct __pyx_obj_6hunter_11_predicates_And *)o; - tmp = ((PyObject*)p->predicates); - p->predicates = ((PyObject*)Py_None); Py_INCREF(Py_None); - Py_XDECREF(tmp); - return 0; + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 61, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Backlog.size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -static PyObject *__pyx_tp_richcompare_6hunter_11_predicates_And(PyObject *o1, PyObject *o2, int op) { - switch (op) { - case Py_EQ: { - return __pyx_pw_6hunter_11_predicates_3And_7__eq__(o1, o2); - } - case Py_NE: { - PyObject *ret; - ret = __pyx_pw_6hunter_11_predicates_3And_7__eq__(o1, o2); - if (likely(ret && ret != Py_NotImplemented)) { - int b = __Pyx_PyObject_IsTrue(ret); Py_DECREF(ret); - if (unlikely(b < 0)) return NULL; - ret = (b) ? Py_False : Py_True; - Py_INCREF(ret); - } - return ret; - } - default: { - return __Pyx_NewRef(Py_NotImplemented); - } - } +/* "hunter/_predicates.pxd":62 + * readonly object condition + * readonly int size + * readonly int stack # <<<<<<<<<<<<<< + * readonly bint vars + * readonly bint strip +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_5stack_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_5stack_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_7Backlog_5stack___get__(((struct __pyx_obj_6hunter_11_predicates_Backlog *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -static PyObject *__pyx_getprop_6hunter_11_predicates_3And_predicates(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_11_predicates_3And_10predicates_1__get__(o); +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_5stack___get__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[127])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 62, 0, 0, 0, __PYX_ERR(2, 62, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->stack); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 62, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 62, __pyx_L1_error)); + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 62, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Backlog.stack.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -static PyMethodDef __pyx_methods_6hunter_11_predicates_And[] = { - {"__reduce_cython__", (PyCFunction)__pyx_pw_6hunter_11_predicates_3And_19__reduce_cython__, METH_NOARGS, 0}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_6hunter_11_predicates_3And_21__setstate_cython__, METH_O, 0}, - {0, 0, 0, 0} -}; +/* "hunter/_predicates.pxd":63 + * readonly int size + * readonly int stack + * readonly bint vars # <<<<<<<<<<<<<< + * readonly bint strip + * readonly object action +*/ -static struct PyGetSetDef __pyx_getsets_6hunter_11_predicates_And[] = { - {(char *)"predicates", __pyx_getprop_6hunter_11_predicates_3And_predicates, 0, (char *)0, 0}, - {0, 0, 0, 0, 0} -}; +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_4vars_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_4vars_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_7Backlog_4vars___get__(((struct __pyx_obj_6hunter_11_predicates_Backlog *)__pyx_v_self)); -static PyNumberMethods __pyx_tp_as_number_And = { - 0, /*nb_add*/ - 0, /*nb_subtract*/ - 0, /*nb_multiply*/ - #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) - 0, /*nb_divide*/ + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_4vars___get__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[128])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 63, 0, 0, 0, __PYX_ERR(2, 63, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->vars); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 63, __pyx_L1_error)); + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 63, __pyx_L1_error)); #endif - 0, /*nb_remainder*/ - 0, /*nb_divmod*/ - 0, /*nb_power*/ - 0, /*nb_negative*/ - 0, /*nb_positive*/ - 0, /*nb_absolute*/ - 0, /*nb_nonzero*/ - __pyx_pw_6hunter_11_predicates_3And_17__invert__, /*nb_invert*/ - 0, /*nb_lshift*/ - 0, /*nb_rshift*/ - __pyx_pw_6hunter_11_predicates_3And_15__and__, /*nb_and*/ - 0, /*nb_xor*/ - __pyx_pw_6hunter_11_predicates_3And_13__or__, /*nb_or*/ - #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) - 0, /*nb_coerce*/ - #endif - 0, /*nb_int*/ - #if PY_MAJOR_VERSION < 3 - 0, /*nb_long*/ - #else - 0, /*reserved*/ - #endif - 0, /*nb_float*/ - #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) - 0, /*nb_oct*/ - #endif - #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) - 0, /*nb_hex*/ - #endif - 0, /*nb_inplace_add*/ - 0, /*nb_inplace_subtract*/ - 0, /*nb_inplace_multiply*/ - #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) - 0, /*nb_inplace_divide*/ - #endif - 0, /*nb_inplace_remainder*/ - 0, /*nb_inplace_power*/ - 0, /*nb_inplace_lshift*/ - 0, /*nb_inplace_rshift*/ - 0, /*nb_inplace_and*/ - 0, /*nb_inplace_xor*/ - 0, /*nb_inplace_or*/ - 0, /*nb_floor_divide*/ - 0, /*nb_true_divide*/ - 0, /*nb_inplace_floor_divide*/ - 0, /*nb_inplace_true_divide*/ - 0, /*nb_index*/ - #if PY_VERSION_HEX >= 0x03050000 - 0, /*nb_matrix_multiply*/ - #endif - #if PY_VERSION_HEX >= 0x03050000 - 0, /*nb_inplace_matrix_multiply*/ - #endif -}; + __Pyx_AddTraceback("hunter._predicates.Backlog.vars.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} -static PyTypeObject __pyx_type_6hunter_11_predicates_And = { - PyVarObject_HEAD_INIT(0, 0) - "hunter._predicates.And", /*tp_name*/ - sizeof(struct __pyx_obj_6hunter_11_predicates_And), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - __pyx_tp_dealloc_6hunter_11_predicates_And, /*tp_dealloc*/ - #if PY_VERSION_HEX < 0x030800b4 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 - 0, /*tp_vectorcall_offset*/ - #endif - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - __pyx_pw_6hunter_11_predicates_3And_5__repr__, /*tp_repr*/ - &__pyx_tp_as_number_And, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - __pyx_pw_6hunter_11_predicates_3And_9__hash__, /*tp_hash*/ - __pyx_pw_6hunter_11_predicates_3And_11__call__, /*tp_call*/ - __pyx_pw_6hunter_11_predicates_3And_3__str__, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - "\n `And` predicate. Exits at the first sub-predicate that returns ``False``.\n ", /*tp_doc*/ - __pyx_tp_traverse_6hunter_11_predicates_And, /*tp_traverse*/ - __pyx_tp_clear_6hunter_11_predicates_And, /*tp_clear*/ - __pyx_tp_richcompare_6hunter_11_predicates_And, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - __pyx_methods_6hunter_11_predicates_And, /*tp_methods*/ - 0, /*tp_members*/ - __pyx_getsets_6hunter_11_predicates_And, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - __pyx_pw_6hunter_11_predicates_3And_1__init__, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_6hunter_11_predicates_And, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - 0, /*tp_finalize*/ - #endif - #if PY_VERSION_HEX >= 0x030800b1 - 0, /*tp_vectorcall*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 - 0, /*tp_print*/ - #endif -}; +/* "hunter/_predicates.pxd":64 + * readonly int stack + * readonly bint vars + * readonly bint strip # <<<<<<<<<<<<<< + * readonly object action + * readonly object _try_repr +*/ -static PyObject *__pyx_tp_new_6hunter_11_predicates_Or(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { - struct __pyx_obj_6hunter_11_predicates_Or *p; - PyObject *o; - o = (*t->tp_alloc)(t, 0); - if (unlikely(!o)) return 0; - p = ((struct __pyx_obj_6hunter_11_predicates_Or *)o); - p->predicates = ((PyObject*)Py_None); Py_INCREF(Py_None); - return o; +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_5strip_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_5strip_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_7Backlog_5strip___get__(((struct __pyx_obj_6hunter_11_predicates_Backlog *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -static void __pyx_tp_dealloc_6hunter_11_predicates_Or(PyObject *o) { - struct __pyx_obj_6hunter_11_predicates_Or *p = (struct __pyx_obj_6hunter_11_predicates_Or *)o; - PyObject_GC_UnTrack(o); - Py_CLEAR(p->predicates); - (*Py_TYPE(o)->tp_free)(o); +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_5strip___get__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[129])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 64, 0, 0, 0, __PYX_ERR(2, 64, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->strip); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 64, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 64, __pyx_L1_error)); + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 64, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Backlog.strip.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -static int __pyx_tp_traverse_6hunter_11_predicates_Or(PyObject *o, visitproc v, void *a) { - int e; - struct __pyx_obj_6hunter_11_predicates_Or *p = (struct __pyx_obj_6hunter_11_predicates_Or *)o; - if (p->predicates) { - e = (*v)(p->predicates, a); if (e) return e; - } - return 0; +/* "hunter/_predicates.pxd":65 + * readonly bint vars + * readonly bint strip + * readonly object action # <<<<<<<<<<<<<< + * readonly object _try_repr + * readonly object _filter +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_6action_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_6action_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_7Backlog_6action___get__(((struct __pyx_obj_6hunter_11_predicates_Backlog *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -static int __pyx_tp_clear_6hunter_11_predicates_Or(PyObject *o) { - PyObject* tmp; - struct __pyx_obj_6hunter_11_predicates_Or *p = (struct __pyx_obj_6hunter_11_predicates_Or *)o; - tmp = ((PyObject*)p->predicates); - p->predicates = ((PyObject*)Py_None); Py_INCREF(Py_None); - Py_XDECREF(tmp); - return 0; +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_6action___get__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[130])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 65, 0, 0, 0, __PYX_ERR(2, 65, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->action); + __pyx_r = __pyx_v_self->action; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 65, __pyx_L1_error)); + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 65, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Backlog.action.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -static PyObject *__pyx_tp_richcompare_6hunter_11_predicates_Or(PyObject *o1, PyObject *o2, int op) { - switch (op) { - case Py_EQ: { - return __pyx_pw_6hunter_11_predicates_2Or_7__eq__(o1, o2); - } - case Py_NE: { - PyObject *ret; - ret = __pyx_pw_6hunter_11_predicates_2Or_7__eq__(o1, o2); - if (likely(ret && ret != Py_NotImplemented)) { - int b = __Pyx_PyObject_IsTrue(ret); Py_DECREF(ret); - if (unlikely(b < 0)) return NULL; - ret = (b) ? Py_False : Py_True; - Py_INCREF(ret); - } - return ret; - } - default: { - return __Pyx_NewRef(Py_NotImplemented); - } - } +/* "hunter/_predicates.pxd":66 + * readonly bint strip + * readonly object action + * readonly object _try_repr # <<<<<<<<<<<<<< + * readonly object _filter + * readonly object queue +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_9_try_repr_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_9_try_repr_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_7Backlog_9_try_repr___get__(((struct __pyx_obj_6hunter_11_predicates_Backlog *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -static PyObject *__pyx_getprop_6hunter_11_predicates_2Or_predicates(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_11_predicates_2Or_10predicates_1__get__(o); +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_9_try_repr___get__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[131])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 66, 0, 0, 0, __PYX_ERR(2, 66, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_try_repr); + __pyx_r = __pyx_v_self->_try_repr; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 66, __pyx_L1_error)); + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 66, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Backlog._try_repr.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -static PyMethodDef __pyx_methods_6hunter_11_predicates_Or[] = { - {"__reduce_cython__", (PyCFunction)__pyx_pw_6hunter_11_predicates_2Or_19__reduce_cython__, METH_NOARGS, 0}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_6hunter_11_predicates_2Or_21__setstate_cython__, METH_O, 0}, - {0, 0, 0, 0} -}; +/* "hunter/_predicates.pxd":67 + * readonly object action + * readonly object _try_repr + * readonly object _filter # <<<<<<<<<<<<<< + * readonly object queue + * +*/ -static struct PyGetSetDef __pyx_getsets_6hunter_11_predicates_Or[] = { - {(char *)"predicates", __pyx_getprop_6hunter_11_predicates_2Or_predicates, 0, (char *)0, 0}, - {0, 0, 0, 0, 0} -}; +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_7_filter_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_7_filter_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_7Backlog_7_filter___get__(((struct __pyx_obj_6hunter_11_predicates_Backlog *)__pyx_v_self)); -static PyNumberMethods __pyx_tp_as_number_Or = { - 0, /*nb_add*/ - 0, /*nb_subtract*/ - 0, /*nb_multiply*/ - #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) - 0, /*nb_divide*/ + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_7_filter___get__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[132])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 67, 0, 0, 0, __PYX_ERR(2, 67, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_filter); + __pyx_r = __pyx_v_self->_filter; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 67, __pyx_L1_error)); + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 67, __pyx_L1_error)); #endif - 0, /*nb_remainder*/ - 0, /*nb_divmod*/ - 0, /*nb_power*/ - 0, /*nb_negative*/ - 0, /*nb_positive*/ - 0, /*nb_absolute*/ - 0, /*nb_nonzero*/ - __pyx_pw_6hunter_11_predicates_2Or_17__invert__, /*nb_invert*/ - 0, /*nb_lshift*/ - 0, /*nb_rshift*/ - __pyx_pw_6hunter_11_predicates_2Or_15__and__, /*nb_and*/ - 0, /*nb_xor*/ - __pyx_pw_6hunter_11_predicates_2Or_13__or__, /*nb_or*/ - #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) - 0, /*nb_coerce*/ - #endif - 0, /*nb_int*/ - #if PY_MAJOR_VERSION < 3 - 0, /*nb_long*/ - #else - 0, /*reserved*/ - #endif - 0, /*nb_float*/ - #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) - 0, /*nb_oct*/ - #endif - #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) - 0, /*nb_hex*/ - #endif - 0, /*nb_inplace_add*/ - 0, /*nb_inplace_subtract*/ - 0, /*nb_inplace_multiply*/ - #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) - 0, /*nb_inplace_divide*/ - #endif - 0, /*nb_inplace_remainder*/ - 0, /*nb_inplace_power*/ - 0, /*nb_inplace_lshift*/ - 0, /*nb_inplace_rshift*/ - 0, /*nb_inplace_and*/ - 0, /*nb_inplace_xor*/ - 0, /*nb_inplace_or*/ - 0, /*nb_floor_divide*/ - 0, /*nb_true_divide*/ - 0, /*nb_inplace_floor_divide*/ - 0, /*nb_inplace_true_divide*/ - 0, /*nb_index*/ - #if PY_VERSION_HEX >= 0x03050000 - 0, /*nb_matrix_multiply*/ - #endif - #if PY_VERSION_HEX >= 0x03050000 - 0, /*nb_inplace_matrix_multiply*/ - #endif -}; - -static PyTypeObject __pyx_type_6hunter_11_predicates_Or = { - PyVarObject_HEAD_INIT(0, 0) - "hunter._predicates.Or", /*tp_name*/ - sizeof(struct __pyx_obj_6hunter_11_predicates_Or), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - __pyx_tp_dealloc_6hunter_11_predicates_Or, /*tp_dealloc*/ - #if PY_VERSION_HEX < 0x030800b4 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 - 0, /*tp_vectorcall_offset*/ - #endif - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - __pyx_pw_6hunter_11_predicates_2Or_5__repr__, /*tp_repr*/ - &__pyx_tp_as_number_Or, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - __pyx_pw_6hunter_11_predicates_2Or_9__hash__, /*tp_hash*/ - __pyx_pw_6hunter_11_predicates_2Or_11__call__, /*tp_call*/ - __pyx_pw_6hunter_11_predicates_2Or_3__str__, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - "\n `Or` predicate. Exits at first sub-predicate that returns ``True``.\n ", /*tp_doc*/ - __pyx_tp_traverse_6hunter_11_predicates_Or, /*tp_traverse*/ - __pyx_tp_clear_6hunter_11_predicates_Or, /*tp_clear*/ - __pyx_tp_richcompare_6hunter_11_predicates_Or, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - __pyx_methods_6hunter_11_predicates_Or, /*tp_methods*/ - 0, /*tp_members*/ - __pyx_getsets_6hunter_11_predicates_Or, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - __pyx_pw_6hunter_11_predicates_2Or_1__init__, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_6hunter_11_predicates_Or, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - 0, /*tp_finalize*/ - #endif - #if PY_VERSION_HEX >= 0x030800b1 - 0, /*tp_vectorcall*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 - 0, /*tp_print*/ - #endif -}; - -static PyObject *__pyx_tp_new_6hunter_11_predicates_Not(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { - struct __pyx_obj_6hunter_11_predicates_Not *p; - PyObject *o; - o = (*t->tp_alloc)(t, 0); - if (unlikely(!o)) return 0; - p = ((struct __pyx_obj_6hunter_11_predicates_Not *)o); - p->predicate = Py_None; Py_INCREF(Py_None); - return o; + __Pyx_AddTraceback("hunter._predicates.Backlog._filter.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -static void __pyx_tp_dealloc_6hunter_11_predicates_Not(PyObject *o) { - struct __pyx_obj_6hunter_11_predicates_Not *p = (struct __pyx_obj_6hunter_11_predicates_Not *)o; - PyObject_GC_UnTrack(o); - Py_CLEAR(p->predicate); - (*Py_TYPE(o)->tp_free)(o); -} +/* "hunter/_predicates.pxd":68 + * readonly object _try_repr + * readonly object _filter + * readonly object queue # <<<<<<<<<<<<<< + * + * cdef fast_And_call(And self, Event event) +*/ -static int __pyx_tp_traverse_6hunter_11_predicates_Not(PyObject *o, visitproc v, void *a) { - int e; - struct __pyx_obj_6hunter_11_predicates_Not *p = (struct __pyx_obj_6hunter_11_predicates_Not *)o; - if (p->predicate) { - e = (*v)(p->predicate, a); if (e) return e; - } - return 0; -} +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_5queue_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_5queue_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_11_predicates_7Backlog_5queue___get__(((struct __pyx_obj_6hunter_11_predicates_Backlog *)__pyx_v_self)); -static int __pyx_tp_clear_6hunter_11_predicates_Not(PyObject *o) { - PyObject* tmp; - struct __pyx_obj_6hunter_11_predicates_Not *p = (struct __pyx_obj_6hunter_11_predicates_Not *)o; - tmp = ((PyObject*)p->predicate); - p->predicate = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - return 0; + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -static PyObject *__pyx_tp_richcompare_6hunter_11_predicates_Not(PyObject *o1, PyObject *o2, int op) { - switch (op) { - case Py_EQ: { - return __pyx_pw_6hunter_11_predicates_3Not_7__eq__(o1, o2); - } - case Py_NE: { - PyObject *ret; - ret = __pyx_pw_6hunter_11_predicates_3Not_7__eq__(o1, o2); - if (likely(ret && ret != Py_NotImplemented)) { - int b = __Pyx_PyObject_IsTrue(ret); Py_DECREF(ret); - if (unlikely(b < 0)) return NULL; - ret = (b) ? Py_False : Py_True; - Py_INCREF(ret); - } - return ret; - } - default: { - return __Pyx_NewRef(Py_NotImplemented); - } - } -} +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_5queue___get__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[133])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 68, 0, 0, 0, __PYX_ERR(2, 68, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->queue); + __pyx_r = __pyx_v_self->queue; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 68, __pyx_L1_error)); + goto __pyx_L0; -static PyObject *__pyx_getprop_6hunter_11_predicates_3Not_predicate(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_11_predicates_3Not_9predicate_1__get__(o); + /* function exit code */ + __pyx_L1_error:; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 68, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Backlog.queue.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -static PyMethodDef __pyx_methods_6hunter_11_predicates_Not[] = { - {"__reduce_cython__", (PyCFunction)__pyx_pw_6hunter_11_predicates_3Not_19__reduce_cython__, METH_NOARGS, 0}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_6hunter_11_predicates_3Not_21__setstate_cython__, METH_O, 0}, - {0, 0, 0, 0} -}; - -static struct PyGetSetDef __pyx_getsets_6hunter_11_predicates_Not[] = { - {(char *)"predicate", __pyx_getprop_6hunter_11_predicates_3Not_predicate, 0, (char *)0, 0}, - {0, 0, 0, 0, 0} -}; +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ -static PyNumberMethods __pyx_tp_as_number_Not = { - 0, /*nb_add*/ - 0, /*nb_subtract*/ - 0, /*nb_multiply*/ - #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) - 0, /*nb_divide*/ - #endif - 0, /*nb_remainder*/ - 0, /*nb_divmod*/ - 0, /*nb_power*/ - 0, /*nb_negative*/ - 0, /*nb_positive*/ - 0, /*nb_absolute*/ - 0, /*nb_nonzero*/ - __pyx_pw_6hunter_11_predicates_3Not_17__invert__, /*nb_invert*/ - 0, /*nb_lshift*/ - 0, /*nb_rshift*/ - __pyx_pw_6hunter_11_predicates_3Not_15__and__, /*nb_and*/ - 0, /*nb_xor*/ - __pyx_pw_6hunter_11_predicates_3Not_13__or__, /*nb_or*/ - #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) - 0, /*nb_coerce*/ +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_19__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_11_predicates_7Backlog_19__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_7Backlog_19__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_19__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif - 0, /*nb_int*/ - #if PY_MAJOR_VERSION < 3 - 0, /*nb_long*/ + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else - 0, /*reserved*/ - #endif - 0, /*nb_float*/ - #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) - 0, /*nb_oct*/ - #endif - #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) - 0, /*nb_hex*/ - #endif - 0, /*nb_inplace_add*/ - 0, /*nb_inplace_subtract*/ - 0, /*nb_inplace_multiply*/ - #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) - 0, /*nb_inplace_divide*/ - #endif - 0, /*nb_inplace_remainder*/ - 0, /*nb_inplace_power*/ - 0, /*nb_inplace_lshift*/ - 0, /*nb_inplace_rshift*/ - 0, /*nb_inplace_and*/ - 0, /*nb_inplace_xor*/ - 0, /*nb_inplace_or*/ - 0, /*nb_floor_divide*/ - 0, /*nb_true_divide*/ - 0, /*nb_inplace_floor_divide*/ - 0, /*nb_inplace_true_divide*/ - 0, /*nb_index*/ - #if PY_VERSION_HEX >= 0x03050000 - 0, /*nb_matrix_multiply*/ + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif - #if PY_VERSION_HEX >= 0x03050000 - 0, /*nb_inplace_matrix_multiply*/ #endif -}; + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_6hunter_11_predicates_7Backlog_18__reduce_cython__(((struct __pyx_obj_6hunter_11_predicates_Backlog *)__pyx_v_self)); -static PyTypeObject __pyx_type_6hunter_11_predicates_Not = { - PyVarObject_HEAD_INIT(0, 0) - "hunter._predicates.Not", /*tp_name*/ - sizeof(struct __pyx_obj_6hunter_11_predicates_Not), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - __pyx_tp_dealloc_6hunter_11_predicates_Not, /*tp_dealloc*/ - #if PY_VERSION_HEX < 0x030800b4 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 - 0, /*tp_vectorcall_offset*/ - #endif - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - __pyx_pw_6hunter_11_predicates_3Not_5__repr__, /*tp_repr*/ - &__pyx_tp_as_number_Not, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - __pyx_pw_6hunter_11_predicates_3Not_9__hash__, /*tp_hash*/ - __pyx_pw_6hunter_11_predicates_3Not_11__call__, /*tp_call*/ - __pyx_pw_6hunter_11_predicates_3Not_3__str__, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - "\n `Not` predicate.\n ", /*tp_doc*/ - __pyx_tp_traverse_6hunter_11_predicates_Not, /*tp_traverse*/ - __pyx_tp_clear_6hunter_11_predicates_Not, /*tp_clear*/ - __pyx_tp_richcompare_6hunter_11_predicates_Not, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - __pyx_methods_6hunter_11_predicates_Not, /*tp_methods*/ - 0, /*tp_members*/ - __pyx_getsets_6hunter_11_predicates_Not, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - __pyx_pw_6hunter_11_predicates_3Not_1__init__, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_6hunter_11_predicates_Not, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - 0, /*tp_finalize*/ - #endif - #if PY_VERSION_HEX >= 0x030800b1 - 0, /*tp_vectorcall*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 - 0, /*tp_print*/ - #endif -}; - -static PyObject *__pyx_tp_new_6hunter_11_predicates_When(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { - struct __pyx_obj_6hunter_11_predicates_When *p; - PyObject *o; - o = (*t->tp_alloc)(t, 0); - if (unlikely(!o)) return 0; - p = ((struct __pyx_obj_6hunter_11_predicates_When *)o); - p->condition = Py_None; Py_INCREF(Py_None); - p->actions = ((PyObject*)Py_None); Py_INCREF(Py_None); - return o; + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -static void __pyx_tp_dealloc_6hunter_11_predicates_When(PyObject *o) { - struct __pyx_obj_6hunter_11_predicates_When *p = (struct __pyx_obj_6hunter_11_predicates_When *)o; - PyObject_GC_UnTrack(o); - Py_CLEAR(p->condition); - Py_CLEAR(p->actions); - (*Py_TYPE(o)->tp_free)(o); -} +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_18__reduce_cython__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[134])) + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + __Pyx_TraceStartFunc("__reduce_cython__", __pyx_f[1], 1, 0, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); -static int __pyx_tp_traverse_6hunter_11_predicates_When(PyObject *o, visitproc v, void *a) { - int e; - struct __pyx_obj_6hunter_11_predicates_When *p = (struct __pyx_obj_6hunter_11_predicates_When *)o; - if (p->condition) { - e = (*v)(p->condition, a); if (e) return e; - } - if (p->actions) { - e = (*v)(p->actions, a); if (e) return e; - } - return 0; -} + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self._filter, self._try_repr, self.action, self.condition, self.queue, self.size, self.stack, self.strip, self.vars) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: +*/ + __Pyx_TraceLine(5,13,0,__PYX_ERR(1, 5, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->size); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_self->stack); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_self->strip); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_self->vars); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(9); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_v_self->_filter); + __Pyx_GIVEREF(__pyx_v_self->_filter); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_self->_filter) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->_try_repr); + __Pyx_GIVEREF(__pyx_v_self->_try_repr); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_v_self->_try_repr) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->action); + __Pyx_GIVEREF(__pyx_v_self->action); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_self->action) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->condition); + __Pyx_GIVEREF(__pyx_v_self->condition); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_v_self->condition) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->queue); + __Pyx_GIVEREF(__pyx_v_self->queue); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 4, __pyx_v_self->queue) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 5, __pyx_t_1) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 6, __pyx_t_2) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 7, __pyx_t_3) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 8, __pyx_t_4) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_v_state = ((PyObject*)__pyx_t_5); + __pyx_t_5 = 0; -static int __pyx_tp_clear_6hunter_11_predicates_When(PyObject *o) { - PyObject* tmp; - struct __pyx_obj_6hunter_11_predicates_When *p = (struct __pyx_obj_6hunter_11_predicates_When *)o; - tmp = ((PyObject*)p->condition); - p->condition = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->actions); - p->actions = ((PyObject*)Py_None); Py_INCREF(Py_None); - Py_XDECREF(tmp); - return 0; -} + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self._filter, self._try_repr, self.action, self.condition, self.queue, self.size, self.stack, self.strip, self.vars) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) +*/ + __Pyx_TraceLine(6,22,0,__PYX_ERR(1, 6, __pyx_L1_error)) + __pyx_t_5 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_dict, Py_None); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_v__dict = __pyx_t_5; + __pyx_t_5 = 0; -static PyObject *__pyx_tp_richcompare_6hunter_11_predicates_When(PyObject *o1, PyObject *o2, int op) { - switch (op) { - case Py_EQ: { - return __pyx_pw_6hunter_11_predicates_4When_7__eq__(o1, o2); + /* "(tree fragment)":7 + * state = (self._filter, self._try_repr, self.action, self.condition, self.queue, self.size, self.stack, self.strip, self.vars) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + __Pyx_TraceLine(7,29,0,__PYX_ERR(1, 7, __pyx_L1_error)) + __pyx_t_6 = (__pyx_v__dict != Py_None); + if (__pyx_t_6) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: +*/ + __Pyx_TraceLine(8,31,0,__PYX_ERR(1, 8, __pyx_L1_error)) + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v__dict) != (0)) __PYX_ERR(1, 8, __pyx_L1_error); + __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4)); + __pyx_t_4 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self._filter is not None or self._try_repr is not None or self.action is not None or self.condition is not None or self.queue is not None +*/ + __Pyx_TraceLine(9,33,0,__PYX_ERR(1, 9, __pyx_L1_error)) + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self._filter, self._try_repr, self.action, self.condition, self.queue, self.size, self.stack, self.strip, self.vars) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self._filter is not None or self._try_repr is not None or self.action is not None or self.condition is not None or self.queue is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Backlog, (type(self), 0x1428ea1, None), state +*/ + __Pyx_TraceLine(11,39,0,__PYX_ERR(1, 11, __pyx_L1_error)) + /*else*/ { + __pyx_t_7 = (__pyx_v_self->_filter != Py_None); + if (!__pyx_t_7) { + } else { + __pyx_t_6 = __pyx_t_7; + goto __pyx_L4_bool_binop_done; } - case Py_NE: { - PyObject *ret; - ret = __pyx_pw_6hunter_11_predicates_4When_7__eq__(o1, o2); - if (likely(ret && ret != Py_NotImplemented)) { - int b = __Pyx_PyObject_IsTrue(ret); Py_DECREF(ret); - if (unlikely(b < 0)) return NULL; - ret = (b) ? Py_False : Py_True; - Py_INCREF(ret); - } - return ret; + __pyx_t_7 = (__pyx_v_self->_try_repr != Py_None); + if (!__pyx_t_7) { + } else { + __pyx_t_6 = __pyx_t_7; + goto __pyx_L4_bool_binop_done; } - default: { - return __Pyx_NewRef(Py_NotImplemented); + __pyx_t_7 = (__pyx_v_self->action != Py_None); + if (!__pyx_t_7) { + } else { + __pyx_t_6 = __pyx_t_7; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_7 = (__pyx_v_self->condition != Py_None); + if (!__pyx_t_7) { + } else { + __pyx_t_6 = __pyx_t_7; + goto __pyx_L4_bool_binop_done; } + __pyx_t_7 = (__pyx_v_self->queue != Py_None); + __pyx_t_6 = __pyx_t_7; + __pyx_L4_bool_binop_done:; + __pyx_v_use_setstate = __pyx_t_6; } -} + __pyx_L3:; -static PyObject *__pyx_getprop_6hunter_11_predicates_4When_condition(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_11_predicates_4When_9condition_1__get__(o); -} + /* "(tree fragment)":12 + * else: + * use_setstate = self._filter is not None or self._try_repr is not None or self.action is not None or self.condition is not None or self.queue is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Backlog, (type(self), 0x1428ea1, None), state + * else: +*/ + __Pyx_TraceLine(12,60,0,__PYX_ERR(1, 12, __pyx_L1_error)) + if (__pyx_v_use_setstate) { -static PyObject *__pyx_getprop_6hunter_11_predicates_4When_actions(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_11_predicates_4When_7actions_1__get__(o); -} + /* "(tree fragment)":13 + * use_setstate = self._filter is not None or self._try_repr is not None or self.action is not None or self.condition is not None or self.queue is not None + * if use_setstate: + * return __pyx_unpickle_Backlog, (type(self), 0x1428ea1, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Backlog, (type(self), 0x1428ea1, state) +*/ + __Pyx_TraceLine(13,61,0,__PYX_ERR(1, 13, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Backlog); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_21139105); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_21139105); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_mstate_global->__pyx_int_21139105) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, Py_None) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_5) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_5 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + __Pyx_TraceReturnValue(__pyx_r, 61, 0, __PYX_ERR(1, 13, __pyx_L1_error)); + goto __pyx_L0; -static PyMethodDef __pyx_methods_6hunter_11_predicates_When[] = { - {"__reduce_cython__", (PyCFunction)__pyx_pw_6hunter_11_predicates_4When_19__reduce_cython__, METH_NOARGS, 0}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_6hunter_11_predicates_4When_21__setstate_cython__, METH_O, 0}, - {0, 0, 0, 0} -}; + /* "(tree fragment)":12 + * else: + * use_setstate = self._filter is not None or self._try_repr is not None or self.action is not None or self.condition is not None or self.queue is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Backlog, (type(self), 0x1428ea1, None), state + * else: +*/ + } -static struct PyGetSetDef __pyx_getsets_6hunter_11_predicates_When[] = { - {(char *)"condition", __pyx_getprop_6hunter_11_predicates_4When_condition, 0, (char *)0, 0}, - {(char *)"actions", __pyx_getprop_6hunter_11_predicates_4When_actions, 0, (char *)0, 0}, - {0, 0, 0, 0, 0} -}; + /* "(tree fragment)":15 + * return __pyx_unpickle_Backlog, (type(self), 0x1428ea1, None), state + * else: + * return __pyx_unpickle_Backlog, (type(self), 0x1428ea1, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Backlog__set_state(self, __pyx_state) +*/ + __Pyx_TraceLine(15,69,0,__PYX_ERR(1, 15, __pyx_L1_error)) + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Backlog); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_21139105); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_21139105); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_mstate_global->__pyx_int_21139105) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_5) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_5 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + __Pyx_TraceReturnValue(__pyx_r, 69, 0, __PYX_ERR(1, 15, __pyx_L1_error)); + goto __pyx_L0; + } -static PyNumberMethods __pyx_tp_as_number_When = { - 0, /*nb_add*/ - 0, /*nb_subtract*/ - 0, /*nb_multiply*/ - #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) - 0, /*nb_divide*/ - #endif - 0, /*nb_remainder*/ - 0, /*nb_divmod*/ - 0, /*nb_power*/ - 0, /*nb_negative*/ - 0, /*nb_positive*/ - 0, /*nb_absolute*/ - 0, /*nb_nonzero*/ - __pyx_pw_6hunter_11_predicates_4When_17__invert__, /*nb_invert*/ - 0, /*nb_lshift*/ - 0, /*nb_rshift*/ - __pyx_pw_6hunter_11_predicates_4When_15__and__, /*nb_and*/ - 0, /*nb_xor*/ - __pyx_pw_6hunter_11_predicates_4When_13__or__, /*nb_or*/ - #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) - 0, /*nb_coerce*/ - #endif - 0, /*nb_int*/ - #if PY_MAJOR_VERSION < 3 - 0, /*nb_long*/ - #else - 0, /*reserved*/ - #endif - 0, /*nb_float*/ - #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) - 0, /*nb_oct*/ - #endif - #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) - 0, /*nb_hex*/ - #endif - 0, /*nb_inplace_add*/ - 0, /*nb_inplace_subtract*/ - 0, /*nb_inplace_multiply*/ - #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) - 0, /*nb_inplace_divide*/ - #endif - 0, /*nb_inplace_remainder*/ - 0, /*nb_inplace_power*/ - 0, /*nb_inplace_lshift*/ - 0, /*nb_inplace_rshift*/ - 0, /*nb_inplace_and*/ - 0, /*nb_inplace_xor*/ - 0, /*nb_inplace_or*/ - 0, /*nb_floor_divide*/ - 0, /*nb_true_divide*/ - 0, /*nb_inplace_floor_divide*/ - 0, /*nb_inplace_true_divide*/ - 0, /*nb_index*/ - #if PY_VERSION_HEX >= 0x03050000 - 0, /*nb_matrix_multiply*/ - #endif - #if PY_VERSION_HEX >= 0x03050000 - 0, /*nb_inplace_matrix_multiply*/ - #endif -}; + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ -static PyTypeObject __pyx_type_6hunter_11_predicates_When = { - PyVarObject_HEAD_INIT(0, 0) - "hunter._predicates.When", /*tp_name*/ - sizeof(struct __pyx_obj_6hunter_11_predicates_When), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - __pyx_tp_dealloc_6hunter_11_predicates_When, /*tp_dealloc*/ - #if PY_VERSION_HEX < 0x030800b4 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 - 0, /*tp_vectorcall_offset*/ - #endif - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - __pyx_pw_6hunter_11_predicates_4When_5__repr__, /*tp_repr*/ - &__pyx_tp_as_number_When, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - __pyx_pw_6hunter_11_predicates_4When_9__hash__, /*tp_hash*/ - __pyx_pw_6hunter_11_predicates_4When_11__call__, /*tp_call*/ - __pyx_pw_6hunter_11_predicates_4When_3__str__, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - "\n Runs ``actions`` when ``condition(event)`` is ``True``.\n\n Actions take a single ``event`` argument.\n ", /*tp_doc*/ - __pyx_tp_traverse_6hunter_11_predicates_When, /*tp_traverse*/ - __pyx_tp_clear_6hunter_11_predicates_When, /*tp_clear*/ - __pyx_tp_richcompare_6hunter_11_predicates_When, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - __pyx_methods_6hunter_11_predicates_When, /*tp_methods*/ - 0, /*tp_members*/ - __pyx_getsets_6hunter_11_predicates_When, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - __pyx_pw_6hunter_11_predicates_4When_1__init__, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_6hunter_11_predicates_When, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - 0, /*tp_finalize*/ - #endif - #if PY_VERSION_HEX >= 0x030800b1 - 0, /*tp_vectorcall*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 - 0, /*tp_print*/ + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); #endif -}; - -static PyObject *__pyx_tp_new_6hunter_11_predicates_From(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { - struct __pyx_obj_6hunter_11_predicates_From *p; - PyObject *o; - o = (*t->tp_alloc)(t, 0); - if (unlikely(!o)) return 0; - p = ((struct __pyx_obj_6hunter_11_predicates_From *)o); - p->condition = Py_None; Py_INCREF(Py_None); - p->predicate = Py_None; Py_INCREF(Py_None); - return o; + __Pyx_AddTraceback("hunter._predicates.Backlog.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -static void __pyx_tp_dealloc_6hunter_11_predicates_From(PyObject *o) { - struct __pyx_obj_6hunter_11_predicates_From *p = (struct __pyx_obj_6hunter_11_predicates_From *)o; - PyObject_GC_UnTrack(o); - Py_CLEAR(p->condition); - Py_CLEAR(p->predicate); - (*Py_TYPE(o)->tp_free)(o); -} +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Backlog, (type(self), 0x1428ea1, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Backlog__set_state(self, __pyx_state) +*/ -static int __pyx_tp_traverse_6hunter_11_predicates_From(PyObject *o, visitproc v, void *a) { - int e; - struct __pyx_obj_6hunter_11_predicates_From *p = (struct __pyx_obj_6hunter_11_predicates_From *)o; - if (p->condition) { - e = (*v)(p->condition, a); if (e) return e; +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_21__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_11_predicates_7Backlog_21__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_7Backlog_21__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_11_predicates_7Backlog_21__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 16, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 16, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 16, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) + } + __pyx_v___pyx_state = values[0]; } - if (p->predicate) { - e = (*v)(p->predicate, a); if (e) return e; + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - return 0; -} - -static int __pyx_tp_clear_6hunter_11_predicates_From(PyObject *o) { - PyObject* tmp; - struct __pyx_obj_6hunter_11_predicates_From *p = (struct __pyx_obj_6hunter_11_predicates_From *)o; - tmp = ((PyObject*)p->condition); - p->condition = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->predicate); - p->predicate = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - return 0; -} + __Pyx_AddTraceback("hunter._predicates.Backlog.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6hunter_11_predicates_7Backlog_20__setstate_cython__(((struct __pyx_obj_6hunter_11_predicates_Backlog *)__pyx_v_self), __pyx_v___pyx_state); -static PyObject *__pyx_tp_richcompare_6hunter_11_predicates_From(PyObject *o1, PyObject *o2, int op) { - switch (op) { - case Py_EQ: { - return __pyx_pw_6hunter_11_predicates_4From_7__eq__(o1, o2); - } - case Py_NE: { - PyObject *ret; - ret = __pyx_pw_6hunter_11_predicates_4From_7__eq__(o1, o2); - if (likely(ret && ret != Py_NotImplemented)) { - int b = __Pyx_PyObject_IsTrue(ret); Py_DECREF(ret); - if (unlikely(b < 0)) return NULL; - ret = (b) ? Py_False : Py_True; - Py_INCREF(ret); - } - return ret; - } - default: { - return __Pyx_NewRef(Py_NotImplemented); - } + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -static PyObject *__pyx_getprop_6hunter_11_predicates_4From_condition(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_11_predicates_4From_9condition_1__get__(o); -} +static PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_20__setstate_cython__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[135])) + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + __Pyx_TraceStartFunc("__setstate_cython__", __pyx_f[1], 16, 0, 0, 0, __PYX_ERR(1, 16, __pyx_L1_error)); -static PyObject *__pyx_getprop_6hunter_11_predicates_4From_predicate(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_11_predicates_4From_9predicate_1__get__(o); -} + /* "(tree fragment)":17 + * return __pyx_unpickle_Backlog, (type(self), 0x1428ea1, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Backlog__set_state(self, __pyx_state) # <<<<<<<<<<<<<< +*/ + __Pyx_TraceLine(17,4,0,__PYX_ERR(1, 17, __pyx_L1_error)) + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_6hunter_11_predicates___pyx_unpickle_Backlog__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; -static PyObject *__pyx_getprop_6hunter_11_predicates_4From_watermark(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_11_predicates_4From_9watermark_1__get__(o); -} + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Backlog, (type(self), 0x1428ea1, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Backlog__set_state(self, __pyx_state) +*/ -static PyObject *__pyx_getprop_6hunter_11_predicates_4From_origin_depth(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_11_predicates_4From_12origin_depth_1__get__(o); + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(1, 16, __pyx_L1_error)); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 16, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.Backlog.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -static PyObject *__pyx_getprop_6hunter_11_predicates_4From_origin_calls(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_11_predicates_4From_12origin_calls_1__get__(o); -} +/* "hunter/_predicates.pyx":655 + * ) + * + * cdef inline fast_Backlog_call(Backlog self, Event event): # <<<<<<<<<<<<<< + * cdef bint first_is_call + * cdef Event detached_event +*/ + +static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_fast_Backlog_call(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self, struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { + int __pyx_v_first_is_call; + struct __pyx_obj_6hunter_6_event_Event *__pyx_v_detached_event = 0; + struct __pyx_obj_6hunter_6_event_Event *__pyx_v_first_event = 0; + struct __pyx_obj_6hunter_6_event_Event *__pyx_v_stack_event = 0; + FrameType __pyx_v_first_frame = 0; + FrameType __pyx_v_frame = 0; + int __pyx_v_backlog_call_depth; + int __pyx_v_depth_delta; + int __pyx_v_first_depth; + int __pyx_v_missing_depth; + PyObject *__pyx_v_result = 0; + PyObject *__pyx_v_stack_events = 0; + PyObject *__pyx_v_backlog_event = NULL; + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + size_t __pyx_t_4; + int __pyx_t_5; + long __pyx_t_6; + long __pyx_t_7; + int __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + Py_ssize_t __pyx_t_13; + PyObject *(*__pyx_t_14)(PyObject *); + int __pyx_t_15; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[136])) + __Pyx_RefNannySetupContext("fast_Backlog_call", 0); + __Pyx_TraceStartFunc("fast_Backlog_call", __pyx_f[0], 655, 0, 0, 0, __PYX_ERR(0, 655, __pyx_L1_error)); -static PyMethodDef __pyx_methods_6hunter_11_predicates_From[] = { - {"__reduce_cython__", (PyCFunction)__pyx_pw_6hunter_11_predicates_4From_19__reduce_cython__, METH_NOARGS, 0}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_6hunter_11_predicates_4From_21__setstate_cython__, METH_O, 0}, - {0, 0, 0, 0} -}; - -static struct PyGetSetDef __pyx_getsets_6hunter_11_predicates_From[] = { - {(char *)"condition", __pyx_getprop_6hunter_11_predicates_4From_condition, 0, (char *)0, 0}, - {(char *)"predicate", __pyx_getprop_6hunter_11_predicates_4From_predicate, 0, (char *)0, 0}, - {(char *)"watermark", __pyx_getprop_6hunter_11_predicates_4From_watermark, 0, (char *)0, 0}, - {(char *)"origin_depth", __pyx_getprop_6hunter_11_predicates_4From_origin_depth, 0, (char *)0, 0}, - {(char *)"origin_calls", __pyx_getprop_6hunter_11_predicates_4From_origin_calls, 0, (char *)0, 0}, - {0, 0, 0, 0, 0} -}; + /* "hunter/_predicates.pyx":669 + * cdef object stack_events + * + * result = fast_call(self.condition, event) # <<<<<<<<<<<<<< + * if result: + * if self.queue: +*/ + __Pyx_TraceLine(669,5,0,__PYX_ERR(0, 669, __pyx_L1_error)) + __pyx_t_1 = __pyx_v_self->condition; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = __pyx_f_6hunter_11_predicates_fast_call(__pyx_t_1, __pyx_v_event); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 669, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_result = __pyx_t_2; + __pyx_t_2 = 0; -static PyNumberMethods __pyx_tp_as_number_From = { - 0, /*nb_add*/ - 0, /*nb_subtract*/ - 0, /*nb_multiply*/ - #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) - 0, /*nb_divide*/ - #endif - 0, /*nb_remainder*/ - 0, /*nb_divmod*/ - 0, /*nb_power*/ - 0, /*nb_negative*/ - 0, /*nb_positive*/ - 0, /*nb_absolute*/ - 0, /*nb_nonzero*/ - __pyx_pw_6hunter_11_predicates_4From_17__invert__, /*nb_invert*/ - 0, /*nb_lshift*/ - 0, /*nb_rshift*/ - __pyx_pw_6hunter_11_predicates_4From_15__and__, /*nb_and*/ - 0, /*nb_xor*/ - __pyx_pw_6hunter_11_predicates_4From_13__or__, /*nb_or*/ - #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) - 0, /*nb_coerce*/ - #endif - 0, /*nb_int*/ - #if PY_MAJOR_VERSION < 3 - 0, /*nb_long*/ - #else - 0, /*reserved*/ - #endif - 0, /*nb_float*/ - #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) - 0, /*nb_oct*/ - #endif - #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) - 0, /*nb_hex*/ - #endif - 0, /*nb_inplace_add*/ - 0, /*nb_inplace_subtract*/ - 0, /*nb_inplace_multiply*/ - #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) - 0, /*nb_inplace_divide*/ - #endif - 0, /*nb_inplace_remainder*/ - 0, /*nb_inplace_power*/ - 0, /*nb_inplace_lshift*/ - 0, /*nb_inplace_rshift*/ - 0, /*nb_inplace_and*/ - 0, /*nb_inplace_xor*/ - 0, /*nb_inplace_or*/ - 0, /*nb_floor_divide*/ - 0, /*nb_true_divide*/ - 0, /*nb_inplace_floor_divide*/ - 0, /*nb_inplace_true_divide*/ - 0, /*nb_index*/ - #if PY_VERSION_HEX >= 0x03050000 - 0, /*nb_matrix_multiply*/ - #endif - #if PY_VERSION_HEX >= 0x03050000 - 0, /*nb_inplace_matrix_multiply*/ - #endif -}; + /* "hunter/_predicates.pyx":670 + * + * result = fast_call(self.condition, event) + * if result: # <<<<<<<<<<<<<< + * if self.queue: + * self.action.cleanup() +*/ + __Pyx_TraceLine(670,8,0,__PYX_ERR(0, 670, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_result); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 670, __pyx_L1_error) + if (__pyx_t_3) { -static PyTypeObject __pyx_type_6hunter_11_predicates_From = { - PyVarObject_HEAD_INIT(0, 0) - "hunter._predicates.From", /*tp_name*/ - sizeof(struct __pyx_obj_6hunter_11_predicates_From), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - __pyx_tp_dealloc_6hunter_11_predicates_From, /*tp_dealloc*/ - #if PY_VERSION_HEX < 0x030800b4 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 - 0, /*tp_vectorcall_offset*/ - #endif - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - __pyx_pw_6hunter_11_predicates_4From_5__repr__, /*tp_repr*/ - &__pyx_tp_as_number_From, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - __pyx_pw_6hunter_11_predicates_4From_9__hash__, /*tp_hash*/ - __pyx_pw_6hunter_11_predicates_4From_11__call__, /*tp_call*/ - __pyx_pw_6hunter_11_predicates_4From_3__str__, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - "\n Keep running ``predicates`` after ``condition(event)`` is ``True``.\n ", /*tp_doc*/ - __pyx_tp_traverse_6hunter_11_predicates_From, /*tp_traverse*/ - __pyx_tp_clear_6hunter_11_predicates_From, /*tp_clear*/ - __pyx_tp_richcompare_6hunter_11_predicates_From, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - __pyx_methods_6hunter_11_predicates_From, /*tp_methods*/ - 0, /*tp_members*/ - __pyx_getsets_6hunter_11_predicates_From, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - __pyx_pw_6hunter_11_predicates_4From_1__init__, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_6hunter_11_predicates_From, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - 0, /*tp_finalize*/ - #endif - #if PY_VERSION_HEX >= 0x030800b1 - 0, /*tp_vectorcall*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 - 0, /*tp_print*/ - #endif -}; + /* "hunter/_predicates.pyx":671 + * result = fast_call(self.condition, event) + * if result: + * if self.queue: # <<<<<<<<<<<<<< + * self.action.cleanup() + * +*/ + __Pyx_TraceLine(671,11,0,__PYX_ERR(0, 671, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_self->queue); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 671, __pyx_L1_error) + if (__pyx_t_3) { -static struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__ *__pyx_freelist_6hunter_11_predicates___pyx_scope_struct____str__[8]; -static int __pyx_freecount_6hunter_11_predicates___pyx_scope_struct____str__ = 0; + /* "hunter/_predicates.pyx":672 + * if result: + * if self.queue: + * self.action.cleanup() # <<<<<<<<<<<<<< + * + * first_event = self.queue[0] +*/ + __Pyx_TraceLine(672,13,0,__PYX_ERR(0, 672, __pyx_L1_error)) + __pyx_t_1 = __pyx_v_self->action; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_cleanup, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 672, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "hunter/_predicates.pyx":674 + * self.action.cleanup() + * + * first_event = self.queue[0] # <<<<<<<<<<<<<< + * first_depth = first_event.depth + * backlog_call_depth = event.depth - first_depth +*/ + __Pyx_TraceLine(674,20,0,__PYX_ERR(0, 674, __pyx_L1_error)) + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_self->queue, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 674, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __pyx_t_2; + __Pyx_INCREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_first_event = ((struct __pyx_obj_6hunter_6_event_Event *)__pyx_t_1); + __pyx_t_1 = 0; -static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct____str__(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { - PyObject *o; - if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6hunter_11_predicates___pyx_scope_struct____str__ > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__)))) { - o = (PyObject*)__pyx_freelist_6hunter_11_predicates___pyx_scope_struct____str__[--__pyx_freecount_6hunter_11_predicates___pyx_scope_struct____str__]; - memset(o, 0, sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__)); - (void) PyObject_INIT(o, t); - PyObject_GC_Track(o); - } else { - o = (*t->tp_alloc)(t, 0); - if (unlikely(!o)) return 0; - } - return o; -} + /* "hunter/_predicates.pyx":675 + * + * first_event = self.queue[0] + * first_depth = first_event.depth # <<<<<<<<<<<<<< + * backlog_call_depth = event.depth - first_depth + * first_is_call = first_event.kind == 'call' # note that True is 1, thus the following math is valid +*/ + __Pyx_TraceLine(675,24,0,__PYX_ERR(0, 675, __pyx_L1_error)) + __pyx_t_5 = __pyx_v_first_event->depth; + __pyx_v_first_depth = __pyx_t_5; + + /* "hunter/_predicates.pyx":676 + * first_event = self.queue[0] + * first_depth = first_event.depth + * backlog_call_depth = event.depth - first_depth # <<<<<<<<<<<<<< + * first_is_call = first_event.kind == 'call' # note that True is 1, thus the following math is valid + * missing_depth = min(first_depth, max(0, self.stack - backlog_call_depth + first_is_call)) +*/ + __Pyx_TraceLine(676,28,0,__PYX_ERR(0, 676, __pyx_L1_error)) + __pyx_v_backlog_call_depth = (__pyx_v_event->depth - __pyx_v_first_depth); + + /* "hunter/_predicates.pyx":677 + * first_depth = first_event.depth + * backlog_call_depth = event.depth - first_depth + * first_is_call = first_event.kind == 'call' # note that True is 1, thus the following math is valid # <<<<<<<<<<<<<< + * missing_depth = min(first_depth, max(0, self.stack - backlog_call_depth + first_is_call)) + * if missing_depth: +*/ + __Pyx_TraceLine(677,32,0,__PYX_ERR(0, 677, __pyx_L1_error)) + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_v_first_event->kind, __pyx_mstate_global->__pyx_n_u_call, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 677, __pyx_L1_error) + __pyx_v_first_is_call = __pyx_t_3; + + /* "hunter/_predicates.pyx":678 + * backlog_call_depth = event.depth - first_depth + * first_is_call = first_event.kind == 'call' # note that True is 1, thus the following math is valid + * missing_depth = min(first_depth, max(0, self.stack - backlog_call_depth + first_is_call)) # <<<<<<<<<<<<<< + * if missing_depth: + * if first_is_call and first_event.frame is not None: +*/ + __Pyx_TraceLine(678,43,0,__PYX_ERR(0, 678, __pyx_L1_error)) + __pyx_t_5 = ((__pyx_v_self->stack - __pyx_v_backlog_call_depth) + __pyx_v_first_is_call); + __pyx_t_6 = 0; + __pyx_t_3 = (__pyx_t_5 > __pyx_t_6); + if (__pyx_t_3) { + __pyx_t_7 = __pyx_t_5; + } else { + __pyx_t_7 = __pyx_t_6; + } + __pyx_t_6 = __pyx_t_7; + __pyx_t_5 = __pyx_v_first_depth; + __pyx_t_3 = (__pyx_t_6 < __pyx_t_5); + if (__pyx_t_3) { + __pyx_t_7 = __pyx_t_6; + } else { + __pyx_t_7 = __pyx_t_5; + } + __pyx_v_missing_depth = __pyx_t_7; + + /* "hunter/_predicates.pyx":679 + * first_is_call = first_event.kind == 'call' # note that True is 1, thus the following math is valid + * missing_depth = min(first_depth, max(0, self.stack - backlog_call_depth + first_is_call)) + * if missing_depth: # <<<<<<<<<<<<<< + * if first_is_call and first_event.frame is not None: + * first_frame = first_event.frame.f_back +*/ + __Pyx_TraceLine(679,46,0,__PYX_ERR(0, 679, __pyx_L1_error)) + __pyx_t_3 = (__pyx_v_missing_depth != 0); + if (__pyx_t_3) { + + /* "hunter/_predicates.pyx":680 + * missing_depth = min(first_depth, max(0, self.stack - backlog_call_depth + first_is_call)) + * if missing_depth: + * if first_is_call and first_event.frame is not None: # <<<<<<<<<<<<<< + * first_frame = first_event.frame.f_back + * else: +*/ + __Pyx_TraceLine(680,48,0,__PYX_ERR(0, 680, __pyx_L1_error)) + if (__pyx_v_first_is_call) { + } else { + __pyx_t_3 = __pyx_v_first_is_call; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_8 = (__pyx_v_first_event->frame != ((FrameType)Py_None)); + __pyx_t_3 = __pyx_t_8; + __pyx_L7_bool_binop_done:; + if (__pyx_t_3) { + + /* "hunter/_predicates.pyx":681 + * if missing_depth: + * if first_is_call and first_event.frame is not None: + * first_frame = first_event.frame.f_back # <<<<<<<<<<<<<< + * else: + * first_frame = first_event.frame +*/ + __Pyx_TraceLine(681,57,0,__PYX_ERR(0, 681, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_first_event->frame), __pyx_mstate_global->__pyx_n_u_f_back); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 681, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_first_frame = ((FrameType)__pyx_t_1); + __pyx_t_1 = 0; + + /* "hunter/_predicates.pyx":680 + * missing_depth = min(first_depth, max(0, self.stack - backlog_call_depth + first_is_call)) + * if missing_depth: + * if first_is_call and first_event.frame is not None: # <<<<<<<<<<<<<< + * first_frame = first_event.frame.f_back + * else: +*/ + goto __pyx_L6; + } -static void __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct____str__(PyObject *o) { - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__ *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__ *)o; - PyObject_GC_UnTrack(o); - Py_CLEAR(p->__pyx_v_self); - if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6hunter_11_predicates___pyx_scope_struct____str__ < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__)))) { - __pyx_freelist_6hunter_11_predicates___pyx_scope_struct____str__[__pyx_freecount_6hunter_11_predicates___pyx_scope_struct____str__++] = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__ *)o); - } else { - (*Py_TYPE(o)->tp_free)(o); - } -} + /* "hunter/_predicates.pyx":683 + * first_frame = first_event.frame.f_back + * else: + * first_frame = first_event.frame # <<<<<<<<<<<<<< + * if first_frame is not None: + * stack_events = deque() # a new deque because self.queue is limited, we can't add while it's full +*/ + __Pyx_TraceLine(683,60,0,__PYX_ERR(0, 683, __pyx_L1_error)) + /*else*/ { + __pyx_t_1 = ((PyObject *)__pyx_v_first_event->frame); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_first_frame = ((FrameType)__pyx_t_1); + __pyx_t_1 = 0; + } + __pyx_L6:; -static int __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct____str__(PyObject *o, visitproc v, void *a) { - int e; - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__ *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__ *)o; - if (p->__pyx_v_self) { - e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e; - } - return 0; -} + /* "hunter/_predicates.pyx":684 + * else: + * first_frame = first_event.frame + * if first_frame is not None: # <<<<<<<<<<<<<< + * stack_events = deque() # a new deque because self.queue is limited, we can't add while it's full + * frame = first_frame +*/ + __Pyx_TraceLine(684,64,0,__PYX_ERR(0, 684, __pyx_L1_error)) + __pyx_t_3 = (__pyx_v_first_frame != ((FrameType)Py_None)); + if (__pyx_t_3) { + + /* "hunter/_predicates.pyx":685 + * first_frame = first_event.frame + * if first_frame is not None: + * stack_events = deque() # a new deque because self.queue is limited, we can't add while it's full # <<<<<<<<<<<<<< + * frame = first_frame + * depth_delta = 0 +*/ + __Pyx_TraceLine(685,67,0,__PYX_ERR(0, 685, __pyx_L1_error)) + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_deque); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 685, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_4 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_9); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_9, __pyx__function); + __pyx_t_4 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 685, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_stack_events = __pyx_t_1; + __pyx_t_1 = 0; + + /* "hunter/_predicates.pyx":686 + * if first_frame is not None: + * stack_events = deque() # a new deque because self.queue is limited, we can't add while it's full + * frame = first_frame # <<<<<<<<<<<<<< + * depth_delta = 0 + * while frame and depth_delta < missing_depth: +*/ + __Pyx_TraceLine(686,69,0,__PYX_ERR(0, 686, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_first_frame); + __pyx_v_frame = __pyx_v_first_frame; + + /* "hunter/_predicates.pyx":687 + * stack_events = deque() # a new deque because self.queue is limited, we can't add while it's full + * frame = first_frame + * depth_delta = 0 # <<<<<<<<<<<<<< + * while frame and depth_delta < missing_depth: + * stack_event = Event( +*/ + __Pyx_TraceLine(687,71,0,__PYX_ERR(0, 687, __pyx_L1_error)) + __pyx_v_depth_delta = 0; + + /* "hunter/_predicates.pyx":688 + * frame = first_frame + * depth_delta = 0 + * while frame and depth_delta < missing_depth: # <<<<<<<<<<<<<< + * stack_event = Event( + * frame=frame, kind=0, arg=None, +*/ + __Pyx_TraceLine(688,72,0,__PYX_ERR(0, 688, __pyx_L1_error)) + while (1) { + __pyx_t_8 = __Pyx_PyObject_IsTrue(((PyObject *)__pyx_v_frame)); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 688, __pyx_L1_error) + if (__pyx_t_8) { + } else { + __pyx_t_3 = __pyx_t_8; + goto __pyx_L12_bool_binop_done; + } + __pyx_t_8 = (__pyx_v_depth_delta < __pyx_v_missing_depth); + __pyx_t_3 = __pyx_t_8; + __pyx_L12_bool_binop_done:; + if (!__pyx_t_3) break; + + /* "hunter/_predicates.pyx":689 + * depth_delta = 0 + * while frame and depth_delta < missing_depth: + * stack_event = Event( # <<<<<<<<<<<<<< + * frame=frame, kind=0, arg=None, + * threading_support=event.threading_support, +*/ + __Pyx_TraceLine(689,80,0,__PYX_ERR(0, 689, __pyx_L1_error)) + __pyx_t_9 = NULL; + __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_6_event_Event); + __pyx_t_2 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_6_event_Event); + + /* "hunter/_predicates.pyx":691 + * stack_event = Event( + * frame=frame, kind=0, arg=None, + * threading_support=event.threading_support, # <<<<<<<<<<<<<< + * depth=first_depth - depth_delta - 1, calls=-1 + * ) +*/ + __Pyx_TraceLine(691,89,0,__PYX_ERR(0, 691, __pyx_L1_error)) + __pyx_t_10 = __Pyx_PyBool_FromLong(__pyx_v_event->threading_support); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 691, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + + /* "hunter/_predicates.pyx":692 + * frame=frame, kind=0, arg=None, + * threading_support=event.threading_support, + * depth=first_depth - depth_delta - 1, calls=-1 # <<<<<<<<<<<<<< + * ) + * if not self.vars: +*/ + __Pyx_TraceLine(692,94,0,__PYX_ERR(0, 692, __pyx_L1_error)) + __pyx_t_11 = __Pyx_PyLong_From_long(((__pyx_v_first_depth - __pyx_v_depth_delta) - 1)); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 692, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_4 = 1; + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 6 : 0)] = {__pyx_t_9, NULL}; + __pyx_t_12 = __Pyx_MakeVectorcallBuilderKwds(6); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 689, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_frame, ((PyObject *)__pyx_v_frame), __pyx_t_12, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 689, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_kind, __pyx_mstate_global->__pyx_int_0, __pyx_t_12, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 689, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_arg, Py_None, __pyx_t_12, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 689, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_threading_support, __pyx_t_10, __pyx_t_12, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 689, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_depth, __pyx_t_11, __pyx_t_12, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 689, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_calls, __pyx_mstate_global->__pyx_int_neg_1, __pyx_t_12, __pyx_callargs+1, 5) < 0) __PYX_ERR(0, 689, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_2, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_12); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 689, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_1); + } + __Pyx_XDECREF_SET(__pyx_v_stack_event, ((struct __pyx_obj_6hunter_6_event_Event *)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "hunter/_predicates.pyx":694 + * depth=first_depth - depth_delta - 1, calls=-1 + * ) + * if not self.vars: # <<<<<<<<<<<<<< + * # noinspection PyPropertyAccess + * stack_event._locals = {} +*/ + __Pyx_TraceLine(694,99,0,__PYX_ERR(0, 694, __pyx_L1_error)) + __pyx_t_3 = (!__pyx_v_self->vars); + if (__pyx_t_3) { + + /* "hunter/_predicates.pyx":696 + * if not self.vars: + * # noinspection PyPropertyAccess + * stack_event._locals = {} # <<<<<<<<<<<<<< + * stack_event._globals = {} + * stack_event.detached = True +*/ + __Pyx_TraceLine(696,104,0,__PYX_ERR(0, 696, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 696, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_stack_event->_locals); + __Pyx_DECREF(__pyx_v_stack_event->_locals); + __pyx_v_stack_event->_locals = __pyx_t_1; + __pyx_t_1 = 0; + + /* "hunter/_predicates.pyx":697 + * # noinspection PyPropertyAccess + * stack_event._locals = {} + * stack_event._globals = {} # <<<<<<<<<<<<<< + * stack_event.detached = True + * stack_events.appendleft(stack_event) +*/ + __Pyx_TraceLine(697,107,0,__PYX_ERR(0, 697, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 697, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_stack_event->_globals); + __Pyx_DECREF(__pyx_v_stack_event->_globals); + __pyx_v_stack_event->_globals = __pyx_t_1; + __pyx_t_1 = 0; + + /* "hunter/_predicates.pyx":698 + * stack_event._locals = {} + * stack_event._globals = {} + * stack_event.detached = True # <<<<<<<<<<<<<< + * stack_events.appendleft(stack_event) + * frame = frame.f_back +*/ + __Pyx_TraceLine(698,108,0,__PYX_ERR(0, 698, __pyx_L1_error)) + __pyx_v_stack_event->detached = 1; + + /* "hunter/_predicates.pyx":694 + * depth=first_depth - depth_delta - 1, calls=-1 + * ) + * if not self.vars: # <<<<<<<<<<<<<< + * # noinspection PyPropertyAccess + * stack_event._locals = {} +*/ + } -static int __pyx_tp_clear_6hunter_11_predicates___pyx_scope_struct____str__(PyObject *o) { - PyObject* tmp; - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__ *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__ *)o; - tmp = ((PyObject*)p->__pyx_v_self); - p->__pyx_v_self = ((struct __pyx_obj_6hunter_11_predicates_Query *)Py_None); Py_INCREF(Py_None); - Py_XDECREF(tmp); - return 0; -} + /* "hunter/_predicates.pyx":699 + * stack_event._globals = {} + * stack_event.detached = True + * stack_events.appendleft(stack_event) # <<<<<<<<<<<<<< + * frame = frame.f_back + * depth_delta += 1 +*/ + __Pyx_TraceLine(699,111,0,__PYX_ERR(0, 699, __pyx_L1_error)) + __pyx_t_2 = __pyx_v_stack_events; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, ((PyObject *)__pyx_v_stack_event)}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_appendleft, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 699, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "hunter/_predicates.pyx":700 + * stack_event.detached = True + * stack_events.appendleft(stack_event) + * frame = frame.f_back # <<<<<<<<<<<<<< + * depth_delta += 1 + * for stack_event in stack_events: +*/ + __Pyx_TraceLine(700,117,0,__PYX_ERR(0, 700, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_frame), __pyx_mstate_global->__pyx_n_u_f_back); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 700, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_frame, ((FrameType)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "hunter/_predicates.pyx":701 + * stack_events.appendleft(stack_event) + * frame = frame.f_back + * depth_delta += 1 # <<<<<<<<<<<<<< + * for stack_event in stack_events: + * if self._filter is None or self._filter(stack_event): +*/ + __Pyx_TraceLine(701,118,0,__PYX_ERR(0, 701, __pyx_L1_error)) + __pyx_v_depth_delta = (__pyx_v_depth_delta + 1); + } -static PyTypeObject __pyx_type_6hunter_11_predicates___pyx_scope_struct____str__ = { - PyVarObject_HEAD_INIT(0, 0) - "hunter._predicates.__pyx_scope_struct____str__", /*tp_name*/ - sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct____str__, /*tp_dealloc*/ - #if PY_VERSION_HEX < 0x030800b4 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 - 0, /*tp_vectorcall_offset*/ - #endif - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - 0, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - 0, /*tp_doc*/ - __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct____str__, /*tp_traverse*/ - __pyx_tp_clear_6hunter_11_predicates___pyx_scope_struct____str__, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - 0, /*tp_methods*/ - 0, /*tp_members*/ - 0, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - 0, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_6hunter_11_predicates___pyx_scope_struct____str__, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - 0, /*tp_finalize*/ - #endif - #if PY_VERSION_HEX >= 0x030800b1 - 0, /*tp_vectorcall*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 - 0, /*tp_print*/ - #endif -}; + /* "hunter/_predicates.pyx":702 + * frame = frame.f_back + * depth_delta += 1 + * for stack_event in stack_events: # <<<<<<<<<<<<<< + * if self._filter is None or self._filter(stack_event): + * self.action(stack_event) +*/ + __Pyx_TraceLine(702,122,0,__PYX_ERR(0, 702, __pyx_L1_error)) + if (likely(PyList_CheckExact(__pyx_v_stack_events)) || PyTuple_CheckExact(__pyx_v_stack_events)) { + __pyx_t_1 = __pyx_v_stack_events; __Pyx_INCREF(__pyx_t_1); + __pyx_t_13 = 0; + __pyx_t_14 = NULL; + } else { + __pyx_t_13 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_stack_events); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 702, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_14 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 702, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_14)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 702, __pyx_L1_error) + #endif + if (__pyx_t_13 >= __pyx_temp) break; + } + __pyx_t_2 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_13); + ++__pyx_t_13; + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 702, __pyx_L1_error) + #endif + if (__pyx_t_13 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_13)); + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_13); + #endif + ++__pyx_t_13; + } + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 702, __pyx_L1_error) + } else { + __pyx_t_2 = __pyx_t_14(__pyx_t_1); + if (unlikely(!__pyx_t_2)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 702, __pyx_L1_error) + PyErr_Clear(); + } + break; + } + } + __Pyx_GOTREF(__pyx_t_2); + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_mstate_global->__pyx_ptype_6hunter_6_event_Event))))) __PYX_ERR(0, 702, __pyx_L1_error) + __Pyx_XDECREF_SET(__pyx_v_stack_event, ((struct __pyx_obj_6hunter_6_event_Event *)__pyx_t_2)); + __pyx_t_2 = 0; + __Pyx_TraceLine(702,120,0,__PYX_ERR(0, 702, __pyx_L1_error)) + + /* "hunter/_predicates.pyx":703 + * depth_delta += 1 + * for stack_event in stack_events: + * if self._filter is None or self._filter(stack_event): # <<<<<<<<<<<<<< + * self.action(stack_event) + * for backlog_event in self.queue: +*/ + __Pyx_TraceLine(703,127,0,__PYX_ERR(0, 703, __pyx_L1_error)) + __pyx_t_8 = (__pyx_v_self->_filter == Py_None); + if (!__pyx_t_8) { + } else { + __pyx_t_3 = __pyx_t_8; + goto __pyx_L18_bool_binop_done; + } + __pyx_t_12 = NULL; + __Pyx_INCREF(__pyx_v_self->_filter); + __pyx_t_11 = __pyx_v_self->_filter; + __pyx_t_4 = 1; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_11))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_11); + assert(__pyx_t_12); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_11); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_11, __pyx__function); + __pyx_t_4 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, ((PyObject *)__pyx_v_stack_event)}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_11, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 703, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 703, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __pyx_t_8; + __pyx_L18_bool_binop_done:; + if (__pyx_t_3) { + + /* "hunter/_predicates.pyx":704 + * for stack_event in stack_events: + * if self._filter is None or self._filter(stack_event): + * self.action(stack_event) # <<<<<<<<<<<<<< + * for backlog_event in self.queue: + * if self._filter is None: +*/ + __Pyx_TraceLine(704,135,0,__PYX_ERR(0, 704, __pyx_L1_error)) + __pyx_t_11 = NULL; + __Pyx_INCREF(__pyx_v_self->action); + __pyx_t_12 = __pyx_v_self->action; + __pyx_t_4 = 1; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_12))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_12); + assert(__pyx_t_11); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_12); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_12, __pyx__function); + __pyx_t_4 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_11, ((PyObject *)__pyx_v_stack_event)}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_12, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 704, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "hunter/_predicates.pyx":703 + * depth_delta += 1 + * for stack_event in stack_events: + * if self._filter is None or self._filter(stack_event): # <<<<<<<<<<<<<< + * self.action(stack_event) + * for backlog_event in self.queue: +*/ + } -static struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr *__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_1_genexpr[8]; -static int __pyx_freecount_6hunter_11_predicates___pyx_scope_struct_1_genexpr = 0; + /* "hunter/_predicates.pyx":702 + * frame = frame.f_back + * depth_delta += 1 + * for stack_event in stack_events: # <<<<<<<<<<<<<< + * if self._filter is None or self._filter(stack_event): + * self.action(stack_event) +*/ + __Pyx_TraceLine(702,120,0,__PYX_ERR(0, 702, __pyx_L1_error)) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; -static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_1_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { - PyObject *o; - if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_1_genexpr > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr)))) { - o = (PyObject*)__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_1_genexpr[--__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_1_genexpr]; - memset(o, 0, sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr)); - (void) PyObject_INIT(o, t); - PyObject_GC_Track(o); - } else { - o = (*t->tp_alloc)(t, 0); - if (unlikely(!o)) return 0; - } - return o; -} + /* "hunter/_predicates.pyx":684 + * else: + * first_frame = first_event.frame + * if first_frame is not None: # <<<<<<<<<<<<<< + * stack_events = deque() # a new deque because self.queue is limited, we can't add while it's full + * frame = first_frame +*/ + } -static void __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_1_genexpr(PyObject *o) { - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr *)o; - PyObject_GC_UnTrack(o); - Py_CLEAR(p->__pyx_outer_scope); - Py_CLEAR(p->__pyx_v_genexpr); - Py_CLEAR(p->__pyx_v_kind); - Py_CLEAR(p->__pyx_v_mapping); - Py_CLEAR(p->__pyx_t_0); - if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_1_genexpr < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr)))) { - __pyx_freelist_6hunter_11_predicates___pyx_scope_struct_1_genexpr[__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_1_genexpr++] = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr *)o); - } else { - (*Py_TYPE(o)->tp_free)(o); - } -} + /* "hunter/_predicates.pyx":679 + * first_is_call = first_event.kind == 'call' # note that True is 1, thus the following math is valid + * missing_depth = min(first_depth, max(0, self.stack - backlog_call_depth + first_is_call)) + * if missing_depth: # <<<<<<<<<<<<<< + * if first_is_call and first_event.frame is not None: + * first_frame = first_event.frame.f_back +*/ + } -static int __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_1_genexpr(PyObject *o, visitproc v, void *a) { - int e; - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr *)o; - if (p->__pyx_outer_scope) { - e = (*v)(((PyObject *)p->__pyx_outer_scope), a); if (e) return e; - } - if (p->__pyx_v_genexpr) { - e = (*v)(p->__pyx_v_genexpr, a); if (e) return e; - } - if (p->__pyx_v_kind) { - e = (*v)(p->__pyx_v_kind, a); if (e) return e; - } - if (p->__pyx_v_mapping) { - e = (*v)(p->__pyx_v_mapping, a); if (e) return e; - } - if (p->__pyx_t_0) { - e = (*v)(p->__pyx_t_0, a); if (e) return e; - } - return 0; -} + /* "hunter/_predicates.pyx":705 + * if self._filter is None or self._filter(stack_event): + * self.action(stack_event) + * for backlog_event in self.queue: # <<<<<<<<<<<<<< + * if self._filter is None: + * self.action(backlog_event) +*/ + __Pyx_TraceLine(705,139,0,__PYX_ERR(0, 705, __pyx_L1_error)) + if (likely(PyList_CheckExact(__pyx_v_self->queue)) || PyTuple_CheckExact(__pyx_v_self->queue)) { + __pyx_t_1 = __pyx_v_self->queue; __Pyx_INCREF(__pyx_t_1); + __pyx_t_13 = 0; + __pyx_t_14 = NULL; + } else { + __pyx_t_13 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_self->queue); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 705, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_14 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 705, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_14)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 705, __pyx_L1_error) + #endif + if (__pyx_t_13 >= __pyx_temp) break; + } + __pyx_t_2 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_13); + ++__pyx_t_13; + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 705, __pyx_L1_error) + #endif + if (__pyx_t_13 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_13)); + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_13); + #endif + ++__pyx_t_13; + } + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 705, __pyx_L1_error) + } else { + __pyx_t_2 = __pyx_t_14(__pyx_t_1); + if (unlikely(!__pyx_t_2)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 705, __pyx_L1_error) + PyErr_Clear(); + } + break; + } + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_backlog_event, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_TraceLine(705,137,0,__PYX_ERR(0, 705, __pyx_L1_error)) + + /* "hunter/_predicates.pyx":706 + * self.action(stack_event) + * for backlog_event in self.queue: + * if self._filter is None: # <<<<<<<<<<<<<< + * self.action(backlog_event) + * elif fast_call(self._filter, backlog_event): +*/ + __Pyx_TraceLine(706,145,0,__PYX_ERR(0, 706, __pyx_L1_error)) + __pyx_t_3 = (__pyx_v_self->_filter == Py_None); + if (__pyx_t_3) { + + /* "hunter/_predicates.pyx":707 + * for backlog_event in self.queue: + * if self._filter is None: + * self.action(backlog_event) # <<<<<<<<<<<<<< + * elif fast_call(self._filter, backlog_event): + * self.action(backlog_event) +*/ + __Pyx_TraceLine(707,148,0,__PYX_ERR(0, 707, __pyx_L1_error)) + __pyx_t_12 = NULL; + __Pyx_INCREF(__pyx_v_self->action); + __pyx_t_11 = __pyx_v_self->action; + __pyx_t_4 = 1; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_11))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_11); + assert(__pyx_t_12); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_11); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_11, __pyx__function); + __pyx_t_4 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_v_backlog_event}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_11, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 707, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "hunter/_predicates.pyx":706 + * self.action(stack_event) + * for backlog_event in self.queue: + * if self._filter is None: # <<<<<<<<<<<<<< + * self.action(backlog_event) + * elif fast_call(self._filter, backlog_event): +*/ + goto __pyx_L23; + } -static PyTypeObject __pyx_type_6hunter_11_predicates___pyx_scope_struct_1_genexpr = { - PyVarObject_HEAD_INIT(0, 0) - "hunter._predicates.__pyx_scope_struct_1_genexpr", /*tp_name*/ - sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_1_genexpr, /*tp_dealloc*/ - #if PY_VERSION_HEX < 0x030800b4 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 - 0, /*tp_vectorcall_offset*/ - #endif - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - 0, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - 0, /*tp_doc*/ - __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_1_genexpr, /*tp_traverse*/ - 0, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - 0, /*tp_methods*/ - 0, /*tp_members*/ - 0, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - 0, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_1_genexpr, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - 0, /*tp_finalize*/ - #endif - #if PY_VERSION_HEX >= 0x030800b1 - 0, /*tp_vectorcall*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 - 0, /*tp_print*/ - #endif -}; + /* "hunter/_predicates.pyx":708 + * if self._filter is None: + * self.action(backlog_event) + * elif fast_call(self._filter, backlog_event): # <<<<<<<<<<<<<< + * self.action(backlog_event) + * self.queue.clear() +*/ + __Pyx_TraceLine(708,153,0,__PYX_ERR(0, 708, __pyx_L1_error)) + __pyx_t_2 = __pyx_v_self->_filter; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_11 = __pyx_f_6hunter_11_predicates_fast_call(__pyx_t_2, ((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_backlog_event)); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 708, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_11); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 708, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + if (__pyx_t_3) { + + /* "hunter/_predicates.pyx":709 + * self.action(backlog_event) + * elif fast_call(self._filter, backlog_event): + * self.action(backlog_event) # <<<<<<<<<<<<<< + * self.queue.clear() + * else: +*/ + __Pyx_TraceLine(709,158,0,__PYX_ERR(0, 709, __pyx_L1_error)) + __pyx_t_2 = NULL; + __Pyx_INCREF(__pyx_v_self->action); + __pyx_t_12 = __pyx_v_self->action; + __pyx_t_4 = 1; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_12))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_12); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_12); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_12, __pyx__function); + __pyx_t_4 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_backlog_event}; + __pyx_t_11 = __Pyx_PyObject_FastCall(__pyx_t_12, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 709, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + } + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + + /* "hunter/_predicates.pyx":708 + * if self._filter is None: + * self.action(backlog_event) + * elif fast_call(self._filter, backlog_event): # <<<<<<<<<<<<<< + * self.action(backlog_event) + * self.queue.clear() +*/ + } + __pyx_L23:; + + /* "hunter/_predicates.pyx":705 + * if self._filter is None or self._filter(stack_event): + * self.action(stack_event) + * for backlog_event in self.queue: # <<<<<<<<<<<<<< + * if self._filter is None: + * self.action(backlog_event) +*/ + __Pyx_TraceLine(705,137,0,__PYX_ERR(0, 705, __pyx_L1_error)) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "hunter/_predicates.pyx":710 + * elif fast_call(self._filter, backlog_event): + * self.action(backlog_event) + * self.queue.clear() # <<<<<<<<<<<<<< + * else: + * if self.strip and event.depth < 1: +*/ + __Pyx_TraceLine(710,161,0,__PYX_ERR(0, 710, __pyx_L1_error)) + __pyx_t_11 = __pyx_v_self->queue; + __Pyx_INCREF(__pyx_t_11); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_11, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_clear, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 710, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; -static struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr *__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_2_genexpr[8]; -static int __pyx_freecount_6hunter_11_predicates___pyx_scope_struct_2_genexpr = 0; + /* "hunter/_predicates.pyx":671 + * result = fast_call(self.condition, event) + * if result: + * if self.queue: # <<<<<<<<<<<<<< + * self.action.cleanup() + * +*/ + } -static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_2_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { - PyObject *o; - if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_2_genexpr > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr)))) { - o = (PyObject*)__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_2_genexpr[--__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_2_genexpr]; - memset(o, 0, sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr)); - (void) PyObject_INIT(o, t); - PyObject_GC_Track(o); - } else { - o = (*t->tp_alloc)(t, 0); - if (unlikely(!o)) return 0; + /* "hunter/_predicates.pyx":670 + * + * result = fast_call(self.condition, event) + * if result: # <<<<<<<<<<<<<< + * if self.queue: + * self.action.cleanup() +*/ + goto __pyx_L3; } - return o; -} -static void __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_2_genexpr(PyObject *o) { - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr *)o; - PyObject_GC_UnTrack(o); - Py_CLEAR(p->__pyx_outer_scope); - Py_CLEAR(p->__pyx_v_key); - Py_CLEAR(p->__pyx_v_value); - Py_CLEAR(p->__pyx_t_0); - if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_2_genexpr < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr)))) { - __pyx_freelist_6hunter_11_predicates___pyx_scope_struct_2_genexpr[__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_2_genexpr++] = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr *)o); - } else { - (*Py_TYPE(o)->tp_free)(o); - } -} + /* "hunter/_predicates.pyx":712 + * self.queue.clear() + * else: + * if self.strip and event.depth < 1: # <<<<<<<<<<<<<< + * # Looks like we're back to depth 0 for some reason. + * # Delete everything because we don't want to see what is likely just a long stream of useless returns. +*/ + __Pyx_TraceLine(712,164,0,__PYX_ERR(0, 712, __pyx_L1_error)) + /*else*/ { + if (__pyx_v_self->strip) { + } else { + __pyx_t_3 = __pyx_v_self->strip; + goto __pyx_L26_bool_binop_done; + } + __pyx_t_8 = (__pyx_v_event->depth < 1); + __pyx_t_3 = __pyx_t_8; + __pyx_L26_bool_binop_done:; + if (__pyx_t_3) { + + /* "hunter/_predicates.pyx":715 + * # Looks like we're back to depth 0 for some reason. + * # Delete everything because we don't want to see what is likely just a long stream of useless returns. + * self.queue.clear() # <<<<<<<<<<<<<< + * if self._filter is None or self._filter(event): + * detached_event = fast_detach(event, self._try_repr) +*/ + __Pyx_TraceLine(715,173,0,__PYX_ERR(0, 715, __pyx_L1_error)) + __pyx_t_11 = __pyx_v_self->queue; + __Pyx_INCREF(__pyx_t_11); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_11, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_clear, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 715, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; -static int __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_2_genexpr(PyObject *o, visitproc v, void *a) { - int e; - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr *)o; - if (p->__pyx_outer_scope) { - e = (*v)(((PyObject *)p->__pyx_outer_scope), a); if (e) return e; - } - if (p->__pyx_v_key) { - e = (*v)(p->__pyx_v_key, a); if (e) return e; - } - if (p->__pyx_v_value) { - e = (*v)(p->__pyx_v_value, a); if (e) return e; - } - if (p->__pyx_t_0) { - e = (*v)(p->__pyx_t_0, a); if (e) return e; + /* "hunter/_predicates.pyx":712 + * self.queue.clear() + * else: + * if self.strip and event.depth < 1: # <<<<<<<<<<<<<< + * # Looks like we're back to depth 0 for some reason. + * # Delete everything because we don't want to see what is likely just a long stream of useless returns. +*/ + } + + /* "hunter/_predicates.pyx":716 + * # Delete everything because we don't want to see what is likely just a long stream of useless returns. + * self.queue.clear() + * if self._filter is None or self._filter(event): # <<<<<<<<<<<<<< + * detached_event = fast_detach(event, self._try_repr) + * detached_event.frame = event.frame +*/ + __Pyx_TraceLine(716,180,0,__PYX_ERR(0, 716, __pyx_L1_error)) + __pyx_t_8 = (__pyx_v_self->_filter == Py_None); + if (!__pyx_t_8) { + } else { + __pyx_t_3 = __pyx_t_8; + goto __pyx_L29_bool_binop_done; + } + __pyx_t_11 = NULL; + __Pyx_INCREF(__pyx_v_self->_filter); + __pyx_t_12 = __pyx_v_self->_filter; + __pyx_t_4 = 1; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_12))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_12); + assert(__pyx_t_11); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_12); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_12, __pyx__function); + __pyx_t_4 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_11, ((PyObject *)__pyx_v_event)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_12, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 716, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 716, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __pyx_t_8; + __pyx_L29_bool_binop_done:; + if (__pyx_t_3) { + + /* "hunter/_predicates.pyx":717 + * self.queue.clear() + * if self._filter is None or self._filter(event): + * detached_event = fast_detach(event, self._try_repr) # <<<<<<<<<<<<<< + * detached_event.frame = event.frame + * self.queue.append(detached_event) +*/ + __Pyx_TraceLine(717,191,0,__PYX_ERR(0, 717, __pyx_L1_error)) + __pyx_t_1 = __pyx_v_self->_try_repr; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_12 = ((PyObject *)__pyx_f_6hunter_6_event_fast_detach(__pyx_v_event, __pyx_t_1)); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 717, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_detached_event = ((struct __pyx_obj_6hunter_6_event_Event *)__pyx_t_12); + __pyx_t_12 = 0; + + /* "hunter/_predicates.pyx":718 + * if self._filter is None or self._filter(event): + * detached_event = fast_detach(event, self._try_repr) + * detached_event.frame = event.frame # <<<<<<<<<<<<<< + * self.queue.append(detached_event) + * +*/ + __Pyx_TraceLine(718,195,0,__PYX_ERR(0, 718, __pyx_L1_error)) + __pyx_t_12 = ((PyObject *)__pyx_v_event->frame); + __Pyx_INCREF(__pyx_t_12); + __Pyx_GIVEREF(__pyx_t_12); + __Pyx_GOTREF(__pyx_v_detached_event->frame); + __Pyx_DECREF(__pyx_v_detached_event->frame); + __pyx_v_detached_event->frame = ((FrameType)__pyx_t_12); + __pyx_t_12 = 0; + + /* "hunter/_predicates.pyx":719 + * detached_event = fast_detach(event, self._try_repr) + * detached_event.frame = event.frame + * self.queue.append(detached_event) # <<<<<<<<<<<<<< + * + * return result +*/ + __Pyx_TraceLine(719,199,0,__PYX_ERR(0, 719, __pyx_L1_error)) + __pyx_t_15 = __Pyx_PyObject_Append(__pyx_v_self->queue, ((PyObject *)__pyx_v_detached_event)); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(0, 719, __pyx_L1_error) + + /* "hunter/_predicates.pyx":716 + * # Delete everything because we don't want to see what is likely just a long stream of useless returns. + * self.queue.clear() + * if self._filter is None or self._filter(event): # <<<<<<<<<<<<<< + * detached_event = fast_detach(event, self._try_repr) + * detached_event.frame = event.frame +*/ + } } - return 0; -} + __pyx_L3:; -static PyTypeObject __pyx_type_6hunter_11_predicates___pyx_scope_struct_2_genexpr = { - PyVarObject_HEAD_INIT(0, 0) - "hunter._predicates.__pyx_scope_struct_2_genexpr", /*tp_name*/ - sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_2_genexpr, /*tp_dealloc*/ - #if PY_VERSION_HEX < 0x030800b4 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 - 0, /*tp_vectorcall_offset*/ + /* "hunter/_predicates.pyx":721 + * self.queue.append(detached_event) + * + * return result # <<<<<<<<<<<<<< +*/ + __Pyx_TraceLine(721,201,0,__PYX_ERR(0, 721, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + __Pyx_TraceReturnValue(__pyx_r, 201, 0, __PYX_ERR(0, 721, __pyx_L1_error)); + goto __pyx_L0; + + /* "hunter/_predicates.pyx":655 + * ) + * + * cdef inline fast_Backlog_call(Backlog self, Event event): # <<<<<<<<<<<<<< + * cdef bint first_is_call + * cdef Event detached_event +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 655, __pyx_L1_error)); #endif - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ + __Pyx_AddTraceback("hunter._predicates.fast_Backlog_call", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_detached_event); + __Pyx_XDECREF((PyObject *)__pyx_v_first_event); + __Pyx_XDECREF((PyObject *)__pyx_v_stack_event); + __Pyx_XDECREF(__pyx_v_first_frame); + __Pyx_XDECREF(__pyx_v_frame); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_stack_events); + __Pyx_XDECREF(__pyx_v_backlog_event); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_Query(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_1__pyx_unpickle_Query(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_11_predicates_1__pyx_unpickle_Query = {"__pyx_unpickle_Query", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_1__pyx_unpickle_Query, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_11_predicates_1__pyx_unpickle_Query(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_Query (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ #endif - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - 0, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - 0, /*tp_doc*/ - __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_2_genexpr, /*tp_traverse*/ - 0, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - 0, /*tp_methods*/ - 0, /*tp_members*/ - 0, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - 0, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_2_genexpr, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - 0, /*tp_finalize*/ - #endif - #if PY_VERSION_HEX >= 0x030800b1 - 0, /*tp_vectorcall*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 - 0, /*tp_print*/ - #endif -}; - -static struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3___repr__ *__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_3___repr__[8]; -static int __pyx_freecount_6hunter_11_predicates___pyx_scope_struct_3___repr__ = 0; - -static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_3___repr__(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { - PyObject *o; - if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_3___repr__ > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3___repr__)))) { - o = (PyObject*)__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_3___repr__[--__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_3___repr__]; - memset(o, 0, sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3___repr__)); - (void) PyObject_INIT(o, t); - PyObject_GC_Track(o); - } else { - o = (*t->tp_alloc)(t, 0); - if (unlikely(!o)) return 0; + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_type,&__pyx_mstate_global->__pyx_n_u_pyx_checksum,&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 1, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 1, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 1, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 1, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__pyx_unpickle_Query", 0) < 0) __PYX_ERR(1, 1, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Query", 1, 3, 3, i); __PYX_ERR(1, 1, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 1, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 1, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 1, __pyx_L3_error) + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyLong_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; } - return o; -} - -static void __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_3___repr__(PyObject *o) { - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3___repr__ *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3___repr__ *)o; - PyObject_GC_UnTrack(o); - Py_CLEAR(p->__pyx_v_self); - if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_3___repr__ < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3___repr__)))) { - __pyx_freelist_6hunter_11_predicates___pyx_scope_struct_3___repr__[__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_3___repr__++] = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3___repr__ *)o); - } else { - (*Py_TYPE(o)->tp_free)(o); + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Query", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } -} + __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_Query", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6hunter_11_predicates___pyx_unpickle_Query(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); -static int __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_3___repr__(PyObject *o, visitproc v, void *a) { - int e; - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3___repr__ *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3___repr__ *)o; - if (p->__pyx_v_self) { - e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e; + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - return 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -static int __pyx_tp_clear_6hunter_11_predicates___pyx_scope_struct_3___repr__(PyObject *o) { - PyObject* tmp; - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3___repr__ *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3___repr__ *)o; - tmp = ((PyObject*)p->__pyx_v_self); - p->__pyx_v_self = ((struct __pyx_obj_6hunter_11_predicates_Query *)Py_None); Py_INCREF(Py_None); - Py_XDECREF(tmp); - return 0; -} +static PyObject *__pyx_pf_6hunter_11_predicates___pyx_unpickle_Query(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[137])) + __Pyx_RefNannySetupContext("__pyx_unpickle_Query", 0); + __Pyx_TraceStartFunc("__pyx_unpickle_Query", __pyx_f[1], 1, 0, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); -static PyTypeObject __pyx_type_6hunter_11_predicates___pyx_scope_struct_3___repr__ = { - PyVarObject_HEAD_INIT(0, 0) - "hunter._predicates.__pyx_scope_struct_3___repr__", /*tp_name*/ - sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3___repr__), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_3___repr__, /*tp_dealloc*/ - #if PY_VERSION_HEX < 0x030800b4 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 - 0, /*tp_vectorcall_offset*/ - #endif - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - 0, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - 0, /*tp_doc*/ - __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_3___repr__, /*tp_traverse*/ - __pyx_tp_clear_6hunter_11_predicates___pyx_scope_struct_3___repr__, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - 0, /*tp_methods*/ - 0, /*tp_members*/ - 0, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - 0, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_3___repr__, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - 0, /*tp_finalize*/ - #endif - #if PY_VERSION_HEX >= 0x030800b1 - 0, /*tp_vectorcall*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 - 0, /*tp_print*/ - #endif -}; + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x5503a44, 0x9ea0a45, 0x4eca0a2): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x5503a44, 0x9ea0a45, 0x4eca0a2) = (query_contains, query_endswith, query_eq, query_gt, query_gte, query_in, query_lt, query_lte, query_regex, query_startswith))" % __pyx_checksum +*/ + __Pyx_TraceLine(4,2,0,__PYX_ERR(1, 4, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyLong_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_mstate_global->__pyx_tuple[0], Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { -static struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr *__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_4_genexpr[8]; -static int __pyx_freecount_6hunter_11_predicates___pyx_scope_struct_4_genexpr = 0; + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0x5503a44, 0x9ea0a45, 0x4eca0a2): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x5503a44, 0x9ea0a45, 0x4eca0a2) = (query_contains, query_endswith, query_eq, query_gt, query_gte, query_in, query_lt, query_lte, query_regex, query_startswith))" % __pyx_checksum + * __pyx_result = Query.__new__(__pyx_type) +*/ + __Pyx_TraceLine(5,9,0,__PYX_ERR(1, 5, __pyx_L1_error)) + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_PickleError); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_mstate_global->__pyx_n_u_PickleError) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; -static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_4_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { - PyObject *o; - if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_4_genexpr > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr)))) { - o = (PyObject*)__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_4_genexpr[--__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_4_genexpr]; - memset(o, 0, sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr)); - (void) PyObject_INIT(o, t); - PyObject_GC_Track(o); - } else { - o = (*t->tp_alloc)(t, 0); - if (unlikely(!o)) return 0; - } - return o; -} + /* "(tree fragment)":6 + * if __pyx_checksum not in (0x5503a44, 0x9ea0a45, 0x4eca0a2): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x5503a44, 0x9ea0a45, 0x4eca0a2) = (query_contains, query_endswith, query_eq, query_gt, query_gte, query_in, query_lt, query_lte, query_regex, query_startswith))" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = Query.__new__(__pyx_type) + * if __pyx_state is not None: +*/ + __Pyx_TraceLine(6,14,0,__PYX_ERR(1, 6, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyLong_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyUnicode_Format(__pyx_mstate_global->__pyx_kp_u_Incompatible_checksums_0x_x_vs_0, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 6, __pyx_L1_error) -static void __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_4_genexpr(PyObject *o) { - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr *)o; - PyObject_GC_UnTrack(o); - Py_CLEAR(p->__pyx_outer_scope); - Py_CLEAR(p->__pyx_v_fmt); - Py_CLEAR(p->__pyx_v_mapping); - Py_CLEAR(p->__pyx_t_0); - if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_4_genexpr < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr)))) { - __pyx_freelist_6hunter_11_predicates___pyx_scope_struct_4_genexpr[__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_4_genexpr++] = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr *)o); - } else { - (*Py_TYPE(o)->tp_free)(o); + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x5503a44, 0x9ea0a45, 0x4eca0a2): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x5503a44, 0x9ea0a45, 0x4eca0a2) = (query_contains, query_endswith, query_eq, query_gt, query_gte, query_in, query_lt, query_lte, query_regex, query_startswith))" % __pyx_checksum +*/ } -} -static int __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_4_genexpr(PyObject *o, visitproc v, void *a) { - int e; - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr *)o; - if (p->__pyx_outer_scope) { - e = (*v)(((PyObject *)p->__pyx_outer_scope), a); if (e) return e; - } - if (p->__pyx_v_fmt) { - e = (*v)(p->__pyx_v_fmt, a); if (e) return e; - } - if (p->__pyx_v_mapping) { - e = (*v)(p->__pyx_v_mapping, a); if (e) return e; + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x5503a44, 0x9ea0a45, 0x4eca0a2) = (query_contains, query_endswith, query_eq, query_gt, query_gte, query_in, query_lt, query_lte, query_regex, query_startswith))" % __pyx_checksum + * __pyx_result = Query.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_Query__set_state( __pyx_result, __pyx_state) +*/ + __Pyx_TraceLine(7,16,0,__PYX_ERR(1, 7, __pyx_L1_error)) + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Query); + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_new, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); } - if (p->__pyx_t_0) { - e = (*v)(p->__pyx_t_0, a); if (e) return e; + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x5503a44, 0x9ea0a45, 0x4eca0a2) = (query_contains, query_endswith, query_eq, query_gt, query_gte, query_in, query_lt, query_lte, query_regex, query_startswith))" % __pyx_checksum + * __pyx_result = Query.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Query__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + __Pyx_TraceLine(8,23,0,__PYX_ERR(1, 8, __pyx_L1_error)) + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = Query.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_Query__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_Query__set_state(Query __pyx_result, tuple __pyx_state): +*/ + __Pyx_TraceLine(9,28,0,__PYX_ERR(1, 9, __pyx_L1_error)) + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_6hunter_11_predicates___pyx_unpickle_Query__set_state(((struct __pyx_obj_6hunter_11_predicates_Query *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x5503a44, 0x9ea0a45, 0x4eca0a2) = (query_contains, query_endswith, query_eq, query_gt, query_gte, query_in, query_lt, query_lte, query_regex, query_startswith))" % __pyx_checksum + * __pyx_result = Query.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Query__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ } - return 0; -} -static PyTypeObject __pyx_type_6hunter_11_predicates___pyx_scope_struct_4_genexpr = { - PyVarObject_HEAD_INIT(0, 0) - "hunter._predicates.__pyx_scope_struct_4_genexpr", /*tp_name*/ - sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_4_genexpr, /*tp_dealloc*/ - #if PY_VERSION_HEX < 0x030800b4 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 - 0, /*tp_vectorcall_offset*/ - #endif - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - 0, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - 0, /*tp_doc*/ - __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_4_genexpr, /*tp_traverse*/ - 0, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - 0, /*tp_methods*/ - 0, /*tp_members*/ - 0, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - 0, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_4_genexpr, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - 0, /*tp_finalize*/ - #endif - #if PY_VERSION_HEX >= 0x030800b1 - 0, /*tp_vectorcall*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 - 0, /*tp_print*/ - #endif -}; - -static struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5___init__ *__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_5___init__[8]; -static int __pyx_freecount_6hunter_11_predicates___pyx_scope_struct_5___init__ = 0; - -static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_5___init__(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { - PyObject *o; - if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_5___init__ > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5___init__)))) { - o = (PyObject*)__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_5___init__[--__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_5___init__]; - memset(o, 0, sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5___init__)); - (void) PyObject_INIT(o, t); - PyObject_GC_Track(o); - } else { - o = (*t->tp_alloc)(t, 0); - if (unlikely(!o)) return 0; - } - return o; -} - -static void __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_5___init__(PyObject *o) { - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5___init__ *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5___init__ *)o; - PyObject_GC_UnTrack(o); - Py_CLEAR(p->__pyx_v_actions); - if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_5___init__ < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5___init__)))) { - __pyx_freelist_6hunter_11_predicates___pyx_scope_struct_5___init__[__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_5___init__++] = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5___init__ *)o); - } else { - (*Py_TYPE(o)->tp_free)(o); - } -} + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_Query__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_Query__set_state(Query __pyx_result, tuple __pyx_state): + * __pyx_result.query_contains = __pyx_state[0]; __pyx_result.query_endswith = __pyx_state[1]; __pyx_result.query_eq = __pyx_state[2]; __pyx_result.query_gt = __pyx_state[3]; __pyx_result.query_gte = __pyx_state[4]; __pyx_result.query_in = __pyx_state[5]; __pyx_result.query_lt = __pyx_state[6]; __pyx_result.query_lte = __pyx_state[7]; __pyx_result.query_regex = __pyx_state[8]; __pyx_result.query_startswith = __pyx_state[9] +*/ + __Pyx_TraceLine(10,29,0,__PYX_ERR(1, 10, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + __Pyx_TraceReturnValue(__pyx_r, 29, 0, __PYX_ERR(1, 10, __pyx_L1_error)); + goto __pyx_L0; -static int __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_5___init__(PyObject *o, visitproc v, void *a) { - int e; - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5___init__ *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5___init__ *)o; - if (p->__pyx_v_actions) { - e = (*v)(p->__pyx_v_actions, a); if (e) return e; - } - return 0; -} + /* "(tree fragment)":1 + * def __pyx_unpickle_Query(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result +*/ -static int __pyx_tp_clear_6hunter_11_predicates___pyx_scope_struct_5___init__(PyObject *o) { - PyObject* tmp; - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5___init__ *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5___init__ *)o; - tmp = ((PyObject*)p->__pyx_v_actions); - p->__pyx_v_actions = ((PyObject*)Py_None); Py_INCREF(Py_None); - Py_XDECREF(tmp); - return 0; + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_Query", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -static PyTypeObject __pyx_type_6hunter_11_predicates___pyx_scope_struct_5___init__ = { - PyVarObject_HEAD_INIT(0, 0) - "hunter._predicates.__pyx_scope_struct_5___init__", /*tp_name*/ - sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5___init__), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_5___init__, /*tp_dealloc*/ - #if PY_VERSION_HEX < 0x030800b4 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 - 0, /*tp_vectorcall_offset*/ - #endif - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - 0, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - 0, /*tp_doc*/ - __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_5___init__, /*tp_traverse*/ - __pyx_tp_clear_6hunter_11_predicates___pyx_scope_struct_5___init__, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - 0, /*tp_methods*/ - 0, /*tp_members*/ - 0, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - 0, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_5___init__, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - 0, /*tp_finalize*/ - #endif - #if PY_VERSION_HEX >= 0x030800b1 - 0, /*tp_vectorcall*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 - 0, /*tp_print*/ - #endif -}; +/* "(tree fragment)":11 + * __pyx_unpickle_Query__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Query__set_state(Query __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.query_contains = __pyx_state[0]; __pyx_result.query_endswith = __pyx_state[1]; __pyx_result.query_eq = __pyx_state[2]; __pyx_result.query_gt = __pyx_state[3]; __pyx_result.query_gte = __pyx_state[4]; __pyx_result.query_in = __pyx_state[5]; __pyx_result.query_lt = __pyx_state[6]; __pyx_result.query_lte = __pyx_state[7]; __pyx_result.query_regex = __pyx_state[8]; __pyx_result.query_startswith = __pyx_state[9] + * if len(__pyx_state) > 10 and hasattr(__pyx_result, '__dict__'): +*/ -static struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_6_genexpr *__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_6_genexpr[8]; -static int __pyx_freecount_6hunter_11_predicates___pyx_scope_struct_6_genexpr = 0; +static PyObject *__pyx_f_6hunter_11_predicates___pyx_unpickle_Query__set_state(struct __pyx_obj_6hunter_11_predicates_Query *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + size_t __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[138])) + __Pyx_RefNannySetupContext("__pyx_unpickle_Query__set_state", 0); + __Pyx_TraceStartFunc("__pyx_unpickle_Query__set_state", __pyx_f[1], 11, 0, 0, 0, __PYX_ERR(1, 11, __pyx_L1_error)); -static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_6_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { - PyObject *o; - if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_6_genexpr > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_6_genexpr)))) { - o = (PyObject*)__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_6_genexpr[--__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_6_genexpr]; - memset(o, 0, sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_6_genexpr)); - (void) PyObject_INIT(o, t); - PyObject_GC_Track(o); - } else { - o = (*t->tp_alloc)(t, 0); - if (unlikely(!o)) return 0; + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_Query__set_state(Query __pyx_result, tuple __pyx_state): + * __pyx_result.query_contains = __pyx_state[0]; __pyx_result.query_endswith = __pyx_state[1]; __pyx_result.query_eq = __pyx_state[2]; __pyx_result.query_gt = __pyx_state[3]; __pyx_result.query_gte = __pyx_state[4]; __pyx_result.query_in = __pyx_state[5]; __pyx_result.query_lt = __pyx_state[6]; __pyx_result.query_lte = __pyx_state[7]; __pyx_result.query_regex = __pyx_state[8]; __pyx_result.query_startswith = __pyx_state[9] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 10 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[10]) +*/ + __Pyx_TraceLine(12,3,0,__PYX_ERR(1, 12, __pyx_L1_error)) + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) } - return o; -} - -static void __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_6_genexpr(PyObject *o) { - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_6_genexpr *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_6_genexpr *)o; - PyObject_GC_UnTrack(o); - Py_CLEAR(p->__pyx_outer_scope); - Py_CLEAR(p->__pyx_v_action); - Py_CLEAR(p->__pyx_t_0); - if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_6_genexpr < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_6_genexpr)))) { - __pyx_freelist_6hunter_11_predicates___pyx_scope_struct_6_genexpr[__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_6_genexpr++] = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_6_genexpr *)o); - } else { - (*Py_TYPE(o)->tp_free)(o); + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_t_1))) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->query_contains); + __Pyx_DECREF(__pyx_v___pyx_result->query_contains); + __pyx_v___pyx_result->query_contains = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) } -} - -static int __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_6_genexpr(PyObject *o, visitproc v, void *a) { - int e; - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_6_genexpr *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_6_genexpr *)o; - if (p->__pyx_outer_scope) { - e = (*v)(((PyObject *)p->__pyx_outer_scope), a); if (e) return e; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_t_1))) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->query_endswith); + __Pyx_DECREF(__pyx_v___pyx_result->query_endswith); + __pyx_v___pyx_result->query_endswith = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) } - if (p->__pyx_v_action) { - e = (*v)(p->__pyx_v_action, a); if (e) return e; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_t_1))) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->query_eq); + __Pyx_DECREF(__pyx_v___pyx_result->query_eq); + __pyx_v___pyx_result->query_eq = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) } - if (p->__pyx_t_0) { - e = (*v)(p->__pyx_t_0, a); if (e) return e; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_t_1))) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->query_gt); + __Pyx_DECREF(__pyx_v___pyx_result->query_gt); + __pyx_v___pyx_result->query_gt = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) } - return 0; -} - -static PyTypeObject __pyx_type_6hunter_11_predicates___pyx_scope_struct_6_genexpr = { - PyVarObject_HEAD_INIT(0, 0) - "hunter._predicates.__pyx_scope_struct_6_genexpr", /*tp_name*/ - sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_6_genexpr), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_6_genexpr, /*tp_dealloc*/ - #if PY_VERSION_HEX < 0x030800b4 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 - 0, /*tp_vectorcall_offset*/ - #endif - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - 0, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - 0, /*tp_doc*/ - __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_6_genexpr, /*tp_traverse*/ - 0, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - 0, /*tp_methods*/ - 0, /*tp_members*/ - 0, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - 0, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_6_genexpr, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - 0, /*tp_finalize*/ - #endif - #if PY_VERSION_HEX >= 0x030800b1 - 0, /*tp_vectorcall*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 - 0, /*tp_print*/ - #endif -}; - -static struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_7___str__ *__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_7___str__[8]; -static int __pyx_freecount_6hunter_11_predicates___pyx_scope_struct_7___str__ = 0; - -static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_7___str__(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { - PyObject *o; - if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_7___str__ > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_7___str__)))) { - o = (PyObject*)__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_7___str__[--__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_7___str__]; - memset(o, 0, sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_7___str__)); - (void) PyObject_INIT(o, t); - PyObject_GC_Track(o); - } else { - o = (*t->tp_alloc)(t, 0); - if (unlikely(!o)) return 0; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 4, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_t_1))) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->query_gte); + __Pyx_DECREF(__pyx_v___pyx_result->query_gte); + __pyx_v___pyx_result->query_gte = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) } - return o; -} + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 5, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_t_1))) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->query_in); + __Pyx_DECREF(__pyx_v___pyx_result->query_in); + __pyx_v___pyx_result->query_in = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 6, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_t_1))) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->query_lt); + __Pyx_DECREF(__pyx_v___pyx_result->query_lt); + __pyx_v___pyx_result->query_lt = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 7, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_t_1))) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->query_lte); + __Pyx_DECREF(__pyx_v___pyx_result->query_lte); + __pyx_v___pyx_result->query_lte = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 8, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_t_1))) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->query_regex); + __Pyx_DECREF(__pyx_v___pyx_result->query_regex); + __pyx_v___pyx_result->query_regex = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 9, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_t_1))) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->query_startswith); + __Pyx_DECREF(__pyx_v___pyx_result->query_startswith); + __pyx_v___pyx_result->query_startswith = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; -static void __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_7___str__(PyObject *o) { - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_7___str__ *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_7___str__ *)o; - PyObject_GC_UnTrack(o); - Py_CLEAR(p->__pyx_v_self); - if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_7___str__ < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_7___str__)))) { - __pyx_freelist_6hunter_11_predicates___pyx_scope_struct_7___str__[__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_7___str__++] = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_7___str__ *)o); + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Query__set_state(Query __pyx_result, tuple __pyx_state): + * __pyx_result.query_contains = __pyx_state[0]; __pyx_result.query_endswith = __pyx_state[1]; __pyx_result.query_eq = __pyx_state[2]; __pyx_result.query_gt = __pyx_state[3]; __pyx_result.query_gte = __pyx_state[4]; __pyx_result.query_in = __pyx_state[5]; __pyx_result.query_lt = __pyx_state[6]; __pyx_result.query_lte = __pyx_state[7]; __pyx_result.query_regex = __pyx_state[8]; __pyx_result.query_startswith = __pyx_state[9] + * if len(__pyx_state) > 10 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[10]) +*/ + __Pyx_TraceLine(13,54,0,__PYX_ERR(1, 13, __pyx_L1_error)) + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(1, 13, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 > 10); + if (__pyx_t_4) { } else { - (*Py_TYPE(o)->tp_free)(o); + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; } -} + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_mstate_global->__pyx_n_u_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { -static int __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_7___str__(PyObject *o, visitproc v, void *a) { - int e; - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_7___str__ *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_7___str__ *)o; - if (p->__pyx_v_self) { - e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e; + /* "(tree fragment)":14 + * __pyx_result.query_contains = __pyx_state[0]; __pyx_result.query_endswith = __pyx_state[1]; __pyx_result.query_eq = __pyx_state[2]; __pyx_result.query_gt = __pyx_state[3]; __pyx_result.query_gte = __pyx_state[4]; __pyx_result.query_in = __pyx_state[5]; __pyx_result.query_lt = __pyx_state[6]; __pyx_result.query_lte = __pyx_state[7]; __pyx_result.query_regex = __pyx_state[8]; __pyx_result.query_startswith = __pyx_state[9] + * if len(__pyx_state) > 10 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[10]) # <<<<<<<<<<<<<< +*/ + __Pyx_TraceLine(14,63,0,__PYX_ERR(1, 14, __pyx_L1_error)) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_mstate_global->__pyx_n_u_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = __pyx_t_6; + __Pyx_INCREF(__pyx_t_5); + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 14, __pyx_L1_error) + } + __pyx_t_7 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 10, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_7}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_update, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Query__set_state(Query __pyx_result, tuple __pyx_state): + * __pyx_result.query_contains = __pyx_state[0]; __pyx_result.query_endswith = __pyx_state[1]; __pyx_result.query_eq = __pyx_state[2]; __pyx_result.query_gt = __pyx_state[3]; __pyx_result.query_gte = __pyx_state[4]; __pyx_result.query_in = __pyx_state[5]; __pyx_result.query_lt = __pyx_state[6]; __pyx_result.query_lte = __pyx_state[7]; __pyx_result.query_regex = __pyx_state[8]; __pyx_result.query_startswith = __pyx_state[9] + * if len(__pyx_state) > 10 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[10]) +*/ } - return 0; -} -static int __pyx_tp_clear_6hunter_11_predicates___pyx_scope_struct_7___str__(PyObject *o) { - PyObject* tmp; - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_7___str__ *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_7___str__ *)o; - tmp = ((PyObject*)p->__pyx_v_self); - p->__pyx_v_self = ((struct __pyx_obj_6hunter_11_predicates_When *)Py_None); Py_INCREF(Py_None); - Py_XDECREF(tmp); - return 0; -} + /* "(tree fragment)":11 + * __pyx_unpickle_Query__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Query__set_state(Query __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.query_contains = __pyx_state[0]; __pyx_result.query_endswith = __pyx_state[1]; __pyx_result.query_eq = __pyx_state[2]; __pyx_result.query_gt = __pyx_state[3]; __pyx_result.query_gte = __pyx_state[4]; __pyx_result.query_in = __pyx_state[5]; __pyx_result.query_lt = __pyx_state[6]; __pyx_result.query_lte = __pyx_state[7]; __pyx_result.query_regex = __pyx_state[8]; __pyx_result.query_startswith = __pyx_state[9] + * if len(__pyx_state) > 10 and hasattr(__pyx_result, '__dict__'): +*/ -static PyTypeObject __pyx_type_6hunter_11_predicates___pyx_scope_struct_7___str__ = { - PyVarObject_HEAD_INIT(0, 0) - "hunter._predicates.__pyx_scope_struct_7___str__", /*tp_name*/ - sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_7___str__), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_7___str__, /*tp_dealloc*/ - #if PY_VERSION_HEX < 0x030800b4 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 - 0, /*tp_vectorcall_offset*/ - #endif - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - 0, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - 0, /*tp_doc*/ - __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_7___str__, /*tp_traverse*/ - __pyx_tp_clear_6hunter_11_predicates___pyx_scope_struct_7___str__, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - 0, /*tp_methods*/ - 0, /*tp_members*/ - 0, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - 0, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_7___str__, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - 0, /*tp_finalize*/ - #endif - #if PY_VERSION_HEX >= 0x030800b1 - 0, /*tp_vectorcall*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 - 0, /*tp_print*/ + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(1, 11, __pyx_L1_error)); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 11, __pyx_L1_error)); #endif -}; - -static struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_8_genexpr *__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_8_genexpr[8]; -static int __pyx_freecount_6hunter_11_predicates___pyx_scope_struct_8_genexpr = 0; - -static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_8_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { - PyObject *o; - if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_8_genexpr > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_8_genexpr)))) { - o = (PyObject*)__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_8_genexpr[--__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_8_genexpr]; - memset(o, 0, sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_8_genexpr)); - (void) PyObject_INIT(o, t); - PyObject_GC_Track(o); - } else { - o = (*t->tp_alloc)(t, 0); - if (unlikely(!o)) return 0; - } - return o; -} - -static void __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_8_genexpr(PyObject *o) { - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_8_genexpr *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_8_genexpr *)o; - PyObject_GC_UnTrack(o); - Py_CLEAR(p->__pyx_outer_scope); - Py_CLEAR(p->__pyx_v_p); - Py_CLEAR(p->__pyx_t_0); - if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_8_genexpr < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_8_genexpr)))) { - __pyx_freelist_6hunter_11_predicates___pyx_scope_struct_8_genexpr[__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_8_genexpr++] = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_8_genexpr *)o); - } else { - (*Py_TYPE(o)->tp_free)(o); - } + __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_Query__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -static int __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_8_genexpr(PyObject *o, visitproc v, void *a) { - int e; - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_8_genexpr *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_8_genexpr *)o; - if (p->__pyx_outer_scope) { - e = (*v)(((PyObject *)p->__pyx_outer_scope), a); if (e) return e; - } - if (p->__pyx_v_p) { - e = (*v)(p->__pyx_v_p, a); if (e) return e; - } - if (p->__pyx_t_0) { - e = (*v)(p->__pyx_t_0, a); if (e) return e; - } - return 0; -} +/* "(tree fragment)":1 + * def __pyx_unpickle_When(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result +*/ -static PyTypeObject __pyx_type_6hunter_11_predicates___pyx_scope_struct_8_genexpr = { - PyVarObject_HEAD_INIT(0, 0) - "hunter._predicates.__pyx_scope_struct_8_genexpr", /*tp_name*/ - sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_8_genexpr), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_8_genexpr, /*tp_dealloc*/ - #if PY_VERSION_HEX < 0x030800b4 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 - 0, /*tp_vectorcall_offset*/ - #endif - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - 0, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - 0, /*tp_doc*/ - __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_8_genexpr, /*tp_traverse*/ - 0, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - 0, /*tp_methods*/ - 0, /*tp_members*/ - 0, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - 0, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_8_genexpr, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - 0, /*tp_finalize*/ - #endif - #if PY_VERSION_HEX >= 0x030800b1 - 0, /*tp_vectorcall*/ +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_3__pyx_unpickle_When(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_11_predicates_3__pyx_unpickle_When = {"__pyx_unpickle_When", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_3__pyx_unpickle_When, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_11_predicates_3__pyx_unpickle_When(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_When (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 - 0, /*tp_print*/ #endif -}; - -static struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_9___str__ *__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_9___str__[8]; -static int __pyx_freecount_6hunter_11_predicates___pyx_scope_struct_9___str__ = 0; - -static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_9___str__(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { - PyObject *o; - if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_9___str__ > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_9___str__)))) { - o = (PyObject*)__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_9___str__[--__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_9___str__]; - memset(o, 0, sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_9___str__)); - (void) PyObject_INIT(o, t); - PyObject_GC_Track(o); - } else { - o = (*t->tp_alloc)(t, 0); - if (unlikely(!o)) return 0; + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_type,&__pyx_mstate_global->__pyx_n_u_pyx_checksum,&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 1, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 1, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 1, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 1, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__pyx_unpickle_When", 0) < 0) __PYX_ERR(1, 1, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_When", 1, 3, 3, i); __PYX_ERR(1, 1, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 1, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 1, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 1, __pyx_L3_error) + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyLong_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; } - return o; -} - -static void __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_9___str__(PyObject *o) { - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_9___str__ *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_9___str__ *)o; - PyObject_GC_UnTrack(o); - Py_CLEAR(p->__pyx_v_self); - if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_9___str__ < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_9___str__)))) { - __pyx_freelist_6hunter_11_predicates___pyx_scope_struct_9___str__[__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_9___str__++] = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_9___str__ *)o); - } else { - (*Py_TYPE(o)->tp_free)(o); + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_When", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } -} + __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_When", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6hunter_11_predicates_2__pyx_unpickle_When(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); -static int __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_9___str__(PyObject *o, visitproc v, void *a) { - int e; - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_9___str__ *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_9___str__ *)o; - if (p->__pyx_v_self) { - e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e; + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - return 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -static int __pyx_tp_clear_6hunter_11_predicates___pyx_scope_struct_9___str__(PyObject *o) { - PyObject* tmp; - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_9___str__ *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_9___str__ *)o; - tmp = ((PyObject*)p->__pyx_v_self); - p->__pyx_v_self = ((struct __pyx_obj_6hunter_11_predicates_And *)Py_None); Py_INCREF(Py_None); - Py_XDECREF(tmp); - return 0; -} +static PyObject *__pyx_pf_6hunter_11_predicates_2__pyx_unpickle_When(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[139])) + __Pyx_RefNannySetupContext("__pyx_unpickle_When", 0); + __Pyx_TraceStartFunc("__pyx_unpickle_When", __pyx_f[1], 1, 0, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); -static PyTypeObject __pyx_type_6hunter_11_predicates___pyx_scope_struct_9___str__ = { - PyVarObject_HEAD_INIT(0, 0) - "hunter._predicates.__pyx_scope_struct_9___str__", /*tp_name*/ - sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_9___str__), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_9___str__, /*tp_dealloc*/ - #if PY_VERSION_HEX < 0x030800b4 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 - 0, /*tp_vectorcall_offset*/ - #endif - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - 0, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - 0, /*tp_doc*/ - __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_9___str__, /*tp_traverse*/ - __pyx_tp_clear_6hunter_11_predicates___pyx_scope_struct_9___str__, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - 0, /*tp_methods*/ - 0, /*tp_members*/ - 0, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - 0, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_9___str__, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - 0, /*tp_finalize*/ - #endif - #if PY_VERSION_HEX >= 0x030800b1 - 0, /*tp_vectorcall*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 - 0, /*tp_print*/ - #endif -}; + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe710366, 0x7718bb4, 0xb55b71c): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe710366, 0x7718bb4, 0xb55b71c) = (actions, condition))" % __pyx_checksum +*/ + __Pyx_TraceLine(4,2,0,__PYX_ERR(1, 4, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyLong_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_mstate_global->__pyx_tuple[1], Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { -static struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_10_genexpr *__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_10_genexpr[8]; -static int __pyx_freecount_6hunter_11_predicates___pyx_scope_struct_10_genexpr = 0; + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0xe710366, 0x7718bb4, 0xb55b71c): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe710366, 0x7718bb4, 0xb55b71c) = (actions, condition))" % __pyx_checksum + * __pyx_result = When.__new__(__pyx_type) +*/ + __Pyx_TraceLine(5,9,0,__PYX_ERR(1, 5, __pyx_L1_error)) + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_PickleError); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_mstate_global->__pyx_n_u_PickleError) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; -static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_10_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { - PyObject *o; - if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_10_genexpr > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_10_genexpr)))) { - o = (PyObject*)__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_10_genexpr[--__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_10_genexpr]; - memset(o, 0, sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_10_genexpr)); - (void) PyObject_INIT(o, t); - PyObject_GC_Track(o); - } else { - o = (*t->tp_alloc)(t, 0); - if (unlikely(!o)) return 0; - } - return o; -} + /* "(tree fragment)":6 + * if __pyx_checksum not in (0xe710366, 0x7718bb4, 0xb55b71c): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe710366, 0x7718bb4, 0xb55b71c) = (actions, condition))" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = When.__new__(__pyx_type) + * if __pyx_state is not None: +*/ + __Pyx_TraceLine(6,14,0,__PYX_ERR(1, 6, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyLong_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyUnicode_Format(__pyx_mstate_global->__pyx_kp_u_Incompatible_checksums_0x_x_vs_0_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 6, __pyx_L1_error) -static void __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_10_genexpr(PyObject *o) { - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_10_genexpr *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_10_genexpr *)o; - PyObject_GC_UnTrack(o); - Py_CLEAR(p->__pyx_outer_scope); - Py_CLEAR(p->__pyx_v_p); - Py_CLEAR(p->__pyx_t_0); - if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_10_genexpr < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_10_genexpr)))) { - __pyx_freelist_6hunter_11_predicates___pyx_scope_struct_10_genexpr[__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_10_genexpr++] = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_10_genexpr *)o); - } else { - (*Py_TYPE(o)->tp_free)(o); + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe710366, 0x7718bb4, 0xb55b71c): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe710366, 0x7718bb4, 0xb55b71c) = (actions, condition))" % __pyx_checksum +*/ } -} -static int __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_10_genexpr(PyObject *o, visitproc v, void *a) { - int e; - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_10_genexpr *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_10_genexpr *)o; - if (p->__pyx_outer_scope) { - e = (*v)(((PyObject *)p->__pyx_outer_scope), a); if (e) return e; - } - if (p->__pyx_v_p) { - e = (*v)(p->__pyx_v_p, a); if (e) return e; - } - if (p->__pyx_t_0) { - e = (*v)(p->__pyx_t_0, a); if (e) return e; + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe710366, 0x7718bb4, 0xb55b71c) = (actions, condition))" % __pyx_checksum + * __pyx_result = When.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_When__set_state( __pyx_result, __pyx_state) +*/ + __Pyx_TraceLine(7,16,0,__PYX_ERR(1, 7, __pyx_L1_error)) + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_When); + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_new, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); } - return 0; -} + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; -static PyTypeObject __pyx_type_6hunter_11_predicates___pyx_scope_struct_10_genexpr = { - PyVarObject_HEAD_INIT(0, 0) - "hunter._predicates.__pyx_scope_struct_10_genexpr", /*tp_name*/ - sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_10_genexpr), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_10_genexpr, /*tp_dealloc*/ - #if PY_VERSION_HEX < 0x030800b4 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 - 0, /*tp_vectorcall_offset*/ - #endif - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - 0, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - 0, /*tp_doc*/ - __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_10_genexpr, /*tp_traverse*/ - 0, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - 0, /*tp_methods*/ - 0, /*tp_members*/ - 0, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - 0, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_10_genexpr, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - 0, /*tp_finalize*/ - #endif - #if PY_VERSION_HEX >= 0x030800b1 - 0, /*tp_vectorcall*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 - 0, /*tp_print*/ - #endif -}; + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe710366, 0x7718bb4, 0xb55b71c) = (actions, condition))" % __pyx_checksum + * __pyx_result = When.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_When__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + __Pyx_TraceLine(8,23,0,__PYX_ERR(1, 8, __pyx_L1_error)) + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { -static struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_11___str__ *__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_11___str__[8]; -static int __pyx_freecount_6hunter_11_predicates___pyx_scope_struct_11___str__ = 0; + /* "(tree fragment)":9 + * __pyx_result = When.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_When__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_When__set_state(When __pyx_result, tuple __pyx_state): +*/ + __Pyx_TraceLine(9,28,0,__PYX_ERR(1, 9, __pyx_L1_error)) + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_6hunter_11_predicates___pyx_unpickle_When__set_state(((struct __pyx_obj_6hunter_11_predicates_When *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; -static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_11___str__(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { - PyObject *o; - if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_11___str__ > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_11___str__)))) { - o = (PyObject*)__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_11___str__[--__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_11___str__]; - memset(o, 0, sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_11___str__)); - (void) PyObject_INIT(o, t); - PyObject_GC_Track(o); - } else { - o = (*t->tp_alloc)(t, 0); - if (unlikely(!o)) return 0; + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe710366, 0x7718bb4, 0xb55b71c) = (actions, condition))" % __pyx_checksum + * __pyx_result = When.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_When__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ } - return o; -} -static void __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_11___str__(PyObject *o) { - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_11___str__ *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_11___str__ *)o; - PyObject_GC_UnTrack(o); - Py_CLEAR(p->__pyx_v_self); - if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_11___str__ < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_11___str__)))) { - __pyx_freelist_6hunter_11_predicates___pyx_scope_struct_11___str__[__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_11___str__++] = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_11___str__ *)o); - } else { - (*Py_TYPE(o)->tp_free)(o); - } -} + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_When__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_When__set_state(When __pyx_result, tuple __pyx_state): + * __pyx_result.actions = __pyx_state[0]; __pyx_result.condition = __pyx_state[1] +*/ + __Pyx_TraceLine(10,29,0,__PYX_ERR(1, 10, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + __Pyx_TraceReturnValue(__pyx_r, 29, 0, __PYX_ERR(1, 10, __pyx_L1_error)); + goto __pyx_L0; -static int __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_11___str__(PyObject *o, visitproc v, void *a) { - int e; - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_11___str__ *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_11___str__ *)o; - if (p->__pyx_v_self) { - e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e; - } - return 0; -} + /* "(tree fragment)":1 + * def __pyx_unpickle_When(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result +*/ -static int __pyx_tp_clear_6hunter_11_predicates___pyx_scope_struct_11___str__(PyObject *o) { - PyObject* tmp; - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_11___str__ *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_11___str__ *)o; - tmp = ((PyObject*)p->__pyx_v_self); - p->__pyx_v_self = ((struct __pyx_obj_6hunter_11_predicates_Or *)Py_None); Py_INCREF(Py_None); - Py_XDECREF(tmp); - return 0; + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_When", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -static PyTypeObject __pyx_type_6hunter_11_predicates___pyx_scope_struct_11___str__ = { - PyVarObject_HEAD_INIT(0, 0) - "hunter._predicates.__pyx_scope_struct_11___str__", /*tp_name*/ - sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_11___str__), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_11___str__, /*tp_dealloc*/ - #if PY_VERSION_HEX < 0x030800b4 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 - 0, /*tp_vectorcall_offset*/ - #endif - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - 0, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - 0, /*tp_doc*/ - __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_11___str__, /*tp_traverse*/ - __pyx_tp_clear_6hunter_11_predicates___pyx_scope_struct_11___str__, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - 0, /*tp_methods*/ - 0, /*tp_members*/ - 0, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - 0, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_11___str__, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - 0, /*tp_finalize*/ - #endif - #if PY_VERSION_HEX >= 0x030800b1 - 0, /*tp_vectorcall*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 - 0, /*tp_print*/ - #endif -}; +/* "(tree fragment)":11 + * __pyx_unpickle_When__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_When__set_state(When __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.actions = __pyx_state[0]; __pyx_result.condition = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): +*/ -static struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_12_genexpr *__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_12_genexpr[8]; -static int __pyx_freecount_6hunter_11_predicates___pyx_scope_struct_12_genexpr = 0; +static PyObject *__pyx_f_6hunter_11_predicates___pyx_unpickle_When__set_state(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + size_t __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[140])) + __Pyx_RefNannySetupContext("__pyx_unpickle_When__set_state", 0); + __Pyx_TraceStartFunc("__pyx_unpickle_When__set_state", __pyx_f[1], 11, 0, 0, 0, __PYX_ERR(1, 11, __pyx_L1_error)); -static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_12_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { - PyObject *o; - if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_12_genexpr > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_12_genexpr)))) { - o = (PyObject*)__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_12_genexpr[--__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_12_genexpr]; - memset(o, 0, sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_12_genexpr)); - (void) PyObject_INIT(o, t); - PyObject_GC_Track(o); - } else { - o = (*t->tp_alloc)(t, 0); - if (unlikely(!o)) return 0; + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_When__set_state(When __pyx_result, tuple __pyx_state): + * __pyx_result.actions = __pyx_state[0]; __pyx_result.condition = __pyx_state[1] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[2]) +*/ + __Pyx_TraceLine(12,3,0,__PYX_ERR(1, 12, __pyx_L1_error)) + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) } - return o; -} - -static void __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_12_genexpr(PyObject *o) { - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_12_genexpr *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_12_genexpr *)o; - PyObject_GC_UnTrack(o); - Py_CLEAR(p->__pyx_outer_scope); - Py_CLEAR(p->__pyx_v_p); - Py_CLEAR(p->__pyx_t_0); - if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_12_genexpr < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_12_genexpr)))) { - __pyx_freelist_6hunter_11_predicates___pyx_scope_struct_12_genexpr[__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_12_genexpr++] = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_12_genexpr *)o); - } else { - (*Py_TYPE(o)->tp_free)(o); + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_t_1))) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->actions); + __Pyx_DECREF(__pyx_v___pyx_result->actions); + __pyx_v___pyx_result->actions = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) } -} + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->condition); + __Pyx_DECREF(__pyx_v___pyx_result->condition); + __pyx_v___pyx_result->condition = __pyx_t_1; + __pyx_t_1 = 0; -static int __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_12_genexpr(PyObject *o, visitproc v, void *a) { - int e; - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_12_genexpr *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_12_genexpr *)o; - if (p->__pyx_outer_scope) { - e = (*v)(((PyObject *)p->__pyx_outer_scope), a); if (e) return e; - } - if (p->__pyx_v_p) { - e = (*v)(p->__pyx_v_p, a); if (e) return e; + /* "(tree fragment)":13 + * cdef __pyx_unpickle_When__set_state(When __pyx_result, tuple __pyx_state): + * __pyx_result.actions = __pyx_state[0]; __pyx_result.condition = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[2]) +*/ + __Pyx_TraceLine(13,14,0,__PYX_ERR(1, 13, __pyx_L1_error)) + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(1, 13, __pyx_L1_error) } - if (p->__pyx_t_0) { - e = (*v)(p->__pyx_t_0, a); if (e) return e; + __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 > 2); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; } - return 0; -} + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_mstate_global->__pyx_n_u_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { -static PyTypeObject __pyx_type_6hunter_11_predicates___pyx_scope_struct_12_genexpr = { - PyVarObject_HEAD_INIT(0, 0) - "hunter._predicates.__pyx_scope_struct_12_genexpr", /*tp_name*/ - sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_12_genexpr), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_12_genexpr, /*tp_dealloc*/ - #if PY_VERSION_HEX < 0x030800b4 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 - 0, /*tp_vectorcall_offset*/ - #endif - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - 0, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - 0, /*tp_doc*/ - __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_12_genexpr, /*tp_traverse*/ - 0, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - 0, /*tp_methods*/ - 0, /*tp_members*/ - 0, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - 0, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_12_genexpr, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - 0, /*tp_finalize*/ - #endif - #if PY_VERSION_HEX >= 0x030800b1 - 0, /*tp_vectorcall*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 - 0, /*tp_print*/ - #endif -}; + /* "(tree fragment)":14 + * __pyx_result.actions = __pyx_state[0]; __pyx_result.condition = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[2]) # <<<<<<<<<<<<<< +*/ + __Pyx_TraceLine(14,23,0,__PYX_ERR(1, 14, __pyx_L1_error)) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_mstate_global->__pyx_n_u_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = __pyx_t_6; + __Pyx_INCREF(__pyx_t_5); + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 14, __pyx_L1_error) + } + __pyx_t_7 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_7}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_update, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; -static PyMethodDef __pyx_methods[] = { - {0, 0, 0, 0} -}; + /* "(tree fragment)":13 + * cdef __pyx_unpickle_When__set_state(When __pyx_result, tuple __pyx_state): + * __pyx_result.actions = __pyx_state[0]; __pyx_result.condition = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[2]) +*/ + } -#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__predicates(PyObject* module); /*proto*/ -static PyModuleDef_Slot __pyx_moduledef_slots[] = { - {Py_mod_create, (void*)__pyx_pymod_create}, - {Py_mod_exec, (void*)__pyx_pymod_exec__predicates}, - {0, NULL} -}; -#endif + /* "(tree fragment)":11 + * __pyx_unpickle_When__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_When__set_state(When __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.actions = __pyx_state[0]; __pyx_result.condition = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): +*/ -static struct PyModuleDef __pyx_moduledef = { - PyModuleDef_HEAD_INIT, - "_predicates", - 0, /* 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 */ + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(1, 11, __pyx_L1_error)); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); #else - NULL, /* m_reload */ + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 11, __pyx_L1_error)); #endif - NULL, /* m_traverse */ - NULL, /* m_clear */ - NULL /* m_free */ -}; -#endif -#ifndef CYTHON_SMALL_CODE -#if defined(__clang__) - #define CYTHON_SMALL_CODE -#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) - #define CYTHON_SMALL_CODE __attribute__((cold)) + __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_When__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_From(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_5__pyx_unpickle_From(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else - #define CYTHON_SMALL_CODE +PyObject *__pyx_args, PyObject *__pyx_kwds #endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_11_predicates_5__pyx_unpickle_From = {"__pyx_unpickle_From", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_5__pyx_unpickle_From, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_11_predicates_5__pyx_unpickle_From(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds #endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_From (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_type,&__pyx_mstate_global->__pyx_n_u_pyx_checksum,&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 1, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 1, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 1, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 1, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__pyx_unpickle_From", 0) < 0) __PYX_ERR(1, 1, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_From", 1, 3, 3, i); __PYX_ERR(1, 1, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 1, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 1, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 1, __pyx_L3_error) + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyLong_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_From", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_From", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6hunter_11_predicates_4__pyx_unpickle_From(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); -static __Pyx_StringTabEntry __pyx_string_tab[] = { - {&__pyx_n_s_, __pyx_k_, sizeof(__pyx_k_), 0, 0, 1, 1}, - {&__pyx_n_s_Action, __pyx_k_Action, sizeof(__pyx_k_Action), 0, 0, 1, 1}, - {&__pyx_n_s_And, __pyx_k_And, sizeof(__pyx_k_And), 0, 0, 1, 1}, - {&__pyx_kp_s_And_s, __pyx_k_And_s, sizeof(__pyx_k_And_s), 0, 0, 1, 0}, - {&__pyx_n_s_From, __pyx_k_From, sizeof(__pyx_k_From), 0, 0, 1, 1}, - {&__pyx_kp_s_From_s_s_watermark_s, __pyx_k_From_s_s_watermark_s, sizeof(__pyx_k_From_s_s_watermark_s), 0, 0, 1, 0}, - {&__pyx_kp_s_Incompatible_checksums_s_vs_0x1a, __pyx_k_Incompatible_checksums_s_vs_0x1a, sizeof(__pyx_k_Incompatible_checksums_s_vs_0x1a), 0, 0, 1, 0}, - {&__pyx_kp_s_Incompatible_checksums_s_vs_0x4e, __pyx_k_Incompatible_checksums_s_vs_0x4e, sizeof(__pyx_k_Incompatible_checksums_s_vs_0x4e), 0, 0, 1, 0}, - {&__pyx_kp_s_Incompatible_checksums_s_vs_0xaa, __pyx_k_Incompatible_checksums_s_vs_0xaa, sizeof(__pyx_k_Incompatible_checksums_s_vs_0xaa), 0, 0, 1, 0}, - {&__pyx_kp_s_Incompatible_checksums_s_vs_0xb5, __pyx_k_Incompatible_checksums_s_vs_0xb5, sizeof(__pyx_k_Incompatible_checksums_s_vs_0xb5), 0, 0, 1, 0}, - {&__pyx_kp_s_Incompatible_checksums_s_vs_0xf6, __pyx_k_Incompatible_checksums_s_vs_0xf6, sizeof(__pyx_k_Incompatible_checksums_s_vs_0xf6), 0, 0, 1, 0}, - {&__pyx_kp_s_Must_give_at_least_one_action, __pyx_k_Must_give_at_least_one_action, sizeof(__pyx_k_Must_give_at_least_one_action), 0, 0, 1, 0}, - {&__pyx_n_s_Not, __pyx_k_Not, sizeof(__pyx_k_Not), 0, 0, 1, 1}, - {&__pyx_kp_s_Not_s, __pyx_k_Not_s, sizeof(__pyx_k_Not_s), 0, 0, 1, 0}, - {&__pyx_n_s_Or, __pyx_k_Or, sizeof(__pyx_k_Or), 0, 0, 1, 1}, - {&__pyx_kp_s_Or_s, __pyx_k_Or_s, sizeof(__pyx_k_Or_s), 0, 0, 1, 0}, - {&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 0, 1, 1}, - {&__pyx_n_s_Query, __pyx_k_Query, sizeof(__pyx_k_Query), 0, 0, 1, 1}, - {&__pyx_kp_s_Query_s, __pyx_k_Query_s, sizeof(__pyx_k_Query_s), 0, 0, 1, 0}, - {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, - {&__pyx_kp_s_Unexpected_argument_r_Must_be_on, __pyx_k_Unexpected_argument_r_Must_be_on, sizeof(__pyx_k_Unexpected_argument_r_Must_be_on), 0, 0, 1, 0}, - {&__pyx_kp_s_Unexpected_argument_r_Must_be_on_2, __pyx_k_Unexpected_argument_r_Must_be_on_2, sizeof(__pyx_k_Unexpected_argument_r_Must_be_on_2), 0, 0, 1, 0}, - {&__pyx_kp_s_Unexpected_operator_r_Must_be_on, __pyx_k_Unexpected_operator_r_Must_be_on, sizeof(__pyx_k_Unexpected_operator_r_Must_be_on), 0, 0, 1, 0}, - {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, - {&__pyx_kp_s_Value_r_for_r_is_invalid_Must_be, __pyx_k_Value_r_for_r_is_invalid_Must_be, sizeof(__pyx_k_Value_r_for_r_is_invalid_Must_be), 0, 0, 1, 0}, - {&__pyx_n_s_When, __pyx_k_When, sizeof(__pyx_k_When), 0, 0, 1, 1}, - {&__pyx_kp_s_When_s_s, __pyx_k_When_s_s, sizeof(__pyx_k_When_s_s), 0, 0, 1, 0}, - {&__pyx_kp_s__2, __pyx_k__2, sizeof(__pyx_k__2), 0, 0, 1, 0}, - {&__pyx_kp_s__3, __pyx_k__3, sizeof(__pyx_k__3), 0, 0, 1, 0}, - {&__pyx_kp_s__4, __pyx_k__4, sizeof(__pyx_k__4), 0, 0, 1, 0}, - {&__pyx_n_s_actions, __pyx_k_actions, sizeof(__pyx_k_actions), 0, 0, 1, 1}, - {&__pyx_n_s_all, __pyx_k_all, sizeof(__pyx_k_all), 0, 0, 1, 1}, - {&__pyx_n_s_arg, __pyx_k_arg, sizeof(__pyx_k_arg), 0, 0, 1, 1}, - {&__pyx_n_s_args, __pyx_k_args, sizeof(__pyx_k_args), 0, 0, 1, 1}, - {&__pyx_n_s_calls, __pyx_k_calls, sizeof(__pyx_k_calls), 0, 0, 1, 1}, - {&__pyx_n_s_chain, __pyx_k_chain, sizeof(__pyx_k_chain), 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_close, __pyx_k_close, sizeof(__pyx_k_close), 0, 0, 1, 1}, - {&__pyx_n_s_code, __pyx_k_code, sizeof(__pyx_k_code), 0, 0, 1, 1}, - {&__pyx_n_s_compile, __pyx_k_compile, sizeof(__pyx_k_compile), 0, 0, 1, 1}, - {&__pyx_n_s_condition, __pyx_k_condition, sizeof(__pyx_k_condition), 0, 0, 1, 1}, - {&__pyx_n_s_contains, __pyx_k_contains, sizeof(__pyx_k_contains), 0, 0, 1, 1}, - {&__pyx_n_s_contains_2, __pyx_k_contains_2, sizeof(__pyx_k_contains_2), 0, 0, 1, 1}, - {&__pyx_n_s_depth, __pyx_k_depth, sizeof(__pyx_k_depth), 0, 0, 1, 1}, - {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1}, - {&__pyx_n_s_endswith, __pyx_k_endswith, sizeof(__pyx_k_endswith), 0, 0, 1, 1}, - {&__pyx_n_s_endswith_2, __pyx_k_endswith_2, sizeof(__pyx_k_endswith_2), 0, 0, 1, 1}, - {&__pyx_n_s_event, __pyx_k_event, sizeof(__pyx_k_event), 0, 0, 1, 1}, - {&__pyx_n_s_ew, __pyx_k_ew, sizeof(__pyx_k_ew), 0, 0, 1, 1}, - {&__pyx_n_s_filename, __pyx_k_filename, sizeof(__pyx_k_filename), 0, 0, 1, 1}, - {&__pyx_n_s_frame, __pyx_k_frame, sizeof(__pyx_k_frame), 0, 0, 1, 1}, - {&__pyx_n_s_fullsource, __pyx_k_fullsource, sizeof(__pyx_k_fullsource), 0, 0, 1, 1}, - {&__pyx_n_s_function, __pyx_k_function, sizeof(__pyx_k_function), 0, 0, 1, 1}, - {&__pyx_n_s_genexpr, __pyx_k_genexpr, sizeof(__pyx_k_genexpr), 0, 0, 1, 1}, - {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, - {&__pyx_n_s_globals, __pyx_k_globals, sizeof(__pyx_k_globals), 0, 0, 1, 1}, - {&__pyx_n_s_gt, __pyx_k_gt, sizeof(__pyx_k_gt), 0, 0, 1, 1}, - {&__pyx_n_s_gt_2, __pyx_k_gt_2, sizeof(__pyx_k_gt_2), 0, 0, 1, 1}, - {&__pyx_n_s_gte, __pyx_k_gte, sizeof(__pyx_k_gte), 0, 0, 1, 1}, - {&__pyx_n_s_gte_2, __pyx_k_gte_2, sizeof(__pyx_k_gte_2), 0, 0, 1, 1}, - {&__pyx_n_s_has, __pyx_k_has, sizeof(__pyx_k_has), 0, 0, 1, 1}, - {&__pyx_n_s_hunter__predicates, __pyx_k_hunter__predicates, sizeof(__pyx_k_hunter__predicates), 0, 0, 1, 1}, - {&__pyx_kp_s_hunter__predicates_And_predicat, __pyx_k_hunter__predicates_And_predicat, sizeof(__pyx_k_hunter__predicates_And_predicat), 0, 0, 1, 0}, - {&__pyx_kp_s_hunter__predicates_From_conditi, __pyx_k_hunter__predicates_From_conditi, sizeof(__pyx_k_hunter__predicates_From_conditi), 0, 0, 1, 0}, - {&__pyx_kp_s_hunter__predicates_Not_predicat, __pyx_k_hunter__predicates_Not_predicat, sizeof(__pyx_k_hunter__predicates_Not_predicat), 0, 0, 1, 0}, - {&__pyx_kp_s_hunter__predicates_Or_predicate, __pyx_k_hunter__predicates_Or_predicate, sizeof(__pyx_k_hunter__predicates_Or_predicate), 0, 0, 1, 0}, - {&__pyx_kp_s_hunter__predicates_Query_s, __pyx_k_hunter__predicates_Query_s, sizeof(__pyx_k_hunter__predicates_Query_s), 0, 0, 1, 0}, - {&__pyx_kp_s_hunter__predicates_When_conditi, __pyx_k_hunter__predicates_When_conditi, sizeof(__pyx_k_hunter__predicates_When_conditi), 0, 0, 1, 0}, - {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, - {&__pyx_n_s_in, __pyx_k_in, sizeof(__pyx_k_in), 0, 0, 1, 1}, - {&__pyx_n_s_in_2, __pyx_k_in_2, sizeof(__pyx_k_in_2), 0, 0, 1, 1}, - {&__pyx_n_s_init___locals_genexpr, __pyx_k_init___locals_genexpr, sizeof(__pyx_k_init___locals_genexpr), 0, 0, 1, 1}, - {&__pyx_n_s_inspect, __pyx_k_inspect, sizeof(__pyx_k_inspect), 0, 0, 1, 1}, - {&__pyx_n_s_isclass, __pyx_k_isclass, sizeof(__pyx_k_isclass), 0, 0, 1, 1}, - {&__pyx_n_s_items, __pyx_k_items, sizeof(__pyx_k_items), 0, 0, 1, 1}, - {&__pyx_n_s_itertools, __pyx_k_itertools, sizeof(__pyx_k_itertools), 0, 0, 1, 1}, - {&__pyx_n_s_join, __pyx_k_join, sizeof(__pyx_k_join), 0, 0, 1, 1}, - {&__pyx_n_s_kind, __pyx_k_kind, sizeof(__pyx_k_kind), 0, 0, 1, 1}, - {&__pyx_n_s_lineno, __pyx_k_lineno, sizeof(__pyx_k_lineno), 0, 0, 1, 1}, - {&__pyx_n_s_locals, __pyx_k_locals, sizeof(__pyx_k_locals), 0, 0, 1, 1}, - {&__pyx_n_s_lt, __pyx_k_lt, sizeof(__pyx_k_lt), 0, 0, 1, 1}, - {&__pyx_n_s_lt_2, __pyx_k_lt_2, sizeof(__pyx_k_lt_2), 0, 0, 1, 1}, - {&__pyx_n_s_lte, __pyx_k_lte, sizeof(__pyx_k_lte), 0, 0, 1, 1}, - {&__pyx_n_s_lte_2, __pyx_k_lte_2, sizeof(__pyx_k_lte_2), 0, 0, 1, 1}, - {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, - {&__pyx_n_s_match, __pyx_k_match, sizeof(__pyx_k_match), 0, 0, 1, 1}, - {&__pyx_n_s_module, __pyx_k_module, sizeof(__pyx_k_module), 0, 0, 1, 1}, - {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, - {&__pyx_n_s_new, __pyx_k_new, sizeof(__pyx_k_new), 0, 0, 1, 1}, - {&__pyx_n_s_pickle, __pyx_k_pickle, sizeof(__pyx_k_pickle), 0, 0, 1, 1}, - {&__pyx_n_s_predicate, __pyx_k_predicate, sizeof(__pyx_k_predicate), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_PickleError, __pyx_k_pyx_PickleError, sizeof(__pyx_k_pyx_PickleError), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_checksum, __pyx_k_pyx_checksum, sizeof(__pyx_k_pyx_checksum), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_result, __pyx_k_pyx_result, sizeof(__pyx_k_pyx_result), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_type, __pyx_k_pyx_type, sizeof(__pyx_k_pyx_type), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_unpickle_And, __pyx_k_pyx_unpickle_And, sizeof(__pyx_k_pyx_unpickle_And), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_unpickle_From, __pyx_k_pyx_unpickle_From, sizeof(__pyx_k_pyx_unpickle_From), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_unpickle_Not, __pyx_k_pyx_unpickle_Not, sizeof(__pyx_k_pyx_unpickle_Not), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_unpickle_Or, __pyx_k_pyx_unpickle_Or, sizeof(__pyx_k_pyx_unpickle_Or), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_unpickle_Query, __pyx_k_pyx_unpickle_Query, sizeof(__pyx_k_pyx_unpickle_Query), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_unpickle_When, __pyx_k_pyx_unpickle_When, sizeof(__pyx_k_pyx_unpickle_When), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, - {&__pyx_kp_s_query_contains_r, __pyx_k_query_contains_r, sizeof(__pyx_k_query_contains_r), 0, 0, 1, 0}, - {&__pyx_kp_s_query_endswith_r, __pyx_k_query_endswith_r, sizeof(__pyx_k_query_endswith_r), 0, 0, 1, 0}, - {&__pyx_kp_s_query_eq_r, __pyx_k_query_eq_r, sizeof(__pyx_k_query_eq_r), 0, 0, 1, 0}, - {&__pyx_kp_s_query_gt_r, __pyx_k_query_gt_r, sizeof(__pyx_k_query_gt_r), 0, 0, 1, 0}, - {&__pyx_kp_s_query_gte_r, __pyx_k_query_gte_r, sizeof(__pyx_k_query_gte_r), 0, 0, 1, 0}, - {&__pyx_kp_s_query_in_r, __pyx_k_query_in_r, sizeof(__pyx_k_query_in_r), 0, 0, 1, 0}, - {&__pyx_kp_s_query_lt_r, __pyx_k_query_lt_r, sizeof(__pyx_k_query_lt_r), 0, 0, 1, 0}, - {&__pyx_kp_s_query_lte_r, __pyx_k_query_lte_r, sizeof(__pyx_k_query_lte_r), 0, 0, 1, 0}, - {&__pyx_kp_s_query_regex_r, __pyx_k_query_regex_r, sizeof(__pyx_k_query_regex_r), 0, 0, 1, 0}, - {&__pyx_kp_s_query_startswith_r, __pyx_k_query_startswith_r, sizeof(__pyx_k_query_startswith_r), 0, 0, 1, 0}, - {&__pyx_n_s_re, __pyx_k_re, sizeof(__pyx_k_re), 0, 0, 1, 1}, - {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, - {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, - {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, - {&__pyx_n_s_regex, __pyx_k_regex, sizeof(__pyx_k_regex), 0, 0, 1, 1}, - {&__pyx_n_s_regex_2, __pyx_k_regex_2, sizeof(__pyx_k_regex_2), 0, 0, 1, 1}, - {&__pyx_n_s_repr___locals_genexpr, __pyx_k_repr___locals_genexpr, sizeof(__pyx_k_repr___locals_genexpr), 0, 0, 1, 1}, - {&__pyx_n_s_rx, __pyx_k_rx, sizeof(__pyx_k_rx), 0, 0, 1, 1}, - {&__pyx_kp_s_s_s_r, __pyx_k_s_s_r, sizeof(__pyx_k_s_s_r), 0, 0, 1, 0}, - {&__pyx_n_s_send, __pyx_k_send, sizeof(__pyx_k_send), 0, 0, 1, 1}, - {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, - {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, - {&__pyx_n_s_source, __pyx_k_source, sizeof(__pyx_k_source), 0, 0, 1, 1}, - {&__pyx_n_s_split, __pyx_k_split, sizeof(__pyx_k_split), 0, 0, 1, 1}, - {&__pyx_n_s_startswith, __pyx_k_startswith, sizeof(__pyx_k_startswith), 0, 0, 1, 1}, - {&__pyx_n_s_startswith_2, __pyx_k_startswith_2, sizeof(__pyx_k_startswith_2), 0, 0, 1, 1}, - {&__pyx_n_s_stdlib, __pyx_k_stdlib, sizeof(__pyx_k_stdlib), 0, 0, 1, 1}, - {&__pyx_n_s_str___locals_genexpr, __pyx_k_str___locals_genexpr, sizeof(__pyx_k_str___locals_genexpr), 0, 0, 1, 1}, - {&__pyx_n_s_str___locals_genexpr_locals_ge, __pyx_k_str___locals_genexpr_locals_ge, sizeof(__pyx_k_str___locals_genexpr_locals_ge), 0, 0, 1, 1}, - {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0}, - {&__pyx_n_s_sw, __pyx_k_sw, sizeof(__pyx_k_sw), 0, 0, 1, 1}, - {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, - {&__pyx_n_s_threadid, __pyx_k_threadid, sizeof(__pyx_k_threadid), 0, 0, 1, 1}, - {&__pyx_n_s_threadname, __pyx_k_threadname, sizeof(__pyx_k_threadname), 0, 0, 1, 1}, - {&__pyx_n_s_throw, __pyx_k_throw, sizeof(__pyx_k_throw), 0, 0, 1, 1}, - {&__pyx_n_s_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1}, - {&__pyx_n_s_watermark, __pyx_k_watermark, sizeof(__pyx_k_watermark), 0, 0, 1, 1}, - {0, 0, 0, 0, 0, 0, 0} -}; -static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { - __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 83, __pyx_L1_error) - __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 91, __pyx_L1_error) - return 0; - __pyx_L1_error:; - return -1; + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { +static PyObject *__pyx_pf_6hunter_11_predicates_4__pyx_unpickle_From(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - - /* "hunter/_predicates.pyx":270 - * def __init__(self, condition, *actions): - * if not actions: - * raise TypeError('Must give at least one action.') # <<<<<<<<<<<<<< - * self.condition = condition - * self.actions = tuple( - */ - __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s_Must_give_at_least_one_action); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 270, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__5); - __Pyx_GIVEREF(__pyx_tuple__5); + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[141])) + __Pyx_RefNannySetupContext("__pyx_unpickle_From", 0); + __Pyx_TraceStartFunc("__pyx_unpickle_From", __pyx_f[1], 1, 0, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); - /* "hunter/_predicates.pyx":18 - * - * __all__ = ( - * 'And', # <<<<<<<<<<<<<< - * 'From', - * 'Not', - */ - __pyx_tuple__12 = PyTuple_Pack(6, __pyx_n_s_And, __pyx_n_s_From, __pyx_n_s_Not, __pyx_n_s_Or, __pyx_n_s_Query, __pyx_n_s_When); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(0, 18, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__12); - __Pyx_GIVEREF(__pyx_tuple__12); + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xcfd05cc, 0xd4c8954, 0x1acd5f7): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xcfd05cc, 0xd4c8954, 0x1acd5f7) = (condition, origin_calls, origin_depth, predicate, watermark))" % __pyx_checksum +*/ + __Pyx_TraceLine(4,2,0,__PYX_ERR(1, 4, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyLong_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_mstate_global->__pyx_tuple[2], Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { - /* "hunter/_predicates.pyx":27 - * - * cdef tuple ALLOWED_KEYS = ( - * 'function', 'code', 'frame', 'module', 'lineno', 'globals', 'stdlib', 'arg', 'locals', 'kind', 'filename', 'source', # <<<<<<<<<<<<<< - * 'fullsource', 'threadname', 'threadid', 'depth', 'calls', - * ) - */ - __pyx_tuple__13 = PyTuple_Pack(17, __pyx_n_s_function, __pyx_n_s_code, __pyx_n_s_frame, __pyx_n_s_module, __pyx_n_s_lineno, __pyx_n_s_globals, __pyx_n_s_stdlib, __pyx_n_s_arg, __pyx_n_s_locals, __pyx_n_s_kind, __pyx_n_s_filename, __pyx_n_s_source, __pyx_n_s_fullsource, __pyx_n_s_threadname, __pyx_n_s_threadid, __pyx_n_s_depth, __pyx_n_s_calls); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 27, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__13); - __Pyx_GIVEREF(__pyx_tuple__13); + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0xcfd05cc, 0xd4c8954, 0x1acd5f7): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xcfd05cc, 0xd4c8954, 0x1acd5f7) = (condition, origin_calls, origin_depth, predicate, watermark))" % __pyx_checksum + * __pyx_result = From.__new__(__pyx_type) +*/ + __Pyx_TraceLine(5,9,0,__PYX_ERR(1, 5, __pyx_L1_error)) + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_PickleError); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_mstate_global->__pyx_n_u_PickleError) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "hunter/_predicates.pyx":31 - * ) - * cdef tuple ALLOWED_OPERATORS = ( - * 'startswith', 'endswith', 'in', 'contains', 'regex', # <<<<<<<<<<<<<< - * 'sw', 'ew', 'has', 'rx', - * 'gt', 'gte', 'lt', 'lte', - */ - __pyx_tuple__14 = PyTuple_Pack(13, __pyx_n_s_startswith, __pyx_n_s_endswith, __pyx_n_s_in, __pyx_n_s_contains, __pyx_n_s_regex, __pyx_n_s_sw, __pyx_n_s_ew, __pyx_n_s_has, __pyx_n_s_rx, __pyx_n_s_gt, __pyx_n_s_gte, __pyx_n_s_lt, __pyx_n_s_lte); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(0, 31, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__14); - __Pyx_GIVEREF(__pyx_tuple__14); + /* "(tree fragment)":6 + * if __pyx_checksum not in (0xcfd05cc, 0xd4c8954, 0x1acd5f7): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xcfd05cc, 0xd4c8954, 0x1acd5f7) = (condition, origin_calls, origin_depth, predicate, watermark))" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = From.__new__(__pyx_type) + * if __pyx_state is not None: +*/ + __Pyx_TraceLine(6,14,0,__PYX_ERR(1, 6, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyLong_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyUnicode_Format(__pyx_mstate_global->__pyx_kp_u_Incompatible_checksums_0x_x_vs_0_3, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 6, __pyx_L1_error) - /* "(tree fragment)":1 - * def __pyx_unpickle_Query(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result - */ - __pyx_tuple__15 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(2, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__15); - __Pyx_GIVEREF(__pyx_tuple__15); - __pyx_codeobj__6 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__15, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Query, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__6)) __PYX_ERR(2, 1, __pyx_L1_error) - __pyx_tuple__16 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(2, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__16); - __Pyx_GIVEREF(__pyx_tuple__16); - __pyx_codeobj__7 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_When, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__7)) __PYX_ERR(2, 1, __pyx_L1_error) - __pyx_tuple__17 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(2, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__17); - __Pyx_GIVEREF(__pyx_tuple__17); - __pyx_codeobj__8 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__17, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_From, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__8)) __PYX_ERR(2, 1, __pyx_L1_error) - __pyx_tuple__18 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(2, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__18); - __Pyx_GIVEREF(__pyx_tuple__18); - __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_And, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(2, 1, __pyx_L1_error) - __pyx_tuple__19 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(2, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__19); - __Pyx_GIVEREF(__pyx_tuple__19); - __pyx_codeobj__10 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__19, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Or, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__10)) __PYX_ERR(2, 1, __pyx_L1_error) - __pyx_tuple__20 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(2, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__20); - __Pyx_GIVEREF(__pyx_tuple__20); - __pyx_codeobj__11 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__20, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Not, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__11)) __PYX_ERR(2, 1, __pyx_L1_error) - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_RefNannyFinishContext(); - return -1; -} - -static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { - __pyx_umethod_PyDict_Type_items.type = (PyObject*)&PyDict_Type; - if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); - __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_28104183 = PyInt_FromLong(28104183L); if (unlikely(!__pyx_int_28104183)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_82616482 = PyInt_FromLong(82616482L); if (unlikely(!__pyx_int_82616482)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_178834394 = PyInt_FromLong(178834394L); if (unlikely(!__pyx_int_178834394)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_190166812 = PyInt_FromLong(190166812L); if (unlikely(!__pyx_int_190166812)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_258412278 = PyInt_FromLong(258412278L); if (unlikely(!__pyx_int_258412278)) __PYX_ERR(0, 1, __pyx_L1_error) - return 0; - __pyx_L1_error:; - return -1; -} + * if __pyx_checksum not in (0xcfd05cc, 0xd4c8954, 0x1acd5f7): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xcfd05cc, 0xd4c8954, 0x1acd5f7) = (condition, origin_calls, origin_depth, predicate, watermark))" % __pyx_checksum +*/ + } -static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xcfd05cc, 0xd4c8954, 0x1acd5f7) = (condition, origin_calls, origin_depth, predicate, watermark))" % __pyx_checksum + * __pyx_result = From.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_From__set_state( __pyx_result, __pyx_state) +*/ + __Pyx_TraceLine(7,16,0,__PYX_ERR(1, 7, __pyx_L1_error)) + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_From); + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_new, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; -static int __Pyx_modinit_global_init_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); - /*--- Global init code ---*/ - __pyx_v_6hunter_11_predicates_ALLOWED_KEYS = ((PyObject*)Py_None); Py_INCREF(Py_None); - __pyx_v_6hunter_11_predicates_ALLOWED_OPERATORS = ((PyObject*)Py_None); Py_INCREF(Py_None); - __Pyx_RefNannyFinishContext(); - return 0; -} + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xcfd05cc, 0xd4c8954, 0x1acd5f7) = (condition, origin_calls, origin_depth, predicate, watermark))" % __pyx_checksum + * __pyx_result = From.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_From__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + __Pyx_TraceLine(8,23,0,__PYX_ERR(1, 8, __pyx_L1_error)) + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { -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; -} + /* "(tree fragment)":9 + * __pyx_result = From.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_From__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_From__set_state(From __pyx_result, tuple __pyx_state): +*/ + __Pyx_TraceLine(9,28,0,__PYX_ERR(1, 9, __pyx_L1_error)) + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_6hunter_11_predicates___pyx_unpickle_From__set_state(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; -static int __Pyx_modinit_function_export_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); - /*--- Function export code ---*/ - if (__Pyx_ExportFunction("fast_And_call", (void (*)(void))__pyx_f_6hunter_11_predicates_fast_And_call, "PyObject *(struct __pyx_obj_6hunter_11_predicates_And *, struct __pyx_obj_6hunter_6_event_Event *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) - if (__Pyx_ExportFunction("fast_From_call", (void (*)(void))__pyx_f_6hunter_11_predicates_fast_From_call, "PyObject *(struct __pyx_obj_6hunter_11_predicates_From *, struct __pyx_obj_6hunter_6_event_Event *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) - if (__Pyx_ExportFunction("fast_Not_call", (void (*)(void))__pyx_f_6hunter_11_predicates_fast_Not_call, "PyObject *(struct __pyx_obj_6hunter_11_predicates_Not *, struct __pyx_obj_6hunter_6_event_Event *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) - if (__Pyx_ExportFunction("fast_Or_call", (void (*)(void))__pyx_f_6hunter_11_predicates_fast_Or_call, "PyObject *(struct __pyx_obj_6hunter_11_predicates_Or *, struct __pyx_obj_6hunter_6_event_Event *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) - if (__Pyx_ExportFunction("fast_Query_call", (void (*)(void))__pyx_f_6hunter_11_predicates_fast_Query_call, "PyObject *(struct __pyx_obj_6hunter_11_predicates_Query *, struct __pyx_obj_6hunter_6_event_Event *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) - if (__Pyx_ExportFunction("fast_When_call", (void (*)(void))__pyx_f_6hunter_11_predicates_fast_When_call, "PyObject *(struct __pyx_obj_6hunter_11_predicates_When *, struct __pyx_obj_6hunter_6_event_Event *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) - if (__Pyx_ExportFunction("fast_call", (void (*)(void))__pyx_f_6hunter_11_predicates_fast_call, "PyObject *(PyObject *, struct __pyx_obj_6hunter_6_event_Event *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_RefNannyFinishContext(); - return 0; + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xcfd05cc, 0xd4c8954, 0x1acd5f7) = (condition, origin_calls, origin_depth, predicate, watermark))" % __pyx_checksum + * __pyx_result = From.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_From__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_From__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_From__set_state(From __pyx_result, tuple __pyx_state): + * __pyx_result.condition = __pyx_state[0]; __pyx_result.origin_calls = __pyx_state[1]; __pyx_result.origin_depth = __pyx_state[2]; __pyx_result.predicate = __pyx_state[3]; __pyx_result.watermark = __pyx_state[4] +*/ + __Pyx_TraceLine(10,29,0,__PYX_ERR(1, 10, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + __Pyx_TraceReturnValue(__pyx_r, 29, 0, __PYX_ERR(1, 10, __pyx_L1_error)); + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_From(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result +*/ + + /* function exit code */ __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_From", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); - return -1; + return __pyx_r; } -static int __Pyx_modinit_type_init_code(void) { +/* "(tree fragment)":11 + * __pyx_unpickle_From__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_From__set_state(From __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.condition = __pyx_state[0]; __pyx_result.origin_calls = __pyx_state[1]; __pyx_result.origin_depth = __pyx_state[2]; __pyx_result.predicate = __pyx_state[3]; __pyx_result.watermark = __pyx_state[4] + * if len(__pyx_state) > 5 and hasattr(__pyx_result, '__dict__'): +*/ + +static PyObject *__pyx_f_6hunter_11_predicates___pyx_unpickle_From__set_state(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); - /*--- Type init code ---*/ - if (PyType_Ready(&__pyx_type_6hunter_11_predicates_Query) < 0) __PYX_ERR(0, 38, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_6hunter_11_predicates_Query.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6hunter_11_predicates_Query.tp_dictoffset && __pyx_type_6hunter_11_predicates_Query.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_6hunter_11_predicates_Query.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; - } - #if CYTHON_COMPILING_IN_CPYTHON - { - PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_6hunter_11_predicates_Query, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(0, 38, __pyx_L1_error) - if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { - __pyx_wrapperbase_6hunter_11_predicates_5Query___init__ = *((PyWrapperDescrObject *)wrapper)->d_base; - __pyx_wrapperbase_6hunter_11_predicates_5Query___init__.doc = __pyx_doc_6hunter_11_predicates_5Query___init__; - ((PyWrapperDescrObject *)wrapper)->d_base = &__pyx_wrapperbase_6hunter_11_predicates_5Query___init__; - } - } - #endif - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Query, (PyObject *)&__pyx_type_6hunter_11_predicates_Query) < 0) __PYX_ERR(0, 38, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6hunter_11_predicates_Query) < 0) __PYX_ERR(0, 38, __pyx_L1_error) - __pyx_ptype_6hunter_11_predicates_Query = &__pyx_type_6hunter_11_predicates_Query; - if (PyType_Ready(&__pyx_type_6hunter_11_predicates_And) < 0) __PYX_ERR(0, 394, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_6hunter_11_predicates_And.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6hunter_11_predicates_And.tp_dictoffset && __pyx_type_6hunter_11_predicates_And.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_6hunter_11_predicates_And.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; - } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_And, (PyObject *)&__pyx_type_6hunter_11_predicates_And) < 0) __PYX_ERR(0, 394, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6hunter_11_predicates_And) < 0) __PYX_ERR(0, 394, __pyx_L1_error) - __pyx_ptype_6hunter_11_predicates_And = &__pyx_type_6hunter_11_predicates_And; - if (PyType_Ready(&__pyx_type_6hunter_11_predicates_Or) < 0) __PYX_ERR(0, 446, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_6hunter_11_predicates_Or.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6hunter_11_predicates_Or.tp_dictoffset && __pyx_type_6hunter_11_predicates_Or.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_6hunter_11_predicates_Or.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; - } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Or, (PyObject *)&__pyx_type_6hunter_11_predicates_Or) < 0) __PYX_ERR(0, 446, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6hunter_11_predicates_Or) < 0) __PYX_ERR(0, 446, __pyx_L1_error) - __pyx_ptype_6hunter_11_predicates_Or = &__pyx_type_6hunter_11_predicates_Or; - if (PyType_Ready(&__pyx_type_6hunter_11_predicates_Not) < 0) __PYX_ERR(0, 498, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_6hunter_11_predicates_Not.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6hunter_11_predicates_Not.tp_dictoffset && __pyx_type_6hunter_11_predicates_Not.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_6hunter_11_predicates_Not.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; - } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Not, (PyObject *)&__pyx_type_6hunter_11_predicates_Not) < 0) __PYX_ERR(0, 498, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6hunter_11_predicates_Not) < 0) __PYX_ERR(0, 498, __pyx_L1_error) - __pyx_ptype_6hunter_11_predicates_Not = &__pyx_type_6hunter_11_predicates_Not; - if (PyType_Ready(&__pyx_type_6hunter_11_predicates_When) < 0) __PYX_ERR(0, 261, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_6hunter_11_predicates_When.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6hunter_11_predicates_When.tp_dictoffset && __pyx_type_6hunter_11_predicates_When.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_6hunter_11_predicates_When.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; - } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_When, (PyObject *)&__pyx_type_6hunter_11_predicates_When) < 0) __PYX_ERR(0, 261, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6hunter_11_predicates_When) < 0) __PYX_ERR(0, 261, __pyx_L1_error) - __pyx_ptype_6hunter_11_predicates_When = &__pyx_type_6hunter_11_predicates_When; - if (PyType_Ready(&__pyx_type_6hunter_11_predicates_From) < 0) __PYX_ERR(0, 320, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_6hunter_11_predicates_From.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6hunter_11_predicates_From.tp_dictoffset && __pyx_type_6hunter_11_predicates_From.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_6hunter_11_predicates_From.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; - } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_From, (PyObject *)&__pyx_type_6hunter_11_predicates_From) < 0) __PYX_ERR(0, 320, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6hunter_11_predicates_From) < 0) __PYX_ERR(0, 320, __pyx_L1_error) - __pyx_ptype_6hunter_11_predicates_From = &__pyx_type_6hunter_11_predicates_From; - if (PyType_Ready(&__pyx_type_6hunter_11_predicates___pyx_scope_struct____str__) < 0) __PYX_ERR(0, 137, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_6hunter_11_predicates___pyx_scope_struct____str__.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6hunter_11_predicates___pyx_scope_struct____str__.tp_dictoffset && __pyx_type_6hunter_11_predicates___pyx_scope_struct____str__.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_6hunter_11_predicates___pyx_scope_struct____str__.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; - } - __pyx_ptype_6hunter_11_predicates___pyx_scope_struct____str__ = &__pyx_type_6hunter_11_predicates___pyx_scope_struct____str__; - if (PyType_Ready(&__pyx_type_6hunter_11_predicates___pyx_scope_struct_1_genexpr) < 0) __PYX_ERR(0, 140, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_6hunter_11_predicates___pyx_scope_struct_1_genexpr.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6hunter_11_predicates___pyx_scope_struct_1_genexpr.tp_dictoffset && __pyx_type_6hunter_11_predicates___pyx_scope_struct_1_genexpr.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_6hunter_11_predicates___pyx_scope_struct_1_genexpr.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; - } - __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_1_genexpr = &__pyx_type_6hunter_11_predicates___pyx_scope_struct_1_genexpr; - if (PyType_Ready(&__pyx_type_6hunter_11_predicates___pyx_scope_struct_2_genexpr) < 0) __PYX_ERR(0, 140, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_6hunter_11_predicates___pyx_scope_struct_2_genexpr.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6hunter_11_predicates___pyx_scope_struct_2_genexpr.tp_dictoffset && __pyx_type_6hunter_11_predicates___pyx_scope_struct_2_genexpr.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_6hunter_11_predicates___pyx_scope_struct_2_genexpr.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; - } - __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_2_genexpr = &__pyx_type_6hunter_11_predicates___pyx_scope_struct_2_genexpr; - if (PyType_Ready(&__pyx_type_6hunter_11_predicates___pyx_scope_struct_3___repr__) < 0) __PYX_ERR(0, 156, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_6hunter_11_predicates___pyx_scope_struct_3___repr__.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6hunter_11_predicates___pyx_scope_struct_3___repr__.tp_dictoffset && __pyx_type_6hunter_11_predicates___pyx_scope_struct_3___repr__.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_6hunter_11_predicates___pyx_scope_struct_3___repr__.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + Py_ssize_t __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + size_t __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[142])) + __Pyx_RefNannySetupContext("__pyx_unpickle_From__set_state", 0); + __Pyx_TraceStartFunc("__pyx_unpickle_From__set_state", __pyx_f[1], 11, 0, 0, 0, __PYX_ERR(1, 11, __pyx_L1_error)); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_From__set_state(From __pyx_result, tuple __pyx_state): + * __pyx_result.condition = __pyx_state[0]; __pyx_result.origin_calls = __pyx_state[1]; __pyx_result.origin_depth = __pyx_state[2]; __pyx_result.predicate = __pyx_state[3]; __pyx_result.watermark = __pyx_state[4] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 5 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[5]) +*/ + __Pyx_TraceLine(12,3,0,__PYX_ERR(1, 12, __pyx_L1_error)) + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) } - __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_3___repr__ = &__pyx_type_6hunter_11_predicates___pyx_scope_struct_3___repr__; - if (PyType_Ready(&__pyx_type_6hunter_11_predicates___pyx_scope_struct_4_genexpr) < 0) __PYX_ERR(0, 158, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_6hunter_11_predicates___pyx_scope_struct_4_genexpr.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6hunter_11_predicates___pyx_scope_struct_4_genexpr.tp_dictoffset && __pyx_type_6hunter_11_predicates___pyx_scope_struct_4_genexpr.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_6hunter_11_predicates___pyx_scope_struct_4_genexpr.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->condition); + __Pyx_DECREF(__pyx_v___pyx_result->condition); + __pyx_v___pyx_result->condition = __pyx_t_1; + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) } - __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_4_genexpr = &__pyx_type_6hunter_11_predicates___pyx_scope_struct_4_genexpr; - if (PyType_Ready(&__pyx_type_6hunter_11_predicates___pyx_scope_struct_5___init__) < 0) __PYX_ERR(0, 268, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_6hunter_11_predicates___pyx_scope_struct_5___init__.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6hunter_11_predicates___pyx_scope_struct_5___init__.tp_dictoffset && __pyx_type_6hunter_11_predicates___pyx_scope_struct_5___init__.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_6hunter_11_predicates___pyx_scope_struct_5___init__.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; - } - __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_5___init__ = &__pyx_type_6hunter_11_predicates___pyx_scope_struct_5___init__; - if (PyType_Ready(&__pyx_type_6hunter_11_predicates___pyx_scope_struct_6_genexpr) < 0) __PYX_ERR(0, 273, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_6hunter_11_predicates___pyx_scope_struct_6_genexpr.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6hunter_11_predicates___pyx_scope_struct_6_genexpr.tp_dictoffset && __pyx_type_6hunter_11_predicates___pyx_scope_struct_6_genexpr.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_6hunter_11_predicates___pyx_scope_struct_6_genexpr.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; - } - __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_6_genexpr = &__pyx_type_6hunter_11_predicates___pyx_scope_struct_6_genexpr; - if (PyType_Ready(&__pyx_type_6hunter_11_predicates___pyx_scope_struct_7___str__) < 0) __PYX_ERR(0, 276, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_6hunter_11_predicates___pyx_scope_struct_7___str__.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6hunter_11_predicates___pyx_scope_struct_7___str__.tp_dictoffset && __pyx_type_6hunter_11_predicates___pyx_scope_struct_7___str__.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_6hunter_11_predicates___pyx_scope_struct_7___str__.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->origin_calls = __pyx_t_2; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) } - __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_7___str__ = &__pyx_type_6hunter_11_predicates___pyx_scope_struct_7___str__; - if (PyType_Ready(&__pyx_type_6hunter_11_predicates___pyx_scope_struct_8_genexpr) < 0) __PYX_ERR(0, 279, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_6hunter_11_predicates___pyx_scope_struct_8_genexpr.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6hunter_11_predicates___pyx_scope_struct_8_genexpr.tp_dictoffset && __pyx_type_6hunter_11_predicates___pyx_scope_struct_8_genexpr.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_6hunter_11_predicates___pyx_scope_struct_8_genexpr.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->origin_depth = __pyx_t_2; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) } - __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_8_genexpr = &__pyx_type_6hunter_11_predicates___pyx_scope_struct_8_genexpr; - if (PyType_Ready(&__pyx_type_6hunter_11_predicates___pyx_scope_struct_9___str__) < 0) __PYX_ERR(0, 401, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_6hunter_11_predicates___pyx_scope_struct_9___str__.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6hunter_11_predicates___pyx_scope_struct_9___str__.tp_dictoffset && __pyx_type_6hunter_11_predicates___pyx_scope_struct_9___str__.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_6hunter_11_predicates___pyx_scope_struct_9___str__.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->predicate); + __Pyx_DECREF(__pyx_v___pyx_result->predicate); + __pyx_v___pyx_result->predicate = __pyx_t_1; + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) } - __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_9___str__ = &__pyx_type_6hunter_11_predicates___pyx_scope_struct_9___str__; - if (PyType_Ready(&__pyx_type_6hunter_11_predicates___pyx_scope_struct_10_genexpr) < 0) __PYX_ERR(0, 402, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_6hunter_11_predicates___pyx_scope_struct_10_genexpr.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6hunter_11_predicates___pyx_scope_struct_10_genexpr.tp_dictoffset && __pyx_type_6hunter_11_predicates___pyx_scope_struct_10_genexpr.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_6hunter_11_predicates___pyx_scope_struct_10_genexpr.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 4, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->watermark = __pyx_t_2; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_From__set_state(From __pyx_result, tuple __pyx_state): + * __pyx_result.condition = __pyx_state[0]; __pyx_result.origin_calls = __pyx_state[1]; __pyx_result.origin_depth = __pyx_state[2]; __pyx_result.predicate = __pyx_state[3]; __pyx_result.watermark = __pyx_state[4] + * if len(__pyx_state) > 5 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[5]) +*/ + __Pyx_TraceLine(13,29,0,__PYX_ERR(1, 13, __pyx_L1_error)) + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(1, 13, __pyx_L1_error) } - __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_10_genexpr = &__pyx_type_6hunter_11_predicates___pyx_scope_struct_10_genexpr; - if (PyType_Ready(&__pyx_type_6hunter_11_predicates___pyx_scope_struct_11___str__) < 0) __PYX_ERR(0, 454, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_6hunter_11_predicates___pyx_scope_struct_11___str__.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6hunter_11_predicates___pyx_scope_struct_11___str__.tp_dictoffset && __pyx_type_6hunter_11_predicates___pyx_scope_struct_11___str__.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_6hunter_11_predicates___pyx_scope_struct_11___str__.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + __pyx_t_4 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + __pyx_t_5 = (__pyx_t_4 > 5); + if (__pyx_t_5) { + } else { + __pyx_t_3 = __pyx_t_5; + goto __pyx_L4_bool_binop_done; } - __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_11___str__ = &__pyx_type_6hunter_11_predicates___pyx_scope_struct_11___str__; - if (PyType_Ready(&__pyx_type_6hunter_11_predicates___pyx_scope_struct_12_genexpr) < 0) __PYX_ERR(0, 455, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_6hunter_11_predicates___pyx_scope_struct_12_genexpr.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6hunter_11_predicates___pyx_scope_struct_12_genexpr.tp_dictoffset && __pyx_type_6hunter_11_predicates___pyx_scope_struct_12_genexpr.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_6hunter_11_predicates___pyx_scope_struct_12_genexpr.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + __pyx_t_5 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_mstate_global->__pyx_n_u_dict); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + __pyx_t_3 = __pyx_t_5; + __pyx_L4_bool_binop_done:; + if (__pyx_t_3) { + + /* "(tree fragment)":14 + * __pyx_result.condition = __pyx_state[0]; __pyx_result.origin_calls = __pyx_state[1]; __pyx_result.origin_depth = __pyx_state[2]; __pyx_result.predicate = __pyx_state[3]; __pyx_result.watermark = __pyx_state[4] + * if len(__pyx_state) > 5 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[5]) # <<<<<<<<<<<<<< +*/ + __Pyx_TraceLine(14,38,0,__PYX_ERR(1, 14, __pyx_L1_error)) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_mstate_global->__pyx_n_u_dict); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __pyx_t_7; + __Pyx_INCREF(__pyx_t_6); + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 14, __pyx_L1_error) + } + __pyx_t_8 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 5, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_8}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_update, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_From__set_state(From __pyx_result, tuple __pyx_state): + * __pyx_result.condition = __pyx_state[0]; __pyx_result.origin_calls = __pyx_state[1]; __pyx_result.origin_depth = __pyx_state[2]; __pyx_result.predicate = __pyx_state[3]; __pyx_result.watermark = __pyx_state[4] + * if len(__pyx_state) > 5 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[5]) +*/ } - __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_12_genexpr = &__pyx_type_6hunter_11_predicates___pyx_scope_struct_12_genexpr; - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_RefNannyFinishContext(); - return -1; -} -static int __Pyx_modinit_type_import_code(void) { - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); - /*--- Type import code ---*/ - __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", - #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 - sizeof(PyTypeObject), - #else - sizeof(PyHeapTypeObject), - #endif - __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(3, 9, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyImport_ImportModule("types"); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_6hunter_7_tracer_CodeType = __Pyx_ImportType(__pyx_t_1, "types", "CodeType", sizeof(PyCodeObject), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_6hunter_7_tracer_CodeType) __PYX_ERR(4, 9, __pyx_L1_error) - __pyx_ptype_6hunter_7_tracer_FrameType = __Pyx_ImportType(__pyx_t_1, "types", "FrameType", sizeof(PyFrameObject), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_6hunter_7_tracer_FrameType) __PYX_ERR(4, 13, __pyx_L1_error) - __pyx_t_2 = PyImport_ImportModule("hunter._tracer"); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 28, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_ptype_6hunter_7_tracer_Tracer = __Pyx_ImportType(__pyx_t_2, "hunter._tracer", "Tracer", sizeof(struct __pyx_obj_6hunter_7_tracer_Tracer), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_6hunter_7_tracer_Tracer) __PYX_ERR(4, 28, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = PyImport_ImportModule("hunter._event"); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 11, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_ptype_6hunter_6_event_Event = __Pyx_ImportType(__pyx_t_2, "hunter._event", "Event", sizeof(struct __pyx_obj_6hunter_6_event_Event), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_6hunter_6_event_Event) __PYX_ERR(5, 11, __pyx_L1_error) - __pyx_vtabptr_6hunter_6_event_Event = (struct __pyx_vtabstruct_6hunter_6_event_Event*)__Pyx_GetVtable(__pyx_ptype_6hunter_6_event_Event->tp_dict); if (unlikely(!__pyx_vtabptr_6hunter_6_event_Event)) __PYX_ERR(5, 11, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_RefNannyFinishContext(); - return 0; + /* "(tree fragment)":11 + * __pyx_unpickle_From__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_From__set_state(From __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.condition = __pyx_state[0]; __pyx_result.origin_calls = __pyx_state[1]; __pyx_result.origin_depth = __pyx_state[2]; __pyx_result.predicate = __pyx_state[3]; __pyx_result.watermark = __pyx_state[4] + * if len(__pyx_state) > 5 and hasattr(__pyx_result, '__dict__'): +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(1, 11, __pyx_L1_error)); + goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_RefNannyFinishContext(); - return -1; -} - -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_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 11, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_From__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); - return 0; + return __pyx_r; } +/* "(tree fragment)":1 + * def __pyx_unpickle_And(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result +*/ -#if PY_MAJOR_VERSION < 3 -#ifdef CYTHON_NO_PYINIT_EXPORT -#define __Pyx_PyMODINIT_FUNC void +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_7__pyx_unpickle_And(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else -#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +PyObject *__pyx_args, PyObject *__pyx_kwds #endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_11_predicates_7__pyx_unpickle_And = {"__pyx_unpickle_And", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_7__pyx_unpickle_And, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_11_predicates_7__pyx_unpickle_And(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else -#ifdef CYTHON_NO_PYINIT_EXPORT -#define __Pyx_PyMODINIT_FUNC PyObject * -#else -#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC -#endif +PyObject *__pyx_args, PyObject *__pyx_kwds #endif - - -#if PY_MAJOR_VERSION < 3 -__Pyx_PyMODINIT_FUNC init_predicates(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC init_predicates(void) -#else -__Pyx_PyMODINIT_FUNC PyInit__predicates(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC PyInit__predicates(void) -#if CYTHON_PEP489_MULTI_PHASE_INIT -{ - return PyModuleDef_Init(&__pyx_moduledef); -} -static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { - #if PY_VERSION_HEX >= 0x030700A1 - static PY_INT64_T main_interpreter_id = -1; - PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); - if (main_interpreter_id == -1) { - main_interpreter_id = current_id; - return (unlikely(current_id == -1)) ? -1 : 0; - } else if (unlikely(main_interpreter_id != current_id)) - #else - static PyInterpreterState *main_interpreter = NULL; - PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; - if (!main_interpreter) { - main_interpreter = current_interpreter; - } else if (unlikely(main_interpreter != current_interpreter)) - #endif - { - PyErr_SetString( - PyExc_ImportError, - "Interpreter change detected - this module can only be loaded into one interpreter per process."); - return -1; - } - return 0; -} -static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { - PyObject *value = PyObject_GetAttrString(spec, from_name); - int result = 0; - if (likely(value)) { - if (allow_none || value != Py_None) { - result = PyDict_SetItemString(moddict, to_name, value); - } - Py_DECREF(value); - } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { - PyErr_Clear(); - } else { - result = -1; - } - return result; -} -static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { - PyObject *module = NULL, *moddict, *modname; - if (__Pyx_check_single_interpreter()) - return NULL; - 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__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; - return module; -bad: - Py_XDECREF(module); - return NULL; -} - - -static CYTHON_SMALL_CODE int __pyx_pymod_exec__predicates(PyObject *__pyx_pyinit_module) -#endif -#endif -{ - __Pyx_TraceDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - #if CYTHON_PEP489_MULTI_PHASE_INIT - if (__pyx_m) { - if (__pyx_m == __pyx_pyinit_module) return 0; - PyErr_SetString(PyExc_RuntimeError, "Module '_predicates' has already been imported. Re-initialisation is not supported."); - return -1; - } - #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__predicates(void)", 0); - if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #ifdef __Pxy_PyFrame_Initialize_Offsets - __Pxy_PyFrame_Initialize_Offsets(); - #endif - __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("_predicates", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + __Pyx_RefNannySetupContext("__pyx_unpickle_And (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else - __pyx_m = PyModule_Create(&__pyx_moduledef); - #endif - if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #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) - Py_INCREF(__pyx_b); - __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_cython_runtime); - 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_hunter___predicates) { - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - } - #if PY_MAJOR_VERSION >= 3 + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) - if (!PyDict_GetItemString(modules, "hunter._predicates")) { - if (unlikely(PyDict_SetItemString(modules, "hunter._predicates", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_type,&__pyx_mstate_global->__pyx_n_u_pyx_checksum,&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 1, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 1, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 1, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 1, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__pyx_unpickle_And", 0) < 0) __PYX_ERR(1, 1, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_And", 1, 3, 3, i); __PYX_ERR(1, 1, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 1, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 1, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 1, __pyx_L3_error) } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyLong_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; } - #endif - /*--- Builtin init code ---*/ - if (__Pyx_InitCachedBuiltins() < 0) goto __pyx_L1_error; - /*--- Constants init code ---*/ - if (__Pyx_InitCachedConstants() < 0) goto __pyx_L1_error; - /*--- Global type/function init code ---*/ - (void)__Pyx_modinit_global_init_code(); - (void)__Pyx_modinit_variable_export_code(); - if (unlikely(__Pyx_modinit_function_export_code() != 0)) goto __pyx_L1_error; - if (unlikely(__Pyx_modinit_type_init_code() != 0)) goto __pyx_L1_error; - if (unlikely(__Pyx_modinit_type_import_code() != 0)) goto __pyx_L1_error; - (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 - __Pyx_TraceCall("__Pyx_PyMODINIT_FUNC PyInit__predicates(void)", __pyx_f[0], 1, 0, __PYX_ERR(0, 1, __pyx_L1_error)); + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_And", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_And", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6hunter_11_predicates_6__pyx_unpickle_And(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); - /* "hunter/_predicates.pyx":4 - * from __future__ import absolute_import - * - * import inspect # <<<<<<<<<<<<<< - * import re - * from itertools import chain - */ - __Pyx_TraceLine(4,0,__PYX_ERR(0, 4, __pyx_L1_error)) - __pyx_t_1 = __Pyx_patch_inspect(__Pyx_Import(__pyx_n_s_inspect, 0, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_inspect, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":5 - * - * import inspect - * import re # <<<<<<<<<<<<<< - * from itertools import chain - * - */ - __Pyx_TraceLine(5,0,__PYX_ERR(0, 5, __pyx_L1_error)) - __pyx_t_1 = __Pyx_Import(__pyx_n_s_re, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_re, __pyx_t_1) < 0) __PYX_ERR(0, 5, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; +static PyObject *__pyx_pf_6hunter_11_predicates_6__pyx_unpickle_And(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[143])) + __Pyx_RefNannySetupContext("__pyx_unpickle_And", 0); + __Pyx_TraceStartFunc("__pyx_unpickle_And", __pyx_f[1], 1, 0, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); - /* "hunter/_predicates.pyx":6 - * import inspect - * import re - * from itertools import chain # <<<<<<<<<<<<<< - * - * cimport cython - */ - __Pyx_TraceLine(6,0,__PYX_ERR(0, 6, __pyx_L1_error)) - __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(__pyx_n_s_chain); - __Pyx_GIVEREF(__pyx_n_s_chain); - PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_chain); - __pyx_t_2 = __Pyx_Import(__pyx_n_s_itertools, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_chain); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x8e21672, 0xc8ea956, 0xaa8cbda): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x8e21672, 0xc8ea956, 0xaa8cbda) = (predicates))" % __pyx_checksum +*/ + __Pyx_TraceLine(4,2,0,__PYX_ERR(1, 4, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyLong_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_chain, __pyx_t_1) < 0) __PYX_ERR(0, 6, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_mstate_global->__pyx_tuple[3], Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_2) { - /* "hunter/_predicates.pyx":15 - * from ._event cimport Event - * - * from .actions import Action # <<<<<<<<<<<<<< - * - * __all__ = ( - */ - __Pyx_TraceLine(15,0,__PYX_ERR(0, 15, __pyx_L1_error)) - __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_n_s_Action); - __Pyx_GIVEREF(__pyx_n_s_Action); - PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_Action); - __pyx_t_1 = __Pyx_Import(__pyx_n_s_actions, __pyx_t_2, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_Action); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_Action, __pyx_t_2) < 0) __PYX_ERR(0, 15, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0x8e21672, 0xc8ea956, 0xaa8cbda): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x8e21672, 0xc8ea956, 0xaa8cbda) = (predicates))" % __pyx_checksum + * __pyx_result = And.__new__(__pyx_type) +*/ + __Pyx_TraceLine(5,9,0,__PYX_ERR(1, 5, __pyx_L1_error)) + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_PickleError); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_mstate_global->__pyx_n_u_PickleError) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "hunter/_predicates.pyx":18 - * - * __all__ = ( - * 'And', # <<<<<<<<<<<<<< - * 'From', - * 'Not', - */ - __Pyx_TraceLine(18,0,__PYX_ERR(0, 18, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_d, __pyx_n_s_all, __pyx_tuple__12) < 0) __PYX_ERR(0, 17, __pyx_L1_error) + /* "(tree fragment)":6 + * if __pyx_checksum not in (0x8e21672, 0xc8ea956, 0xaa8cbda): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x8e21672, 0xc8ea956, 0xaa8cbda) = (predicates))" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = And.__new__(__pyx_type) + * if __pyx_state is not None: +*/ + __Pyx_TraceLine(6,14,0,__PYX_ERR(1, 6, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyLong_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyUnicode_Format(__pyx_mstate_global->__pyx_kp_u_Incompatible_checksums_0x_x_vs_0_4, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 6, __pyx_L1_error) - /* "hunter/_predicates.pyx":27 - * - * cdef tuple ALLOWED_KEYS = ( - * 'function', 'code', 'frame', 'module', 'lineno', 'globals', 'stdlib', 'arg', 'locals', 'kind', 'filename', 'source', # <<<<<<<<<<<<<< - * 'fullsource', 'threadname', 'threadid', 'depth', 'calls', - * ) - */ - __Pyx_TraceLine(27,0,__PYX_ERR(0, 27, __pyx_L1_error)) - __Pyx_INCREF(__pyx_tuple__13); - __Pyx_XGOTREF(__pyx_v_6hunter_11_predicates_ALLOWED_KEYS); - __Pyx_DECREF_SET(__pyx_v_6hunter_11_predicates_ALLOWED_KEYS, __pyx_tuple__13); - __Pyx_GIVEREF(__pyx_tuple__13); + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x8e21672, 0xc8ea956, 0xaa8cbda): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x8e21672, 0xc8ea956, 0xaa8cbda) = (predicates))" % __pyx_checksum +*/ + } - /* "hunter/_predicates.pyx":31 - * ) - * cdef tuple ALLOWED_OPERATORS = ( - * 'startswith', 'endswith', 'in', 'contains', 'regex', # <<<<<<<<<<<<<< - * 'sw', 'ew', 'has', 'rx', - * 'gt', 'gte', 'lt', 'lte', - */ - __Pyx_TraceLine(31,0,__PYX_ERR(0, 31, __pyx_L1_error)) - __Pyx_INCREF(__pyx_tuple__14); - __Pyx_XGOTREF(__pyx_v_6hunter_11_predicates_ALLOWED_OPERATORS); - __Pyx_DECREF_SET(__pyx_v_6hunter_11_predicates_ALLOWED_OPERATORS, __pyx_tuple__14); - __Pyx_GIVEREF(__pyx_tuple__14); + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x8e21672, 0xc8ea956, 0xaa8cbda) = (predicates))" % __pyx_checksum + * __pyx_result = And.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_And__set_state( __pyx_result, __pyx_state) +*/ + __Pyx_TraceLine(7,16,0,__PYX_ERR(1, 7, __pyx_L1_error)) + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_And); + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_new, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; - /* "hunter/_predicates.pyx":215 - * return Not(self) - * - * cdef fast_Query_call(Query self, Event event): # <<<<<<<<<<<<<< - * for key, value in self.query_eq: - * evalue = event[key] - */ - __Pyx_TraceLine(215,0,__PYX_ERR(0, 215, __pyx_L1_error)) + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x8e21672, 0xc8ea956, 0xaa8cbda) = (predicates))" % __pyx_checksum + * __pyx_result = And.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_And__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + __Pyx_TraceLine(8,23,0,__PYX_ERR(1, 8, __pyx_L1_error)) + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + /* "(tree fragment)":9 + * __pyx_result = And.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_And__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_And__set_state(And __pyx_result, tuple __pyx_state): +*/ + __Pyx_TraceLine(9,28,0,__PYX_ERR(1, 9, __pyx_L1_error)) + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_6hunter_11_predicates___pyx_unpickle_And__set_state(((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "hunter/_predicates.pyx":307 - * return Not(self) - * - * cdef inline fast_When_call(When self, Event event): # <<<<<<<<<<<<<< - * cdef object result - * - */ - __Pyx_TraceLine(307,0,__PYX_ERR(0, 307, __pyx_L1_error)) - - - /* "hunter/_predicates.pyx":364 - * return Not(self) - * - * cdef inline fast_From_call(From self, Event event): # <<<<<<<<<<<<<< - * cdef object result - * cdef int delta_depth - */ - __Pyx_TraceLine(364,0,__PYX_ERR(0, 364, __pyx_L1_error)) - + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x8e21672, 0xc8ea956, 0xaa8cbda) = (predicates))" % __pyx_checksum + * __pyx_result = And.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_And__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + } - /* "hunter/_predicates.pyx":437 - * return Not(self) - * - * cdef inline fast_And_call(And self, Event event): # <<<<<<<<<<<<<< - * for predicate in self.predicates: - * if not fast_call(predicate, event): - */ - __Pyx_TraceLine(437,0,__PYX_ERR(0, 437, __pyx_L1_error)) + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_And__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_And__set_state(And __pyx_result, tuple __pyx_state): + * __pyx_result.predicates = __pyx_state[0] +*/ + __Pyx_TraceLine(10,29,0,__PYX_ERR(1, 10, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + __Pyx_TraceReturnValue(__pyx_r, 29, 0, __PYX_ERR(1, 10, __pyx_L1_error)); + goto __pyx_L0; + /* "(tree fragment)":1 + * def __pyx_unpickle_And(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result +*/ - /* "hunter/_predicates.pyx":490 - * return Not(self) - * - * cdef inline fast_Or_call(Or self, Event event): # <<<<<<<<<<<<<< - * for predicate in self.predicates: - * if fast_call(predicate, event): - */ - __Pyx_TraceLine(490,0,__PYX_ERR(0, 490, __pyx_L1_error)) + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_And", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +/* "(tree fragment)":11 + * __pyx_unpickle_And__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_And__set_state(And __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.predicates = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): +*/ - /* "hunter/_predicates.pyx":538 - * return self.predicate - * - * cdef inline fast_Not_call(Not self, Event event): # <<<<<<<<<<<<<< - * return not fast_call(self.predicate, event) - * - */ - __Pyx_TraceLine(538,0,__PYX_ERR(0, 538, __pyx_L1_error)) +static PyObject *__pyx_f_6hunter_11_predicates___pyx_unpickle_And__set_state(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + size_t __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[144])) + __Pyx_RefNannySetupContext("__pyx_unpickle_And__set_state", 0); + __Pyx_TraceStartFunc("__pyx_unpickle_And__set_state", __pyx_f[1], 11, 0, 0, 0, __PYX_ERR(1, 11, __pyx_L1_error)); + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_And__set_state(And __pyx_result, tuple __pyx_state): + * __pyx_result.predicates = __pyx_state[0] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) +*/ + __Pyx_TraceLine(12,3,0,__PYX_ERR(1, 12, __pyx_L1_error)) + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_t_1))) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->predicates); + __Pyx_DECREF(__pyx_v___pyx_result->predicates); + __pyx_v___pyx_result->predicates = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; - /* "hunter/_predicates.pyx":542 - * - * - * cdef inline fast_call(callable, Event event): # <<<<<<<<<<<<<< - * if type(callable) is Query: - * return fast_Query_call( callable, event) - */ - __Pyx_TraceLine(542,0,__PYX_ERR(0, 542, __pyx_L1_error)) + /* "(tree fragment)":13 + * cdef __pyx_unpickle_And__set_state(And __pyx_result, tuple __pyx_state): + * __pyx_result.predicates = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) +*/ + __Pyx_TraceLine(13,9,0,__PYX_ERR(1, 13, __pyx_L1_error)) + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(1, 13, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 > 1); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_mstate_global->__pyx_n_u_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + /* "(tree fragment)":14 + * __pyx_result.predicates = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) # <<<<<<<<<<<<<< +*/ + __Pyx_TraceLine(14,18,0,__PYX_ERR(1, 14, __pyx_L1_error)) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_mstate_global->__pyx_n_u_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = __pyx_t_6; + __Pyx_INCREF(__pyx_t_5); + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 14, __pyx_L1_error) + } + __pyx_t_7 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_7}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_update, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "(tree fragment)":1 - * def __pyx_unpickle_Query(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ - __Pyx_TraceLine(1,0,__PYX_ERR(2, 1, __pyx_L1_error)) - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6hunter_11_predicates_1__pyx_unpickle_Query, NULL, __pyx_n_s_hunter__predicates); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Query, __pyx_t_1) < 0) __PYX_ERR(2, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /* "(tree fragment)":13 + * cdef __pyx_unpickle_And__set_state(And __pyx_result, tuple __pyx_state): + * __pyx_result.predicates = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) +*/ + } /* "(tree fragment)":11 - * __pyx_unpickle_Query__set_state( __pyx_result, __pyx_state) + * __pyx_unpickle_And__set_state( __pyx_result, __pyx_state) * return __pyx_result - * cdef __pyx_unpickle_Query__set_state(Query __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< - * __pyx_result.query_contains = __pyx_state[0]; __pyx_result.query_endswith = __pyx_state[1]; __pyx_result.query_eq = __pyx_state[2]; __pyx_result.query_gt = __pyx_state[3]; __pyx_result.query_gte = __pyx_state[4]; __pyx_result.query_in = __pyx_state[5]; __pyx_result.query_lt = __pyx_state[6]; __pyx_result.query_lte = __pyx_state[7]; __pyx_result.query_regex = __pyx_state[8]; __pyx_result.query_startswith = __pyx_state[9] - * if len(__pyx_state) > 10 and hasattr(__pyx_result, '__dict__'): - */ - __Pyx_TraceLine(11,0,__PYX_ERR(2, 11, __pyx_L1_error)) + * cdef __pyx_unpickle_And__set_state(And __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.predicates = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): +*/ + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(1, 11, __pyx_L1_error)); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 11, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_And__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "(tree fragment)":1 - * def __pyx_unpickle_When(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< +/* "(tree fragment)":1 + * def __pyx_unpickle_Or(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result - */ - __Pyx_TraceLine(1,0,__PYX_ERR(2, 1, __pyx_L1_error)) - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6hunter_11_predicates_3__pyx_unpickle_When, NULL, __pyx_n_s_hunter__predicates); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_When, __pyx_t_1) < 0) __PYX_ERR(2, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; +*/ - /* "(tree fragment)":11 - * __pyx_unpickle_When__set_state( __pyx_result, __pyx_state) - * return __pyx_result - * cdef __pyx_unpickle_When__set_state(When __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< - * __pyx_result.actions = __pyx_state[0]; __pyx_result.condition = __pyx_state[1] - * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): - */ - __Pyx_TraceLine(11,0,__PYX_ERR(2, 11, __pyx_L1_error)) +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_9__pyx_unpickle_Or(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_11_predicates_9__pyx_unpickle_Or = {"__pyx_unpickle_Or", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_9__pyx_unpickle_Or, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_11_predicates_9__pyx_unpickle_Or(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_Or (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_type,&__pyx_mstate_global->__pyx_n_u_pyx_checksum,&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 1, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 1, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 1, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 1, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__pyx_unpickle_Or", 0) < 0) __PYX_ERR(1, 1, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Or", 1, 3, 3, i); __PYX_ERR(1, 1, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 1, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 1, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 1, __pyx_L3_error) + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyLong_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Or", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_Or", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6hunter_11_predicates_8__pyx_unpickle_Or(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "(tree fragment)":1 - * def __pyx_unpickle_From(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< +static PyObject *__pyx_pf_6hunter_11_predicates_8__pyx_unpickle_Or(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[145])) + __Pyx_RefNannySetupContext("__pyx_unpickle_Or", 0); + __Pyx_TraceStartFunc("__pyx_unpickle_Or", __pyx_f[1], 1, 0, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); + + /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result - */ - __Pyx_TraceLine(1,0,__PYX_ERR(2, 1, __pyx_L1_error)) - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6hunter_11_predicates_5__pyx_unpickle_From, NULL, __pyx_n_s_hunter__predicates); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1, __pyx_L1_error) + * if __pyx_checksum not in (0x8e21672, 0xc8ea956, 0xaa8cbda): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x8e21672, 0xc8ea956, 0xaa8cbda) = (predicates))" % __pyx_checksum +*/ + __Pyx_TraceLine(4,2,0,__PYX_ERR(1, 4, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyLong_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_From, __pyx_t_1) < 0) __PYX_ERR(2, 1, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_mstate_global->__pyx_tuple[3], Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { - /* "(tree fragment)":11 - * __pyx_unpickle_From__set_state( __pyx_result, __pyx_state) - * return __pyx_result - * cdef __pyx_unpickle_From__set_state(From __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< - * __pyx_result.condition = __pyx_state[0]; __pyx_result.origin_calls = __pyx_state[1]; __pyx_result.origin_depth = __pyx_state[2]; __pyx_result.predicate = __pyx_state[3]; __pyx_result.watermark = __pyx_state[4] - * if len(__pyx_state) > 5 and hasattr(__pyx_result, '__dict__'): - */ - __Pyx_TraceLine(11,0,__PYX_ERR(2, 11, __pyx_L1_error)) - + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0x8e21672, 0xc8ea956, 0xaa8cbda): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x8e21672, 0xc8ea956, 0xaa8cbda) = (predicates))" % __pyx_checksum + * __pyx_result = Or.__new__(__pyx_type) +*/ + __Pyx_TraceLine(5,9,0,__PYX_ERR(1, 5, __pyx_L1_error)) + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_PickleError); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_mstate_global->__pyx_n_u_PickleError) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0x8e21672, 0xc8ea956, 0xaa8cbda): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x8e21672, 0xc8ea956, 0xaa8cbda) = (predicates))" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = Or.__new__(__pyx_type) + * if __pyx_state is not None: +*/ + __Pyx_TraceLine(6,14,0,__PYX_ERR(1, 6, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyLong_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyUnicode_Format(__pyx_mstate_global->__pyx_kp_u_Incompatible_checksums_0x_x_vs_0_4, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x8e21672, 0xc8ea956, 0xaa8cbda): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x8e21672, 0xc8ea956, 0xaa8cbda) = (predicates))" % __pyx_checksum +*/ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x8e21672, 0xc8ea956, 0xaa8cbda) = (predicates))" % __pyx_checksum + * __pyx_result = Or.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_Or__set_state( __pyx_result, __pyx_state) +*/ + __Pyx_TraceLine(7,16,0,__PYX_ERR(1, 7, __pyx_L1_error)) + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Or); + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_new, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x8e21672, 0xc8ea956, 0xaa8cbda) = (predicates))" % __pyx_checksum + * __pyx_result = Or.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Or__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + __Pyx_TraceLine(8,23,0,__PYX_ERR(1, 8, __pyx_L1_error)) + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = Or.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_Or__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_Or__set_state(Or __pyx_result, tuple __pyx_state): +*/ + __Pyx_TraceLine(9,28,0,__PYX_ERR(1, 9, __pyx_L1_error)) + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_6hunter_11_predicates___pyx_unpickle_Or__set_state(((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x8e21672, 0xc8ea956, 0xaa8cbda) = (predicates))" % __pyx_checksum + * __pyx_result = Or.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Or__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_Or__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_Or__set_state(Or __pyx_result, tuple __pyx_state): + * __pyx_result.predicates = __pyx_state[0] +*/ + __Pyx_TraceLine(10,29,0,__PYX_ERR(1, 10, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + __Pyx_TraceReturnValue(__pyx_r, 29, 0, __PYX_ERR(1, 10, __pyx_L1_error)); + goto __pyx_L0; /* "(tree fragment)":1 - * def __pyx_unpickle_And(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * def __pyx_unpickle_Or(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result - */ - __Pyx_TraceLine(1,0,__PYX_ERR(2, 1, __pyx_L1_error)) - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6hunter_11_predicates_7__pyx_unpickle_And, NULL, __pyx_n_s_hunter__predicates); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1, __pyx_L1_error) +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_Or", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_Or__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Or__set_state(Or __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.predicates = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): +*/ + +static PyObject *__pyx_f_6hunter_11_predicates___pyx_unpickle_Or__set_state(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + size_t __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[146])) + __Pyx_RefNannySetupContext("__pyx_unpickle_Or__set_state", 0); + __Pyx_TraceStartFunc("__pyx_unpickle_Or__set_state", __pyx_f[1], 11, 0, 0, 0, __PYX_ERR(1, 11, __pyx_L1_error)); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_Or__set_state(Or __pyx_result, tuple __pyx_state): + * __pyx_result.predicates = __pyx_state[0] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) +*/ + __Pyx_TraceLine(12,3,0,__PYX_ERR(1, 12, __pyx_L1_error)) + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_And, __pyx_t_1) < 0) __PYX_ERR(2, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_t_1))) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->predicates); + __Pyx_DECREF(__pyx_v___pyx_result->predicates); + __pyx_v___pyx_result->predicates = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Or__set_state(Or __pyx_result, tuple __pyx_state): + * __pyx_result.predicates = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) +*/ + __Pyx_TraceLine(13,9,0,__PYX_ERR(1, 13, __pyx_L1_error)) + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(1, 13, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 > 1); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_mstate_global->__pyx_n_u_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":14 + * __pyx_result.predicates = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) # <<<<<<<<<<<<<< +*/ + __Pyx_TraceLine(14,18,0,__PYX_ERR(1, 14, __pyx_L1_error)) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_mstate_global->__pyx_n_u_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = __pyx_t_6; + __Pyx_INCREF(__pyx_t_5); + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 14, __pyx_L1_error) + } + __pyx_t_7 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_7}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_update, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Or__set_state(Or __pyx_result, tuple __pyx_state): + * __pyx_result.predicates = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) +*/ + } /* "(tree fragment)":11 - * __pyx_unpickle_And__set_state( __pyx_result, __pyx_state) + * __pyx_unpickle_Or__set_state( __pyx_result, __pyx_state) * return __pyx_result - * cdef __pyx_unpickle_And__set_state(And __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_Or__set_state(Or __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< * __pyx_result.predicates = __pyx_state[0] * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): - */ - __Pyx_TraceLine(11,0,__PYX_ERR(2, 11, __pyx_L1_error)) +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(1, 11, __pyx_L1_error)); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 11, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_Or__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_Not(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_11__pyx_unpickle_Not(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_11_predicates_11__pyx_unpickle_Not = {"__pyx_unpickle_Not", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_11__pyx_unpickle_Not, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_11_predicates_11__pyx_unpickle_Not(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_Not (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_type,&__pyx_mstate_global->__pyx_n_u_pyx_checksum,&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 1, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 1, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 1, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 1, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__pyx_unpickle_Not", 0) < 0) __PYX_ERR(1, 1, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Not", 1, 3, 3, i); __PYX_ERR(1, 1, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 1, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 1, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 1, __pyx_L3_error) + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyLong_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Not", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_Not", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6hunter_11_predicates_10__pyx_unpickle_Not(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_11_predicates_10__pyx_unpickle_Not(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[147])) + __Pyx_RefNannySetupContext("__pyx_unpickle_Not", 0); + __Pyx_TraceStartFunc("__pyx_unpickle_Not", __pyx_f[1], 1, 0, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x23761c9, 0x0444431, 0xf670ef6): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x23761c9, 0x0444431, 0xf670ef6) = (predicate))" % __pyx_checksum +*/ + __Pyx_TraceLine(4,2,0,__PYX_ERR(1, 4, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyLong_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_mstate_global->__pyx_tuple[4], Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0x23761c9, 0x0444431, 0xf670ef6): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x23761c9, 0x0444431, 0xf670ef6) = (predicate))" % __pyx_checksum + * __pyx_result = Not.__new__(__pyx_type) +*/ + __Pyx_TraceLine(5,9,0,__PYX_ERR(1, 5, __pyx_L1_error)) + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_PickleError); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_mstate_global->__pyx_n_u_PickleError) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0x23761c9, 0x0444431, 0xf670ef6): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x23761c9, 0x0444431, 0xf670ef6) = (predicate))" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = Not.__new__(__pyx_type) + * if __pyx_state is not None: +*/ + __Pyx_TraceLine(6,14,0,__PYX_ERR(1, 6, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyLong_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyUnicode_Format(__pyx_mstate_global->__pyx_kp_u_Incompatible_checksums_0x_x_vs_0_5, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x23761c9, 0x0444431, 0xf670ef6): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x23761c9, 0x0444431, 0xf670ef6) = (predicate))" % __pyx_checksum +*/ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x23761c9, 0x0444431, 0xf670ef6) = (predicate))" % __pyx_checksum + * __pyx_result = Not.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_Not__set_state( __pyx_result, __pyx_state) +*/ + __Pyx_TraceLine(7,16,0,__PYX_ERR(1, 7, __pyx_L1_error)) + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Not); + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_new, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x23761c9, 0x0444431, 0xf670ef6) = (predicate))" % __pyx_checksum + * __pyx_result = Not.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Not__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + __Pyx_TraceLine(8,23,0,__PYX_ERR(1, 8, __pyx_L1_error)) + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = Not.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_Not__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_Not__set_state(Not __pyx_result, tuple __pyx_state): +*/ + __Pyx_TraceLine(9,28,0,__PYX_ERR(1, 9, __pyx_L1_error)) + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_6hunter_11_predicates___pyx_unpickle_Not__set_state(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x23761c9, 0x0444431, 0xf670ef6) = (predicate))" % __pyx_checksum + * __pyx_result = Not.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Not__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_Not__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_Not__set_state(Not __pyx_result, tuple __pyx_state): + * __pyx_result.predicate = __pyx_state[0] +*/ + __Pyx_TraceLine(10,29,0,__PYX_ERR(1, 10, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + __Pyx_TraceReturnValue(__pyx_r, 29, 0, __PYX_ERR(1, 10, __pyx_L1_error)); + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_Not(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_Not", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_Not__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Not__set_state(Not __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.predicate = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): +*/ + +static PyObject *__pyx_f_6hunter_11_predicates___pyx_unpickle_Not__set_state(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + size_t __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[148])) + __Pyx_RefNannySetupContext("__pyx_unpickle_Not__set_state", 0); + __Pyx_TraceStartFunc("__pyx_unpickle_Not__set_state", __pyx_f[1], 11, 0, 0, 0, __PYX_ERR(1, 11, __pyx_L1_error)); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_Not__set_state(Not __pyx_result, tuple __pyx_state): + * __pyx_result.predicate = __pyx_state[0] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) +*/ + __Pyx_TraceLine(12,3,0,__PYX_ERR(1, 12, __pyx_L1_error)) + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->predicate); + __Pyx_DECREF(__pyx_v___pyx_result->predicate); + __pyx_v___pyx_result->predicate = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Not__set_state(Not __pyx_result, tuple __pyx_state): + * __pyx_result.predicate = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) +*/ + __Pyx_TraceLine(13,9,0,__PYX_ERR(1, 13, __pyx_L1_error)) + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(1, 13, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 > 1); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_mstate_global->__pyx_n_u_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":14 + * __pyx_result.predicate = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) # <<<<<<<<<<<<<< +*/ + __Pyx_TraceLine(14,18,0,__PYX_ERR(1, 14, __pyx_L1_error)) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_mstate_global->__pyx_n_u_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = __pyx_t_6; + __Pyx_INCREF(__pyx_t_5); + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 14, __pyx_L1_error) + } + __pyx_t_7 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_7}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_update, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Not__set_state(Not __pyx_result, tuple __pyx_state): + * __pyx_result.predicate = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) +*/ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_Not__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Not__set_state(Not __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.predicate = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(1, 11, __pyx_L1_error)); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 11, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_Not__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_Backlog(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_11_predicates_13__pyx_unpickle_Backlog(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_11_predicates_13__pyx_unpickle_Backlog = {"__pyx_unpickle_Backlog", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_13__pyx_unpickle_Backlog, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_11_predicates_13__pyx_unpickle_Backlog(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_Backlog (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_type,&__pyx_mstate_global->__pyx_n_u_pyx_checksum,&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 1, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 1, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 1, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 1, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__pyx_unpickle_Backlog", 0) < 0) __PYX_ERR(1, 1, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Backlog", 1, 3, 3, i); __PYX_ERR(1, 1, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 1, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 1, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 1, __pyx_L3_error) + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyLong_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Backlog", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_Backlog", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6hunter_11_predicates_12__pyx_unpickle_Backlog(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_11_predicates_12__pyx_unpickle_Backlog(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[149])) + __Pyx_RefNannySetupContext("__pyx_unpickle_Backlog", 0); + __Pyx_TraceStartFunc("__pyx_unpickle_Backlog", __pyx_f[1], 1, 0, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x1428ea1, 0xbd128e6, 0x4bbfdb4): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x1428ea1, 0xbd128e6, 0x4bbfdb4) = (_filter, _try_repr, action, condition, queue, size, stack, strip, vars))" % __pyx_checksum +*/ + __Pyx_TraceLine(4,2,0,__PYX_ERR(1, 4, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyLong_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_mstate_global->__pyx_tuple[5], Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0x1428ea1, 0xbd128e6, 0x4bbfdb4): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x1428ea1, 0xbd128e6, 0x4bbfdb4) = (_filter, _try_repr, action, condition, queue, size, stack, strip, vars))" % __pyx_checksum + * __pyx_result = Backlog.__new__(__pyx_type) +*/ + __Pyx_TraceLine(5,9,0,__PYX_ERR(1, 5, __pyx_L1_error)) + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_PickleError); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_mstate_global->__pyx_n_u_PickleError) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0x1428ea1, 0xbd128e6, 0x4bbfdb4): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x1428ea1, 0xbd128e6, 0x4bbfdb4) = (_filter, _try_repr, action, condition, queue, size, stack, strip, vars))" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = Backlog.__new__(__pyx_type) + * if __pyx_state is not None: +*/ + __Pyx_TraceLine(6,14,0,__PYX_ERR(1, 6, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyLong_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyUnicode_Format(__pyx_mstate_global->__pyx_kp_u_Incompatible_checksums_0x_x_vs_0_6, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x1428ea1, 0xbd128e6, 0x4bbfdb4): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x1428ea1, 0xbd128e6, 0x4bbfdb4) = (_filter, _try_repr, action, condition, queue, size, stack, strip, vars))" % __pyx_checksum +*/ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x1428ea1, 0xbd128e6, 0x4bbfdb4) = (_filter, _try_repr, action, condition, queue, size, stack, strip, vars))" % __pyx_checksum + * __pyx_result = Backlog.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_Backlog__set_state( __pyx_result, __pyx_state) +*/ + __Pyx_TraceLine(7,16,0,__PYX_ERR(1, 7, __pyx_L1_error)) + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Backlog); + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_new, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x1428ea1, 0xbd128e6, 0x4bbfdb4) = (_filter, _try_repr, action, condition, queue, size, stack, strip, vars))" % __pyx_checksum + * __pyx_result = Backlog.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Backlog__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + __Pyx_TraceLine(8,23,0,__PYX_ERR(1, 8, __pyx_L1_error)) + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = Backlog.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_Backlog__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_Backlog__set_state(Backlog __pyx_result, tuple __pyx_state): +*/ + __Pyx_TraceLine(9,28,0,__PYX_ERR(1, 9, __pyx_L1_error)) + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_6hunter_11_predicates___pyx_unpickle_Backlog__set_state(((struct __pyx_obj_6hunter_11_predicates_Backlog *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x1428ea1, 0xbd128e6, 0x4bbfdb4) = (_filter, _try_repr, action, condition, queue, size, stack, strip, vars))" % __pyx_checksum + * __pyx_result = Backlog.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Backlog__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_Backlog__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_Backlog__set_state(Backlog __pyx_result, tuple __pyx_state): + * __pyx_result._filter = __pyx_state[0]; __pyx_result._try_repr = __pyx_state[1]; __pyx_result.action = __pyx_state[2]; __pyx_result.condition = __pyx_state[3]; __pyx_result.queue = __pyx_state[4]; __pyx_result.size = __pyx_state[5]; __pyx_result.stack = __pyx_state[6]; __pyx_result.strip = __pyx_state[7]; __pyx_result.vars = __pyx_state[8] +*/ + __Pyx_TraceLine(10,29,0,__PYX_ERR(1, 10, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + __Pyx_TraceReturnValue(__pyx_r, 29, 0, __PYX_ERR(1, 10, __pyx_L1_error)); + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_Backlog(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_Backlog", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_Backlog__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Backlog__set_state(Backlog __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result._filter = __pyx_state[0]; __pyx_result._try_repr = __pyx_state[1]; __pyx_result.action = __pyx_state[2]; __pyx_result.condition = __pyx_state[3]; __pyx_result.queue = __pyx_state[4]; __pyx_result.size = __pyx_state[5]; __pyx_result.stack = __pyx_state[6]; __pyx_result.strip = __pyx_state[7]; __pyx_result.vars = __pyx_state[8] + * if len(__pyx_state) > 9 and hasattr(__pyx_result, '__dict__'): +*/ + +static PyObject *__pyx_f_6hunter_11_predicates___pyx_unpickle_Backlog__set_state(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + Py_ssize_t __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + size_t __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[150])) + __Pyx_RefNannySetupContext("__pyx_unpickle_Backlog__set_state", 0); + __Pyx_TraceStartFunc("__pyx_unpickle_Backlog__set_state", __pyx_f[1], 11, 0, 0, 0, __PYX_ERR(1, 11, __pyx_L1_error)); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_Backlog__set_state(Backlog __pyx_result, tuple __pyx_state): + * __pyx_result._filter = __pyx_state[0]; __pyx_result._try_repr = __pyx_state[1]; __pyx_result.action = __pyx_state[2]; __pyx_result.condition = __pyx_state[3]; __pyx_result.queue = __pyx_state[4]; __pyx_result.size = __pyx_state[5]; __pyx_result.stack = __pyx_state[6]; __pyx_result.strip = __pyx_state[7]; __pyx_result.vars = __pyx_state[8] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 9 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[9]) +*/ + __Pyx_TraceLine(12,3,0,__PYX_ERR(1, 12, __pyx_L1_error)) + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->_filter); + __Pyx_DECREF(__pyx_v___pyx_result->_filter); + __pyx_v___pyx_result->_filter = __pyx_t_1; + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->_try_repr); + __Pyx_DECREF(__pyx_v___pyx_result->_try_repr); + __pyx_v___pyx_result->_try_repr = __pyx_t_1; + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->action); + __Pyx_DECREF(__pyx_v___pyx_result->action); + __pyx_v___pyx_result->action = __pyx_t_1; + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->condition); + __Pyx_DECREF(__pyx_v___pyx_result->condition); + __pyx_v___pyx_result->condition = __pyx_t_1; + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 4, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->queue); + __Pyx_DECREF(__pyx_v___pyx_result->queue); + __pyx_v___pyx_result->queue = __pyx_t_1; + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 5, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->size = __pyx_t_2; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 6, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->stack = __pyx_t_2; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 7, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->strip = __pyx_t_3; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 8, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->vars = __pyx_t_3; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Backlog__set_state(Backlog __pyx_result, tuple __pyx_state): + * __pyx_result._filter = __pyx_state[0]; __pyx_result._try_repr = __pyx_state[1]; __pyx_result.action = __pyx_state[2]; __pyx_result.condition = __pyx_state[3]; __pyx_result.queue = __pyx_state[4]; __pyx_result.size = __pyx_state[5]; __pyx_result.stack = __pyx_state[6]; __pyx_result.strip = __pyx_state[7]; __pyx_result.vars = __pyx_state[8] + * if len(__pyx_state) > 9 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[9]) +*/ + __Pyx_TraceLine(13,49,0,__PYX_ERR(1, 13, __pyx_L1_error)) + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(1, 13, __pyx_L1_error) + } + __pyx_t_4 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + __pyx_t_5 = (__pyx_t_4 > 9); + if (__pyx_t_5) { + } else { + __pyx_t_3 = __pyx_t_5; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_5 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_mstate_global->__pyx_n_u_dict); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + __pyx_t_3 = __pyx_t_5; + __pyx_L4_bool_binop_done:; + if (__pyx_t_3) { + + /* "(tree fragment)":14 + * __pyx_result._filter = __pyx_state[0]; __pyx_result._try_repr = __pyx_state[1]; __pyx_result.action = __pyx_state[2]; __pyx_result.condition = __pyx_state[3]; __pyx_result.queue = __pyx_state[4]; __pyx_result.size = __pyx_state[5]; __pyx_result.stack = __pyx_state[6]; __pyx_result.strip = __pyx_state[7]; __pyx_result.vars = __pyx_state[8] + * if len(__pyx_state) > 9 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[9]) # <<<<<<<<<<<<<< +*/ + __Pyx_TraceLine(14,58,0,__PYX_ERR(1, 14, __pyx_L1_error)) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_mstate_global->__pyx_n_u_dict); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __pyx_t_7; + __Pyx_INCREF(__pyx_t_6); + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 14, __pyx_L1_error) + } + __pyx_t_8 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 9, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_8}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_update, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Backlog__set_state(Backlog __pyx_result, tuple __pyx_state): + * __pyx_result._filter = __pyx_state[0]; __pyx_result._try_repr = __pyx_state[1]; __pyx_result.action = __pyx_state[2]; __pyx_result.condition = __pyx_state[3]; __pyx_result.queue = __pyx_state[4]; __pyx_result.size = __pyx_state[5]; __pyx_result.stack = __pyx_state[6]; __pyx_result.strip = __pyx_state[7]; __pyx_result.vars = __pyx_state[8] + * if len(__pyx_state) > 9 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[9]) +*/ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_Backlog__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Backlog__set_state(Backlog __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result._filter = __pyx_state[0]; __pyx_result._try_repr = __pyx_state[1]; __pyx_result.action = __pyx_state[2]; __pyx_result.condition = __pyx_state[3]; __pyx_result.queue = __pyx_state[4]; __pyx_result.size = __pyx_state[5]; __pyx_result.stack = __pyx_state[6]; __pyx_result.strip = __pyx_state[7]; __pyx_result.vars = __pyx_state[8] + * if len(__pyx_state) > 9 and hasattr(__pyx_result, '__dict__'): +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(1, 11, __pyx_L1_error)); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 11, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_Backlog__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +/* #### Code section: module_exttypes ### */ + +static PyObject *__pyx_tp_new_6hunter_11_predicates_Query(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_6hunter_11_predicates_Query *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_6hunter_11_predicates_Query *)o); + p->query_contains = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->query_endswith = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->query_eq = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->query_gt = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->query_gte = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->query_in = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->query_lt = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->query_lte = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->query_regex = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->query_startswith = ((PyObject*)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_6hunter_11_predicates_Query(PyObject *o) { + struct __pyx_obj_6hunter_11_predicates_Query *p = (struct __pyx_obj_6hunter_11_predicates_Query *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->query_contains); + Py_CLEAR(p->query_endswith); + Py_CLEAR(p->query_eq); + Py_CLEAR(p->query_gt); + Py_CLEAR(p->query_gte); + Py_CLEAR(p->query_in); + Py_CLEAR(p->query_lt); + Py_CLEAR(p->query_lte); + Py_CLEAR(p->query_regex); + Py_CLEAR(p->query_startswith); + #if CYTHON_USE_TYPE_SLOTS + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_6hunter_11_predicates_Query(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_6hunter_11_predicates_Query *p = (struct __pyx_obj_6hunter_11_predicates_Query *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->query_contains) { + e = (*v)(p->query_contains, a); if (e) return e; + } + if (p->query_endswith) { + e = (*v)(p->query_endswith, a); if (e) return e; + } + if (p->query_eq) { + e = (*v)(p->query_eq, a); if (e) return e; + } + if (p->query_gt) { + e = (*v)(p->query_gt, a); if (e) return e; + } + if (p->query_gte) { + e = (*v)(p->query_gte, a); if (e) return e; + } + if (p->query_in) { + e = (*v)(p->query_in, a); if (e) return e; + } + if (p->query_lt) { + e = (*v)(p->query_lt, a); if (e) return e; + } + if (p->query_lte) { + e = (*v)(p->query_lte, a); if (e) return e; + } + if (p->query_regex) { + e = (*v)(p->query_regex, a); if (e) return e; + } + if (p->query_startswith) { + e = (*v)(p->query_startswith, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_6hunter_11_predicates_Query(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_6hunter_11_predicates_Query *p = (struct __pyx_obj_6hunter_11_predicates_Query *)o; + tmp = ((PyObject*)p->query_contains); + p->query_contains = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->query_endswith); + p->query_endswith = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->query_eq); + p->query_eq = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->query_gt); + p->query_gt = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->query_gte); + p->query_gte = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->query_in); + p->query_in = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->query_lt); + p->query_lt = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->query_lte); + p->query_lte = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->query_regex); + p->query_regex = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->query_startswith); + p->query_startswith = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_tp_richcompare_6hunter_11_predicates_Query(PyObject *o1, PyObject *o2, int op) { + switch (op) { + case Py_EQ: { + return __pyx_pw_6hunter_11_predicates_5Query_7__eq__(o1, o2); + } + case Py_NE: { + PyObject *ret; + ret = __pyx_pw_6hunter_11_predicates_5Query_7__eq__(o1, o2); + if (likely(ret && ret != Py_NotImplemented)) { + int b = __Pyx_PyObject_IsTrue(ret); + Py_DECREF(ret); + if (unlikely(b < 0)) return NULL; + ret = (b) ? Py_False : Py_True; + Py_INCREF(ret); + } + return ret; + } + default: { + return __Pyx_NewRef(Py_NotImplemented); + } + } +} +#define __pyx_nb_and_6hunter_11_predicates_Query __pyx_pw_6hunter_11_predicates_5Query_13__and__ +#define __pyx_nb_or_6hunter_11_predicates_Query __pyx_pw_6hunter_11_predicates_5Query_11__or__ + +static PyObject *__pyx_getprop_6hunter_11_predicates_5Query_query_contains(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_11_predicates_5Query_14query_contains_1__get__(o); +} + +static PyObject *__pyx_getprop_6hunter_11_predicates_5Query_query_endswith(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_11_predicates_5Query_14query_endswith_1__get__(o); +} + +static PyObject *__pyx_getprop_6hunter_11_predicates_5Query_query_eq(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_11_predicates_5Query_8query_eq_1__get__(o); +} + +static PyObject *__pyx_getprop_6hunter_11_predicates_5Query_query_gt(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_11_predicates_5Query_8query_gt_1__get__(o); +} + +static PyObject *__pyx_getprop_6hunter_11_predicates_5Query_query_gte(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_11_predicates_5Query_9query_gte_1__get__(o); +} + +static PyObject *__pyx_getprop_6hunter_11_predicates_5Query_query_in(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_11_predicates_5Query_8query_in_1__get__(o); +} + +static PyObject *__pyx_getprop_6hunter_11_predicates_5Query_query_lt(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_11_predicates_5Query_8query_lt_1__get__(o); +} + +static PyObject *__pyx_getprop_6hunter_11_predicates_5Query_query_lte(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_11_predicates_5Query_9query_lte_1__get__(o); +} + +static PyObject *__pyx_getprop_6hunter_11_predicates_5Query_query_regex(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_11_predicates_5Query_11query_regex_1__get__(o); +} + +static PyObject *__pyx_getprop_6hunter_11_predicates_5Query_query_startswith(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_11_predicates_5Query_16query_startswith_1__get__(o); +} + +static PyMethodDef __pyx_methods_6hunter_11_predicates_Query[] = { + {"__or__", (PyCFunction)__pyx_pw_6hunter_11_predicates_5Query_11__or__, METH_O|METH_COEXIST, 0}, + {"__and__", (PyCFunction)__pyx_pw_6hunter_11_predicates_5Query_13__and__, METH_O|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_5Query_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_5Query_19__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_6hunter_11_predicates_Query[] = { + {"query_contains", __pyx_getprop_6hunter_11_predicates_5Query_query_contains, 0, 0, 0}, + {"query_endswith", __pyx_getprop_6hunter_11_predicates_5Query_query_endswith, 0, 0, 0}, + {"query_eq", __pyx_getprop_6hunter_11_predicates_5Query_query_eq, 0, 0, 0}, + {"query_gt", __pyx_getprop_6hunter_11_predicates_5Query_query_gt, 0, 0, 0}, + {"query_gte", __pyx_getprop_6hunter_11_predicates_5Query_query_gte, 0, 0, 0}, + {"query_in", __pyx_getprop_6hunter_11_predicates_5Query_query_in, 0, 0, 0}, + {"query_lt", __pyx_getprop_6hunter_11_predicates_5Query_query_lt, 0, 0, 0}, + {"query_lte", __pyx_getprop_6hunter_11_predicates_5Query_query_lte, 0, 0, 0}, + {"query_regex", __pyx_getprop_6hunter_11_predicates_5Query_query_regex, 0, 0, 0}, + {"query_startswith", __pyx_getprop_6hunter_11_predicates_5Query_query_startswith, 0, 0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_6hunter_11_predicates_Query_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_6hunter_11_predicates_Query}, + {Py_tp_repr, (void *)__pyx_pw_6hunter_11_predicates_5Query_5__repr__}, + {Py_nb_invert, (void *)__pyx_pw_6hunter_11_predicates_5Query_15__invert__}, + {Py_nb_and, (void *)__pyx_nb_and_6hunter_11_predicates_Query}, + {Py_nb_or, (void *)__pyx_nb_or_6hunter_11_predicates_Query}, + {Py_tp_call, (void *)__pyx_pw_6hunter_11_predicates_5Query_9__call__}, + {Py_tp_str, (void *)__pyx_pw_6hunter_11_predicates_5Query_3__str__}, + {Py_tp_doc, (void *)PyDoc_STR("\n A query class.\n\n See :class:`hunter.event.Event` for fields that can be filtered on.\n ")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_6hunter_11_predicates_Query}, + {Py_tp_clear, (void *)__pyx_tp_clear_6hunter_11_predicates_Query}, + {Py_tp_richcompare, (void *)__pyx_tp_richcompare_6hunter_11_predicates_Query}, + {Py_tp_methods, (void *)__pyx_methods_6hunter_11_predicates_Query}, + {Py_tp_getset, (void *)__pyx_getsets_6hunter_11_predicates_Query}, + {Py_tp_init, (void *)__pyx_pw_6hunter_11_predicates_5Query_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_6hunter_11_predicates_Query}, + {0, 0}, +}; +static PyType_Spec __pyx_type_6hunter_11_predicates_Query_spec = { + "hunter._predicates.Query", + sizeof(struct __pyx_obj_6hunter_11_predicates_Query), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, + __pyx_type_6hunter_11_predicates_Query_slots, +}; +#else + +static PyNumberMethods __pyx_tp_as_number_Query = { + 0, /*nb_add*/ + 0, /*nb_subtract*/ + 0, /*nb_multiply*/ + 0, /*nb_remainder*/ + 0, /*nb_divmod*/ + 0, /*nb_power*/ + 0, /*nb_negative*/ + 0, /*nb_positive*/ + 0, /*nb_absolute*/ + 0, /*nb_bool*/ + __pyx_pw_6hunter_11_predicates_5Query_15__invert__, /*nb_invert*/ + 0, /*nb_lshift*/ + 0, /*nb_rshift*/ + __pyx_nb_and_6hunter_11_predicates_Query, /*nb_and*/ + 0, /*nb_xor*/ + __pyx_nb_or_6hunter_11_predicates_Query, /*nb_or*/ + 0, /*nb_int*/ + 0, /*nb_long (reserved)*/ + 0, /*nb_float*/ + 0, /*nb_inplace_add*/ + 0, /*nb_inplace_subtract*/ + 0, /*nb_inplace_multiply*/ + 0, /*nb_inplace_remainder*/ + 0, /*nb_inplace_power*/ + 0, /*nb_inplace_lshift*/ + 0, /*nb_inplace_rshift*/ + 0, /*nb_inplace_and*/ + 0, /*nb_inplace_xor*/ + 0, /*nb_inplace_or*/ + 0, /*nb_floor_divide*/ + 0, /*nb_true_divide*/ + 0, /*nb_inplace_floor_divide*/ + 0, /*nb_inplace_true_divide*/ + 0, /*nb_index*/ + 0, /*nb_matrix_multiply*/ + 0, /*nb_inplace_matrix_multiply*/ +}; + +static PyTypeObject __pyx_type_6hunter_11_predicates_Query = { + PyVarObject_HEAD_INIT(0, 0) + "hunter._predicates.""Query", /*tp_name*/ + sizeof(struct __pyx_obj_6hunter_11_predicates_Query), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6hunter_11_predicates_Query, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + __pyx_pw_6hunter_11_predicates_5Query_5__repr__, /*tp_repr*/ + &__pyx_tp_as_number_Query, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + __pyx_pw_6hunter_11_predicates_5Query_9__call__, /*tp_call*/ + __pyx_pw_6hunter_11_predicates_5Query_3__str__, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + PyDoc_STR("\n A query class.\n\n See :class:`hunter.event.Event` for fields that can be filtered on.\n "), /*tp_doc*/ + __pyx_tp_traverse_6hunter_11_predicates_Query, /*tp_traverse*/ + __pyx_tp_clear_6hunter_11_predicates_Query, /*tp_clear*/ + __pyx_tp_richcompare_6hunter_11_predicates_Query, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_6hunter_11_predicates_Query, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_6hunter_11_predicates_Query, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_6hunter_11_predicates_5Query_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6hunter_11_predicates_Query, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_6hunter_11_predicates_And(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_6hunter_11_predicates_And *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_6hunter_11_predicates_And *)o); + p->predicates = ((PyObject*)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_6hunter_11_predicates_And(PyObject *o) { + struct __pyx_obj_6hunter_11_predicates_And *p = (struct __pyx_obj_6hunter_11_predicates_And *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->predicates); + #if CYTHON_USE_TYPE_SLOTS + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_6hunter_11_predicates_And(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_6hunter_11_predicates_And *p = (struct __pyx_obj_6hunter_11_predicates_And *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->predicates) { + e = (*v)(p->predicates, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_6hunter_11_predicates_And(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_6hunter_11_predicates_And *p = (struct __pyx_obj_6hunter_11_predicates_And *)o; + tmp = ((PyObject*)p->predicates); + p->predicates = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_tp_richcompare_6hunter_11_predicates_And(PyObject *o1, PyObject *o2, int op) { + switch (op) { + case Py_EQ: { + return __pyx_pw_6hunter_11_predicates_3And_7__eq__(o1, o2); + } + case Py_NE: { + PyObject *ret; + ret = __pyx_pw_6hunter_11_predicates_3And_7__eq__(o1, o2); + if (likely(ret && ret != Py_NotImplemented)) { + int b = __Pyx_PyObject_IsTrue(ret); + Py_DECREF(ret); + if (unlikely(b < 0)) return NULL; + ret = (b) ? Py_False : Py_True; + Py_INCREF(ret); + } + return ret; + } + default: { + return __Pyx_NewRef(Py_NotImplemented); + } + } +} +#define __pyx_nb_and_6hunter_11_predicates_And __pyx_pw_6hunter_11_predicates_3And_13__and__ +#define __pyx_nb_or_6hunter_11_predicates_And __pyx_pw_6hunter_11_predicates_3And_11__or__ + +static PyObject *__pyx_getprop_6hunter_11_predicates_3And_predicates(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_11_predicates_3And_10predicates_1__get__(o); +} + +static PyMethodDef __pyx_methods_6hunter_11_predicates_And[] = { + {"__or__", (PyCFunction)__pyx_pw_6hunter_11_predicates_3And_11__or__, METH_O|METH_COEXIST, 0}, + {"__and__", (PyCFunction)__pyx_pw_6hunter_11_predicates_3And_13__and__, METH_O|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_3And_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_3And_19__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_6hunter_11_predicates_And[] = { + {"predicates", __pyx_getprop_6hunter_11_predicates_3And_predicates, 0, 0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_6hunter_11_predicates_And_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_6hunter_11_predicates_And}, + {Py_tp_repr, (void *)__pyx_pw_6hunter_11_predicates_3And_5__repr__}, + {Py_nb_invert, (void *)__pyx_pw_6hunter_11_predicates_3And_15__invert__}, + {Py_nb_and, (void *)__pyx_nb_and_6hunter_11_predicates_And}, + {Py_nb_or, (void *)__pyx_nb_or_6hunter_11_predicates_And}, + {Py_tp_call, (void *)__pyx_pw_6hunter_11_predicates_3And_9__call__}, + {Py_tp_str, (void *)__pyx_pw_6hunter_11_predicates_3And_3__str__}, + {Py_tp_doc, (void *)PyDoc_STR("\n `And` predicate. Exits at the first sub-predicate that returns ``False``.\n ")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_6hunter_11_predicates_And}, + {Py_tp_clear, (void *)__pyx_tp_clear_6hunter_11_predicates_And}, + {Py_tp_richcompare, (void *)__pyx_tp_richcompare_6hunter_11_predicates_And}, + {Py_tp_methods, (void *)__pyx_methods_6hunter_11_predicates_And}, + {Py_tp_getset, (void *)__pyx_getsets_6hunter_11_predicates_And}, + {Py_tp_init, (void *)__pyx_pw_6hunter_11_predicates_3And_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_6hunter_11_predicates_And}, + {0, 0}, +}; +static PyType_Spec __pyx_type_6hunter_11_predicates_And_spec = { + "hunter._predicates.And", + sizeof(struct __pyx_obj_6hunter_11_predicates_And), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, + __pyx_type_6hunter_11_predicates_And_slots, +}; +#else + +static PyNumberMethods __pyx_tp_as_number_And = { + 0, /*nb_add*/ + 0, /*nb_subtract*/ + 0, /*nb_multiply*/ + 0, /*nb_remainder*/ + 0, /*nb_divmod*/ + 0, /*nb_power*/ + 0, /*nb_negative*/ + 0, /*nb_positive*/ + 0, /*nb_absolute*/ + 0, /*nb_bool*/ + __pyx_pw_6hunter_11_predicates_3And_15__invert__, /*nb_invert*/ + 0, /*nb_lshift*/ + 0, /*nb_rshift*/ + __pyx_nb_and_6hunter_11_predicates_And, /*nb_and*/ + 0, /*nb_xor*/ + __pyx_nb_or_6hunter_11_predicates_And, /*nb_or*/ + 0, /*nb_int*/ + 0, /*nb_long (reserved)*/ + 0, /*nb_float*/ + 0, /*nb_inplace_add*/ + 0, /*nb_inplace_subtract*/ + 0, /*nb_inplace_multiply*/ + 0, /*nb_inplace_remainder*/ + 0, /*nb_inplace_power*/ + 0, /*nb_inplace_lshift*/ + 0, /*nb_inplace_rshift*/ + 0, /*nb_inplace_and*/ + 0, /*nb_inplace_xor*/ + 0, /*nb_inplace_or*/ + 0, /*nb_floor_divide*/ + 0, /*nb_true_divide*/ + 0, /*nb_inplace_floor_divide*/ + 0, /*nb_inplace_true_divide*/ + 0, /*nb_index*/ + 0, /*nb_matrix_multiply*/ + 0, /*nb_inplace_matrix_multiply*/ +}; + +static PyTypeObject __pyx_type_6hunter_11_predicates_And = { + PyVarObject_HEAD_INIT(0, 0) + "hunter._predicates.""And", /*tp_name*/ + sizeof(struct __pyx_obj_6hunter_11_predicates_And), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6hunter_11_predicates_And, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + __pyx_pw_6hunter_11_predicates_3And_5__repr__, /*tp_repr*/ + &__pyx_tp_as_number_And, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + __pyx_pw_6hunter_11_predicates_3And_9__call__, /*tp_call*/ + __pyx_pw_6hunter_11_predicates_3And_3__str__, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + PyDoc_STR("\n `And` predicate. Exits at the first sub-predicate that returns ``False``.\n "), /*tp_doc*/ + __pyx_tp_traverse_6hunter_11_predicates_And, /*tp_traverse*/ + __pyx_tp_clear_6hunter_11_predicates_And, /*tp_clear*/ + __pyx_tp_richcompare_6hunter_11_predicates_And, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_6hunter_11_predicates_And, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_6hunter_11_predicates_And, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_6hunter_11_predicates_3And_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6hunter_11_predicates_And, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_6hunter_11_predicates_Or(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_6hunter_11_predicates_Or *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_6hunter_11_predicates_Or *)o); + p->predicates = ((PyObject*)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_6hunter_11_predicates_Or(PyObject *o) { + struct __pyx_obj_6hunter_11_predicates_Or *p = (struct __pyx_obj_6hunter_11_predicates_Or *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->predicates); + #if CYTHON_USE_TYPE_SLOTS + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_6hunter_11_predicates_Or(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_6hunter_11_predicates_Or *p = (struct __pyx_obj_6hunter_11_predicates_Or *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->predicates) { + e = (*v)(p->predicates, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_6hunter_11_predicates_Or(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_6hunter_11_predicates_Or *p = (struct __pyx_obj_6hunter_11_predicates_Or *)o; + tmp = ((PyObject*)p->predicates); + p->predicates = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_tp_richcompare_6hunter_11_predicates_Or(PyObject *o1, PyObject *o2, int op) { + switch (op) { + case Py_EQ: { + return __pyx_pw_6hunter_11_predicates_2Or_7__eq__(o1, o2); + } + case Py_NE: { + PyObject *ret; + ret = __pyx_pw_6hunter_11_predicates_2Or_7__eq__(o1, o2); + if (likely(ret && ret != Py_NotImplemented)) { + int b = __Pyx_PyObject_IsTrue(ret); + Py_DECREF(ret); + if (unlikely(b < 0)) return NULL; + ret = (b) ? Py_False : Py_True; + Py_INCREF(ret); + } + return ret; + } + default: { + return __Pyx_NewRef(Py_NotImplemented); + } + } +} +#define __pyx_nb_and_6hunter_11_predicates_Or __pyx_pw_6hunter_11_predicates_2Or_13__and__ +#define __pyx_nb_or_6hunter_11_predicates_Or __pyx_pw_6hunter_11_predicates_2Or_11__or__ + +static PyObject *__pyx_getprop_6hunter_11_predicates_2Or_predicates(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_11_predicates_2Or_10predicates_1__get__(o); +} + +static PyMethodDef __pyx_methods_6hunter_11_predicates_Or[] = { + {"__or__", (PyCFunction)__pyx_pw_6hunter_11_predicates_2Or_11__or__, METH_O|METH_COEXIST, 0}, + {"__and__", (PyCFunction)__pyx_pw_6hunter_11_predicates_2Or_13__and__, METH_O|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_2Or_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_2Or_19__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_6hunter_11_predicates_Or[] = { + {"predicates", __pyx_getprop_6hunter_11_predicates_2Or_predicates, 0, 0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_6hunter_11_predicates_Or_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_6hunter_11_predicates_Or}, + {Py_tp_repr, (void *)__pyx_pw_6hunter_11_predicates_2Or_5__repr__}, + {Py_nb_invert, (void *)__pyx_pw_6hunter_11_predicates_2Or_15__invert__}, + {Py_nb_and, (void *)__pyx_nb_and_6hunter_11_predicates_Or}, + {Py_nb_or, (void *)__pyx_nb_or_6hunter_11_predicates_Or}, + {Py_tp_call, (void *)__pyx_pw_6hunter_11_predicates_2Or_9__call__}, + {Py_tp_str, (void *)__pyx_pw_6hunter_11_predicates_2Or_3__str__}, + {Py_tp_doc, (void *)PyDoc_STR("\n `Or` predicate. Exits at first sub-predicate that returns ``True``.\n ")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_6hunter_11_predicates_Or}, + {Py_tp_clear, (void *)__pyx_tp_clear_6hunter_11_predicates_Or}, + {Py_tp_richcompare, (void *)__pyx_tp_richcompare_6hunter_11_predicates_Or}, + {Py_tp_methods, (void *)__pyx_methods_6hunter_11_predicates_Or}, + {Py_tp_getset, (void *)__pyx_getsets_6hunter_11_predicates_Or}, + {Py_tp_init, (void *)__pyx_pw_6hunter_11_predicates_2Or_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_6hunter_11_predicates_Or}, + {0, 0}, +}; +static PyType_Spec __pyx_type_6hunter_11_predicates_Or_spec = { + "hunter._predicates.Or", + sizeof(struct __pyx_obj_6hunter_11_predicates_Or), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, + __pyx_type_6hunter_11_predicates_Or_slots, +}; +#else + +static PyNumberMethods __pyx_tp_as_number_Or = { + 0, /*nb_add*/ + 0, /*nb_subtract*/ + 0, /*nb_multiply*/ + 0, /*nb_remainder*/ + 0, /*nb_divmod*/ + 0, /*nb_power*/ + 0, /*nb_negative*/ + 0, /*nb_positive*/ + 0, /*nb_absolute*/ + 0, /*nb_bool*/ + __pyx_pw_6hunter_11_predicates_2Or_15__invert__, /*nb_invert*/ + 0, /*nb_lshift*/ + 0, /*nb_rshift*/ + __pyx_nb_and_6hunter_11_predicates_Or, /*nb_and*/ + 0, /*nb_xor*/ + __pyx_nb_or_6hunter_11_predicates_Or, /*nb_or*/ + 0, /*nb_int*/ + 0, /*nb_long (reserved)*/ + 0, /*nb_float*/ + 0, /*nb_inplace_add*/ + 0, /*nb_inplace_subtract*/ + 0, /*nb_inplace_multiply*/ + 0, /*nb_inplace_remainder*/ + 0, /*nb_inplace_power*/ + 0, /*nb_inplace_lshift*/ + 0, /*nb_inplace_rshift*/ + 0, /*nb_inplace_and*/ + 0, /*nb_inplace_xor*/ + 0, /*nb_inplace_or*/ + 0, /*nb_floor_divide*/ + 0, /*nb_true_divide*/ + 0, /*nb_inplace_floor_divide*/ + 0, /*nb_inplace_true_divide*/ + 0, /*nb_index*/ + 0, /*nb_matrix_multiply*/ + 0, /*nb_inplace_matrix_multiply*/ +}; + +static PyTypeObject __pyx_type_6hunter_11_predicates_Or = { + PyVarObject_HEAD_INIT(0, 0) + "hunter._predicates.""Or", /*tp_name*/ + sizeof(struct __pyx_obj_6hunter_11_predicates_Or), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6hunter_11_predicates_Or, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + __pyx_pw_6hunter_11_predicates_2Or_5__repr__, /*tp_repr*/ + &__pyx_tp_as_number_Or, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + __pyx_pw_6hunter_11_predicates_2Or_9__call__, /*tp_call*/ + __pyx_pw_6hunter_11_predicates_2Or_3__str__, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + PyDoc_STR("\n `Or` predicate. Exits at first sub-predicate that returns ``True``.\n "), /*tp_doc*/ + __pyx_tp_traverse_6hunter_11_predicates_Or, /*tp_traverse*/ + __pyx_tp_clear_6hunter_11_predicates_Or, /*tp_clear*/ + __pyx_tp_richcompare_6hunter_11_predicates_Or, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_6hunter_11_predicates_Or, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_6hunter_11_predicates_Or, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_6hunter_11_predicates_2Or_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6hunter_11_predicates_Or, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_6hunter_11_predicates_Not(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_6hunter_11_predicates_Not *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_6hunter_11_predicates_Not *)o); + p->predicate = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_6hunter_11_predicates_Not(PyObject *o) { + struct __pyx_obj_6hunter_11_predicates_Not *p = (struct __pyx_obj_6hunter_11_predicates_Not *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->predicate); + #if CYTHON_USE_TYPE_SLOTS + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_6hunter_11_predicates_Not(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_6hunter_11_predicates_Not *p = (struct __pyx_obj_6hunter_11_predicates_Not *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->predicate) { + e = (*v)(p->predicate, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_6hunter_11_predicates_Not(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_6hunter_11_predicates_Not *p = (struct __pyx_obj_6hunter_11_predicates_Not *)o; + tmp = ((PyObject*)p->predicate); + p->predicate = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_tp_richcompare_6hunter_11_predicates_Not(PyObject *o1, PyObject *o2, int op) { + switch (op) { + case Py_EQ: { + return __pyx_pw_6hunter_11_predicates_3Not_7__eq__(o1, o2); + } + case Py_NE: { + PyObject *ret; + ret = __pyx_pw_6hunter_11_predicates_3Not_7__eq__(o1, o2); + if (likely(ret && ret != Py_NotImplemented)) { + int b = __Pyx_PyObject_IsTrue(ret); + Py_DECREF(ret); + if (unlikely(b < 0)) return NULL; + ret = (b) ? Py_False : Py_True; + Py_INCREF(ret); + } + return ret; + } + default: { + return __Pyx_NewRef(Py_NotImplemented); + } + } +} +#define __pyx_nb_and_6hunter_11_predicates_Not __pyx_pw_6hunter_11_predicates_3Not_13__and__ +#define __pyx_nb_or_6hunter_11_predicates_Not __pyx_pw_6hunter_11_predicates_3Not_11__or__ + +static PyObject *__pyx_getprop_6hunter_11_predicates_3Not_predicate(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_11_predicates_3Not_9predicate_1__get__(o); +} + +static PyMethodDef __pyx_methods_6hunter_11_predicates_Not[] = { + {"__or__", (PyCFunction)__pyx_pw_6hunter_11_predicates_3Not_11__or__, METH_O|METH_COEXIST, 0}, + {"__and__", (PyCFunction)__pyx_pw_6hunter_11_predicates_3Not_13__and__, METH_O|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_3Not_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_3Not_19__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_6hunter_11_predicates_Not[] = { + {"predicate", __pyx_getprop_6hunter_11_predicates_3Not_predicate, 0, 0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_6hunter_11_predicates_Not_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_6hunter_11_predicates_Not}, + {Py_tp_repr, (void *)__pyx_pw_6hunter_11_predicates_3Not_5__repr__}, + {Py_nb_invert, (void *)__pyx_pw_6hunter_11_predicates_3Not_15__invert__}, + {Py_nb_and, (void *)__pyx_nb_and_6hunter_11_predicates_Not}, + {Py_nb_or, (void *)__pyx_nb_or_6hunter_11_predicates_Not}, + {Py_tp_call, (void *)__pyx_pw_6hunter_11_predicates_3Not_9__call__}, + {Py_tp_str, (void *)__pyx_pw_6hunter_11_predicates_3Not_3__str__}, + {Py_tp_doc, (void *)PyDoc_STR("\n `Not` predicate.\n ")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_6hunter_11_predicates_Not}, + {Py_tp_clear, (void *)__pyx_tp_clear_6hunter_11_predicates_Not}, + {Py_tp_richcompare, (void *)__pyx_tp_richcompare_6hunter_11_predicates_Not}, + {Py_tp_methods, (void *)__pyx_methods_6hunter_11_predicates_Not}, + {Py_tp_getset, (void *)__pyx_getsets_6hunter_11_predicates_Not}, + {Py_tp_init, (void *)__pyx_pw_6hunter_11_predicates_3Not_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_6hunter_11_predicates_Not}, + {0, 0}, +}; +static PyType_Spec __pyx_type_6hunter_11_predicates_Not_spec = { + "hunter._predicates.Not", + sizeof(struct __pyx_obj_6hunter_11_predicates_Not), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, + __pyx_type_6hunter_11_predicates_Not_slots, +}; +#else + +static PyNumberMethods __pyx_tp_as_number_Not = { + 0, /*nb_add*/ + 0, /*nb_subtract*/ + 0, /*nb_multiply*/ + 0, /*nb_remainder*/ + 0, /*nb_divmod*/ + 0, /*nb_power*/ + 0, /*nb_negative*/ + 0, /*nb_positive*/ + 0, /*nb_absolute*/ + 0, /*nb_bool*/ + __pyx_pw_6hunter_11_predicates_3Not_15__invert__, /*nb_invert*/ + 0, /*nb_lshift*/ + 0, /*nb_rshift*/ + __pyx_nb_and_6hunter_11_predicates_Not, /*nb_and*/ + 0, /*nb_xor*/ + __pyx_nb_or_6hunter_11_predicates_Not, /*nb_or*/ + 0, /*nb_int*/ + 0, /*nb_long (reserved)*/ + 0, /*nb_float*/ + 0, /*nb_inplace_add*/ + 0, /*nb_inplace_subtract*/ + 0, /*nb_inplace_multiply*/ + 0, /*nb_inplace_remainder*/ + 0, /*nb_inplace_power*/ + 0, /*nb_inplace_lshift*/ + 0, /*nb_inplace_rshift*/ + 0, /*nb_inplace_and*/ + 0, /*nb_inplace_xor*/ + 0, /*nb_inplace_or*/ + 0, /*nb_floor_divide*/ + 0, /*nb_true_divide*/ + 0, /*nb_inplace_floor_divide*/ + 0, /*nb_inplace_true_divide*/ + 0, /*nb_index*/ + 0, /*nb_matrix_multiply*/ + 0, /*nb_inplace_matrix_multiply*/ +}; + +static PyTypeObject __pyx_type_6hunter_11_predicates_Not = { + PyVarObject_HEAD_INIT(0, 0) + "hunter._predicates.""Not", /*tp_name*/ + sizeof(struct __pyx_obj_6hunter_11_predicates_Not), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6hunter_11_predicates_Not, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + __pyx_pw_6hunter_11_predicates_3Not_5__repr__, /*tp_repr*/ + &__pyx_tp_as_number_Not, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + __pyx_pw_6hunter_11_predicates_3Not_9__call__, /*tp_call*/ + __pyx_pw_6hunter_11_predicates_3Not_3__str__, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + PyDoc_STR("\n `Not` predicate.\n "), /*tp_doc*/ + __pyx_tp_traverse_6hunter_11_predicates_Not, /*tp_traverse*/ + __pyx_tp_clear_6hunter_11_predicates_Not, /*tp_clear*/ + __pyx_tp_richcompare_6hunter_11_predicates_Not, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_6hunter_11_predicates_Not, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_6hunter_11_predicates_Not, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_6hunter_11_predicates_3Not_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6hunter_11_predicates_Not, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_6hunter_11_predicates_When(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_6hunter_11_predicates_When *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_6hunter_11_predicates_When *)o); + p->condition = Py_None; Py_INCREF(Py_None); + p->actions = ((PyObject*)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_6hunter_11_predicates_When(PyObject *o) { + struct __pyx_obj_6hunter_11_predicates_When *p = (struct __pyx_obj_6hunter_11_predicates_When *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->condition); + Py_CLEAR(p->actions); + #if CYTHON_USE_TYPE_SLOTS + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_6hunter_11_predicates_When(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_6hunter_11_predicates_When *p = (struct __pyx_obj_6hunter_11_predicates_When *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->condition) { + e = (*v)(p->condition, a); if (e) return e; + } + if (p->actions) { + e = (*v)(p->actions, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_6hunter_11_predicates_When(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_6hunter_11_predicates_When *p = (struct __pyx_obj_6hunter_11_predicates_When *)o; + tmp = ((PyObject*)p->condition); + p->condition = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->actions); + p->actions = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_tp_richcompare_6hunter_11_predicates_When(PyObject *o1, PyObject *o2, int op) { + switch (op) { + case Py_EQ: { + return __pyx_pw_6hunter_11_predicates_4When_7__eq__(o1, o2); + } + case Py_NE: { + PyObject *ret; + ret = __pyx_pw_6hunter_11_predicates_4When_7__eq__(o1, o2); + if (likely(ret && ret != Py_NotImplemented)) { + int b = __Pyx_PyObject_IsTrue(ret); + Py_DECREF(ret); + if (unlikely(b < 0)) return NULL; + ret = (b) ? Py_False : Py_True; + Py_INCREF(ret); + } + return ret; + } + default: { + return __Pyx_NewRef(Py_NotImplemented); + } + } +} +#define __pyx_nb_and_6hunter_11_predicates_When __pyx_pw_6hunter_11_predicates_4When_13__and__ +#define __pyx_nb_or_6hunter_11_predicates_When __pyx_pw_6hunter_11_predicates_4When_11__or__ + +static PyObject *__pyx_getprop_6hunter_11_predicates_4When_condition(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_11_predicates_4When_9condition_1__get__(o); +} + +static PyObject *__pyx_getprop_6hunter_11_predicates_4When_actions(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_11_predicates_4When_7actions_1__get__(o); +} + +static PyMethodDef __pyx_methods_6hunter_11_predicates_When[] = { + {"__or__", (PyCFunction)__pyx_pw_6hunter_11_predicates_4When_11__or__, METH_O|METH_COEXIST, 0}, + {"__and__", (PyCFunction)__pyx_pw_6hunter_11_predicates_4When_13__and__, METH_O|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_4When_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_4When_19__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_6hunter_11_predicates_When[] = { + {"condition", __pyx_getprop_6hunter_11_predicates_4When_condition, 0, 0, 0}, + {"actions", __pyx_getprop_6hunter_11_predicates_4When_actions, 0, 0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_6hunter_11_predicates_When_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_6hunter_11_predicates_When}, + {Py_tp_repr, (void *)__pyx_pw_6hunter_11_predicates_4When_5__repr__}, + {Py_nb_invert, (void *)__pyx_pw_6hunter_11_predicates_4When_15__invert__}, + {Py_nb_and, (void *)__pyx_nb_and_6hunter_11_predicates_When}, + {Py_nb_or, (void *)__pyx_nb_or_6hunter_11_predicates_When}, + {Py_tp_call, (void *)__pyx_pw_6hunter_11_predicates_4When_9__call__}, + {Py_tp_str, (void *)__pyx_pw_6hunter_11_predicates_4When_3__str__}, + {Py_tp_doc, (void *)PyDoc_STR("\n Runs ``actions`` when ``condition(event)`` is ``True``.\n\n Actions take a single ``event`` argument.\n ")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_6hunter_11_predicates_When}, + {Py_tp_clear, (void *)__pyx_tp_clear_6hunter_11_predicates_When}, + {Py_tp_richcompare, (void *)__pyx_tp_richcompare_6hunter_11_predicates_When}, + {Py_tp_methods, (void *)__pyx_methods_6hunter_11_predicates_When}, + {Py_tp_getset, (void *)__pyx_getsets_6hunter_11_predicates_When}, + {Py_tp_init, (void *)__pyx_pw_6hunter_11_predicates_4When_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_6hunter_11_predicates_When}, + {0, 0}, +}; +static PyType_Spec __pyx_type_6hunter_11_predicates_When_spec = { + "hunter._predicates.When", + sizeof(struct __pyx_obj_6hunter_11_predicates_When), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, + __pyx_type_6hunter_11_predicates_When_slots, +}; +#else + +static PyNumberMethods __pyx_tp_as_number_When = { + 0, /*nb_add*/ + 0, /*nb_subtract*/ + 0, /*nb_multiply*/ + 0, /*nb_remainder*/ + 0, /*nb_divmod*/ + 0, /*nb_power*/ + 0, /*nb_negative*/ + 0, /*nb_positive*/ + 0, /*nb_absolute*/ + 0, /*nb_bool*/ + __pyx_pw_6hunter_11_predicates_4When_15__invert__, /*nb_invert*/ + 0, /*nb_lshift*/ + 0, /*nb_rshift*/ + __pyx_nb_and_6hunter_11_predicates_When, /*nb_and*/ + 0, /*nb_xor*/ + __pyx_nb_or_6hunter_11_predicates_When, /*nb_or*/ + 0, /*nb_int*/ + 0, /*nb_long (reserved)*/ + 0, /*nb_float*/ + 0, /*nb_inplace_add*/ + 0, /*nb_inplace_subtract*/ + 0, /*nb_inplace_multiply*/ + 0, /*nb_inplace_remainder*/ + 0, /*nb_inplace_power*/ + 0, /*nb_inplace_lshift*/ + 0, /*nb_inplace_rshift*/ + 0, /*nb_inplace_and*/ + 0, /*nb_inplace_xor*/ + 0, /*nb_inplace_or*/ + 0, /*nb_floor_divide*/ + 0, /*nb_true_divide*/ + 0, /*nb_inplace_floor_divide*/ + 0, /*nb_inplace_true_divide*/ + 0, /*nb_index*/ + 0, /*nb_matrix_multiply*/ + 0, /*nb_inplace_matrix_multiply*/ +}; + +static PyTypeObject __pyx_type_6hunter_11_predicates_When = { + PyVarObject_HEAD_INIT(0, 0) + "hunter._predicates.""When", /*tp_name*/ + sizeof(struct __pyx_obj_6hunter_11_predicates_When), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6hunter_11_predicates_When, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + __pyx_pw_6hunter_11_predicates_4When_5__repr__, /*tp_repr*/ + &__pyx_tp_as_number_When, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + __pyx_pw_6hunter_11_predicates_4When_9__call__, /*tp_call*/ + __pyx_pw_6hunter_11_predicates_4When_3__str__, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + PyDoc_STR("\n Runs ``actions`` when ``condition(event)`` is ``True``.\n\n Actions take a single ``event`` argument.\n "), /*tp_doc*/ + __pyx_tp_traverse_6hunter_11_predicates_When, /*tp_traverse*/ + __pyx_tp_clear_6hunter_11_predicates_When, /*tp_clear*/ + __pyx_tp_richcompare_6hunter_11_predicates_When, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_6hunter_11_predicates_When, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_6hunter_11_predicates_When, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_6hunter_11_predicates_4When_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6hunter_11_predicates_When, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_6hunter_11_predicates_From(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_6hunter_11_predicates_From *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_6hunter_11_predicates_From *)o); + p->condition = Py_None; Py_INCREF(Py_None); + p->predicate = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_6hunter_11_predicates_From(PyObject *o) { + struct __pyx_obj_6hunter_11_predicates_From *p = (struct __pyx_obj_6hunter_11_predicates_From *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->condition); + Py_CLEAR(p->predicate); + #if CYTHON_USE_TYPE_SLOTS + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_6hunter_11_predicates_From(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_6hunter_11_predicates_From *p = (struct __pyx_obj_6hunter_11_predicates_From *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->condition) { + e = (*v)(p->condition, a); if (e) return e; + } + if (p->predicate) { + e = (*v)(p->predicate, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_6hunter_11_predicates_From(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_6hunter_11_predicates_From *p = (struct __pyx_obj_6hunter_11_predicates_From *)o; + tmp = ((PyObject*)p->condition); + p->condition = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->predicate); + p->predicate = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_tp_richcompare_6hunter_11_predicates_From(PyObject *o1, PyObject *o2, int op) { + switch (op) { + case Py_EQ: { + return __pyx_pw_6hunter_11_predicates_4From_7__eq__(o1, o2); + } + case Py_NE: { + PyObject *ret; + ret = __pyx_pw_6hunter_11_predicates_4From_7__eq__(o1, o2); + if (likely(ret && ret != Py_NotImplemented)) { + int b = __Pyx_PyObject_IsTrue(ret); + Py_DECREF(ret); + if (unlikely(b < 0)) return NULL; + ret = (b) ? Py_False : Py_True; + Py_INCREF(ret); + } + return ret; + } + default: { + return __Pyx_NewRef(Py_NotImplemented); + } + } +} +#define __pyx_nb_and_6hunter_11_predicates_From __pyx_pw_6hunter_11_predicates_4From_13__and__ +#define __pyx_nb_or_6hunter_11_predicates_From __pyx_pw_6hunter_11_predicates_4From_11__or__ + +static PyObject *__pyx_getprop_6hunter_11_predicates_4From_condition(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_11_predicates_4From_9condition_1__get__(o); +} + +static PyObject *__pyx_getprop_6hunter_11_predicates_4From_predicate(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_11_predicates_4From_9predicate_1__get__(o); +} + +static PyObject *__pyx_getprop_6hunter_11_predicates_4From_watermark(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_11_predicates_4From_9watermark_1__get__(o); +} + +static PyObject *__pyx_getprop_6hunter_11_predicates_4From_origin_depth(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_11_predicates_4From_12origin_depth_1__get__(o); +} + +static PyObject *__pyx_getprop_6hunter_11_predicates_4From_origin_calls(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_11_predicates_4From_12origin_calls_1__get__(o); +} + +static PyMethodDef __pyx_methods_6hunter_11_predicates_From[] = { + {"__or__", (PyCFunction)__pyx_pw_6hunter_11_predicates_4From_11__or__, METH_O|METH_COEXIST, 0}, + {"__and__", (PyCFunction)__pyx_pw_6hunter_11_predicates_4From_13__and__, METH_O|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_4From_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_4From_19__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_6hunter_11_predicates_From[] = { + {"condition", __pyx_getprop_6hunter_11_predicates_4From_condition, 0, 0, 0}, + {"predicate", __pyx_getprop_6hunter_11_predicates_4From_predicate, 0, 0, 0}, + {"watermark", __pyx_getprop_6hunter_11_predicates_4From_watermark, 0, 0, 0}, + {"origin_depth", __pyx_getprop_6hunter_11_predicates_4From_origin_depth, 0, 0, 0}, + {"origin_calls", __pyx_getprop_6hunter_11_predicates_4From_origin_calls, 0, 0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_6hunter_11_predicates_From_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_6hunter_11_predicates_From}, + {Py_tp_repr, (void *)__pyx_pw_6hunter_11_predicates_4From_5__repr__}, + {Py_nb_invert, (void *)__pyx_pw_6hunter_11_predicates_4From_15__invert__}, + {Py_nb_and, (void *)__pyx_nb_and_6hunter_11_predicates_From}, + {Py_nb_or, (void *)__pyx_nb_or_6hunter_11_predicates_From}, + {Py_tp_call, (void *)__pyx_pw_6hunter_11_predicates_4From_9__call__}, + {Py_tp_str, (void *)__pyx_pw_6hunter_11_predicates_4From_3__str__}, + {Py_tp_doc, (void *)PyDoc_STR("\n Keep running ``predicates`` after ``condition(event)`` is ``True``.\n ")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_6hunter_11_predicates_From}, + {Py_tp_clear, (void *)__pyx_tp_clear_6hunter_11_predicates_From}, + {Py_tp_richcompare, (void *)__pyx_tp_richcompare_6hunter_11_predicates_From}, + {Py_tp_methods, (void *)__pyx_methods_6hunter_11_predicates_From}, + {Py_tp_getset, (void *)__pyx_getsets_6hunter_11_predicates_From}, + {Py_tp_init, (void *)__pyx_pw_6hunter_11_predicates_4From_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_6hunter_11_predicates_From}, + {0, 0}, +}; +static PyType_Spec __pyx_type_6hunter_11_predicates_From_spec = { + "hunter._predicates.From", + sizeof(struct __pyx_obj_6hunter_11_predicates_From), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, + __pyx_type_6hunter_11_predicates_From_slots, +}; +#else + +static PyNumberMethods __pyx_tp_as_number_From = { + 0, /*nb_add*/ + 0, /*nb_subtract*/ + 0, /*nb_multiply*/ + 0, /*nb_remainder*/ + 0, /*nb_divmod*/ + 0, /*nb_power*/ + 0, /*nb_negative*/ + 0, /*nb_positive*/ + 0, /*nb_absolute*/ + 0, /*nb_bool*/ + __pyx_pw_6hunter_11_predicates_4From_15__invert__, /*nb_invert*/ + 0, /*nb_lshift*/ + 0, /*nb_rshift*/ + __pyx_nb_and_6hunter_11_predicates_From, /*nb_and*/ + 0, /*nb_xor*/ + __pyx_nb_or_6hunter_11_predicates_From, /*nb_or*/ + 0, /*nb_int*/ + 0, /*nb_long (reserved)*/ + 0, /*nb_float*/ + 0, /*nb_inplace_add*/ + 0, /*nb_inplace_subtract*/ + 0, /*nb_inplace_multiply*/ + 0, /*nb_inplace_remainder*/ + 0, /*nb_inplace_power*/ + 0, /*nb_inplace_lshift*/ + 0, /*nb_inplace_rshift*/ + 0, /*nb_inplace_and*/ + 0, /*nb_inplace_xor*/ + 0, /*nb_inplace_or*/ + 0, /*nb_floor_divide*/ + 0, /*nb_true_divide*/ + 0, /*nb_inplace_floor_divide*/ + 0, /*nb_inplace_true_divide*/ + 0, /*nb_index*/ + 0, /*nb_matrix_multiply*/ + 0, /*nb_inplace_matrix_multiply*/ +}; + +static PyTypeObject __pyx_type_6hunter_11_predicates_From = { + PyVarObject_HEAD_INIT(0, 0) + "hunter._predicates.""From", /*tp_name*/ + sizeof(struct __pyx_obj_6hunter_11_predicates_From), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6hunter_11_predicates_From, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + __pyx_pw_6hunter_11_predicates_4From_5__repr__, /*tp_repr*/ + &__pyx_tp_as_number_From, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + __pyx_pw_6hunter_11_predicates_4From_9__call__, /*tp_call*/ + __pyx_pw_6hunter_11_predicates_4From_3__str__, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + PyDoc_STR("\n Keep running ``predicates`` after ``condition(event)`` is ``True``.\n "), /*tp_doc*/ + __pyx_tp_traverse_6hunter_11_predicates_From, /*tp_traverse*/ + __pyx_tp_clear_6hunter_11_predicates_From, /*tp_clear*/ + __pyx_tp_richcompare_6hunter_11_predicates_From, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_6hunter_11_predicates_From, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_6hunter_11_predicates_From, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_6hunter_11_predicates_4From_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6hunter_11_predicates_From, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_6hunter_11_predicates_Backlog(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_6hunter_11_predicates_Backlog *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_6hunter_11_predicates_Backlog *)o); + p->condition = Py_None; Py_INCREF(Py_None); + p->action = Py_None; Py_INCREF(Py_None); + p->_try_repr = Py_None; Py_INCREF(Py_None); + p->_filter = Py_None; Py_INCREF(Py_None); + p->queue = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_6hunter_11_predicates_Backlog(PyObject *o) { + struct __pyx_obj_6hunter_11_predicates_Backlog *p = (struct __pyx_obj_6hunter_11_predicates_Backlog *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->condition); + Py_CLEAR(p->action); + Py_CLEAR(p->_try_repr); + Py_CLEAR(p->_filter); + Py_CLEAR(p->queue); + #if CYTHON_USE_TYPE_SLOTS + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_6hunter_11_predicates_Backlog(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_6hunter_11_predicates_Backlog *p = (struct __pyx_obj_6hunter_11_predicates_Backlog *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->condition) { + e = (*v)(p->condition, a); if (e) return e; + } + if (p->action) { + e = (*v)(p->action, a); if (e) return e; + } + if (p->_try_repr) { + e = (*v)(p->_try_repr, a); if (e) return e; + } + if (p->_filter) { + e = (*v)(p->_filter, a); if (e) return e; + } + if (p->queue) { + e = (*v)(p->queue, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_6hunter_11_predicates_Backlog(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_6hunter_11_predicates_Backlog *p = (struct __pyx_obj_6hunter_11_predicates_Backlog *)o; + tmp = ((PyObject*)p->condition); + p->condition = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->action); + p->action = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_try_repr); + p->_try_repr = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_filter); + p->_filter = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->queue); + p->queue = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_tp_richcompare_6hunter_11_predicates_Backlog(PyObject *o1, PyObject *o2, int op) { + switch (op) { + case Py_EQ: { + return __pyx_pw_6hunter_11_predicates_7Backlog_9__eq__(o1, o2); + } + case Py_NE: { + PyObject *ret; + ret = __pyx_pw_6hunter_11_predicates_7Backlog_9__eq__(o1, o2); + if (likely(ret && ret != Py_NotImplemented)) { + int b = __Pyx_PyObject_IsTrue(ret); + Py_DECREF(ret); + if (unlikely(b < 0)) return NULL; + ret = (b) ? Py_False : Py_True; + Py_INCREF(ret); + } + return ret; + } + default: { + return __Pyx_NewRef(Py_NotImplemented); + } + } +} +#define __pyx_nb_and_6hunter_11_predicates_Backlog __pyx_pw_6hunter_11_predicates_7Backlog_13__and__ +#define __pyx_nb_or_6hunter_11_predicates_Backlog __pyx_pw_6hunter_11_predicates_7Backlog_11__or__ + +static PyObject *__pyx_getprop_6hunter_11_predicates_7Backlog_condition(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_11_predicates_7Backlog_9condition_1__get__(o); +} + +static PyObject *__pyx_getprop_6hunter_11_predicates_7Backlog_size(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_11_predicates_7Backlog_4size_1__get__(o); +} + +static PyObject *__pyx_getprop_6hunter_11_predicates_7Backlog_stack(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_11_predicates_7Backlog_5stack_1__get__(o); +} + +static PyObject *__pyx_getprop_6hunter_11_predicates_7Backlog_vars(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_11_predicates_7Backlog_4vars_1__get__(o); +} + +static PyObject *__pyx_getprop_6hunter_11_predicates_7Backlog_strip(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_11_predicates_7Backlog_5strip_1__get__(o); +} + +static PyObject *__pyx_getprop_6hunter_11_predicates_7Backlog_action(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_11_predicates_7Backlog_6action_1__get__(o); +} + +static PyObject *__pyx_getprop_6hunter_11_predicates_7Backlog__try_repr(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_11_predicates_7Backlog_9_try_repr_1__get__(o); +} + +static PyObject *__pyx_getprop_6hunter_11_predicates_7Backlog__filter(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_11_predicates_7Backlog_7_filter_1__get__(o); +} + +static PyObject *__pyx_getprop_6hunter_11_predicates_7Backlog_queue(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_11_predicates_7Backlog_5queue_1__get__(o); +} + +static PyMethodDef __pyx_methods_6hunter_11_predicates_Backlog[] = { + {"__or__", (PyCFunction)__pyx_pw_6hunter_11_predicates_7Backlog_11__or__, METH_O|METH_COEXIST, 0}, + {"__and__", (PyCFunction)__pyx_pw_6hunter_11_predicates_7Backlog_13__and__, METH_O|METH_COEXIST, 0}, + {"filter", (PyCFunction)(void(*)(void))(PyCFunctionWithKeywords)__pyx_pw_6hunter_11_predicates_7Backlog_17filter, METH_VARARGS|METH_KEYWORDS, 0}, + {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_7Backlog_19__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_7Backlog_21__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_6hunter_11_predicates_Backlog[] = { + {"condition", __pyx_getprop_6hunter_11_predicates_7Backlog_condition, 0, 0, 0}, + {"size", __pyx_getprop_6hunter_11_predicates_7Backlog_size, 0, 0, 0}, + {"stack", __pyx_getprop_6hunter_11_predicates_7Backlog_stack, 0, 0, 0}, + {"vars", __pyx_getprop_6hunter_11_predicates_7Backlog_vars, 0, 0, 0}, + {"strip", __pyx_getprop_6hunter_11_predicates_7Backlog_strip, 0, 0, 0}, + {"action", __pyx_getprop_6hunter_11_predicates_7Backlog_action, 0, 0, 0}, + {"_try_repr", __pyx_getprop_6hunter_11_predicates_7Backlog__try_repr, 0, 0, 0}, + {"_filter", __pyx_getprop_6hunter_11_predicates_7Backlog__filter, 0, 0, 0}, + {"queue", __pyx_getprop_6hunter_11_predicates_7Backlog_queue, 0, 0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_6hunter_11_predicates_Backlog_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_6hunter_11_predicates_Backlog}, + {Py_tp_repr, (void *)__pyx_pw_6hunter_11_predicates_7Backlog_7__repr__}, + {Py_nb_invert, (void *)__pyx_pw_6hunter_11_predicates_7Backlog_15__invert__}, + {Py_nb_and, (void *)__pyx_nb_and_6hunter_11_predicates_Backlog}, + {Py_nb_or, (void *)__pyx_nb_or_6hunter_11_predicates_Backlog}, + {Py_tp_call, (void *)__pyx_pw_6hunter_11_predicates_7Backlog_3__call__}, + {Py_tp_str, (void *)__pyx_pw_6hunter_11_predicates_7Backlog_5__str__}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_6hunter_11_predicates_Backlog}, + {Py_tp_clear, (void *)__pyx_tp_clear_6hunter_11_predicates_Backlog}, + {Py_tp_richcompare, (void *)__pyx_tp_richcompare_6hunter_11_predicates_Backlog}, + {Py_tp_methods, (void *)__pyx_methods_6hunter_11_predicates_Backlog}, + {Py_tp_getset, (void *)__pyx_getsets_6hunter_11_predicates_Backlog}, + {Py_tp_init, (void *)__pyx_pw_6hunter_11_predicates_7Backlog_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_6hunter_11_predicates_Backlog}, + {0, 0}, +}; +static PyType_Spec __pyx_type_6hunter_11_predicates_Backlog_spec = { + "hunter._predicates.Backlog", + sizeof(struct __pyx_obj_6hunter_11_predicates_Backlog), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, + __pyx_type_6hunter_11_predicates_Backlog_slots, +}; +#else + +static PyNumberMethods __pyx_tp_as_number_Backlog = { + 0, /*nb_add*/ + 0, /*nb_subtract*/ + 0, /*nb_multiply*/ + 0, /*nb_remainder*/ + 0, /*nb_divmod*/ + 0, /*nb_power*/ + 0, /*nb_negative*/ + 0, /*nb_positive*/ + 0, /*nb_absolute*/ + 0, /*nb_bool*/ + __pyx_pw_6hunter_11_predicates_7Backlog_15__invert__, /*nb_invert*/ + 0, /*nb_lshift*/ + 0, /*nb_rshift*/ + __pyx_nb_and_6hunter_11_predicates_Backlog, /*nb_and*/ + 0, /*nb_xor*/ + __pyx_nb_or_6hunter_11_predicates_Backlog, /*nb_or*/ + 0, /*nb_int*/ + 0, /*nb_long (reserved)*/ + 0, /*nb_float*/ + 0, /*nb_inplace_add*/ + 0, /*nb_inplace_subtract*/ + 0, /*nb_inplace_multiply*/ + 0, /*nb_inplace_remainder*/ + 0, /*nb_inplace_power*/ + 0, /*nb_inplace_lshift*/ + 0, /*nb_inplace_rshift*/ + 0, /*nb_inplace_and*/ + 0, /*nb_inplace_xor*/ + 0, /*nb_inplace_or*/ + 0, /*nb_floor_divide*/ + 0, /*nb_true_divide*/ + 0, /*nb_inplace_floor_divide*/ + 0, /*nb_inplace_true_divide*/ + 0, /*nb_index*/ + 0, /*nb_matrix_multiply*/ + 0, /*nb_inplace_matrix_multiply*/ +}; + +static PyTypeObject __pyx_type_6hunter_11_predicates_Backlog = { + PyVarObject_HEAD_INIT(0, 0) + "hunter._predicates.""Backlog", /*tp_name*/ + sizeof(struct __pyx_obj_6hunter_11_predicates_Backlog), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6hunter_11_predicates_Backlog, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + __pyx_pw_6hunter_11_predicates_7Backlog_7__repr__, /*tp_repr*/ + &__pyx_tp_as_number_Backlog, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + __pyx_pw_6hunter_11_predicates_7Backlog_3__call__, /*tp_call*/ + __pyx_pw_6hunter_11_predicates_7Backlog_5__str__, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_6hunter_11_predicates_Backlog, /*tp_traverse*/ + __pyx_tp_clear_6hunter_11_predicates_Backlog, /*tp_clear*/ + __pyx_tp_richcompare_6hunter_11_predicates_Backlog, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_6hunter_11_predicates_Backlog, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_6hunter_11_predicates_Backlog, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_6hunter_11_predicates_7Backlog_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6hunter_11_predicates_Backlog, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_6hunter_11_predicates_QueryEntry(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_6hunter_11_predicates_QueryEntry *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_6hunter_11_predicates_QueryEntry *)o); + p->value = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_6hunter_11_predicates_QueryEntry(PyObject *o) { + struct __pyx_obj_6hunter_11_predicates_QueryEntry *p = (struct __pyx_obj_6hunter_11_predicates_QueryEntry *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->value); + #if CYTHON_USE_TYPE_SLOTS + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_6hunter_11_predicates_QueryEntry(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_6hunter_11_predicates_QueryEntry *p = (struct __pyx_obj_6hunter_11_predicates_QueryEntry *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->value) { + e = (*v)(p->value, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_6hunter_11_predicates_QueryEntry(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_6hunter_11_predicates_QueryEntry *p = (struct __pyx_obj_6hunter_11_predicates_QueryEntry *)o; + tmp = ((PyObject*)p->value); + p->value = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_tp_richcompare_6hunter_11_predicates_QueryEntry(PyObject *o1, PyObject *o2, int op) { + switch (op) { + case Py_EQ: { + return __pyx_pw_6hunter_11_predicates_10QueryEntry_5__eq__(o1, o2); + } + case Py_NE: { + PyObject *ret; + ret = __pyx_pw_6hunter_11_predicates_10QueryEntry_5__eq__(o1, o2); + if (likely(ret && ret != Py_NotImplemented)) { + int b = __Pyx_PyObject_IsTrue(ret); + Py_DECREF(ret); + if (unlikely(b < 0)) return NULL; + ret = (b) ? Py_False : Py_True; + Py_INCREF(ret); + } + return ret; + } + default: { + return __Pyx_NewRef(Py_NotImplemented); + } + } +} + +static PyMethodDef __pyx_methods_6hunter_11_predicates_QueryEntry[] = { + {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_10QueryEntry_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_10QueryEntry_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_6hunter_11_predicates_QueryEntry_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_6hunter_11_predicates_QueryEntry}, + {Py_tp_repr, (void *)__pyx_pw_6hunter_11_predicates_10QueryEntry_3__repr__}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_6hunter_11_predicates_QueryEntry}, + {Py_tp_clear, (void *)__pyx_tp_clear_6hunter_11_predicates_QueryEntry}, + {Py_tp_richcompare, (void *)__pyx_tp_richcompare_6hunter_11_predicates_QueryEntry}, + {Py_tp_methods, (void *)__pyx_methods_6hunter_11_predicates_QueryEntry}, + {Py_tp_init, (void *)__pyx_pw_6hunter_11_predicates_10QueryEntry_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_6hunter_11_predicates_QueryEntry}, + {0, 0}, +}; +static PyType_Spec __pyx_type_6hunter_11_predicates_QueryEntry_spec = { + "hunter._predicates.QueryEntry", + sizeof(struct __pyx_obj_6hunter_11_predicates_QueryEntry), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, + __pyx_type_6hunter_11_predicates_QueryEntry_slots, +}; +#else + +static PyTypeObject __pyx_type_6hunter_11_predicates_QueryEntry = { + PyVarObject_HEAD_INIT(0, 0) + "hunter._predicates.""QueryEntry", /*tp_name*/ + sizeof(struct __pyx_obj_6hunter_11_predicates_QueryEntry), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6hunter_11_predicates_QueryEntry, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + __pyx_pw_6hunter_11_predicates_10QueryEntry_3__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_6hunter_11_predicates_QueryEntry, /*tp_traverse*/ + __pyx_tp_clear_6hunter_11_predicates_QueryEntry, /*tp_clear*/ + __pyx_tp_richcompare_6hunter_11_predicates_QueryEntry, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_6hunter_11_predicates_QueryEntry, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_6hunter_11_predicates_10QueryEntry_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6hunter_11_predicates_QueryEntry, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct____str__(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_mstate_global->__pyx_freecount_6hunter_11_predicates___pyx_scope_struct____str__ > 0) & (int)(t->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__)))) { + o = (PyObject*)__pyx_mstate_global->__pyx_freelist_6hunter_11_predicates___pyx_scope_struct____str__[--__pyx_mstate_global->__pyx_freecount_6hunter_11_predicates___pyx_scope_struct____str__]; + memset(o, 0, sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else + #endif + { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + #endif + return o; +} + +static void __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct____str__(PyObject *o) { + struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__ *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__ *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct____str__) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_8genexpr1__pyx_v_kind); + #if CYTHON_USE_FREELISTS + if (((int)(__pyx_mstate_global->__pyx_freecount_6hunter_11_predicates___pyx_scope_struct____str__ < 8) & (int)(Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__)))) { + __pyx_mstate_global->__pyx_freelist_6hunter_11_predicates___pyx_scope_struct____str__[__pyx_mstate_global->__pyx_freecount_6hunter_11_predicates___pyx_scope_struct____str__++] = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__ *)o); + } else + #endif + { + #if CYTHON_USE_TYPE_SLOTS + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + } +} + +static int __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct____str__(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__ *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__ *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->__pyx_8genexpr1__pyx_v_kind) { + e = (*v)(p->__pyx_8genexpr1__pyx_v_kind, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_6hunter_11_predicates___pyx_scope_struct____str__(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__ *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__ *)o; + tmp = ((PyObject*)p->__pyx_8genexpr1__pyx_v_kind); + p->__pyx_8genexpr1__pyx_v_kind = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_6hunter_11_predicates___pyx_scope_struct____str___slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct____str__}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct____str__}, + {Py_tp_clear, (void *)__pyx_tp_clear_6hunter_11_predicates___pyx_scope_struct____str__}, + {Py_tp_new, (void *)__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct____str__}, + {0, 0}, +}; +static PyType_Spec __pyx_type_6hunter_11_predicates___pyx_scope_struct____str___spec = { + "hunter._predicates.__pyx_scope_struct____str__", + sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, + __pyx_type_6hunter_11_predicates___pyx_scope_struct____str___slots, +}; +#else + +static PyTypeObject __pyx_type_6hunter_11_predicates___pyx_scope_struct____str__ = { + PyVarObject_HEAD_INIT(0, 0) + "hunter._predicates.""__pyx_scope_struct____str__", /*tp_name*/ + sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct____str__), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct____str__, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct____str__, /*tp_traverse*/ + __pyx_tp_clear_6hunter_11_predicates___pyx_scope_struct____str__, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6hunter_11_predicates___pyx_scope_struct____str__, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_1_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_mstate_global->__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_1_genexpr > 0) & (int)(t->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr)))) { + o = (PyObject*)__pyx_mstate_global->__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_1_genexpr[--__pyx_mstate_global->__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_1_genexpr]; + memset(o, 0, sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else + #endif + { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + #endif + return o; +} + +static void __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_1_genexpr(PyObject *o) { + struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_1_genexpr) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_outer_scope); + Py_CLEAR(p->__pyx_genexpr_arg_0); + Py_CLEAR(p->__pyx_v_key); + Py_CLEAR(p->__pyx_v_value); + #if CYTHON_USE_FREELISTS + if (((int)(__pyx_mstate_global->__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_1_genexpr < 8) & (int)(Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr)))) { + __pyx_mstate_global->__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_1_genexpr[__pyx_mstate_global->__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_1_genexpr++] = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr *)o); + } else + #endif + { + #if CYTHON_USE_TYPE_SLOTS + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + } +} + +static int __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_1_genexpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->__pyx_outer_scope) { + e = (*v)(((PyObject *)p->__pyx_outer_scope), a); if (e) return e; + } + if (p->__pyx_genexpr_arg_0) { + e = (*v)(p->__pyx_genexpr_arg_0, a); if (e) return e; + } + if (p->__pyx_v_key) { + e = (*v)(p->__pyx_v_key, a); if (e) return e; + } + if (p->__pyx_v_value) { + e = (*v)(p->__pyx_v_value, a); if (e) return e; + } + return 0; +} +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_6hunter_11_predicates___pyx_scope_struct_1_genexpr_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_1_genexpr}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_1_genexpr}, + {Py_tp_new, (void *)__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_1_genexpr}, + {0, 0}, +}; +static PyType_Spec __pyx_type_6hunter_11_predicates___pyx_scope_struct_1_genexpr_spec = { + "hunter._predicates.__pyx_scope_struct_1_genexpr", + sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, + __pyx_type_6hunter_11_predicates___pyx_scope_struct_1_genexpr_slots, +}; +#else + +static PyTypeObject __pyx_type_6hunter_11_predicates___pyx_scope_struct_1_genexpr = { + PyVarObject_HEAD_INIT(0, 0) + "hunter._predicates.""__pyx_scope_struct_1_genexpr", /*tp_name*/ + sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_1_genexpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_1_genexpr, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_1_genexpr, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_1_genexpr, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_2_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_mstate_global->__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_2_genexpr > 0) & (int)(t->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr)))) { + o = (PyObject*)__pyx_mstate_global->__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_2_genexpr[--__pyx_mstate_global->__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_2_genexpr]; + memset(o, 0, sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else + #endif + { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + #endif + return o; +} + +static void __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_2_genexpr(PyObject *o) { + struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_2_genexpr) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_genexpr_arg_0); + Py_CLEAR(p->__pyx_v_action); + Py_CLEAR(p->__pyx_t_0); + #if CYTHON_USE_FREELISTS + if (((int)(__pyx_mstate_global->__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_2_genexpr < 8) & (int)(Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr)))) { + __pyx_mstate_global->__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_2_genexpr[__pyx_mstate_global->__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_2_genexpr++] = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr *)o); + } else + #endif + { + #if CYTHON_USE_TYPE_SLOTS + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + } +} + +static int __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_2_genexpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->__pyx_genexpr_arg_0) { + e = (*v)(p->__pyx_genexpr_arg_0, a); if (e) return e; + } + if (p->__pyx_v_action) { + e = (*v)(p->__pyx_v_action, a); if (e) return e; + } + if (p->__pyx_t_0) { + e = (*v)(p->__pyx_t_0, a); if (e) return e; + } + return 0; +} +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_6hunter_11_predicates___pyx_scope_struct_2_genexpr_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_2_genexpr}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_2_genexpr}, + {Py_tp_new, (void *)__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_2_genexpr}, + {0, 0}, +}; +static PyType_Spec __pyx_type_6hunter_11_predicates___pyx_scope_struct_2_genexpr_spec = { + "hunter._predicates.__pyx_scope_struct_2_genexpr", + sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, + __pyx_type_6hunter_11_predicates___pyx_scope_struct_2_genexpr_slots, +}; +#else + +static PyTypeObject __pyx_type_6hunter_11_predicates___pyx_scope_struct_2_genexpr = { + PyVarObject_HEAD_INIT(0, 0) + "hunter._predicates.""__pyx_scope_struct_2_genexpr", /*tp_name*/ + sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_2_genexpr, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_2_genexpr, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_2_genexpr, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_3_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_mstate_global->__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_3_genexpr > 0) & (int)(t->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3_genexpr)))) { + o = (PyObject*)__pyx_mstate_global->__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_3_genexpr[--__pyx_mstate_global->__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_3_genexpr]; + memset(o, 0, sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3_genexpr)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else + #endif + { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + #endif + return o; +} + +static void __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_3_genexpr(PyObject *o) { + struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3_genexpr *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3_genexpr *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_3_genexpr) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_genexpr_arg_0); + Py_CLEAR(p->__pyx_v_p); + #if CYTHON_USE_FREELISTS + if (((int)(__pyx_mstate_global->__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_3_genexpr < 8) & (int)(Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3_genexpr)))) { + __pyx_mstate_global->__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_3_genexpr[__pyx_mstate_global->__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_3_genexpr++] = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3_genexpr *)o); + } else + #endif + { + #if CYTHON_USE_TYPE_SLOTS + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + } +} + +static int __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_3_genexpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3_genexpr *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3_genexpr *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->__pyx_genexpr_arg_0) { + e = (*v)(p->__pyx_genexpr_arg_0, a); if (e) return e; + } + if (p->__pyx_v_p) { + e = (*v)(p->__pyx_v_p, a); if (e) return e; + } + return 0; +} +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_6hunter_11_predicates___pyx_scope_struct_3_genexpr_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_3_genexpr}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_3_genexpr}, + {Py_tp_new, (void *)__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_3_genexpr}, + {0, 0}, +}; +static PyType_Spec __pyx_type_6hunter_11_predicates___pyx_scope_struct_3_genexpr_spec = { + "hunter._predicates.__pyx_scope_struct_3_genexpr", + sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3_genexpr), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, + __pyx_type_6hunter_11_predicates___pyx_scope_struct_3_genexpr_slots, +}; +#else + +static PyTypeObject __pyx_type_6hunter_11_predicates___pyx_scope_struct_3_genexpr = { + PyVarObject_HEAD_INIT(0, 0) + "hunter._predicates.""__pyx_scope_struct_3_genexpr", /*tp_name*/ + sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3_genexpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_3_genexpr, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_3_genexpr, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_3_genexpr, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_4_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_mstate_global->__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_4_genexpr > 0) & (int)(t->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr)))) { + o = (PyObject*)__pyx_mstate_global->__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_4_genexpr[--__pyx_mstate_global->__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_4_genexpr]; + memset(o, 0, sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else + #endif + { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + #endif + return o; +} + +static void __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_4_genexpr(PyObject *o) { + struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_4_genexpr) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_genexpr_arg_0); + Py_CLEAR(p->__pyx_v_p); + #if CYTHON_USE_FREELISTS + if (((int)(__pyx_mstate_global->__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_4_genexpr < 8) & (int)(Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr)))) { + __pyx_mstate_global->__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_4_genexpr[__pyx_mstate_global->__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_4_genexpr++] = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr *)o); + } else + #endif + { + #if CYTHON_USE_TYPE_SLOTS + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + } +} + +static int __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_4_genexpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->__pyx_genexpr_arg_0) { + e = (*v)(p->__pyx_genexpr_arg_0, a); if (e) return e; + } + if (p->__pyx_v_p) { + e = (*v)(p->__pyx_v_p, a); if (e) return e; + } + return 0; +} +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_6hunter_11_predicates___pyx_scope_struct_4_genexpr_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_4_genexpr}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_4_genexpr}, + {Py_tp_new, (void *)__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_4_genexpr}, + {0, 0}, +}; +static PyType_Spec __pyx_type_6hunter_11_predicates___pyx_scope_struct_4_genexpr_spec = { + "hunter._predicates.__pyx_scope_struct_4_genexpr", + sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, + __pyx_type_6hunter_11_predicates___pyx_scope_struct_4_genexpr_slots, +}; +#else + +static PyTypeObject __pyx_type_6hunter_11_predicates___pyx_scope_struct_4_genexpr = { + PyVarObject_HEAD_INIT(0, 0) + "hunter._predicates.""__pyx_scope_struct_4_genexpr", /*tp_name*/ + sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_4_genexpr, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_4_genexpr, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_4_genexpr, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_5_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_mstate_global->__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_5_genexpr > 0) & (int)(t->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5_genexpr)))) { + o = (PyObject*)__pyx_mstate_global->__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_5_genexpr[--__pyx_mstate_global->__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_5_genexpr]; + memset(o, 0, sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5_genexpr)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else + #endif + { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + #endif + return o; +} + +static void __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_5_genexpr(PyObject *o) { + struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5_genexpr *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5_genexpr *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_5_genexpr) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_genexpr_arg_0); + Py_CLEAR(p->__pyx_v_p); + #if CYTHON_USE_FREELISTS + if (((int)(__pyx_mstate_global->__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_5_genexpr < 8) & (int)(Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5_genexpr)))) { + __pyx_mstate_global->__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_5_genexpr[__pyx_mstate_global->__pyx_freecount_6hunter_11_predicates___pyx_scope_struct_5_genexpr++] = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5_genexpr *)o); + } else + #endif + { + #if CYTHON_USE_TYPE_SLOTS + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + } +} + +static int __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_5_genexpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5_genexpr *p = (struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5_genexpr *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->__pyx_genexpr_arg_0) { + e = (*v)(p->__pyx_genexpr_arg_0, a); if (e) return e; + } + if (p->__pyx_v_p) { + e = (*v)(p->__pyx_v_p, a); if (e) return e; + } + return 0; +} +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_6hunter_11_predicates___pyx_scope_struct_5_genexpr_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_5_genexpr}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_5_genexpr}, + {Py_tp_new, (void *)__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_5_genexpr}, + {0, 0}, +}; +static PyType_Spec __pyx_type_6hunter_11_predicates___pyx_scope_struct_5_genexpr_spec = { + "hunter._predicates.__pyx_scope_struct_5_genexpr", + sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5_genexpr), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, + __pyx_type_6hunter_11_predicates___pyx_scope_struct_5_genexpr_slots, +}; +#else + +static PyTypeObject __pyx_type_6hunter_11_predicates___pyx_scope_struct_5_genexpr = { + PyVarObject_HEAD_INIT(0, 0) + "hunter._predicates.""__pyx_scope_struct_5_genexpr", /*tp_name*/ + sizeof(struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5_genexpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6hunter_11_predicates___pyx_scope_struct_5_genexpr, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_6hunter_11_predicates___pyx_scope_struct_5_genexpr, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_5_genexpr, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_mstate_global->__pyx_freecount___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event > 0) & (int)(t->tp_basicsize == sizeof(struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event)))) { + o = (PyObject*)__pyx_mstate_global->__pyx_freelist___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event[--__pyx_mstate_global->__pyx_freecount___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event]; + memset(o, 0, sizeof(struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event)); + (void) PyObject_INIT(o, t); + } else + #endif + { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + #endif + return o; +} + +static void __pyx_tp_dealloc___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event(PyObject *o) { + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + #if CYTHON_USE_FREELISTS + if (((int)(__pyx_mstate_global->__pyx_freecount___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event < 8) & (int)(Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event)))) { + __pyx_mstate_global->__pyx_freelist___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event[__pyx_mstate_global->__pyx_freecount___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event++] = ((struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event *)o); + } else + #endif + { + #if CYTHON_USE_TYPE_SLOTS + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + } +} +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event}, + {Py_tp_new, (void *)__pyx_tp_new___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event}, + {0, 0}, +}; +static PyType_Spec __pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event_spec = { + "hunter._predicates.__pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event", + sizeof(struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_FINALIZE, + __pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event_slots, +}; +#else + +static PyTypeObject __pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event = { + PyVarObject_HEAD_INIT(0, 0) + "hunter._predicates.""__pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event", /*tp_name*/ + sizeof(struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; +/* #### Code section: initfunc_declarations ### */ +static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate); /*proto*/ +/* #### Code section: init_module ### */ + +static int __Pyx_modinit_global_init_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); + /*--- Global init code ---*/ + __pyx_v_6hunter_11_predicates_ALLOWED_KEYS = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_6hunter_11_predicates_ALLOWED_OPERATORS = ((PyObject*)Py_None); Py_INCREF(Py_None); + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_export_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); + /*--- Variable export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_export_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); + /*--- Function export code ---*/ + if (__Pyx_ExportFunction("fast_And_call", (void (*)(void))__pyx_f_6hunter_11_predicates_fast_And_call, "PyObject *(struct __pyx_obj_6hunter_11_predicates_And *, struct __pyx_obj_6hunter_6_event_Event *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("fast_From_call", (void (*)(void))__pyx_f_6hunter_11_predicates_fast_From_call, "PyObject *(struct __pyx_obj_6hunter_11_predicates_From *, struct __pyx_obj_6hunter_6_event_Event *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("fast_Not_call", (void (*)(void))__pyx_f_6hunter_11_predicates_fast_Not_call, "PyObject *(struct __pyx_obj_6hunter_11_predicates_Not *, struct __pyx_obj_6hunter_6_event_Event *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("fast_Or_call", (void (*)(void))__pyx_f_6hunter_11_predicates_fast_Or_call, "PyObject *(struct __pyx_obj_6hunter_11_predicates_Or *, struct __pyx_obj_6hunter_6_event_Event *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("fast_Query_call", (void (*)(void))__pyx_f_6hunter_11_predicates_fast_Query_call, "PyObject *(struct __pyx_obj_6hunter_11_predicates_Query *, struct __pyx_obj_6hunter_6_event_Event *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("fast_When_call", (void (*)(void))__pyx_f_6hunter_11_predicates_fast_When_call, "PyObject *(struct __pyx_obj_6hunter_11_predicates_When *, struct __pyx_obj_6hunter_6_event_Event *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("fast_call", (void (*)(void))__pyx_f_6hunter_11_predicates_fast_call, "PyObject *(PyObject *, struct __pyx_obj_6hunter_6_event_Event *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_type_init_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); + /*--- Type init code ---*/ + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Query = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6hunter_11_predicates_Query_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_6hunter_11_predicates_Query)) __PYX_ERR(0, 99, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_11_predicates_Query_spec, __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Query) < 0) __PYX_ERR(0, 99, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Query = &__pyx_type_6hunter_11_predicates_Query; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_6hunter_11_predicates_Query) < 0) __PYX_ERR(0, 99, __pyx_L1_error) + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_6hunter_11_predicates_Query->tp_dictoffset && __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Query->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Query->tp_getattro = PyObject_GenericGetAttr; + } + #endif + #if CYTHON_UPDATE_DESCRIPTOR_DOC + { + PyObject *wrapper = PyObject_GetAttrString((PyObject *)__pyx_mstate->__pyx_ptype_6hunter_11_predicates_Query, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(0, 99, __pyx_L1_error) + if (__Pyx_IS_TYPE(wrapper, &PyWrapperDescr_Type)) { + __pyx_wrapperbase_6hunter_11_predicates_5Query___init__ = *((PyWrapperDescrObject *)wrapper)->d_base; + __pyx_wrapperbase_6hunter_11_predicates_5Query___init__.doc = __pyx_doc_6hunter_11_predicates_5Query___init__; + ((PyWrapperDescrObject *)wrapper)->d_base = &__pyx_wrapperbase_6hunter_11_predicates_5Query___init__; + } + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_Query, (PyObject *) __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Query) < 0) __PYX_ERR(0, 99, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Query) < 0) __PYX_ERR(0, 99, __pyx_L1_error) + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_6hunter_11_predicates_And = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6hunter_11_predicates_And_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_6hunter_11_predicates_And)) __PYX_ERR(0, 437, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_11_predicates_And_spec, __pyx_mstate->__pyx_ptype_6hunter_11_predicates_And) < 0) __PYX_ERR(0, 437, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_6hunter_11_predicates_And = &__pyx_type_6hunter_11_predicates_And; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_6hunter_11_predicates_And) < 0) __PYX_ERR(0, 437, __pyx_L1_error) + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_6hunter_11_predicates_And->tp_dictoffset && __pyx_mstate->__pyx_ptype_6hunter_11_predicates_And->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_6hunter_11_predicates_And->tp_getattro = PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_And, (PyObject *) __pyx_mstate->__pyx_ptype_6hunter_11_predicates_And) < 0) __PYX_ERR(0, 437, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_6hunter_11_predicates_And) < 0) __PYX_ERR(0, 437, __pyx_L1_error) + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Or = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6hunter_11_predicates_Or_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_6hunter_11_predicates_Or)) __PYX_ERR(0, 486, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_11_predicates_Or_spec, __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Or) < 0) __PYX_ERR(0, 486, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Or = &__pyx_type_6hunter_11_predicates_Or; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_6hunter_11_predicates_Or) < 0) __PYX_ERR(0, 486, __pyx_L1_error) + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_6hunter_11_predicates_Or->tp_dictoffset && __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Or->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Or->tp_getattro = PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_Or, (PyObject *) __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Or) < 0) __PYX_ERR(0, 486, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Or) < 0) __PYX_ERR(0, 486, __pyx_L1_error) + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Not = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6hunter_11_predicates_Not_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_6hunter_11_predicates_Not)) __PYX_ERR(0, 536, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_11_predicates_Not_spec, __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Not) < 0) __PYX_ERR(0, 536, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Not = &__pyx_type_6hunter_11_predicates_Not; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_6hunter_11_predicates_Not) < 0) __PYX_ERR(0, 536, __pyx_L1_error) + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_6hunter_11_predicates_Not->tp_dictoffset && __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Not->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Not->tp_getattro = PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_Not, (PyObject *) __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Not) < 0) __PYX_ERR(0, 536, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Not) < 0) __PYX_ERR(0, 536, __pyx_L1_error) + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_6hunter_11_predicates_When = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6hunter_11_predicates_When_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_6hunter_11_predicates_When)) __PYX_ERR(0, 309, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_11_predicates_When_spec, __pyx_mstate->__pyx_ptype_6hunter_11_predicates_When) < 0) __PYX_ERR(0, 309, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_6hunter_11_predicates_When = &__pyx_type_6hunter_11_predicates_When; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_6hunter_11_predicates_When) < 0) __PYX_ERR(0, 309, __pyx_L1_error) + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_6hunter_11_predicates_When->tp_dictoffset && __pyx_mstate->__pyx_ptype_6hunter_11_predicates_When->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_6hunter_11_predicates_When->tp_getattro = PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_When_2, (PyObject *) __pyx_mstate->__pyx_ptype_6hunter_11_predicates_When) < 0) __PYX_ERR(0, 309, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_6hunter_11_predicates_When) < 0) __PYX_ERR(0, 309, __pyx_L1_error) + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_6hunter_11_predicates_From = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6hunter_11_predicates_From_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_6hunter_11_predicates_From)) __PYX_ERR(0, 365, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_11_predicates_From_spec, __pyx_mstate->__pyx_ptype_6hunter_11_predicates_From) < 0) __PYX_ERR(0, 365, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_6hunter_11_predicates_From = &__pyx_type_6hunter_11_predicates_From; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_6hunter_11_predicates_From) < 0) __PYX_ERR(0, 365, __pyx_L1_error) + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_6hunter_11_predicates_From->tp_dictoffset && __pyx_mstate->__pyx_ptype_6hunter_11_predicates_From->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_6hunter_11_predicates_From->tp_getattro = PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_From_2, (PyObject *) __pyx_mstate->__pyx_ptype_6hunter_11_predicates_From) < 0) __PYX_ERR(0, 365, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_6hunter_11_predicates_From) < 0) __PYX_ERR(0, 365, __pyx_L1_error) + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Backlog = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6hunter_11_predicates_Backlog_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_6hunter_11_predicates_Backlog)) __PYX_ERR(0, 596, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_11_predicates_Backlog_spec, __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Backlog) < 0) __PYX_ERR(0, 596, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Backlog = &__pyx_type_6hunter_11_predicates_Backlog; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_6hunter_11_predicates_Backlog) < 0) __PYX_ERR(0, 596, __pyx_L1_error) + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_6hunter_11_predicates_Backlog->tp_dictoffset && __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Backlog->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Backlog->tp_getattro = PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_Backlog_2, (PyObject *) __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Backlog) < 0) __PYX_ERR(0, 596, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Backlog) < 0) __PYX_ERR(0, 596, __pyx_L1_error) + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_6hunter_11_predicates_QueryEntry = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6hunter_11_predicates_QueryEntry_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_6hunter_11_predicates_QueryEntry)) __PYX_ERR(0, 77, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_11_predicates_QueryEntry_spec, __pyx_mstate->__pyx_ptype_6hunter_11_predicates_QueryEntry) < 0) __PYX_ERR(0, 77, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_6hunter_11_predicates_QueryEntry = &__pyx_type_6hunter_11_predicates_QueryEntry; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_6hunter_11_predicates_QueryEntry) < 0) __PYX_ERR(0, 77, __pyx_L1_error) + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_6hunter_11_predicates_QueryEntry->tp_dictoffset && __pyx_mstate->__pyx_ptype_6hunter_11_predicates_QueryEntry->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_6hunter_11_predicates_QueryEntry->tp_getattro = PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_QueryEntry, (PyObject *) __pyx_mstate->__pyx_ptype_6hunter_11_predicates_QueryEntry) < 0) __PYX_ERR(0, 77, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_6hunter_11_predicates_QueryEntry) < 0) __PYX_ERR(0, 77, __pyx_L1_error) + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct____str__ = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6hunter_11_predicates___pyx_scope_struct____str___spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct____str__)) __PYX_ERR(0, 199, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_11_predicates___pyx_scope_struct____str___spec, __pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct____str__) < 0) __PYX_ERR(0, 199, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct____str__ = &__pyx_type_6hunter_11_predicates___pyx_scope_struct____str__; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct____str__) < 0) __PYX_ERR(0, 199, __pyx_L1_error) + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct____str__->tp_dictoffset && __pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct____str__->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct____str__->tp_getattro = PyObject_GenericGetAttr; + } + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_1_genexpr = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6hunter_11_predicates___pyx_scope_struct_1_genexpr_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_1_genexpr)) __PYX_ERR(0, 202, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_11_predicates___pyx_scope_struct_1_genexpr_spec, __pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_1_genexpr) < 0) __PYX_ERR(0, 202, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_1_genexpr = &__pyx_type_6hunter_11_predicates___pyx_scope_struct_1_genexpr; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_1_genexpr) < 0) __PYX_ERR(0, 202, __pyx_L1_error) + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_1_genexpr->tp_dictoffset && __pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_1_genexpr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_1_genexpr->tp_getattro = PyObject_GenericGetAttr; + } + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_2_genexpr = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6hunter_11_predicates___pyx_scope_struct_2_genexpr_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_2_genexpr)) __PYX_ERR(0, 322, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_11_predicates___pyx_scope_struct_2_genexpr_spec, __pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_2_genexpr) < 0) __PYX_ERR(0, 322, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_2_genexpr = &__pyx_type_6hunter_11_predicates___pyx_scope_struct_2_genexpr; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_2_genexpr) < 0) __PYX_ERR(0, 322, __pyx_L1_error) + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_2_genexpr->tp_dictoffset && __pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_2_genexpr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_2_genexpr->tp_getattro = PyObject_GenericGetAttr; + } + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_3_genexpr = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6hunter_11_predicates___pyx_scope_struct_3_genexpr_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_3_genexpr)) __PYX_ERR(0, 328, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_11_predicates___pyx_scope_struct_3_genexpr_spec, __pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_3_genexpr) < 0) __PYX_ERR(0, 328, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_3_genexpr = &__pyx_type_6hunter_11_predicates___pyx_scope_struct_3_genexpr; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_3_genexpr) < 0) __PYX_ERR(0, 328, __pyx_L1_error) + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_3_genexpr->tp_dictoffset && __pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_3_genexpr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_3_genexpr->tp_getattro = PyObject_GenericGetAttr; + } + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_4_genexpr = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6hunter_11_predicates___pyx_scope_struct_4_genexpr_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_4_genexpr)) __PYX_ERR(0, 446, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_11_predicates___pyx_scope_struct_4_genexpr_spec, __pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_4_genexpr) < 0) __PYX_ERR(0, 446, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_4_genexpr = &__pyx_type_6hunter_11_predicates___pyx_scope_struct_4_genexpr; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_4_genexpr) < 0) __PYX_ERR(0, 446, __pyx_L1_error) + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_4_genexpr->tp_dictoffset && __pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_4_genexpr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_4_genexpr->tp_getattro = PyObject_GenericGetAttr; + } + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_5_genexpr = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6hunter_11_predicates___pyx_scope_struct_5_genexpr_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_5_genexpr)) __PYX_ERR(0, 496, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_11_predicates___pyx_scope_struct_5_genexpr_spec, __pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_5_genexpr) < 0) __PYX_ERR(0, 496, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_5_genexpr = &__pyx_type_6hunter_11_predicates___pyx_scope_struct_5_genexpr; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_5_genexpr) < 0) __PYX_ERR(0, 496, __pyx_L1_error) + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_5_genexpr->tp_dictoffset && __pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_5_genexpr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_5_genexpr->tp_getattro = PyObject_GenericGetAttr; + } + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event)) __PYX_ERR(1, 65, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event_spec, __pyx_mstate->__pyx_ptype___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event) < 0) __PYX_ERR(1, 65, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event = &__pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event) < 0) __PYX_ERR(1, 65, __pyx_L1_error) + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event->tp_dictoffset && __pyx_mstate->__pyx_ptype___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event->tp_getattro = PyObject_GenericGetAttr; + } + #endif + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_type_import_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); + /*--- Type import code ---*/ + __pyx_t_1 = PyImport_ImportModule("types"); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_mstate->__pyx_ptype_6hunter_6_event_CodeType = __Pyx_ImportType_3_1_3(__pyx_t_1, "types", "CodeType", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyCodeObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(PyCodeObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyCodeObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(PyCodeObject), + #else + sizeof(PyCodeObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(PyCodeObject), + #endif + __Pyx_ImportType_CheckSize_Ignore_3_1_3); if (!__pyx_mstate->__pyx_ptype_6hunter_6_event_CodeType) __PYX_ERR(3, 7, __pyx_L1_error) + __pyx_t_2 = PyImport_ImportModule("hunter._event"); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_mstate->__pyx_ptype_6hunter_6_event_Event = __Pyx_ImportType_3_1_3(__pyx_t_2, "hunter._event", "Event", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(struct __pyx_obj_6hunter_6_event_Event), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(struct __pyx_obj_6hunter_6_event_Event), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(struct __pyx_obj_6hunter_6_event_Event), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(struct __pyx_obj_6hunter_6_event_Event), + #else + sizeof(struct __pyx_obj_6hunter_6_event_Event), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(struct __pyx_obj_6hunter_6_event_Event), + #endif + __Pyx_ImportType_CheckSize_Warn_3_1_3); if (!__pyx_mstate->__pyx_ptype_6hunter_6_event_Event) __PYX_ERR(3, 39, __pyx_L1_error) + __pyx_vtabptr_6hunter_6_event_Event = (struct __pyx_vtabstruct_6hunter_6_event_Event*)__Pyx_GetVtable(__pyx_mstate->__pyx_ptype_6hunter_6_event_Event); if (unlikely(!__pyx_vtabptr_6hunter_6_event_Event)) __PYX_ERR(3, 39, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_mstate->__pyx_ptype_7cpython_4type_type = __Pyx_ImportType_3_1_3(__pyx_t_2, __Pyx_BUILTIN_MODULE_NAME, "type", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(PyTypeObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + 0, 0, + #else + sizeof(PyHeapTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(PyHeapTypeObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_1_3); if (!__pyx_mstate->__pyx_ptype_7cpython_4type_type) __PYX_ERR(4, 9, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyImport_ImportModule("types"); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_mstate->__pyx_ptype_6hunter_7_tracer_CodeType = __Pyx_ImportType_3_1_3(__pyx_t_2, "types", "CodeType", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyCodeObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(PyCodeObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyCodeObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(PyCodeObject), + #else + sizeof(PyCodeObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(PyCodeObject), + #endif + __Pyx_ImportType_CheckSize_Ignore_3_1_3); if (!__pyx_mstate->__pyx_ptype_6hunter_7_tracer_CodeType) __PYX_ERR(5, 12, __pyx_L1_error) + __pyx_t_1 = PyImport_ImportModule("hunter._tracer"); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 25, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_mstate->__pyx_ptype_6hunter_7_tracer_Tracer = __Pyx_ImportType_3_1_3(__pyx_t_1, "hunter._tracer", "Tracer", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(struct __pyx_obj_6hunter_7_tracer_Tracer), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(struct __pyx_obj_6hunter_7_tracer_Tracer), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(struct __pyx_obj_6hunter_7_tracer_Tracer), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(struct __pyx_obj_6hunter_7_tracer_Tracer), + #else + sizeof(struct __pyx_obj_6hunter_7_tracer_Tracer), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(struct __pyx_obj_6hunter_7_tracer_Tracer), + #endif + __Pyx_ImportType_CheckSize_Warn_3_1_3); if (!__pyx_mstate->__pyx_ptype_6hunter_7_tracer_Tracer) __PYX_ERR(5, 25, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_variable_import_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); + /*--- Variable import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_import_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); + /*--- Function import code ---*/ + __pyx_t_1 = PyImport_ImportModule("hunter._event"); if (!__pyx_t_1) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_ImportFunction_3_1_3(__pyx_t_1, "fast_clone", (void (**)(void))&__pyx_f_6hunter_6_event_fast_clone, "struct __pyx_obj_6hunter_6_event_Event *(struct __pyx_obj_6hunter_6_event_Event *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ImportFunction_3_1_3(__pyx_t_1, "fast_detach", (void (**)(void))&__pyx_f_6hunter_6_event_fast_detach, "struct __pyx_obj_6hunter_6_event_Event *(struct __pyx_obj_6hunter_6_event_Event *, PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_RefNannyFinishContext(); + return -1; +} + +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec__predicates(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec__predicates}, + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + {Py_mod_gil, Py_MOD_GIL_NOT_USED}, + #endif + #if PY_VERSION_HEX >= 0x030C0000 && CYTHON_USE_MODULE_STATE + {Py_mod_multiple_interpreters, Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED}, + #endif + {0, NULL} +}; +#endif + +#ifdef __cplusplus +namespace { + struct PyModuleDef __pyx_moduledef = + #else + static struct PyModuleDef __pyx_moduledef = + #endif + { + PyModuleDef_HEAD_INIT, + "_predicates", + 0, /* m_doc */ + #if CYTHON_USE_MODULE_STATE + sizeof(__pyx_mstatetype), /* m_size */ + #else + (CYTHON_PEP489_MULTI_PHASE_INIT) ? 0 : -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + #if CYTHON_USE_MODULE_STATE + __pyx_m_traverse, /* m_traverse */ + __pyx_m_clear, /* m_clear */ + NULL /* m_free */ + #else + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ + #endif + }; + #ifdef __cplusplus +} /* anonymous namespace */ +#endif + +/* PyModInitFuncType */ +#ifndef CYTHON_NO_PYINIT_EXPORT + #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#else + #ifdef __cplusplus + #define __Pyx_PyMODINIT_FUNC extern "C" PyObject * + #else + #define __Pyx_PyMODINIT_FUNC PyObject * + #endif +#endif + +__Pyx_PyMODINIT_FUNC PyInit__predicates(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit__predicates(void) +#if CYTHON_PEP489_MULTI_PHASE_INIT +{ + return PyModuleDef_Init(&__pyx_moduledef); +} +/* ModuleCreationPEP489 */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x03090000 +static PY_INT64_T __Pyx_GetCurrentInterpreterId(void) { + { + PyObject *module = PyImport_ImportModule("_interpreters"); // 3.13+ I think + if (!module) { + PyErr_Clear(); // just try the 3.8-3.12 version + module = PyImport_ImportModule("_xxsubinterpreters"); + if (!module) goto bad; + } + PyObject *current = PyObject_CallMethod(module, "get_current", NULL); + Py_DECREF(module); + if (!current) goto bad; + if (PyTuple_Check(current)) { + PyObject *new_current = PySequence_GetItem(current, 0); + Py_DECREF(current); + current = new_current; + if (!new_current) goto bad; + } + long long as_c_int = PyLong_AsLongLong(current); + Py_DECREF(current); + return as_c_int; + } + bad: + PySys_WriteStderr("__Pyx_GetCurrentInterpreterId failed. Try setting the C define CYTHON_PEP489_MULTI_PHASE_INIT=0\n"); + return -1; +} +#endif +#if !CYTHON_USE_MODULE_STATE +static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { + static PY_INT64_T main_interpreter_id = -1; +#if CYTHON_COMPILING_IN_GRAAL + PY_INT64_T current_id = PyInterpreterState_GetIDFromThreadState(PyThreadState_Get()); +#elif CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX >= 0x03090000 + PY_INT64_T current_id = PyInterpreterState_GetID(PyInterpreterState_Get()); +#elif CYTHON_COMPILING_IN_LIMITED_API + PY_INT64_T current_id = __Pyx_GetCurrentInterpreterId(); +#else + PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); +#endif + if (unlikely(current_id == -1)) { + return -1; + } + if (main_interpreter_id == -1) { + main_interpreter_id = current_id; + return 0; + } else if (unlikely(main_interpreter_id != current_id)) { + PyErr_SetString( + PyExc_ImportError, + "Interpreter change detected - this module can only be loaded into one interpreter per process."); + return -1; + } + return 0; +} +#endif +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) +{ + PyObject *value = PyObject_GetAttrString(spec, from_name); + int result = 0; + if (likely(value)) { + if (allow_none || value != Py_None) { + result = PyDict_SetItemString(moddict, to_name, value); + } + Py_DECREF(value); + } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + } else { + result = -1; + } + return result; +} +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) { + PyObject *module = NULL, *moddict, *modname; + CYTHON_UNUSED_VAR(def); + #if !CYTHON_USE_MODULE_STATE + if (__Pyx_check_single_interpreter()) + return NULL; + #endif + 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__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; + return module; +bad: + Py_XDECREF(module); + return NULL; +} + + +static CYTHON_SMALL_CODE int __pyx_pymod_exec__predicates(PyObject *__pyx_pyinit_module) +#endif +{ + int stringtab_initialized = 0; + #if CYTHON_USE_MODULE_STATE + int pystate_addmodule_run = 0; + #endif + __pyx_mstatetype *__pyx_mstate = NULL; + __Pyx_TraceDeclarationsFunc + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + static __pyx_t_6hunter_11_predicates_Event_getter_typedef __pyx_t_4[17]; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + #if CYTHON_PEP489_MULTI_PHASE_INIT + if (__pyx_m) { + if (__pyx_m == __pyx_pyinit_module) return 0; + PyErr_SetString(PyExc_RuntimeError, "Module '_predicates' has already been imported. Re-initialisation is not supported."); + return -1; + } + #else + if (__pyx_m) return __Pyx_NewRef(__pyx_m); + #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_t_1 = __pyx_pyinit_module; + Py_INCREF(__pyx_t_1); + #else + __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #if CYTHON_USE_MODULE_STATE + { + int add_module_result = __Pyx_State_AddModule(__pyx_t_1, &__pyx_moduledef); + __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "_predicates" pseudovariable */ + if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + pystate_addmodule_run = 1; + } + #else + __pyx_m = __pyx_t_1; + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + PyUnstable_Module_SetGIL(__pyx_m, Py_MOD_GIL_NOT_USED); + #endif + __pyx_mstate = __pyx_mstate_global; + CYTHON_UNUSED_VAR(__pyx_t_1); + __pyx_mstate->__pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_mstate->__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_mstate->__pyx_d); + __pyx_mstate->__pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_mstate->__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_cython_runtime = __Pyx_PyImport_AddModuleRef("cython_runtime"); if (unlikely(!__pyx_mstate->__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_mstate->__pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /* ImportRefnannyAPI */ + #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("PyInit__predicates", 0); + if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pxy_PyFrame_Initialize_Offsets + __Pxy_PyFrame_Initialize_Offsets(); + #endif + __pyx_mstate->__pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_mstate->__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_mstate->__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_mstate->__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitConstants(__pyx_mstate) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + stringtab_initialized = 1; + if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #if 0 || defined(__Pyx_CyFunction_USED) || defined(__Pyx_FusedFunction_USED) || defined(__Pyx_Coroutine_USED) || defined(__Pyx_Generator_USED) || defined(__Pyx_AsyncGen_USED) + if (__pyx_CommonTypesMetaclass_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + if (__pyx_module_is_main_hunter___predicates) { + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_name_2, __pyx_mstate_global->__pyx_n_u_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + } + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "hunter._predicates")) { + if (unlikely((PyDict_SetItemString(modules, "hunter._predicates", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins(__pyx_mstate) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants(__pyx_mstate) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_CreateCodeObjects(__pyx_mstate) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Global type/function init code ---*/ + (void)__Pyx_modinit_global_init_code(__pyx_mstate); + (void)__Pyx_modinit_variable_export_code(__pyx_mstate); + if (unlikely((__Pyx_modinit_function_export_code(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_type_init_code(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_type_import_code(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + (void)__Pyx_modinit_variable_import_code(__pyx_mstate); + if (unlikely((__Pyx_modinit_function_import_code(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Execution code ---*/ + __Pyx_TraceStartFunc("PyInit__predicates", __pyx_f[0], 1, 3, 0, 0, __PYX_ERR(0, 1, __pyx_L1_error)); + + /* "cfunc.to_py":65 + * + * + * @cname("__Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event") # <<<<<<<<<<<<<< + * cdef object __Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event(object (*f)(Event) ): + * def wrap(Event event): +*/ + __Pyx_TraceLine(65,0,0,__PYX_ERR(1, 65, __pyx_L1_error)) + + + /* "hunter/_predicates.pyx":4 + * from __future__ import absolute_import + * + * from collections import deque # <<<<<<<<<<<<<< + * from inspect import isclass + * from re import compile as re_compile +*/ + __Pyx_TraceLine(4,19,0,__PYX_ERR(0, 4, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_deque); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_collections, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_deque); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_deque, __pyx_t_2) < 0) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "hunter/_predicates.pyx":5 + * + * from collections import deque + * from inspect import isclass # <<<<<<<<<<<<<< + * from re import compile as re_compile + * +*/ + __Pyx_TraceLine(5,22,0,__PYX_ERR(0, 5, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_isclass); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_inspect, __pyx_t_3, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_isclass); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_isclass, __pyx_t_3) < 0) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "hunter/_predicates.pyx":6 + * from collections import deque + * from inspect import isclass + * from re import compile as re_compile # <<<<<<<<<<<<<< + * + * cimport cython +*/ + __Pyx_TraceLine(6,25,0,__PYX_ERR(0, 6, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_compile); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_re, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_compile); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_re_compile, __pyx_t_2) < 0) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "hunter/_predicates.pyx":15 + * from ._tracer cimport * + * + * from .actions import Action # <<<<<<<<<<<<<< + * from .actions import ColorStreamAction + * +*/ + __Pyx_TraceLine(15,45,0,__PYX_ERR(0, 15, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_Action); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_actions_2, __pyx_t_3, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_Action); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_Action, __pyx_t_3) < 0) __PYX_ERR(0, 15, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "hunter/_predicates.pyx":16 + * + * from .actions import Action + * from .actions import ColorStreamAction # <<<<<<<<<<<<<< + * + * __all__ = ( +*/ + __Pyx_TraceLine(16,56,0,__PYX_ERR(0, 16, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_ColorStreamAction); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_actions_2, __pyx_t_2, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_ColorStreamAction); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ColorStreamAction, __pyx_t_2) < 0) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "hunter/_predicates.pyx":19 + * + * __all__ = ( + * 'And', # <<<<<<<<<<<<<< + * 'From', + * 'Not', +*/ + __Pyx_TraceLine(19,61,0,__PYX_ERR(0, 19, __pyx_L1_error)) + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_all, __pyx_mstate_global->__pyx_tuple[6]) < 0) __PYX_ERR(0, 18, __pyx_L1_error) + + /* "hunter/_predicates.pyx":28 + * + * cdef tuple ALLOWED_KEYS = ( + * 'function', 'module', 'lineno', 'globals', 'stdlib', 'arg', 'locals', 'kind', 'filename', 'source', # <<<<<<<<<<<<<< + * 'fullsource', 'threadname', 'threadid', 'instruction', 'depth', 'calls', 'builtin', + * ) +*/ + __Pyx_TraceLine(28,70,0,__PYX_ERR(0, 28, __pyx_L1_error)) + __Pyx_INCREF(__pyx_mstate_global->__pyx_tuple[7]); + __Pyx_XGOTREF(__pyx_v_6hunter_11_predicates_ALLOWED_KEYS); + __Pyx_DECREF_SET(__pyx_v_6hunter_11_predicates_ALLOWED_KEYS, __pyx_mstate_global->__pyx_tuple[7]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[7]); + + /* "hunter/_predicates.pyx":32 + * ) + * cdef tuple ALLOWED_OPERATORS = ( + * 'startswith', 'endswith', 'in', 'contains', 'regex', # <<<<<<<<<<<<<< + * 'sw', 'ew', 'has', 'rx', + * 'gt', 'gte', 'lt', 'lte', +*/ + __Pyx_TraceLine(32,89,0,__PYX_ERR(0, 32, __pyx_L1_error)) + __Pyx_INCREF(__pyx_mstate_global->__pyx_tuple[8]); + __Pyx_XGOTREF(__pyx_v_6hunter_11_predicates_ALLOWED_OPERATORS); + __Pyx_DECREF_SET(__pyx_v_6hunter_11_predicates_ALLOWED_OPERATORS, __pyx_mstate_global->__pyx_tuple[8]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[8]); + + /* "hunter/_predicates.pyx":38 + * + * ctypedef object (*Event_getter_typedef)(Event) + * cdef inline Event_get_function(Event event): return event.function_getter() # <<<<<<<<<<<<<< + * cdef inline Event_get_module(Event event): return event.module_getter() + * cdef inline Event_get_lineno(Event event): return event.lineno_getter() +*/ + __Pyx_TraceLine(38,104,0,__PYX_ERR(0, 38, __pyx_L1_error)) + + + /* "hunter/_predicates.pyx":39 + * ctypedef object (*Event_getter_typedef)(Event) + * cdef inline Event_get_function(Event event): return event.function_getter() + * cdef inline Event_get_module(Event event): return event.module_getter() # <<<<<<<<<<<<<< + * cdef inline Event_get_lineno(Event event): return event.lineno_getter() + * cdef inline Event_get_globals(Event event): return event.globals_getter() +*/ + __Pyx_TraceLine(39,105,0,__PYX_ERR(0, 39, __pyx_L1_error)) + + + /* "hunter/_predicates.pyx":40 + * cdef inline Event_get_function(Event event): return event.function_getter() + * cdef inline Event_get_module(Event event): return event.module_getter() + * cdef inline Event_get_lineno(Event event): return event.lineno_getter() # <<<<<<<<<<<<<< + * cdef inline Event_get_globals(Event event): return event.globals_getter() + * cdef inline Event_get_stdlib(Event event): return event.stdlib_getter() +*/ + __Pyx_TraceLine(40,106,0,__PYX_ERR(0, 40, __pyx_L1_error)) + + + /* "hunter/_predicates.pyx":41 + * cdef inline Event_get_module(Event event): return event.module_getter() + * cdef inline Event_get_lineno(Event event): return event.lineno_getter() + * cdef inline Event_get_globals(Event event): return event.globals_getter() # <<<<<<<<<<<<<< + * cdef inline Event_get_stdlib(Event event): return event.stdlib_getter() + * cdef inline Event_get_arg(Event event): return event.arg +*/ + __Pyx_TraceLine(41,107,0,__PYX_ERR(0, 41, __pyx_L1_error)) + + + /* "hunter/_predicates.pyx":42 + * cdef inline Event_get_lineno(Event event): return event.lineno_getter() + * cdef inline Event_get_globals(Event event): return event.globals_getter() + * cdef inline Event_get_stdlib(Event event): return event.stdlib_getter() # <<<<<<<<<<<<<< + * cdef inline Event_get_arg(Event event): return event.arg + * cdef inline Event_get_locals(Event event): return event.locals_getter() +*/ + __Pyx_TraceLine(42,108,0,__PYX_ERR(0, 42, __pyx_L1_error)) + + + /* "hunter/_predicates.pyx":43 + * cdef inline Event_get_globals(Event event): return event.globals_getter() + * cdef inline Event_get_stdlib(Event event): return event.stdlib_getter() + * cdef inline Event_get_arg(Event event): return event.arg # <<<<<<<<<<<<<< + * cdef inline Event_get_locals(Event event): return event.locals_getter() + * cdef inline Event_get_kind(Event event): return event.kind +*/ + __Pyx_TraceLine(43,109,0,__PYX_ERR(0, 43, __pyx_L1_error)) + + + /* "hunter/_predicates.pyx":44 + * cdef inline Event_get_stdlib(Event event): return event.stdlib_getter() + * cdef inline Event_get_arg(Event event): return event.arg + * cdef inline Event_get_locals(Event event): return event.locals_getter() # <<<<<<<<<<<<<< + * cdef inline Event_get_kind(Event event): return event.kind + * cdef inline Event_get_filename(Event event): return event.filename_getter() +*/ + __Pyx_TraceLine(44,111,0,__PYX_ERR(0, 44, __pyx_L1_error)) + + + /* "hunter/_predicates.pyx":45 + * cdef inline Event_get_arg(Event event): return event.arg + * cdef inline Event_get_locals(Event event): return event.locals_getter() + * cdef inline Event_get_kind(Event event): return event.kind # <<<<<<<<<<<<<< + * cdef inline Event_get_filename(Event event): return event.filename_getter() + * cdef inline Event_get_source(Event event): return event.source_getter() +*/ + __Pyx_TraceLine(45,113,0,__PYX_ERR(0, 45, __pyx_L1_error)) + + + /* "hunter/_predicates.pyx":46 + * cdef inline Event_get_locals(Event event): return event.locals_getter() + * cdef inline Event_get_kind(Event event): return event.kind + * cdef inline Event_get_filename(Event event): return event.filename_getter() # <<<<<<<<<<<<<< + * cdef inline Event_get_source(Event event): return event.source_getter() + * cdef inline Event_get_fullsource(Event event): return event.fullsource_getter() +*/ + __Pyx_TraceLine(46,114,0,__PYX_ERR(0, 46, __pyx_L1_error)) + + + /* "hunter/_predicates.pyx":47 + * cdef inline Event_get_kind(Event event): return event.kind + * cdef inline Event_get_filename(Event event): return event.filename_getter() + * cdef inline Event_get_source(Event event): return event.source_getter() # <<<<<<<<<<<<<< + * cdef inline Event_get_fullsource(Event event): return event.fullsource_getter() + * cdef inline Event_get_threadname(Event event): return event.threadname_getter() +*/ + __Pyx_TraceLine(47,115,0,__PYX_ERR(0, 47, __pyx_L1_error)) + + + /* "hunter/_predicates.pyx":48 + * cdef inline Event_get_filename(Event event): return event.filename_getter() + * cdef inline Event_get_source(Event event): return event.source_getter() + * cdef inline Event_get_fullsource(Event event): return event.fullsource_getter() # <<<<<<<<<<<<<< + * cdef inline Event_get_threadname(Event event): return event.threadname_getter() + * cdef inline Event_get_threadid(Event event): return event.threadid_getter() +*/ + __Pyx_TraceLine(48,116,0,__PYX_ERR(0, 48, __pyx_L1_error)) + + + /* "hunter/_predicates.pyx":49 + * cdef inline Event_get_source(Event event): return event.source_getter() + * cdef inline Event_get_fullsource(Event event): return event.fullsource_getter() + * cdef inline Event_get_threadname(Event event): return event.threadname_getter() # <<<<<<<<<<<<<< + * cdef inline Event_get_threadid(Event event): return event.threadid_getter() + * cdef inline Event_get_instruction(Event event): return event.instruction_getter() +*/ + __Pyx_TraceLine(49,117,0,__PYX_ERR(0, 49, __pyx_L1_error)) + + + /* "hunter/_predicates.pyx":50 + * cdef inline Event_get_fullsource(Event event): return event.fullsource_getter() + * cdef inline Event_get_threadname(Event event): return event.threadname_getter() + * cdef inline Event_get_threadid(Event event): return event.threadid_getter() # <<<<<<<<<<<<<< + * cdef inline Event_get_instruction(Event event): return event.instruction_getter() + * cdef inline Event_get_depth(Event event): return event.depth +*/ + __Pyx_TraceLine(50,118,0,__PYX_ERR(0, 50, __pyx_L1_error)) + + + /* "hunter/_predicates.pyx":51 + * cdef inline Event_get_threadname(Event event): return event.threadname_getter() + * cdef inline Event_get_threadid(Event event): return event.threadid_getter() + * cdef inline Event_get_instruction(Event event): return event.instruction_getter() # <<<<<<<<<<<<<< + * cdef inline Event_get_depth(Event event): return event.depth + * cdef inline Event_get_calls(Event event): return event.calls +*/ + __Pyx_TraceLine(51,120,0,__PYX_ERR(0, 51, __pyx_L1_error)) + + + /* "hunter/_predicates.pyx":52 + * cdef inline Event_get_threadid(Event event): return event.threadid_getter() + * cdef inline Event_get_instruction(Event event): return event.instruction_getter() + * cdef inline Event_get_depth(Event event): return event.depth # <<<<<<<<<<<<<< + * cdef inline Event_get_calls(Event event): return event.calls + * cdef inline Event_get_builtin(Event event): return event.builtin +*/ + __Pyx_TraceLine(52,122,0,__PYX_ERR(0, 52, __pyx_L1_error)) + + + /* "hunter/_predicates.pyx":53 + * cdef inline Event_get_instruction(Event event): return event.instruction_getter() + * cdef inline Event_get_depth(Event event): return event.depth + * cdef inline Event_get_calls(Event event): return event.calls # <<<<<<<<<<<<<< + * cdef inline Event_get_builtin(Event event): return event.builtin + * +*/ + __Pyx_TraceLine(53,124,0,__PYX_ERR(0, 53, __pyx_L1_error)) + + + /* "hunter/_predicates.pyx":54 + * cdef inline Event_get_depth(Event event): return event.depth + * cdef inline Event_get_calls(Event event): return event.calls + * cdef inline Event_get_builtin(Event event): return event.builtin # <<<<<<<<<<<<<< + * + * cdef Event_getter_typedef[17] Event_getters = [ +*/ + __Pyx_TraceLine(54,126,0,__PYX_ERR(0, 54, __pyx_L1_error)) + + + /* "hunter/_predicates.pyx":56 + * cdef inline Event_get_builtin(Event event): return event.builtin + * + * cdef Event_getter_typedef[17] Event_getters = [ # <<<<<<<<<<<<<< + * Event_get_function, + * Event_get_module, +*/ + __Pyx_TraceLine(56,129,0,__PYX_ERR(0, 56, __pyx_L1_error)) + __pyx_t_4[0] = __pyx_f_6hunter_11_predicates_Event_get_function; + __pyx_t_4[1] = __pyx_f_6hunter_11_predicates_Event_get_module; + __pyx_t_4[2] = __pyx_f_6hunter_11_predicates_Event_get_lineno; + __pyx_t_4[3] = __pyx_f_6hunter_11_predicates_Event_get_globals; + __pyx_t_4[4] = __pyx_f_6hunter_11_predicates_Event_get_stdlib; + __pyx_t_4[5] = __pyx_f_6hunter_11_predicates_Event_get_arg; + __pyx_t_4[6] = __pyx_f_6hunter_11_predicates_Event_get_locals; + __pyx_t_4[7] = __pyx_f_6hunter_11_predicates_Event_get_kind; + __pyx_t_4[8] = __pyx_f_6hunter_11_predicates_Event_get_filename; + __pyx_t_4[9] = __pyx_f_6hunter_11_predicates_Event_get_source; + __pyx_t_4[10] = __pyx_f_6hunter_11_predicates_Event_get_fullsource; + __pyx_t_4[11] = __pyx_f_6hunter_11_predicates_Event_get_threadname; + __pyx_t_4[12] = __pyx_f_6hunter_11_predicates_Event_get_threadid; + __pyx_t_4[13] = __pyx_f_6hunter_11_predicates_Event_get_instruction; + __pyx_t_4[14] = __pyx_f_6hunter_11_predicates_Event_get_depth; + __pyx_t_4[15] = __pyx_f_6hunter_11_predicates_Event_get_calls; + __pyx_t_4[16] = __pyx_f_6hunter_11_predicates_Event_get_builtin; + memcpy(&(__pyx_v_6hunter_11_predicates_Event_getters[0]), __pyx_t_4, sizeof(__pyx_v_6hunter_11_predicates_Event_getters[0]) * (17)); + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.getter cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): +*/ + __Pyx_TraceLine(1,6,0,__PYX_ERR(1, 1, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_10QueryEntry_7__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_QueryEntry___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_hunter__predicates, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[22])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_3) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.getter cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.getter cannot be converted to a Python object for pickling" +*/ + __Pyx_TraceLine(3,16,0,__PYX_ERR(1, 3, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_10QueryEntry_9__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_QueryEntry___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_hunter__predicates, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[23])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_3) < 0) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ + __Pyx_TraceLine(1,12,0,__PYX_ERR(1, 1, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_5Query_17__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Query___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_hunter__predicates, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[43])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Query, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_3) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Query, (type(self), 0x5503a44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Query__set_state(self, __pyx_state) +*/ + __Pyx_TraceLine(16,54,0,__PYX_ERR(1, 16, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_5Query_19__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Query___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_hunter__predicates, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[44])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Query, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_3) < 0) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "hunter/_predicates.pyx":264 + * return Not(self) + * + * cdef inline fast_Query_call(Query self, Event event): # <<<<<<<<<<<<<< + * for key, entry in self.query_eq: + * value_from_event = ( entry).getter(event) +*/ + __Pyx_TraceLine(264,169,0,__PYX_ERR(0, 264, __pyx_L1_error)) + + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ + __Pyx_TraceLine(1,1,0,__PYX_ERR(1, 1, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_4When_17__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_When___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_hunter__predicates, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[58])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_When, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_3) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_When, (type(self), 0xe710366, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_When__set_state(self, __pyx_state) +*/ + __Pyx_TraceLine(16,48,0,__PYX_ERR(1, 16, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_4When_19__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_When___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_hunter__predicates, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[59])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_When, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_3) < 0) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "hunter/_predicates.pyx":353 + * return Not(self) + * + * cdef inline fast_When_call(When self, Event event): # <<<<<<<<<<<<<< + * cdef object result + * +*/ + __Pyx_TraceLine(353,179,0,__PYX_ERR(0, 353, __pyx_L1_error)) + + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ + __Pyx_TraceLine(1,11,0,__PYX_ERR(1, 1, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_4From_17__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_From___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_hunter__predicates, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[74])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_From, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_3) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_From, (type(self), 0xcfd05cc, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_From__set_state(self, __pyx_state) +*/ + __Pyx_TraceLine(16,50,0,__PYX_ERR(1, 16, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_4From_19__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_From___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_hunter__predicates, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[75])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_From, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_3) < 0) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "hunter/_predicates.pyx":407 + * return Not(self) + * + * cdef inline fast_From_call(From self, Event event): # <<<<<<<<<<<<<< + * cdef object result + * cdef int delta_depth +*/ + __Pyx_TraceLine(407,189,0,__PYX_ERR(0, 407, __pyx_L1_error)) + + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ + __Pyx_TraceLine(1,8,0,__PYX_ERR(1, 1, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_3And_17__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_And___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_hunter__predicates, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[87])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_And, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_3) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_And, (type(self), 0x8e21672, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_And__set_state(self, __pyx_state) +*/ + __Pyx_TraceLine(16,52,0,__PYX_ERR(1, 16, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_3And_19__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_And___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_hunter__predicates, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[88])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_And, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_3) < 0) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "hunter/_predicates.pyx":478 + * return Not(self) + * + * cdef inline fast_And_call(And self, Event event): # <<<<<<<<<<<<<< + * for predicate in self.predicates: + * if not fast_call(predicate, event): +*/ + __Pyx_TraceLine(478,199,0,__PYX_ERR(0, 478, __pyx_L1_error)) + + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ + __Pyx_TraceLine(1,10,0,__PYX_ERR(1, 1, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_2Or_17__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Or___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_hunter__predicates, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[100])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Or, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_3) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Or, (type(self), 0x8e21672, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Or__set_state(self, __pyx_state) +*/ + __Pyx_TraceLine(16,53,0,__PYX_ERR(1, 16, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_2Or_19__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Or___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_hunter__predicates, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[101])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Or, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_3) < 0) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "hunter/_predicates.pyx":528 + * return Not(self) + * + * cdef inline fast_Or_call(Or self, Event event): # <<<<<<<<<<<<<< + * for predicate in self.predicates: + * if fast_call(predicate, event): +*/ + __Pyx_TraceLine(528,209,0,__PYX_ERR(0, 528, __pyx_L1_error)) + + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ + __Pyx_TraceLine(1,0,0,__PYX_ERR(1, 1, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_3Not_17__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Not___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_hunter__predicates, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[112])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Not, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_3) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Not, (type(self), 0x23761c9, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Not__set_state(self, __pyx_state) +*/ + __Pyx_TraceLine(16,47,0,__PYX_ERR(1, 16, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_3Not_19__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Not___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_hunter__predicates, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[113])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Not, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_3) < 0) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "hunter/_predicates.pyx":573 + * return self.predicate + * + * cdef inline fast_Not_call(Not self, Event event): # <<<<<<<<<<<<<< + * return not fast_call(self.predicate, event) + * +*/ + __Pyx_TraceLine(573,219,0,__PYX_ERR(0, 573, __pyx_L1_error)) + + + /* "hunter/_predicates.pyx":577 + * + * + * cdef inline fast_call(callable, Event event): # <<<<<<<<<<<<<< + * if type(callable) is Query: + * return fast_Query_call( callable, event) +*/ + __Pyx_TraceLine(577,220,0,__PYX_ERR(0, 577, __pyx_L1_error)) + + + /* "hunter/_predicates.pyx":643 + * return Backlog(Not(self.condition), size=self.size, stack=self.stack, vars=self.vars, action=self.action, filter=self._filter) + * + * def filter(self, *predicates, **kwargs): # <<<<<<<<<<<<<< + * from hunter import _merge + * +*/ + __Pyx_TraceLine(643,230,0,__PYX_ERR(0, 643, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_7Backlog_17filter, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Backlog_filter, NULL, __pyx_mstate_global->__pyx_n_u_hunter__predicates, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[124])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 643, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Backlog, __pyx_mstate_global->__pyx_n_u_filter, __pyx_t_3) < 0) __PYX_ERR(0, 643, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ + __Pyx_TraceLine(1,4,0,__PYX_ERR(1, 1, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_7Backlog_19__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Backlog___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_hunter__predicates, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[134])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Backlog, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_3) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Backlog, (type(self), 0x1428ea1, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Backlog__set_state(self, __pyx_state) +*/ + __Pyx_TraceLine(16,51,0,__PYX_ERR(1, 16, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_7Backlog_21__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Backlog___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_hunter__predicates, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[135])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Backlog, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_3) < 0) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "hunter/_predicates.pyx":655 + * ) + * + * cdef inline fast_Backlog_call(Backlog self, Event event): # <<<<<<<<<<<<<< + * cdef bint first_is_call + * cdef Event detached_event +*/ + __Pyx_TraceLine(655,231,0,__PYX_ERR(0, 655, __pyx_L1_error)) + + + /* "(tree fragment)":1 + * def __pyx_unpickle_Query(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result +*/ + __Pyx_TraceLine(1,5,0,__PYX_ERR(1, 1, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_1__pyx_unpickle_Query, 0, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Query, NULL, __pyx_mstate_global->__pyx_n_u_hunter__predicates, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[137])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Query, __pyx_t_3) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":11 + * __pyx_unpickle_Query__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Query__set_state(Query __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.query_contains = __pyx_state[0]; __pyx_result.query_endswith = __pyx_state[1]; __pyx_result.query_eq = __pyx_state[2]; __pyx_result.query_gt = __pyx_state[3]; __pyx_result.query_gte = __pyx_state[4]; __pyx_result.query_in = __pyx_state[5]; __pyx_result.query_lt = __pyx_state[6]; __pyx_result.query_lte = __pyx_state[7]; __pyx_result.query_regex = __pyx_state[8]; __pyx_result.query_startswith = __pyx_state[9] + * if len(__pyx_state) > 10 and hasattr(__pyx_result, '__dict__'): +*/ + __Pyx_TraceLine(11,34,0,__PYX_ERR(1, 11, __pyx_L1_error)) + + + /* "(tree fragment)":1 + * def __pyx_unpickle_When(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result +*/ + __Pyx_TraceLine(1,15,0,__PYX_ERR(1, 1, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_3__pyx_unpickle_When, 0, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_When, NULL, __pyx_mstate_global->__pyx_n_u_hunter__predicates, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[139])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_When, __pyx_t_3) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":11 + * __pyx_unpickle_When__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_When__set_state(When __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.actions = __pyx_state[0]; __pyx_result.condition = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): +*/ + __Pyx_TraceLine(11,29,0,__PYX_ERR(1, 11, __pyx_L1_error)) + + + /* "(tree fragment)":1 + * def __pyx_unpickle_From(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result +*/ + __Pyx_TraceLine(1,7,0,__PYX_ERR(1, 1, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_5__pyx_unpickle_From, 0, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_From, NULL, __pyx_mstate_global->__pyx_n_u_hunter__predicates, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[141])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_From, __pyx_t_3) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":11 + * __pyx_unpickle_From__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_From__set_state(From __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.condition = __pyx_state[0]; __pyx_result.origin_calls = __pyx_state[1]; __pyx_result.origin_depth = __pyx_state[2]; __pyx_result.predicate = __pyx_state[3]; __pyx_result.watermark = __pyx_state[4] + * if len(__pyx_state) > 5 and hasattr(__pyx_result, '__dict__'): +*/ + __Pyx_TraceLine(11,31,0,__PYX_ERR(1, 11, __pyx_L1_error)) + + + /* "(tree fragment)":1 + * def __pyx_unpickle_And(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result +*/ + __Pyx_TraceLine(1,14,0,__PYX_ERR(1, 1, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_7__pyx_unpickle_And, 0, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_And, NULL, __pyx_mstate_global->__pyx_n_u_hunter__predicates, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[143])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_And, __pyx_t_3) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":11 + * __pyx_unpickle_And__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_And__set_state(And __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.predicates = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): +*/ + __Pyx_TraceLine(11,33,0,__PYX_ERR(1, 11, __pyx_L1_error)) + + + /* "(tree fragment)":1 + * def __pyx_unpickle_Or(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result +*/ + __Pyx_TraceLine(1,13,0,__PYX_ERR(1, 1, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_9__pyx_unpickle_Or, 0, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Or, NULL, __pyx_mstate_global->__pyx_n_u_hunter__predicates, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[145])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Or, __pyx_t_3) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":11 + * __pyx_unpickle_Or__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Or__set_state(Or __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.predicates = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): +*/ + __Pyx_TraceLine(11,36,0,__PYX_ERR(1, 11, __pyx_L1_error)) + + + /* "(tree fragment)":1 + * def __pyx_unpickle_Not(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result +*/ + __Pyx_TraceLine(1,2,0,__PYX_ERR(1, 1, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_11__pyx_unpickle_Not, 0, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Not, NULL, __pyx_mstate_global->__pyx_n_u_hunter__predicates, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[147])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Not, __pyx_t_3) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":11 + * __pyx_unpickle_Not__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Not__set_state(Not __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.predicate = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): +*/ + __Pyx_TraceLine(11,35,0,__PYX_ERR(1, 11, __pyx_L1_error)) + + + /* "(tree fragment)":1 + * def __pyx_unpickle_Backlog(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result +*/ + __Pyx_TraceLine(1,9,0,__PYX_ERR(1, 1, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_13__pyx_unpickle_Backlog, 0, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Backlog, NULL, __pyx_mstate_global->__pyx_n_u_hunter__predicates, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[149])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Backlog, __pyx_t_3) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":11 + * __pyx_unpickle_Backlog__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Backlog__set_state(Backlog __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result._filter = __pyx_state[0]; __pyx_result._try_repr = __pyx_state[1]; __pyx_result.action = __pyx_state[2]; __pyx_result.condition = __pyx_state[3]; __pyx_result.queue = __pyx_state[4]; __pyx_result.size = __pyx_state[5]; __pyx_result.stack = __pyx_state[6]; __pyx_result.strip = __pyx_state[7]; __pyx_result.vars = __pyx_state[8] + * if len(__pyx_state) > 9 and hasattr(__pyx_result, '__dict__'): +*/ + __Pyx_TraceLine(11,30,0,__PYX_ERR(1, 11, __pyx_L1_error)) + + + /* "hunter/_predicates.pyx":1 + * # cython: linetrace=True, language_level=3str, c_api_binop_methods=True, freethreading_compatible=True # <<<<<<<<<<<<<< + * from __future__ import absolute_import + * +*/ + __Pyx_TraceLine(1,3,0,__PYX_ERR(0, 1, __pyx_L1_error)) + __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_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_test, __pyx_t_3) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_TraceReturnValue(Py_None, 3, 0, __PYX_ERR(0, 1, __pyx_L1_error)); + __Pyx_PyMonitoring_ExitScope(0); + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + __Pyx_TraceExceptionUnwind(3, 0); + if (__pyx_m) { + if (__pyx_mstate->__pyx_d && stringtab_initialized) { + __Pyx_AddTraceback("init hunter._predicates", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + #if !CYTHON_USE_MODULE_STATE + Py_CLEAR(__pyx_m); + #else + Py_DECREF(__pyx_m); + if (pystate_addmodule_run) { + PyObject *tp, *value, *tb; + PyErr_Fetch(&tp, &value, &tb); + PyState_RemoveModule(&__pyx_moduledef); + PyErr_Restore(tp, value, tb); + } + #endif + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init hunter._predicates"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if CYTHON_PEP489_MULTI_PHASE_INIT + return (__pyx_m != NULL) ? 0 : -1; + #else + return __pyx_m; + #endif +} +/* #### Code section: pystring_table ### */ + +typedef struct { + const char *s; +#if 194 <= 65535 + const unsigned short n; +#elif 194 / 2 < INT_MAX + const unsigned int n; +#elif 194 / 2 < LONG_MAX + const unsigned long n; +#else + const Py_ssize_t n; +#endif +#if 1 <= 31 + const unsigned int encoding : 5; +#elif 1 <= 255 + const unsigned char encoding; +#elif 1 <= 65535 + const unsigned short encoding; +#else + const Py_ssize_t encoding; +#endif + const unsigned int is_unicode : 1; + const unsigned int intern : 1; +} __Pyx_StringTabEntry; +static const char * const __pyx_string_tab_encodings[] = { 0 }; +static const __Pyx_StringTabEntry __pyx_string_tab[] = { + {__pyx_k_, sizeof(__pyx_k_), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ */ + {__pyx_k_ALLOWED_KEYS, sizeof(__pyx_k_ALLOWED_KEYS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ALLOWED_KEYS */ + {__pyx_k_ALLOWED_OPERATORS, sizeof(__pyx_k_ALLOWED_OPERATORS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ALLOWED_OPERATORS */ + {__pyx_k_Action, sizeof(__pyx_k_Action), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Action */ + {__pyx_k_Action_r_must_be_a_ColorStreamAc, sizeof(__pyx_k_Action_r_must_be_a_ColorStreamAc), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Action_r_must_be_a_ColorStreamAc */ + {__pyx_k_And, sizeof(__pyx_k_And), 0, 1, 1}, /* PyObject cname: __pyx_n_u_And */ + {__pyx_k_And___reduce_cython, sizeof(__pyx_k_And___reduce_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_And___reduce_cython */ + {__pyx_k_And___setstate_cython, sizeof(__pyx_k_And___setstate_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_And___setstate_cython */ + {__pyx_k_And_s, sizeof(__pyx_k_And_s), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_And_s */ + {__pyx_k_Backlog, sizeof(__pyx_k_Backlog), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Backlog */ + {__pyx_k_Backlog_2, sizeof(__pyx_k_Backlog_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Backlog_2 */ + {__pyx_k_Backlog___reduce_cython, sizeof(__pyx_k_Backlog___reduce_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Backlog___reduce_cython */ + {__pyx_k_Backlog___setstate_cython, sizeof(__pyx_k_Backlog___setstate_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Backlog___setstate_cython */ + {__pyx_k_Backlog_filter, sizeof(__pyx_k_Backlog_filter), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Backlog_filter */ + {__pyx_k_ColorStreamAction, sizeof(__pyx_k_ColorStreamAction), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ColorStreamAction */ + {__pyx_k_Event_get_arg, sizeof(__pyx_k_Event_get_arg), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Event_get_arg */ + {__pyx_k_Event_get_builtin, sizeof(__pyx_k_Event_get_builtin), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Event_get_builtin */ + {__pyx_k_Event_get_calls, sizeof(__pyx_k_Event_get_calls), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Event_get_calls */ + {__pyx_k_Event_get_depth, sizeof(__pyx_k_Event_get_depth), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Event_get_depth */ + {__pyx_k_Event_get_filename, sizeof(__pyx_k_Event_get_filename), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Event_get_filename */ + {__pyx_k_Event_get_fullsource, sizeof(__pyx_k_Event_get_fullsource), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Event_get_fullsource */ + {__pyx_k_Event_get_function, sizeof(__pyx_k_Event_get_function), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Event_get_function */ + {__pyx_k_Event_get_globals, sizeof(__pyx_k_Event_get_globals), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Event_get_globals */ + {__pyx_k_Event_get_instruction, sizeof(__pyx_k_Event_get_instruction), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Event_get_instruction */ + {__pyx_k_Event_get_kind, sizeof(__pyx_k_Event_get_kind), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Event_get_kind */ + {__pyx_k_Event_get_lineno, sizeof(__pyx_k_Event_get_lineno), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Event_get_lineno */ + {__pyx_k_Event_get_locals, sizeof(__pyx_k_Event_get_locals), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Event_get_locals */ + {__pyx_k_Event_get_module, sizeof(__pyx_k_Event_get_module), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Event_get_module */ + {__pyx_k_Event_get_source, sizeof(__pyx_k_Event_get_source), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Event_get_source */ + {__pyx_k_Event_get_stdlib, sizeof(__pyx_k_Event_get_stdlib), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Event_get_stdlib */ + {__pyx_k_Event_get_threadid, sizeof(__pyx_k_Event_get_threadid), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Event_get_threadid */ + {__pyx_k_Event_get_threadname, sizeof(__pyx_k_Event_get_threadname), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Event_get_threadname */ + {__pyx_k_Event_getters, sizeof(__pyx_k_Event_getters), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Event_getters */ + {__pyx_k_False, sizeof(__pyx_k_False), 0, 1, 1}, /* PyObject cname: __pyx_n_u_False */ + {__pyx_k_From, sizeof(__pyx_k_From), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_From */ + {__pyx_k_From_2, sizeof(__pyx_k_From_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_From_2 */ + {__pyx_k_From___reduce_cython, sizeof(__pyx_k_From___reduce_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_From___reduce_cython */ + {__pyx_k_From___setstate_cython, sizeof(__pyx_k_From___setstate_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_From___setstate_cython */ + {__pyx_k_Incompatible_checksums_0x_x_vs_0, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Incompatible_checksums_0x_x_vs_0 */ + {__pyx_k_Incompatible_checksums_0x_x_vs_0_2, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0_2), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Incompatible_checksums_0x_x_vs_0_2 */ + {__pyx_k_Incompatible_checksums_0x_x_vs_0_3, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0_3), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Incompatible_checksums_0x_x_vs_0_3 */ + {__pyx_k_Incompatible_checksums_0x_x_vs_0_4, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0_4), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Incompatible_checksums_0x_x_vs_0_4 */ + {__pyx_k_Incompatible_checksums_0x_x_vs_0_5, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0_5), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Incompatible_checksums_0x_x_vs_0_5 */ + {__pyx_k_Incompatible_checksums_0x_x_vs_0_6, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0_6), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Incompatible_checksums_0x_x_vs_0_6 */ + {__pyx_k_Must_be_one_of, sizeof(__pyx_k_Must_be_one_of), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Must_be_one_of */ + {__pyx_k_Must_give_at_least_one_action, sizeof(__pyx_k_Must_give_at_least_one_action), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Must_give_at_least_one_action */ + {__pyx_k_Not, sizeof(__pyx_k_Not), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Not */ + {__pyx_k_Not___reduce_cython, sizeof(__pyx_k_Not___reduce_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Not___reduce_cython */ + {__pyx_k_Not___setstate_cython, sizeof(__pyx_k_Not___setstate_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Not___setstate_cython */ + {__pyx_k_Not_s, sizeof(__pyx_k_Not_s), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Not_s */ + {__pyx_k_Note_that_Cython_is_deliberately, sizeof(__pyx_k_Note_that_Cython_is_deliberately), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Note_that_Cython_is_deliberately */ + {__pyx_k_Or, sizeof(__pyx_k_Or), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Or */ + {__pyx_k_Or___reduce_cython, sizeof(__pyx_k_Or___reduce_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Or___reduce_cython */ + {__pyx_k_Or___setstate_cython, sizeof(__pyx_k_Or___setstate_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Or___setstate_cython */ + {__pyx_k_Or_s, sizeof(__pyx_k_Or_s), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Or_s */ + {__pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 1, 1}, /* PyObject cname: __pyx_n_u_PickleError */ + {__pyx_k_Pyx_CFunc_6hunter_11_predicate, sizeof(__pyx_k_Pyx_CFunc_6hunter_11_predicate), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Pyx_CFunc_6hunter_11_predicate */ + {__pyx_k_Pyx_CFunc_6hunter_11_predicate_2, sizeof(__pyx_k_Pyx_CFunc_6hunter_11_predicate_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Pyx_CFunc_6hunter_11_predicate_2 */ + {__pyx_k_Query, sizeof(__pyx_k_Query), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Query */ + {__pyx_k_QueryEntry, sizeof(__pyx_k_QueryEntry), 0, 1, 1}, /* PyObject cname: __pyx_n_u_QueryEntry */ + {__pyx_k_QueryEntry___reduce_cython, sizeof(__pyx_k_QueryEntry___reduce_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_QueryEntry___reduce_cython */ + {__pyx_k_QueryEntry___setstate_cython, sizeof(__pyx_k_QueryEntry___setstate_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_QueryEntry___setstate_cython */ + {__pyx_k_Query___reduce_cython, sizeof(__pyx_k_Query___reduce_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Query___reduce_cython */ + {__pyx_k_Query___setstate_cython, sizeof(__pyx_k_Query___setstate_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Query___setstate_cython */ + {__pyx_k_Query_s, sizeof(__pyx_k_Query_s), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Query_s */ + {__pyx_k_True, sizeof(__pyx_k_True), 0, 1, 1}, /* PyObject cname: __pyx_n_u_True */ + {__pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TypeError */ + {__pyx_k_Unexpected_argument, sizeof(__pyx_k_Unexpected_argument), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Unexpected_argument */ + {__pyx_k_Unexpected_operator, sizeof(__pyx_k_Unexpected_operator), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Unexpected_operator */ + {__pyx_k_Value, sizeof(__pyx_k_Value), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Value */ + {__pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ValueError */ + {__pyx_k_When, sizeof(__pyx_k_When), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_When */ + {__pyx_k_When_2, sizeof(__pyx_k_When_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_When_2 */ + {__pyx_k_When___reduce_cython, sizeof(__pyx_k_When___reduce_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_When___reduce_cython */ + {__pyx_k_When___setstate_cython, sizeof(__pyx_k_When___setstate_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_When___setstate_cython */ + {__pyx_k__2, sizeof(__pyx_k__2), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__2 */ + {__pyx_k__3, sizeof(__pyx_k__3), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__3 */ + {__pyx_k__4, sizeof(__pyx_k__4), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__4 */ + {__pyx_k__5, sizeof(__pyx_k__5), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__5 */ + {__pyx_k__6, sizeof(__pyx_k__6), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__6 */ + {__pyx_k__7, sizeof(__pyx_k__7), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__7 */ + {__pyx_k__8, sizeof(__pyx_k__8), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__8 */ + {__pyx_k__9, sizeof(__pyx_k__9), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__9 */ + {__pyx_k_action, sizeof(__pyx_k_action), 0, 1, 1}, /* PyObject cname: __pyx_n_u_action */ + {__pyx_k_action_2, sizeof(__pyx_k_action_2), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_action_2 */ + {__pyx_k_actions, sizeof(__pyx_k_actions), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_actions */ + {__pyx_k_actions_2, sizeof(__pyx_k_actions_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_actions_2 */ + {__pyx_k_add_note, sizeof(__pyx_k_add_note), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_add_note */ + {__pyx_k_all, sizeof(__pyx_k_all), 0, 1, 1}, /* PyObject cname: __pyx_n_u_all */ + {__pyx_k_and, sizeof(__pyx_k_and), 0, 1, 1}, /* PyObject cname: __pyx_n_u_and */ + {__pyx_k_append, sizeof(__pyx_k_append), 0, 1, 1}, /* PyObject cname: __pyx_n_u_append */ + {__pyx_k_appendleft, sizeof(__pyx_k_appendleft), 0, 1, 1}, /* PyObject cname: __pyx_n_u_appendleft */ + {__pyx_k_arg, sizeof(__pyx_k_arg), 0, 1, 1}, /* PyObject cname: __pyx_n_u_arg */ + {__pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 1, 1}, /* PyObject cname: __pyx_n_u_asyncio_coroutines */ + {__pyx_k_builtin, sizeof(__pyx_k_builtin), 0, 1, 1}, /* PyObject cname: __pyx_n_u_builtin */ + {__pyx_k_call, sizeof(__pyx_k_call), 0, 1, 1}, /* PyObject cname: __pyx_n_u_call */ + {__pyx_k_call_2, sizeof(__pyx_k_call_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_call_2 */ + {__pyx_k_callable, sizeof(__pyx_k_callable), 0, 1, 1}, /* PyObject cname: __pyx_n_u_callable */ + {__pyx_k_calls, sizeof(__pyx_k_calls), 0, 1, 1}, /* PyObject cname: __pyx_n_u_calls */ + {__pyx_k_cfunc_to_py, sizeof(__pyx_k_cfunc_to_py), 0, 1, 1}, /* PyObject cname: __pyx_n_u_cfunc_to_py */ + {__pyx_k_cleanup, sizeof(__pyx_k_cleanup), 0, 1, 1}, /* PyObject cname: __pyx_n_u_cleanup */ + {__pyx_k_clear, sizeof(__pyx_k_clear), 0, 1, 1}, /* PyObject cname: __pyx_n_u_clear */ + {__pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 1, 1}, /* PyObject cname: __pyx_n_u_cline_in_traceback */ + {__pyx_k_close, sizeof(__pyx_k_close), 0, 1, 1}, /* PyObject cname: __pyx_n_u_close */ + {__pyx_k_collections, sizeof(__pyx_k_collections), 0, 1, 1}, /* PyObject cname: __pyx_n_u_collections */ + {__pyx_k_compile, sizeof(__pyx_k_compile), 0, 1, 1}, /* PyObject cname: __pyx_n_u_compile */ + {__pyx_k_condition, sizeof(__pyx_k_condition), 0, 1, 1}, /* PyObject cname: __pyx_n_u_condition */ + {__pyx_k_contains, sizeof(__pyx_k_contains), 0, 1, 1}, /* PyObject cname: __pyx_n_u_contains */ + {__pyx_k_contains_2, sizeof(__pyx_k_contains_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_contains_2 */ + {__pyx_k_count, sizeof(__pyx_k_count), 0, 1, 1}, /* PyObject cname: __pyx_n_u_count */ + {__pyx_k_depth, sizeof(__pyx_k_depth), 0, 1, 1}, /* PyObject cname: __pyx_n_u_depth */ + {__pyx_k_deque, sizeof(__pyx_k_deque), 0, 1, 1}, /* PyObject cname: __pyx_n_u_deque */ + {__pyx_k_dict, sizeof(__pyx_k_dict), 0, 1, 1}, /* PyObject cname: __pyx_n_u_dict */ + {__pyx_k_dict_2, sizeof(__pyx_k_dict_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_dict_2 */ + {__pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_disable */ + {__pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_enable */ + {__pyx_k_endswith, sizeof(__pyx_k_endswith), 0, 1, 1}, /* PyObject cname: __pyx_n_u_endswith */ + {__pyx_k_endswith_2, sizeof(__pyx_k_endswith_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_endswith_2 */ + {__pyx_k_eq, sizeof(__pyx_k_eq), 0, 1, 1}, /* PyObject cname: __pyx_n_u_eq */ + {__pyx_k_event, sizeof(__pyx_k_event), 0, 1, 1}, /* PyObject cname: __pyx_n_u_event */ + {__pyx_k_ew, sizeof(__pyx_k_ew), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ew */ + {__pyx_k_f, sizeof(__pyx_k_f), 0, 1, 1}, /* PyObject cname: __pyx_n_u_f */ + {__pyx_k_f_back, sizeof(__pyx_k_f_back), 0, 1, 1}, /* PyObject cname: __pyx_n_u_f_back */ + {__pyx_k_fast_And_call, sizeof(__pyx_k_fast_And_call), 0, 1, 1}, /* PyObject cname: __pyx_n_u_fast_And_call */ + {__pyx_k_fast_Backlog_call, sizeof(__pyx_k_fast_Backlog_call), 0, 1, 1}, /* PyObject cname: __pyx_n_u_fast_Backlog_call */ + {__pyx_k_fast_From_call, sizeof(__pyx_k_fast_From_call), 0, 1, 1}, /* PyObject cname: __pyx_n_u_fast_From_call */ + {__pyx_k_fast_Not_call, sizeof(__pyx_k_fast_Not_call), 0, 1, 1}, /* PyObject cname: __pyx_n_u_fast_Not_call */ + {__pyx_k_fast_Or_call, sizeof(__pyx_k_fast_Or_call), 0, 1, 1}, /* PyObject cname: __pyx_n_u_fast_Or_call */ + {__pyx_k_fast_Query_call, sizeof(__pyx_k_fast_Query_call), 0, 1, 1}, /* PyObject cname: __pyx_n_u_fast_Query_call */ + {__pyx_k_fast_When_call, sizeof(__pyx_k_fast_When_call), 0, 1, 1}, /* PyObject cname: __pyx_n_u_fast_When_call */ + {__pyx_k_fast_call, sizeof(__pyx_k_fast_call), 0, 1, 1}, /* PyObject cname: __pyx_n_u_fast_call */ + {__pyx_k_filename, sizeof(__pyx_k_filename), 0, 1, 1}, /* PyObject cname: __pyx_n_u_filename */ + {__pyx_k_filter, sizeof(__pyx_k_filter), 0, 1, 1}, /* PyObject cname: __pyx_n_u_filter */ + {__pyx_k_filter_2, sizeof(__pyx_k_filter_2), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_filter_2 */ + {__pyx_k_fmt, sizeof(__pyx_k_fmt), 0, 1, 1}, /* PyObject cname: __pyx_n_u_fmt */ + {__pyx_k_for, sizeof(__pyx_k_for), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_for */ + {__pyx_k_frame, sizeof(__pyx_k_frame), 0, 1, 1}, /* PyObject cname: __pyx_n_u_frame */ + {__pyx_k_fullsource, sizeof(__pyx_k_fullsource), 0, 1, 1}, /* PyObject cname: __pyx_n_u_fullsource */ + {__pyx_k_func, sizeof(__pyx_k_func), 0, 1, 1}, /* PyObject cname: __pyx_n_u_func */ + {__pyx_k_function, sizeof(__pyx_k_function), 0, 1, 1}, /* PyObject cname: __pyx_n_u_function */ + {__pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_gc */ + {__pyx_k_genexpr, sizeof(__pyx_k_genexpr), 0, 1, 1}, /* PyObject cname: __pyx_n_u_genexpr */ + {__pyx_k_get, sizeof(__pyx_k_get), 0, 1, 1}, /* PyObject cname: __pyx_n_u_get */ + {__pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 1, 1}, /* PyObject cname: __pyx_n_u_getstate */ + {__pyx_k_globals, sizeof(__pyx_k_globals), 0, 1, 1}, /* PyObject cname: __pyx_n_u_globals */ + {__pyx_k_gt, sizeof(__pyx_k_gt), 0, 1, 1}, /* PyObject cname: __pyx_n_u_gt */ + {__pyx_k_gt_2, sizeof(__pyx_k_gt_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_gt_2 */ + {__pyx_k_gte, sizeof(__pyx_k_gte), 0, 1, 1}, /* PyObject cname: __pyx_n_u_gte */ + {__pyx_k_gte_2, sizeof(__pyx_k_gte_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_gte_2 */ + {__pyx_k_has, sizeof(__pyx_k_has), 0, 1, 1}, /* PyObject cname: __pyx_n_u_has */ + {__pyx_k_hunter, sizeof(__pyx_k_hunter), 0, 1, 1}, /* PyObject cname: __pyx_n_u_hunter */ + {__pyx_k_hunter__predicates, sizeof(__pyx_k_hunter__predicates), 0, 1, 1}, /* PyObject cname: __pyx_n_u_hunter__predicates */ + {__pyx_k_hunter__predicates_And_predicat, sizeof(__pyx_k_hunter__predicates_And_predicat), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_hunter__predicates_And_predicat */ + {__pyx_k_hunter__predicates_From_conditi, sizeof(__pyx_k_hunter__predicates_From_conditi), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_hunter__predicates_From_conditi */ + {__pyx_k_hunter__predicates_Not_predicat, sizeof(__pyx_k_hunter__predicates_Not_predicat), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_hunter__predicates_Not_predicat */ + {__pyx_k_hunter__predicates_Or_predicate, sizeof(__pyx_k_hunter__predicates_Or_predicate), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_hunter__predicates_Or_predicate */ + {__pyx_k_hunter__predicates_When_conditi, sizeof(__pyx_k_hunter__predicates_When_conditi), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_hunter__predicates_When_conditi */ + {__pyx_k_hunter_predicates_Backlog_condi, sizeof(__pyx_k_hunter_predicates_Backlog_condi), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_hunter_predicates_Backlog_condi */ + {__pyx_k_hunter_predicates_Query_s, sizeof(__pyx_k_hunter_predicates_Query_s), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_hunter_predicates_Query_s */ + {__pyx_k_in, sizeof(__pyx_k_in), 0, 1, 1}, /* PyObject cname: __pyx_n_u_in */ + {__pyx_k_in_2, sizeof(__pyx_k_in_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_in_2 */ + {__pyx_k_index, sizeof(__pyx_k_index), 0, 1, 1}, /* PyObject cname: __pyx_n_u_index */ + {__pyx_k_init, sizeof(__pyx_k_init), 0, 1, 1}, /* PyObject cname: __pyx_n_u_init */ + {__pyx_k_init___locals_genexpr, sizeof(__pyx_k_init___locals_genexpr), 0, 1, 1}, /* PyObject cname: __pyx_n_u_init___locals_genexpr */ + {__pyx_k_inspect, sizeof(__pyx_k_inspect), 0, 1, 1}, /* PyObject cname: __pyx_n_u_inspect */ + {__pyx_k_instruction, sizeof(__pyx_k_instruction), 0, 1, 1}, /* PyObject cname: __pyx_n_u_instruction */ + {__pyx_k_invert, sizeof(__pyx_k_invert), 0, 1, 1}, /* PyObject cname: __pyx_n_u_invert */ + {__pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 1, 1}, /* PyObject cname: __pyx_n_u_is_coroutine */ + {__pyx_k_is_invalid_Must_be_a_string_lis, sizeof(__pyx_k_is_invalid_Must_be_a_string_lis), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_is_invalid_Must_be_a_string_lis */ + {__pyx_k_isclass, sizeof(__pyx_k_isclass), 0, 1, 1}, /* PyObject cname: __pyx_n_u_isclass */ + {__pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_isenabled */ + {__pyx_k_items, sizeof(__pyx_k_items), 0, 1, 1}, /* PyObject cname: __pyx_n_u_items */ + {__pyx_k_key, sizeof(__pyx_k_key), 0, 1, 1}, /* PyObject cname: __pyx_n_u_key */ + {__pyx_k_kind, sizeof(__pyx_k_kind), 0, 1, 1}, /* PyObject cname: __pyx_n_u_kind */ + {__pyx_k_kwargs, sizeof(__pyx_k_kwargs), 0, 1, 1}, /* PyObject cname: __pyx_n_u_kwargs */ + {__pyx_k_lineno, sizeof(__pyx_k_lineno), 0, 1, 1}, /* PyObject cname: __pyx_n_u_lineno */ + {__pyx_k_locals, sizeof(__pyx_k_locals), 0, 1, 1}, /* PyObject cname: __pyx_n_u_locals */ + {__pyx_k_lt, sizeof(__pyx_k_lt), 0, 1, 1}, /* PyObject cname: __pyx_n_u_lt */ + {__pyx_k_lt_2, sizeof(__pyx_k_lt_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_lt_2 */ + {__pyx_k_lte, sizeof(__pyx_k_lte), 0, 1, 1}, /* PyObject cname: __pyx_n_u_lte */ + {__pyx_k_lte_2, sizeof(__pyx_k_lte_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_lte_2 */ + {__pyx_k_main, sizeof(__pyx_k_main), 0, 1, 1}, /* PyObject cname: __pyx_n_u_main */ + {__pyx_k_mapping, sizeof(__pyx_k_mapping), 0, 1, 1}, /* PyObject cname: __pyx_n_u_mapping */ + {__pyx_k_match, sizeof(__pyx_k_match), 0, 1, 1}, /* PyObject cname: __pyx_n_u_match */ + {__pyx_k_maxlen, sizeof(__pyx_k_maxlen), 0, 1, 1}, /* PyObject cname: __pyx_n_u_maxlen */ + {__pyx_k_merge, sizeof(__pyx_k_merge), 0, 1, 1}, /* PyObject cname: __pyx_n_u_merge */ + {__pyx_k_module, sizeof(__pyx_k_module), 0, 1, 1}, /* PyObject cname: __pyx_n_u_module */ + {__pyx_k_module_2, sizeof(__pyx_k_module_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_module_2 */ + {__pyx_k_name, sizeof(__pyx_k_name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_name */ + {__pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_name_2 */ + {__pyx_k_new, sizeof(__pyx_k_new), 0, 1, 1}, /* PyObject cname: __pyx_n_u_new */ + {__pyx_k_next, sizeof(__pyx_k_next), 0, 1, 1}, /* PyObject cname: __pyx_n_u_next */ + {__pyx_k_operator, sizeof(__pyx_k_operator), 0, 1, 1}, /* PyObject cname: __pyx_n_u_operator */ + {__pyx_k_or, sizeof(__pyx_k_or), 0, 1, 1}, /* PyObject cname: __pyx_n_u_or */ + {__pyx_k_other, sizeof(__pyx_k_other), 0, 1, 1}, /* PyObject cname: __pyx_n_u_other */ + {__pyx_k_p, sizeof(__pyx_k_p), 0, 1, 1}, /* PyObject cname: __pyx_n_u_p */ + {__pyx_k_parts, sizeof(__pyx_k_parts), 0, 1, 1}, /* PyObject cname: __pyx_n_u_parts */ + {__pyx_k_pickle, sizeof(__pyx_k_pickle), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pickle */ + {__pyx_k_pop, sizeof(__pyx_k_pop), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pop */ + {__pyx_k_predicate, sizeof(__pyx_k_predicate), 0, 1, 1}, /* PyObject cname: __pyx_n_u_predicate */ + {__pyx_k_predicate_2, sizeof(__pyx_k_predicate_2), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_predicate_2 */ + {__pyx_k_predicates, sizeof(__pyx_k_predicates), 0, 1, 1}, /* PyObject cname: __pyx_n_u_predicates */ + {__pyx_k_prefix, sizeof(__pyx_k_prefix), 0, 1, 1}, /* PyObject cname: __pyx_n_u_prefix */ + {__pyx_k_pyx_PickleError, sizeof(__pyx_k_pyx_PickleError), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pyx_PickleError */ + {__pyx_k_pyx_checksum, sizeof(__pyx_k_pyx_checksum), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pyx_checksum */ + {__pyx_k_pyx_result, sizeof(__pyx_k_pyx_result), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pyx_result */ + {__pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pyx_state */ + {__pyx_k_pyx_type, sizeof(__pyx_k_pyx_type), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pyx_type */ + {__pyx_k_pyx_unpickle_And, sizeof(__pyx_k_pyx_unpickle_And), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pyx_unpickle_And */ + {__pyx_k_pyx_unpickle_And__set_state, sizeof(__pyx_k_pyx_unpickle_And__set_state), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pyx_unpickle_And__set_state */ + {__pyx_k_pyx_unpickle_Backlog, sizeof(__pyx_k_pyx_unpickle_Backlog), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pyx_unpickle_Backlog */ + {__pyx_k_pyx_unpickle_Backlog__set_stat, sizeof(__pyx_k_pyx_unpickle_Backlog__set_stat), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pyx_unpickle_Backlog__set_stat */ + {__pyx_k_pyx_unpickle_From, sizeof(__pyx_k_pyx_unpickle_From), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pyx_unpickle_From */ + {__pyx_k_pyx_unpickle_From__set_state, sizeof(__pyx_k_pyx_unpickle_From__set_state), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pyx_unpickle_From__set_state */ + {__pyx_k_pyx_unpickle_Not, sizeof(__pyx_k_pyx_unpickle_Not), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pyx_unpickle_Not */ + {__pyx_k_pyx_unpickle_Not__set_state, sizeof(__pyx_k_pyx_unpickle_Not__set_state), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pyx_unpickle_Not__set_state */ + {__pyx_k_pyx_unpickle_Or, sizeof(__pyx_k_pyx_unpickle_Or), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pyx_unpickle_Or */ + {__pyx_k_pyx_unpickle_Or__set_state, sizeof(__pyx_k_pyx_unpickle_Or__set_state), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pyx_unpickle_Or__set_state */ + {__pyx_k_pyx_unpickle_Query, sizeof(__pyx_k_pyx_unpickle_Query), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pyx_unpickle_Query */ + {__pyx_k_pyx_unpickle_Query__set_state, sizeof(__pyx_k_pyx_unpickle_Query__set_state), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pyx_unpickle_Query__set_state */ + {__pyx_k_pyx_unpickle_When, sizeof(__pyx_k_pyx_unpickle_When), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pyx_unpickle_When */ + {__pyx_k_pyx_unpickle_When__set_state, sizeof(__pyx_k_pyx_unpickle_When__set_state), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pyx_unpickle_When__set_state */ + {__pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pyx_vtable */ + {__pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 1, 1}, /* PyObject cname: __pyx_n_u_qualname */ + {__pyx_k_query, sizeof(__pyx_k_query), 0, 1, 1}, /* PyObject cname: __pyx_n_u_query */ + {__pyx_k_query_contains, sizeof(__pyx_k_query_contains), 0, 1, 1}, /* PyObject cname: __pyx_n_u_query_contains */ + {__pyx_k_query_contains_r, sizeof(__pyx_k_query_contains_r), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_query_contains_r */ + {__pyx_k_query_endswith, sizeof(__pyx_k_query_endswith), 0, 1, 1}, /* PyObject cname: __pyx_n_u_query_endswith */ + {__pyx_k_query_endswith_r, sizeof(__pyx_k_query_endswith_r), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_query_endswith_r */ + {__pyx_k_query_eq, sizeof(__pyx_k_query_eq), 0, 1, 1}, /* PyObject cname: __pyx_n_u_query_eq */ + {__pyx_k_query_eq_r, sizeof(__pyx_k_query_eq_r), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_query_eq_r */ + {__pyx_k_query_gt, sizeof(__pyx_k_query_gt), 0, 1, 1}, /* PyObject cname: __pyx_n_u_query_gt */ + {__pyx_k_query_gt_r, sizeof(__pyx_k_query_gt_r), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_query_gt_r */ + {__pyx_k_query_gte, sizeof(__pyx_k_query_gte), 0, 1, 1}, /* PyObject cname: __pyx_n_u_query_gte */ + {__pyx_k_query_gte_r, sizeof(__pyx_k_query_gte_r), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_query_gte_r */ + {__pyx_k_query_in, sizeof(__pyx_k_query_in), 0, 1, 1}, /* PyObject cname: __pyx_n_u_query_in */ + {__pyx_k_query_in_r, sizeof(__pyx_k_query_in_r), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_query_in_r */ + {__pyx_k_query_lt, sizeof(__pyx_k_query_lt), 0, 1, 1}, /* PyObject cname: __pyx_n_u_query_lt */ + {__pyx_k_query_lt_r, sizeof(__pyx_k_query_lt_r), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_query_lt_r */ + {__pyx_k_query_lte, sizeof(__pyx_k_query_lte), 0, 1, 1}, /* PyObject cname: __pyx_n_u_query_lte */ + {__pyx_k_query_lte_r, sizeof(__pyx_k_query_lte_r), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_query_lte_r */ + {__pyx_k_query_regex, sizeof(__pyx_k_query_regex), 0, 1, 1}, /* PyObject cname: __pyx_n_u_query_regex */ + {__pyx_k_query_regex_r, sizeof(__pyx_k_query_regex_r), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_query_regex_r */ + {__pyx_k_query_startswith, sizeof(__pyx_k_query_startswith), 0, 1, 1}, /* PyObject cname: __pyx_n_u_query_startswith */ + {__pyx_k_query_startswith_r, sizeof(__pyx_k_query_startswith_r), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_query_startswith_r */ + {__pyx_k_re, sizeof(__pyx_k_re), 0, 1, 1}, /* PyObject cname: __pyx_n_u_re */ + {__pyx_k_re_compile, sizeof(__pyx_k_re_compile), 0, 1, 1}, /* PyObject cname: __pyx_n_u_re_compile */ + {__pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 1, 1}, /* PyObject cname: __pyx_n_u_reduce */ + {__pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_reduce_cython */ + {__pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 1, 1}, /* PyObject cname: __pyx_n_u_reduce_ex */ + {__pyx_k_regex, sizeof(__pyx_k_regex), 0, 1, 1}, /* PyObject cname: __pyx_n_u_regex */ + {__pyx_k_regex_2, sizeof(__pyx_k_regex_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_regex_2 */ + {__pyx_k_repr, sizeof(__pyx_k_repr), 0, 1, 1}, /* PyObject cname: __pyx_n_u_repr */ + {__pyx_k_rx, sizeof(__pyx_k_rx), 0, 1, 1}, /* PyObject cname: __pyx_n_u_rx */ + {__pyx_k_self, sizeof(__pyx_k_self), 0, 1, 1}, /* PyObject cname: __pyx_n_u_self */ + {__pyx_k_self_getter_cannot_be_converted, sizeof(__pyx_k_self_getter_cannot_be_converted), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_self_getter_cannot_be_converted */ + {__pyx_k_send, sizeof(__pyx_k_send), 0, 1, 1}, /* PyObject cname: __pyx_n_u_send */ + {__pyx_k_set_name, sizeof(__pyx_k_set_name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_set_name */ + {__pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 1, 1}, /* PyObject cname: __pyx_n_u_setstate */ + {__pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_setstate_cython */ + {__pyx_k_size, sizeof(__pyx_k_size), 0, 1, 1}, /* PyObject cname: __pyx_n_u_size */ + {__pyx_k_size_2, sizeof(__pyx_k_size_2), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_size_2 */ + {__pyx_k_source, sizeof(__pyx_k_source), 0, 1, 1}, /* PyObject cname: __pyx_n_u_source */ + {__pyx_k_split, sizeof(__pyx_k_split), 0, 1, 1}, /* PyObject cname: __pyx_n_u_split */ + {__pyx_k_src_hunter__predicates_pxd, sizeof(__pyx_k_src_hunter__predicates_pxd), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_src_hunter__predicates_pxd */ + {__pyx_k_src_hunter__predicates_pyx, sizeof(__pyx_k_src_hunter__predicates_pyx), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_src_hunter__predicates_pyx */ + {__pyx_k_stack, sizeof(__pyx_k_stack), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stack */ + {__pyx_k_stack_2, sizeof(__pyx_k_stack_2), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_stack_2 */ + {__pyx_k_startswith, sizeof(__pyx_k_startswith), 0, 1, 1}, /* PyObject cname: __pyx_n_u_startswith */ + {__pyx_k_startswith_2, sizeof(__pyx_k_startswith_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_startswith_2 */ + {__pyx_k_state, sizeof(__pyx_k_state), 0, 1, 1}, /* PyObject cname: __pyx_n_u_state */ + {__pyx_k_stdlib, sizeof(__pyx_k_stdlib), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stdlib */ + {__pyx_k_str, sizeof(__pyx_k_str), 0, 1, 1}, /* PyObject cname: __pyx_n_u_str */ + {__pyx_k_str___locals_genexpr, sizeof(__pyx_k_str___locals_genexpr), 0, 1, 1}, /* PyObject cname: __pyx_n_u_str___locals_genexpr */ + {__pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_stringsource */ + {__pyx_k_strip, sizeof(__pyx_k_strip), 0, 1, 1}, /* PyObject cname: __pyx_n_u_strip */ + {__pyx_k_sw, sizeof(__pyx_k_sw), 0, 1, 1}, /* PyObject cname: __pyx_n_u_sw */ + {__pyx_k_test, sizeof(__pyx_k_test), 0, 1, 1}, /* PyObject cname: __pyx_n_u_test */ + {__pyx_k_threadid, sizeof(__pyx_k_threadid), 0, 1, 1}, /* PyObject cname: __pyx_n_u_threadid */ + {__pyx_k_threading_support, sizeof(__pyx_k_threading_support), 0, 1, 1}, /* PyObject cname: __pyx_n_u_threading_support */ + {__pyx_k_threadname, sizeof(__pyx_k_threadname), 0, 1, 1}, /* PyObject cname: __pyx_n_u_threadname */ + {__pyx_k_throw, sizeof(__pyx_k_throw), 0, 1, 1}, /* PyObject cname: __pyx_n_u_throw */ + {__pyx_k_try_repr, sizeof(__pyx_k_try_repr), 0, 1, 1}, /* PyObject cname: __pyx_n_u_try_repr */ + {__pyx_k_update, sizeof(__pyx_k_update), 0, 1, 1}, /* PyObject cname: __pyx_n_u_update */ + {__pyx_k_use_setstate, sizeof(__pyx_k_use_setstate), 0, 1, 1}, /* PyObject cname: __pyx_n_u_use_setstate */ + {__pyx_k_value, sizeof(__pyx_k_value), 0, 1, 1}, /* PyObject cname: __pyx_n_u_value */ + {__pyx_k_vars, sizeof(__pyx_k_vars), 0, 1, 1}, /* PyObject cname: __pyx_n_u_vars */ + {__pyx_k_vars_2, sizeof(__pyx_k_vars_2), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_vars_2 */ + {__pyx_k_watermark, sizeof(__pyx_k_watermark), 0, 1, 1}, /* PyObject cname: __pyx_n_u_watermark */ + {__pyx_k_watermark_2, sizeof(__pyx_k_watermark_2), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_watermark_2 */ + {__pyx_k_with_optional_operators_like, sizeof(__pyx_k_with_optional_operators_like), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_with_optional_operators_like */ + {__pyx_k_wrap, sizeof(__pyx_k_wrap), 0, 1, 1}, /* PyObject cname: __pyx_n_u_wrap */ + {0, 0, 0, 0, 0} +}; +/* InitStrings.proto */ +static int __Pyx_InitStrings(__Pyx_StringTabEntry const *t, PyObject **target, const char* const* encoding_names); + +/* #### Code section: cached_builtins ### */ + +static int __Pyx_InitCachedBuiltins(__pyx_mstatetype *__pyx_mstate) { + CYTHON_UNUSED_VAR(__pyx_mstate); + __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 2, __pyx_L1_error) + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 153, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: cached_constants ### */ + +static int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x5503a44, 0x9ea0a45, 0x4eca0a2): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x5503a44, 0x9ea0a45, 0x4eca0a2) = (query_contains, query_endswith, query_eq, query_gt, query_gte, query_in, query_lt, query_lte, query_regex, query_startswith))" % __pyx_checksum +*/ + __pyx_mstate_global->__pyx_tuple[0] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_89143876, __pyx_mstate_global->__pyx_int_166332997, __pyx_mstate_global->__pyx_int_82616482); if (unlikely(!__pyx_mstate_global->__pyx_tuple[0])) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[0]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[0]); + __pyx_mstate_global->__pyx_tuple[1] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_242287462, __pyx_mstate_global->__pyx_int_124881844, __pyx_mstate_global->__pyx_int_190166812); if (unlikely(!__pyx_mstate_global->__pyx_tuple[1])) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[1]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[1]); + __pyx_mstate_global->__pyx_tuple[2] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_217908684, __pyx_mstate_global->__pyx_int_223119700, __pyx_mstate_global->__pyx_int_28104183); if (unlikely(!__pyx_mstate_global->__pyx_tuple[2])) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[2]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[2]); + __pyx_mstate_global->__pyx_tuple[3] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_149034610, __pyx_mstate_global->__pyx_int_210676054, __pyx_mstate_global->__pyx_int_178834394); if (unlikely(!__pyx_mstate_global->__pyx_tuple[3])) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[3]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[3]); + __pyx_mstate_global->__pyx_tuple[4] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_37183945, __pyx_mstate_global->__pyx_int_4473905, __pyx_mstate_global->__pyx_int_258412278); if (unlikely(!__pyx_mstate_global->__pyx_tuple[4])) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[4]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[4]); + __pyx_mstate_global->__pyx_tuple[5] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_21139105, __pyx_mstate_global->__pyx_int_198256870, __pyx_mstate_global->__pyx_int_79429044); if (unlikely(!__pyx_mstate_global->__pyx_tuple[5])) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[5]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[5]); + + /* "hunter/_predicates.pyx":19 + * + * __all__ = ( + * 'And', # <<<<<<<<<<<<<< + * 'From', + * 'Not', +*/ + __pyx_mstate_global->__pyx_tuple[6] = PyTuple_Pack(6, __pyx_mstate_global->__pyx_n_u_And, __pyx_mstate_global->__pyx_n_u_From_2, __pyx_mstate_global->__pyx_n_u_Not, __pyx_mstate_global->__pyx_n_u_Or, __pyx_mstate_global->__pyx_n_u_Query, __pyx_mstate_global->__pyx_n_u_When_2); if (unlikely(!__pyx_mstate_global->__pyx_tuple[6])) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[6]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[6]); + + /* "hunter/_predicates.pyx":28 + * + * cdef tuple ALLOWED_KEYS = ( + * 'function', 'module', 'lineno', 'globals', 'stdlib', 'arg', 'locals', 'kind', 'filename', 'source', # <<<<<<<<<<<<<< + * 'fullsource', 'threadname', 'threadid', 'instruction', 'depth', 'calls', 'builtin', + * ) +*/ + __pyx_mstate_global->__pyx_tuple[7] = PyTuple_Pack(17, __pyx_mstate_global->__pyx_n_u_function, __pyx_mstate_global->__pyx_n_u_module, __pyx_mstate_global->__pyx_n_u_lineno, __pyx_mstate_global->__pyx_n_u_globals, __pyx_mstate_global->__pyx_n_u_stdlib, __pyx_mstate_global->__pyx_n_u_arg, __pyx_mstate_global->__pyx_n_u_locals, __pyx_mstate_global->__pyx_n_u_kind, __pyx_mstate_global->__pyx_n_u_filename, __pyx_mstate_global->__pyx_n_u_source, __pyx_mstate_global->__pyx_n_u_fullsource, __pyx_mstate_global->__pyx_n_u_threadname, __pyx_mstate_global->__pyx_n_u_threadid, __pyx_mstate_global->__pyx_n_u_instruction, __pyx_mstate_global->__pyx_n_u_depth, __pyx_mstate_global->__pyx_n_u_calls, __pyx_mstate_global->__pyx_n_u_builtin); if (unlikely(!__pyx_mstate_global->__pyx_tuple[7])) __PYX_ERR(0, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[7]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[7]); + + /* "hunter/_predicates.pyx":32 + * ) + * cdef tuple ALLOWED_OPERATORS = ( + * 'startswith', 'endswith', 'in', 'contains', 'regex', # <<<<<<<<<<<<<< + * 'sw', 'ew', 'has', 'rx', + * 'gt', 'gte', 'lt', 'lte', +*/ + __pyx_mstate_global->__pyx_tuple[8] = PyTuple_Pack(13, __pyx_mstate_global->__pyx_n_u_startswith, __pyx_mstate_global->__pyx_n_u_endswith, __pyx_mstate_global->__pyx_n_u_in, __pyx_mstate_global->__pyx_n_u_contains, __pyx_mstate_global->__pyx_n_u_regex, __pyx_mstate_global->__pyx_n_u_sw, __pyx_mstate_global->__pyx_n_u_ew, __pyx_mstate_global->__pyx_n_u_has, __pyx_mstate_global->__pyx_n_u_rx, __pyx_mstate_global->__pyx_n_u_gt, __pyx_mstate_global->__pyx_n_u_gte, __pyx_mstate_global->__pyx_n_u_lt, __pyx_mstate_global->__pyx_n_u_lte); if (unlikely(!__pyx_mstate_global->__pyx_tuple[8])) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[8]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[8]); + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} +/* #### Code section: init_constants ### */ + +static int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate) { + CYTHON_UNUSED_VAR(__pyx_mstate); + __pyx_mstate->__pyx_umethod_PyDict_Type_items.type = (PyObject*)&PyDict_Type; + __pyx_mstate->__pyx_umethod_PyDict_Type_items.method_name = &__pyx_mstate->__pyx_n_u_items; + __pyx_mstate->__pyx_umethod_PyDict_Type_pop.type = (PyObject*)&PyDict_Type; + __pyx_mstate->__pyx_umethod_PyDict_Type_pop.method_name = &__pyx_mstate->__pyx_n_u_pop; + __pyx_mstate->__pyx_umethod_PyTuple_Type__index.type = (PyObject*)(&PyTuple_Type); + __pyx_mstate->__pyx_umethod_PyTuple_Type__index.method_name = &__pyx_mstate->__pyx_n_u_index; + if (__Pyx_InitStrings(__pyx_string_tab, __pyx_mstate->__pyx_string_tab, __pyx_string_tab_encodings) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + __pyx_mstate->__pyx_int_0 = PyLong_FromLong(0); if (unlikely(!__pyx_mstate->__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_10 = PyLong_FromLong(10); if (unlikely(!__pyx_mstate->__pyx_int_10)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_100 = PyLong_FromLong(100); if (unlikely(!__pyx_mstate->__pyx_int_100)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_4473905 = PyLong_FromLong(4473905L); if (unlikely(!__pyx_mstate->__pyx_int_4473905)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_21139105 = PyLong_FromLong(21139105L); if (unlikely(!__pyx_mstate->__pyx_int_21139105)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_28104183 = PyLong_FromLong(28104183L); if (unlikely(!__pyx_mstate->__pyx_int_28104183)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_37183945 = PyLong_FromLong(37183945L); if (unlikely(!__pyx_mstate->__pyx_int_37183945)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_79429044 = PyLong_FromLong(79429044L); if (unlikely(!__pyx_mstate->__pyx_int_79429044)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_82616482 = PyLong_FromLong(82616482L); if (unlikely(!__pyx_mstate->__pyx_int_82616482)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_89143876 = PyLong_FromLong(89143876L); if (unlikely(!__pyx_mstate->__pyx_int_89143876)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_124881844 = PyLong_FromLong(124881844L); if (unlikely(!__pyx_mstate->__pyx_int_124881844)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_149034610 = PyLong_FromLong(149034610L); if (unlikely(!__pyx_mstate->__pyx_int_149034610)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_166332997 = PyLong_FromLong(166332997L); if (unlikely(!__pyx_mstate->__pyx_int_166332997)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_178834394 = PyLong_FromLong(178834394L); if (unlikely(!__pyx_mstate->__pyx_int_178834394)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_190166812 = PyLong_FromLong(190166812L); if (unlikely(!__pyx_mstate->__pyx_int_190166812)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_198256870 = PyLong_FromLong(198256870L); if (unlikely(!__pyx_mstate->__pyx_int_198256870)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_210676054 = PyLong_FromLong(210676054L); if (unlikely(!__pyx_mstate->__pyx_int_210676054)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_217908684 = PyLong_FromLong(217908684L); if (unlikely(!__pyx_mstate->__pyx_int_217908684)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_223119700 = PyLong_FromLong(223119700L); if (unlikely(!__pyx_mstate->__pyx_int_223119700)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_242287462 = PyLong_FromLong(242287462L); if (unlikely(!__pyx_mstate->__pyx_int_242287462)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_258412278 = PyLong_FromLong(258412278L); if (unlikely(!__pyx_mstate->__pyx_int_258412278)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_neg_1 = PyLong_FromLong(-1); if (unlikely(!__pyx_mstate->__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: init_codeobjects ### */ +\ + typedef struct { + unsigned int argcount : 4; + unsigned int num_posonly_args : 1; + unsigned int num_kwonly_args : 1; + unsigned int nlocals : 5; + unsigned int flags : 10; + unsigned int first_line : 10; + unsigned int line_table_length : 14; + } __Pyx_PyCode_New_function_description; +/* NewCodeObj.proto */ +static PyObject* __Pyx_PyCode_New( + const __Pyx_PyCode_New_function_description descr, + PyObject * const *varnames, + PyObject *filename, + PyObject *funcname, + const char *line_table, + PyObject *tuple_dedup_map +); + + +static int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate) { + PyObject* tuple_dedup_map = PyDict_New(); + if (unlikely(!tuple_dedup_map)) return -1; + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 67, 11}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_event}; + __pyx_mstate_global->__pyx_codeobj_tab[0] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_wrap, __pyx_k_A_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[0])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 65, 12}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_f}; + __pyx_mstate_global->__pyx_codeobj_tab[1] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_Pyx_CFunc_6hunter_11_predicate_2, __pyx_k_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[1])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 38, 12}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_event, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[2] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_Event_get_function, __pyx_k_WE9I, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[2])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 39, 11}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_event, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[3] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_Event_get_module, __pyx_k_7_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[3])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 40, 11}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_event, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[4] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_Event_get_lineno, __pyx_k_7_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[4])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 41, 11}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_event, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[5] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_Event_get_globals, __pyx_k_G5_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[5])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 42, 11}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_event, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[6] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_Event_get_stdlib, __pyx_k_7_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[6])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 43, 9}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_event, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[7] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_Event_get_arg, __pyx_k_uA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[7])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 44, 11}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_event, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[8] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_Event_get_locals, __pyx_k_7_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[8])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 45, 9}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_event, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[9] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_Event_get_kind, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[9])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 46, 12}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_event, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[10] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_Event_get_filename, __pyx_k_WE9I, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[10])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 47, 11}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_event, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[11] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_Event_get_source, __pyx_k_7_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[11])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 48, 12}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_event, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[12] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_Event_get_fullsource, __pyx_k_we_MQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[12])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 49, 12}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_event, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[13] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_Event_get_threadname, __pyx_k_we_MQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[13])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 50, 12}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_event, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[14] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_Event_get_threadid, __pyx_k_WE9I, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[14])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 51, 12}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_event, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[15] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_Event_get_instruction, __pyx_k_0_u_Oq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[15])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 52, 9}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_event, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[16] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_Event_get_depth, __pyx_k_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[16])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 53, 9}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_event, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[17] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_Event_get_calls, __pyx_k_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[17])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 54, 9}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_event, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[18] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_Event_get_builtin, __pyx_k_G5, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[18])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 83, 36}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_value, __pyx_mstate->__pyx_n_u_name}; + __pyx_mstate_global->__pyx_codeobj_tab[19] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_init, __pyx_k_A_IQ_L_aq_Jm1D, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[19])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 88, 13}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[20] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_repr, __pyx_k_A_t1D, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[20])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 91, 44}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_other}; + __pyx_mstate_global->__pyx_codeobj_tab[21] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_eq, __pyx_k_A_awa_G4_F_N_m6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[21])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[22] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[22])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state}; + __pyx_mstate_global->__pyx_codeobj_tab[23] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[23])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 20, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 106, 623}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_query, __pyx_mstate->__pyx_n_u_query_eq, __pyx_mstate->__pyx_n_u_query_startswith, __pyx_mstate->__pyx_n_u_query_endswith, __pyx_mstate->__pyx_n_u_query_in, __pyx_mstate->__pyx_n_u_query_contains, __pyx_mstate->__pyx_n_u_query_regex, __pyx_mstate->__pyx_n_u_query_lt, __pyx_mstate->__pyx_n_u_query_lte, __pyx_mstate->__pyx_n_u_query_gt, __pyx_mstate->__pyx_n_u_query_gte, __pyx_mstate->__pyx_n_u_key, __pyx_mstate->__pyx_n_u_value, __pyx_mstate->__pyx_n_u_parts, __pyx_mstate->__pyx_n_u_count, __pyx_mstate->__pyx_n_u_prefix, __pyx_mstate->__pyx_n_u_operator, __pyx_mstate->__pyx_n_u_mapping, __pyx_mstate->__pyx_n_u_p}; + __pyx_mstate_global->__pyx_codeobj_tab[24] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_init, __pyx_k_A0_1_1_1_a_1_A_1_A_E_vQ_ARt5_6_s, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[24])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {0, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_GENERATOR), 202, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_key, __pyx_mstate->__pyx_n_u_value}; + __pyx_mstate_global->__pyx_codeobj_tab[25] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_genexpr, __pyx_k__10, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[25])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 199, 111}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_kind, __pyx_mstate->__pyx_n_u_mapping, __pyx_mstate->__pyx_n_u_genexpr, __pyx_mstate->__pyx_n_u_genexpr}; + __pyx_mstate_global->__pyx_codeobj_tab[26] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_str, __pyx_k_A_1_Qa_E_F_Q_Q_D_a_D_a_t1_D_T_D, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[26])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 219, 109}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_fmt, __pyx_mstate->__pyx_n_u_mapping}; + __pyx_mstate_global->__pyx_codeobj_tab[27] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_repr, __pyx_k_A_r_E_1_A_A_d_A_d_4q_A_Q_A_Q_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[27])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 237, 167}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_other}; + __pyx_mstate_global->__pyx_codeobj_tab[28] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_eq, __pyx_k_A_awa_Jd_d_D_a_Jd_D_a_M_XV1_Jd_K, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[28])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 252, 13}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_event}; + __pyx_mstate_global->__pyx_codeobj_tab[29] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_call_2, __pyx_k_A_avQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[29])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 255, 13}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_other}; + __pyx_mstate_global->__pyx_codeobj_tab[30] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_or, __pyx_k_A_r, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[30])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 258, 13}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_other}; + __pyx_mstate_global->__pyx_codeobj_tab[31] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_and, __pyx_k_A_s_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[31])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 261, 11}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[32] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_invert, __pyx_k_A_s_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[32])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 10, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[33] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[33])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 11, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[34] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[34])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 12, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[35] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[35])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 13, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[36] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[36])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 14, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[37] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[37])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 15, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[38] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[38])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 16, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[39] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[39])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 17, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[40] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[40])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 18, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[41] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[41])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 19, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[42] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[42])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 436}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_state, __pyx_mstate->__pyx_n_u_dict_2, __pyx_mstate->__pyx_n_u_use_setstate}; + __pyx_mstate_global->__pyx_codeobj_tab[43] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_T_7t_d_UYYeeiittx_y_D_D_H_H_T_T, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[43])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 16, 11}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state}; + __pyx_mstate_global->__pyx_codeobj_tab[44] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_1F, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[44])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 264, 463}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_event, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[45] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_fast_Query_call, __pyx_k_Yd_M_waq_D_V1_1_Yd_M_waq_F_HM_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[45])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {0, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_GENERATOR), 322, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_action}; + __pyx_mstate_global->__pyx_codeobj_tab[46] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_genexpr, __pyx_k_A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[46])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS), 317, 37}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_condition, __pyx_mstate->__pyx_n_u_actions_2, __pyx_mstate->__pyx_n_u_genexpr, __pyx_mstate->__pyx_n_u_genexpr}; + __pyx_mstate_global->__pyx_codeobj_tab[47] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_init, __pyx_k_A_4q_1A_M_KuA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[47])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {0, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_GENERATOR), 328, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_p}; + __pyx_mstate_global->__pyx_codeobj_tab[48] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_genexpr, __pyx_k__10, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[48])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 325, 21}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_genexpr, __pyx_mstate->__pyx_n_u_genexpr}; + __pyx_mstate_global->__pyx_codeobj_tab[49] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_str, __pyx_k_A_q_U, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[49])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 331, 18}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[50] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_repr, __pyx_k_A_H_LX, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[50])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 334, 44}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_other}; + __pyx_mstate_global->__pyx_codeobj_tab[51] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_eq, __pyx_k_A_awa_Kt7_IT_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[51])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 341, 13}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_event}; + __pyx_mstate_global->__pyx_codeobj_tab[52] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_call_2, __pyx_k_A_QfA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[52])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 344, 13}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_other}; + __pyx_mstate_global->__pyx_codeobj_tab[53] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_or, __pyx_k_A_r, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[53])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 347, 13}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_other}; + __pyx_mstate_global->__pyx_codeobj_tab[54] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_and, __pyx_k_A_s_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[54])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 350, 11}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[55] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_invert, __pyx_k_A_s_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[55])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 43, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[56] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k__11, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[56])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 44, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[57] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[57])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 107}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_state, __pyx_mstate->__pyx_n_u_dict_2, __pyx_mstate->__pyx_n_u_use_setstate}; + __pyx_mstate_global->__pyx_codeobj_tab[58] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_T_4q_G1F_a_vWA_q_t9G5_4_q_T_G1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[58])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 16, 11}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state}; + __pyx_mstate_global->__pyx_codeobj_tab[59] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[59])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 353, 43}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_event, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[60] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_fast_When_call, __pyx_k_Yat_q_q_Jd_1_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[60])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 371, 45}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_condition, __pyx_mstate->__pyx_n_u_predicate, __pyx_mstate->__pyx_n_u_watermark}; + __pyx_mstate_global->__pyx_codeobj_tab[61] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_init, __pyx_k_A_M_M_M_Q_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[61])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 378, 20}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[62] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_str, __pyx_k_A_q_D_D, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[62])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 383, 20}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[63] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_repr, __pyx_k_A_q_D_D, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[63])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 388, 44}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_other}; + __pyx_mstate_global->__pyx_codeobj_tab[64] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_eq, __pyx_k_A_awa_Kt7_Kt7, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[64])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 395, 13}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_event}; + __pyx_mstate_global->__pyx_codeobj_tab[65] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_call_2, __pyx_k_A_QfA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[65])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 398, 13}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_other}; + __pyx_mstate_global->__pyx_codeobj_tab[66] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_or, __pyx_k_A_r, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[66])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 401, 13}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_other}; + __pyx_mstate_global->__pyx_codeobj_tab[67] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_and, __pyx_k_A_s_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[67])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 404, 11}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[68] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_invert, __pyx_k_A_s_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[68])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 50, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[69] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k__11, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[69])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 51, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[70] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k__11, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[70])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 52, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[71] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k_Q_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[71])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 53, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[72] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k_Q_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[72])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 54, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[73] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k_Q_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[73])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 121}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_state, __pyx_mstate->__pyx_n_u_dict_2, __pyx_mstate->__pyx_n_u_use_setstate}; + __pyx_mstate_global->__pyx_codeobj_tab[74] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_T_T_O4_SWWX_G1F_a_vWA_q_t_gU_T, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[74])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 16, 11}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state}; + __pyx_mstate_global->__pyx_codeobj_tab[75] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[75])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 407, 167}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_event, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[76] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_fast_From_call, __pyx_k_t_Q_4_1_1_Q_Q_1_e7_D_e7_D_r_Q_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[76])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS), 442, 9}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_predicates}; + __pyx_mstate_global->__pyx_codeobj_tab[77] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_init, __pyx_k_A_N, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[77])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {0, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_GENERATOR), 446, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_p}; + __pyx_mstate_global->__pyx_codeobj_tab[78] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_genexpr, __pyx_k__12, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[78])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 445, 17}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_genexpr, __pyx_mstate->__pyx_n_u_genexpr}; + __pyx_mstate_global->__pyx_codeobj_tab[79] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_str, __pyx_k_A_z_4uD, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[79])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 448, 12}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[80] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_repr, __pyx_k_A_D, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[80])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 451, 29}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_other}; + __pyx_mstate_global->__pyx_codeobj_tab[81] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_eq, __pyx_k_A_awa_L_F, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[81])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 457, 13}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_event}; + __pyx_mstate_global->__pyx_codeobj_tab[82] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_call_2, __pyx_k_A_AV1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[82])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 460, 13}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_other}; + __pyx_mstate_global->__pyx_codeobj_tab[83] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_or, __pyx_k_A_r, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[83])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 463, 77}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_other, __pyx_mstate->__pyx_n_u_predicates}; + __pyx_mstate_global->__pyx_codeobj_tab[84] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_and, __pyx_k_A_4q_c_RvU_QgQ_gRvV1_gQa_s_A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[84])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 475, 11}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[85] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_invert, __pyx_k_A_s_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[85])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 25, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[86] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[86])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 93}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_state, __pyx_mstate->__pyx_n_u_dict_2, __pyx_mstate->__pyx_n_u_use_setstate}; + __pyx_mstate_global->__pyx_codeobj_tab[87] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_T_G1F_a_vWA_q_t_wa_q_D_7_D_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[87])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 16, 11}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state}; + __pyx_mstate_global->__pyx_codeobj_tab[88] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k__13, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[88])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 478, 34}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_event, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[89] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_fast_And_call, __pyx_k_T_4y_A_1_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[89])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS), 492, 9}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_predicates}; + __pyx_mstate_global->__pyx_codeobj_tab[90] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_init, __pyx_k_A_N, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[90])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {0, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_GENERATOR), 496, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_p}; + __pyx_mstate_global->__pyx_codeobj_tab[91] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_genexpr, __pyx_k_q_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[91])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 495, 17}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_genexpr, __pyx_mstate->__pyx_n_u_genexpr}; + __pyx_mstate_global->__pyx_codeobj_tab[92] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_str, __pyx_k_A_y_e4q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[92])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 498, 12}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[93] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_repr, __pyx_k_A_4q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[93])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 501, 29}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_other}; + __pyx_mstate_global->__pyx_codeobj_tab[94] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_eq, __pyx_k_A_awa_L_E_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[94])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 507, 13}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_event}; + __pyx_mstate_global->__pyx_codeobj_tab[95] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_call_2, __pyx_k_A_1F, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[95])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 510, 79}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_other, __pyx_mstate->__pyx_n_u_predicates}; + __pyx_mstate_global->__pyx_codeobj_tab[96] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_or, __pyx_k_A_4q_c_RuE_4q_s_gRuF_gQa_r_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[96])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 522, 13}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_other}; + __pyx_mstate_global->__pyx_codeobj_tab[97] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_and, __pyx_k_A_s_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[97])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 525, 11}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[98] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_invert, __pyx_k_A_s_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[98])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 31, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[99] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[99])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 93}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_state, __pyx_mstate->__pyx_n_u_dict_2, __pyx_mstate->__pyx_n_u_use_setstate}; + __pyx_mstate_global->__pyx_codeobj_tab[100] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_T_G1F_a_vWA_q_t_wa_q_4q_4q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[100])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 16, 11}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state}; + __pyx_mstate_global->__pyx_codeobj_tab[101] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_q_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[101])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 528, 32}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_event, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[102] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_fast_Or_call, __pyx_k_T_9A_1_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[102])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 540, 9}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_predicate}; + __pyx_mstate_global->__pyx_codeobj_tab[103] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_init, __pyx_k_A_M, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[103])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 543, 13}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[104] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_str, __pyx_k_A_z_4q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[104])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 546, 14}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[105] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_repr, __pyx_k_A_8_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[105])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 549, 29}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_other}; + __pyx_mstate_global->__pyx_codeobj_tab[106] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_eq, __pyx_k_A_awa_Kt6_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[106])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 555, 13}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_event}; + __pyx_mstate_global->__pyx_codeobj_tab[107] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_call_2, __pyx_k_A_AV1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[107])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 558, 61}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_other}; + __pyx_mstate_global->__pyx_codeobj_tab[108] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_or, __pyx_k_A_4q_c_T_QgS_3as_F_F_2QfA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[108])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 564, 61}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_other}; + __pyx_mstate_global->__pyx_codeobj_tab[109] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_and, __pyx_k_A_4q_c_T_QgS_3ar_6_m6_q_3avQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[109])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 570, 9}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[110] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_invert, __pyx_k_A_t1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[110])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 37, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[111] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k__11, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[111])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 93}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_state, __pyx_mstate->__pyx_n_u_dict_2, __pyx_mstate->__pyx_n_u_use_setstate}; + __pyx_mstate_global->__pyx_codeobj_tab[112] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_T_G1F_a_vWA_q_t_gQ_q_D_7_D_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[112])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 16, 11}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state}; + __pyx_mstate_global->__pyx_codeobj_tab[113] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k__13, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[113])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 573, 17}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_event, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[114] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_fast_Not_call, __pyx_k_4y, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[114])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 577, 182}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_callable, __pyx_mstate->__pyx_n_u_event, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[115] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_fast_call, __pyx_k_t1Jc_axz_Qj_1_1E_1_Qj_1_AV_Q_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[115])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {8, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 598, 148}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_condition, __pyx_mstate->__pyx_n_u_size, __pyx_mstate->__pyx_n_u_stack, __pyx_mstate->__pyx_n_u_vars, __pyx_mstate->__pyx_n_u_strip, __pyx_mstate->__pyx_n_u_action, __pyx_mstate->__pyx_n_u_filter}; + __pyx_mstate_global->__pyx_codeobj_tab[116] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_init, __pyx_k_Ubbc_JfF_j_VW_4z_iq_1_ERt1_M_IU, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[116])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 611, 14}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_event}; + __pyx_mstate_global->__pyx_codeobj_tab[117] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_call_2, __pyx_k_A_q_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[117])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 614, 32}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[118] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_str, __pyx_k_A_q_D_t84wd_4q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[118])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 619, 32}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[119] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_repr, __pyx_k_A_q_D_t84wd_4q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[119])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 624, 89}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_other}; + __pyx_mstate_global->__pyx_codeobj_tab[120] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_eq, __pyx_k_A_awiq_4z_d_F_t_V7_d_F_JfA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[120])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 634, 13}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_other}; + __pyx_mstate_global->__pyx_codeobj_tab[121] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_or, __pyx_k_A_r, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[121])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 637, 13}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_other}; + __pyx_mstate_global->__pyx_codeobj_tab[122] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_and, __pyx_k_A_s_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[122])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 640, 55}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[123] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_invert, __pyx_k_A_was_4_E_WF_heSWW_eeiirryy, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[123])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS), 643, 77}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_predicates, __pyx_mstate->__pyx_n_u_kwargs, __pyx_mstate->__pyx_n_u_merge}; + __pyx_mstate_global->__pyx_codeobj_tab[124] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_filter, __pyx_k_A_1_4y_q_k_wa_WF_he4wgT_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[124])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 60, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[125] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k__11, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[125])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 61, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[126] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k_Q_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[126])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 62, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[127] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k_Q_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[127])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 63, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[128] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k_a_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[128])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 64, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[129] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k_a_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[129])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 65, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[130] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k__11, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[130])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 66, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[131] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k__11, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[131])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 67, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[132] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k__11, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[132])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 68, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[133] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k__11, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[133])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 215}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_state, __pyx_mstate->__pyx_n_u_dict_2, __pyx_mstate->__pyx_n_u_use_setstate}; + __pyx_mstate_global->__pyx_codeobj_tab[134] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_T_4_4y_L_HTXX__cckkooww_G1F_a_v, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[134])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 16, 11}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state}; + __pyx_mstate_global->__pyx_codeobj_tab[135] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_QfA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[135])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 655, 460}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_event, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[136] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__predicates_pyx, __pyx_mstate->__pyx_n_u_fast_Backlog_call, __pyx_k_Yat_q_q_4q_xq_fAQ_Q_gRq_KvS_q_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[136])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 86}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_pyx_type, __pyx_mstate->__pyx_n_u_pyx_checksum, __pyx_mstate->__pyx_n_u_pyx_state, __pyx_mstate->__pyx_n_u_pyx_PickleError, __pyx_mstate->__pyx_n_u_pyx_result}; + __pyx_mstate_global->__pyx_codeobj_tab[137] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_pyx_unpickle_Query, __pyx_k_hk_A_1_g_g_i_i_j_5_7_q_a_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[137])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 11, 338}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_pyx_result, __pyx_mstate->__pyx_n_u_pyx_state, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[138] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_pyx_unpickle_Query__set_state, __pyx_k_Qd_PP_llx_y_D_D_E_E_I_I_U_U_a_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[138])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 79}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_pyx_type, __pyx_mstate->__pyx_n_u_pyx_checksum, __pyx_mstate->__pyx_n_u_pyx_state, __pyx_mstate->__pyx_n_u_pyx_PickleError, __pyx_mstate->__pyx_n_u_pyx_result}; + __pyx_mstate_global->__pyx_codeobj_tab[139] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_pyx_unpickle_When, __pyx_k_hk_A_1_A_4xq_7_awnA_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[139])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 11, 62}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_pyx_result, __pyx_mstate->__pyx_n_u_pyx_state, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[140] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_pyx_unpickle_When__set_state, __pyx_k_at_KqPQ_s_D_q_a_IWA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[140])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 86}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_pyx_type, __pyx_mstate->__pyx_n_u_pyx_checksum, __pyx_mstate->__pyx_n_u_pyx_state, __pyx_mstate->__pyx_n_u_pyx_PickleError, __pyx_mstate->__pyx_n_u_pyx_result}; + __pyx_mstate_global->__pyx_codeobj_tab[141] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_pyx_unpickle_From, __pyx_k_hk_A_1_g_g_i_i_j_4xq_7_awnA_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[141])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 11, 161}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_pyx_result, __pyx_mstate->__pyx_n_u_pyx_state, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[142] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_pyx_unpickle_From__set_state, __pyx_k_9I_TUUYYeeu_v_A_A_B_B_F_F_R_R, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[142])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 75}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_pyx_type, __pyx_mstate->__pyx_n_u_pyx_checksum, __pyx_mstate->__pyx_n_u_pyx_state, __pyx_mstate->__pyx_n_u_pyx_PickleError, __pyx_mstate->__pyx_n_u_pyx_result}; + __pyx_mstate_global->__pyx_codeobj_tab[143] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_pyx_unpickle_And, __pyx_k_hk_A_1_uuwwx_3haq_7_QfN_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[143])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 11, 51}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_pyx_result, __pyx_mstate->__pyx_n_u_pyx_state, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[144] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_pyx_unpickle_And__set_state, __pyx_k_k_s_D_q_a_IWA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[144])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 75}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_pyx_type, __pyx_mstate->__pyx_n_u_pyx_checksum, __pyx_mstate->__pyx_n_u_pyx_state, __pyx_mstate->__pyx_n_u_pyx_PickleError, __pyx_mstate->__pyx_n_u_pyx_result}; + __pyx_mstate_global->__pyx_codeobj_tab[145] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_pyx_unpickle_Or, __pyx_k_hk_A_1_uuwwx_2XQa_7_AU_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[145])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 11, 51}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_pyx_result, __pyx_mstate->__pyx_n_u_pyx_state, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[146] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_pyx_unpickle_Or__set_state, __pyx_k_k_s_D_q_a_IWA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[146])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 75}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_pyx_type, __pyx_mstate->__pyx_n_u_pyx_checksum, __pyx_mstate->__pyx_n_u_pyx_state, __pyx_mstate->__pyx_n_u_pyx_PickleError, __pyx_mstate->__pyx_n_u_pyx_result}; + __pyx_mstate_global->__pyx_codeobj_tab[147] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_pyx_unpickle_Not, __pyx_k_hk_A_1_ttvvw_3haq_7_QfN_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[147])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 11, 51}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_pyx_result, __pyx_mstate->__pyx_n_u_pyx_state, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[148] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_pyx_unpickle_Not__set_state, __pyx_k_s_D_q_a_IWA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[148])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 86}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_pyx_type, __pyx_mstate->__pyx_n_u_pyx_checksum, __pyx_mstate->__pyx_n_u_pyx_state, __pyx_mstate->__pyx_n_u_pyx_PickleError, __pyx_mstate->__pyx_n_u_pyx_result}; + __pyx_mstate_global->__pyx_codeobj_tab[149] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_pyx_unpickle_Backlog, __pyx_k_hk_A_1_r_r_t_t_u_7_1_7_N_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[149])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 11, 287}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_pyx_result, __pyx_mstate->__pyx_n_u_pyx_state, __pyx_mstate->__pyx_n_u_ALLOWED_KEYS, __pyx_mstate->__pyx_n_u_ALLOWED_OPERATORS, __pyx_mstate->__pyx_n_u_Event_getters}; + __pyx_mstate_global->__pyx_codeobj_tab[150] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_pyx_unpickle_Backlog__set_stat, __pyx_k_at_KqPTT_jjuuvvz_G_G_T_T_____d, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[150])) goto bad; + } + Py_DECREF(tuple_dedup_map); + return 0; + bad: + Py_DECREF(tuple_dedup_map); + return -1; +} +/* #### Code section: init_globals ### */ + +static int __Pyx_InitGlobals(void) { + /* PythonCompatibility.init */ + if (likely(__Pyx_init_co_variables() == 0)); else + +if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + /* CachedMethodType.init */ + #if CYTHON_COMPILING_IN_LIMITED_API +{ + PyObject *typesModule=NULL; + typesModule = PyImport_ImportModule("types"); + if (typesModule) { + __pyx_mstate_global->__Pyx_CachedMethodType = PyObject_GetAttrString(typesModule, "MethodType"); + Py_DECREF(typesModule); + } +} // error handling follows +#endif + +if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: cleanup_globals ### */ +/* #### Code section: cleanup_module ### */ +/* #### Code section: main_method ### */ +/* #### Code section: utility_code_pragmas ### */ +#ifdef _MSC_VER +#pragma warning( push ) +/* Warning 4127: conditional expression is constant + * Cython uses constant conditional expressions to allow in inline functions to be optimized at + * compile-time, so this warning is not useful + */ +#pragma warning( disable : 4127 ) +#endif + + + +/* #### Code section: utility_code_def ### */ + +/* --- 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(modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, "RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +/* PyErrExceptionMatches */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); + for (i=0; i= 0x030C00A6 + PyObject *current_exception = tstate->current_exception; + if (unlikely(!current_exception)) return 0; + exc_type = (PyObject*) Py_TYPE(current_exception); + if (exc_type == err) return 1; +#else + exc_type = tstate->curexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; +#endif + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(exc_type); + #endif + if (unlikely(PyTuple_Check(err))) { + result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + } else { + result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err); + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(exc_type); + #endif + return result; +} +#endif + +/* PyErrFetchRestore */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject *tmp_value; + assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value))); + if (value) { + #if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb)) + #endif + PyException_SetTraceback(value, tb); + } + tmp_value = tstate->current_exception; + tstate->current_exception = value; + Py_XDECREF(tmp_value); + Py_XDECREF(type); + Py_XDECREF(tb); +#else + 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); +#endif +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject* exc_value; + exc_value = tstate->current_exception; + tstate->current_exception = 0; + *value = exc_value; + *type = NULL; + *tb = NULL; + if (exc_value) { + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + #if CYTHON_COMPILING_IN_CPYTHON + *tb = ((PyBaseExceptionObject*) exc_value)->traceback; + Py_XINCREF(*tb); + #else + *tb = PyException_GetTraceback(exc_value); + #endif + } +#else + *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 +} +#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); + return PyObject_GetAttr(obj, attr_name); +} +#endif + +/* PyObjectGetAttrStrNoError */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d0000 +static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + __Pyx_PyErr_Clear(); +} +#endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { + PyObject *result; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + (void) PyObject_GetOptionalAttr(obj, attr_name, &result); + return result; +#else +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { + return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); + } +#endif + result = __Pyx_PyObject_GetAttrStr(obj, attr_name); + if (unlikely(!result)) { + __Pyx_PyObject_GetAttrStr_ClearAttributeError(); + } + return result; +#endif +} + +/* GetBuiltinName */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_mstate_global->__pyx_b, name); + if (unlikely(!result) && !PyErr_Occurred()) { + PyErr_Format(PyExc_NameError, + "name '%U' is not defined", name); + } + return result; +} + +/* TupleAndListFromArray */ +#if !CYTHON_COMPILING_IN_CPYTHON && CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject * +__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + Py_ssize_t i; + if (n <= 0) { + return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_tuple); + } + res = PyTuple_New(n); + if (unlikely(res == NULL)) return NULL; + for (i = 0; i < n; i++) { + if (unlikely(__Pyx_PyTuple_SET_ITEM(res, i, src[i]) < 0)) { + Py_DECREF(res); + return NULL; + } + Py_INCREF(src[i]); + } + return res; +} +#elif CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) { + PyObject *v; + Py_ssize_t i; + for (i = 0; i < length; i++) { + v = dest[i] = src[i]; + Py_INCREF(v); + } +} +static CYTHON_INLINE PyObject * +__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_tuple); + } + res = PyTuple_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n); + return res; +} +static CYTHON_INLINE PyObject * +__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + return PyList_New(0); + } + res = PyList_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n); + return res; +} +#endif + +/* BytesEquals */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL ||\ + !(CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS) + return PyObject_RichCompareBool(s1, s2, equals); +#else + if (s1 == s2) { + return (equals == Py_EQ); + } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { + const char *ps1, *ps2; + Py_ssize_t length = PyBytes_GET_SIZE(s1); + if (length != PyBytes_GET_SIZE(s2)) + return (equals == Py_NE); + ps1 = PyBytes_AS_STRING(s1); + ps2 = PyBytes_AS_STRING(s2); + if (ps1[0] != ps2[0]) { + return (equals == Py_NE); + } else if (length == 1) { + return (equals == Py_EQ); + } else { + int result; +#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000) + Py_hash_t hash1, hash2; + hash1 = ((PyBytesObject*)s1)->ob_shash; + hash2 = ((PyBytesObject*)s2)->ob_shash; + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + return (equals == Py_NE); + } +#endif + result = memcmp(ps1, ps2, (size_t)length); + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { + return (equals == Py_NE); + } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { + return (equals == Py_NE); + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +#endif +} + +/* UnicodeEquals */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL + return PyObject_RichCompareBool(s1, s2, equals); +#else + int s1_is_unicode, s2_is_unicode; + if (s1 == s2) { + goto return_eq; + } + s1_is_unicode = PyUnicode_CheckExact(s1); + s2_is_unicode = PyUnicode_CheckExact(s2); + if (s1_is_unicode & s2_is_unicode) { + Py_ssize_t length, length2; + int kind; + void *data1, *data2; + #if !CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) + return -1; + #endif + length = __Pyx_PyUnicode_GET_LENGTH(s1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(length < 0)) return -1; + #endif + length2 = __Pyx_PyUnicode_GET_LENGTH(s2); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(length2 < 0)) return -1; + #endif + if (length != length2) { + goto return_ne; + } +#if CYTHON_USE_UNICODE_INTERNALS + { + Py_hash_t hash1, hash2; + hash1 = ((PyASCIIObject*)s1)->hash; + hash2 = ((PyASCIIObject*)s2)->hash; + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + goto return_ne; + } + } +#endif + kind = __Pyx_PyUnicode_KIND(s1); + if (kind != __Pyx_PyUnicode_KIND(s2)) { + goto return_ne; + } + data1 = __Pyx_PyUnicode_DATA(s1); + data2 = __Pyx_PyUnicode_DATA(s2); + if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { + goto return_ne; + } else if (length == 1) { + goto return_eq; + } else { + int result = memcmp(data1, data2, (size_t)(length * kind)); + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & s2_is_unicode) { + goto return_ne; + } else if ((s2 == Py_None) & s1_is_unicode) { + goto return_ne; + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +return_eq: + return (equals == Py_EQ); +return_ne: + return (equals == Py_NE); +#endif +} + +/* fastcall */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) +{ + Py_ssize_t i, n = __Pyx_PyTuple_GET_SIZE(kwnames); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(n == -1)) return NULL; + #endif + for (i = 0; i < n; i++) + { + PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!namei)) return NULL; + #endif + if (s == namei) return kwvalues[i]; + } + for (i = 0; i < n; i++) + { + PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!namei)) return NULL; + #endif + int eq = __Pyx_PyUnicode_Equals(s, namei, Py_EQ); + if (unlikely(eq != 0)) { + if (unlikely(eq < 0)) return NULL; + return kwvalues[i]; + } + } + return NULL; +} +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API +CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { + Py_ssize_t i, nkwargs; + PyObject *dict; +#if !CYTHON_ASSUME_SAFE_SIZE + nkwargs = PyTuple_Size(kwnames); + if (unlikely(nkwargs < 0)) return NULL; +#else + nkwargs = PyTuple_GET_SIZE(kwnames); +#endif + dict = PyDict_New(); + if (unlikely(!dict)) + return NULL; + for (i=0; irecursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; + return result; +} +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject *const *args, Py_ssize_t nargs, PyObject *kwargs) { + PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); + PyObject *globals = PyFunction_GET_GLOBALS(func); + PyObject *argdefs = PyFunction_GET_DEFAULTS(func); + PyObject *closure; + PyObject *kwdefs; + 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 (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) { + return NULL; + } + if ( + co->co_kwonlyargcount == 0 && + 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); + kwdefs = PyFunction_GET_KW_DEFAULTS(func); + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); + Py_XDECREF(kwtuple); +done: + Py_LeaveRecursiveCall(); + return result; +} +#endif + +/* PyObjectCall */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = Py_TYPE(func)->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall(" 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 = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); + self = __Pyx_CyOrPyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall(" 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 + +/* PyObjectFastCall */ +#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API +static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject * const*args, size_t nargs, PyObject *kwargs) { + PyObject *argstuple; + PyObject *result = 0; + size_t i; + argstuple = PyTuple_New((Py_ssize_t)nargs); + if (unlikely(!argstuple)) return NULL; + for (i = 0; i < nargs; i++) { + Py_INCREF(args[i]); + if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) != (0)) goto bad; + } + result = __Pyx_PyObject_Call(func, argstuple, kwargs); + bad: + Py_DECREF(argstuple); + return result; +} +#endif +#if CYTHON_VECTORCALL && !CYTHON_COMPILING_IN_LIMITED_API + #if PY_VERSION_HEX < 0x03090000 + #define __Pyx_PyVectorcall_Function(callable) _PyVectorcall_Function(callable) + #elif CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE vectorcallfunc __Pyx_PyVectorcall_Function(PyObject *callable) { + PyTypeObject *tp = Py_TYPE(callable); + #if defined(__Pyx_CyFunction_USED) + if (__Pyx_CyFunction_CheckExact(callable)) { + return __Pyx_CyFunction_func_vectorcall(callable); + } + #endif + if (!PyType_HasFeature(tp, Py_TPFLAGS_HAVE_VECTORCALL)) { + return NULL; + } + assert(PyCallable_Check(callable)); + Py_ssize_t offset = tp->tp_vectorcall_offset; + assert(offset > 0); + vectorcallfunc ptr; + memcpy(&ptr, (char *) callable + offset, sizeof(ptr)); + return ptr; +} + #else + #define __Pyx_PyVectorcall_Function(callable) PyVectorcall_Function(callable) + #endif +#endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject *const *args, size_t _nargs, PyObject *kwargs) { + Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs); +#if CYTHON_COMPILING_IN_CPYTHON + if (nargs == 0 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS)) + return __Pyx_PyObject_CallMethO(func, NULL); + } + else if (nargs == 1 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O)) + return __Pyx_PyObject_CallMethO(func, args[0]); + } +#endif + #if PY_VERSION_HEX < 0x030800B1 + #if CYTHON_FAST_PYCCALL + if (PyCFunction_Check(func)) { + if (kwargs) { + return _PyCFunction_FastCallDict(func, args, nargs, kwargs); + } else { + return _PyCFunction_FastCallKeywords(func, args, nargs, NULL); + } + } + if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) { + return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL); + } + #endif + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs); + } + #endif + #endif + if (kwargs == NULL) { + #if CYTHON_VECTORCALL && !CYTHON_COMPILING_IN_LIMITED_API + vectorcallfunc f = __Pyx_PyVectorcall_Function(func); + if (f) { + return f(func, args, _nargs, NULL); + } + #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL + if (__Pyx_CyFunction_CheckExact(func)) { + __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func); + if (f) return f(func, args, _nargs, NULL); + } + #elif CYTHON_COMPILING_IN_LIMITED_API && CYTHON_VECTORCALL + return PyObject_Vectorcall(func, args, _nargs, NULL); + #endif + } + if (nargs == 0) { + return __Pyx_PyObject_Call(func, __pyx_mstate_global->__pyx_empty_tuple, kwargs); + } + #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API + return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs); + #else + return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs); + #endif +} + +/* UnpackUnboundCMethod */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030C0000 +static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *args, PyObject *kwargs) { + PyObject *result; + PyObject *selfless_args = PyTuple_GetSlice(args, 1, PyTuple_Size(args)); + if (unlikely(!selfless_args)) return NULL; + result = PyObject_Call(method, selfless_args, kwargs); + Py_DECREF(selfless_args); + return result; +} +#elif CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03090000 +static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject **args, Py_ssize_t nargs, PyObject *kwnames) { + return _PyObject_Vectorcall + (method, args ? args+1 : NULL, nargs ? nargs-1 : 0, kwnames); +} +#else +static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) { + return +#if PY_VERSION_HEX < 0x03090000 + _PyObject_Vectorcall +#else + PyObject_Vectorcall +#endif + (method, args ? args+1 : NULL, nargs ? (size_t) nargs-1 : 0, kwnames); +} +#endif +static PyMethodDef __Pyx_UnboundCMethod_Def = { + "CythonUnboundCMethod", + __PYX_REINTERPRET_FUNCION(PyCFunction, __Pyx_SelflessCall), +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030C0000 + METH_VARARGS | METH_KEYWORDS, +#else + METH_FASTCALL | METH_KEYWORDS, +#endif + NULL +}; +static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) { + PyObject *method, *result=NULL; + method = __Pyx_PyObject_GetAttrStr(target->type, *target->method_name); + if (unlikely(!method)) + return -1; + result = method; +#if CYTHON_COMPILING_IN_CPYTHON + if (likely(__Pyx_TypeCheck(method, &PyMethodDescr_Type))) + { + PyMethodDescrObject *descr = (PyMethodDescrObject*) method; + target->func = descr->d_method->ml_meth; + target->flag = descr->d_method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_STACKLESS); + } else +#endif +#if CYTHON_COMPILING_IN_PYPY +#else + if (PyCFunction_Check(method)) +#endif + { + PyObject *self; + int self_found; +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + self = PyObject_GetAttrString(method, "__self__"); + if (!self) { + PyErr_Clear(); + } +#else + self = PyCFunction_GET_SELF(method); +#endif + self_found = (self && self != Py_None); +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + Py_XDECREF(self); +#endif + if (self_found) { + PyObject *unbound_method = PyCFunction_New(&__Pyx_UnboundCMethod_Def, method); + if (unlikely(!unbound_method)) return -1; + Py_DECREF(method); + result = unbound_method; + } + } +#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + if (unlikely(target->method)) { + Py_DECREF(result); + } else +#endif + target->method = result; + return 0; +} + +/* CallUnboundCMethod2 */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2) { + int was_initialized = __Pyx_CachedCFunction_GetAndSetInitializing(cfunc); + if (likely(was_initialized == 2 && cfunc->func)) { + PyObject *args[2] = {arg1, arg2}; + if (cfunc->flag == METH_FASTCALL) { + return __Pyx_CallCFunctionFast(cfunc, self, args, 2); + } + if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS)) + return __Pyx_CallCFunctionFastWithKeywords(cfunc, self, args, 2, NULL); + } +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + else if (unlikely(was_initialized == 1)) { + __Pyx_CachedCFunction tmp_cfunc = { +#ifndef __cplusplus + 0 +#endif + }; + tmp_cfunc.type = cfunc->type; + tmp_cfunc.method_name = cfunc->method_name; + return __Pyx__CallUnboundCMethod2(&tmp_cfunc, self, arg1, arg2); + } +#endif + PyObject *result = __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2); + __Pyx_CachedCFunction_SetFinishedInitializing(cfunc); + return result; +} +#endif +static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2){ + if (unlikely(!cfunc->func && !cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; +#if CYTHON_COMPILING_IN_CPYTHON + if (cfunc->func && (cfunc->flag & METH_VARARGS)) { + PyObject *result = NULL; + PyObject *args = PyTuple_New(2); + if (unlikely(!args)) return NULL; + Py_INCREF(arg1); + PyTuple_SET_ITEM(args, 0, arg1); + Py_INCREF(arg2); + PyTuple_SET_ITEM(args, 1, arg2); + if (cfunc->flag & METH_KEYWORDS) + result = __Pyx_CallCFunctionWithKeywords(cfunc, self, args, NULL); + else + result = __Pyx_CallCFunction(cfunc, self, args); + Py_DECREF(args); + return result; + } +#endif + { + PyObject *args[4] = {NULL, self, arg1, arg2}; + return __Pyx_PyObject_FastCall(cfunc->method, args+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); + } +} + +/* ParseKeywords */ +static int __Pyx_ValidateDuplicatePosArgs( + PyObject *kwds, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + const char* function_name) +{ + PyObject ** const *name = argnames; + while (name != first_kw_arg) { + PyObject *key = **name; + int found = PyDict_Contains(kwds, key); + if (unlikely(found)) { + if (found == 1) __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; + } + name++; + } + return 0; +bad: + return -1; +} +#if CYTHON_USE_UNICODE_INTERNALS +static CYTHON_INLINE int __Pyx_UnicodeKeywordsEqual(PyObject *s1, PyObject *s2) { + int kind; + Py_ssize_t len = PyUnicode_GET_LENGTH(s1); + if (len != PyUnicode_GET_LENGTH(s2)) return 0; + kind = PyUnicode_KIND(s1); + if (kind != PyUnicode_KIND(s2)) return 0; + const void *data1 = PyUnicode_DATA(s1); + const void *data2 = PyUnicode_DATA(s2); + return (memcmp(data1, data2, (size_t) len * (size_t) kind) == 0); +} +#endif +static int __Pyx_MatchKeywordArg_str( + PyObject *key, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + size_t *index_found, + const char *function_name) +{ + PyObject ** const *name; + #if CYTHON_USE_UNICODE_INTERNALS + Py_hash_t key_hash = ((PyASCIIObject*)key)->hash; + if (unlikely(key_hash == -1)) { + key_hash = PyObject_Hash(key); + if (unlikely(key_hash == -1)) + goto bad; + } + #endif + name = first_kw_arg; + while (*name) { + PyObject *name_str = **name; + #if CYTHON_USE_UNICODE_INTERNALS + if (key_hash == ((PyASCIIObject*)name_str)->hash && __Pyx_UnicodeKeywordsEqual(name_str, key)) { + *index_found = (size_t) (name - argnames); + return 1; + } + #else + #if CYTHON_ASSUME_SAFE_SIZE + if (PyUnicode_GET_LENGTH(name_str) == PyUnicode_GET_LENGTH(key)) + #endif + { + int cmp = PyUnicode_Compare(name_str, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + *index_found = (size_t) (name - argnames); + return 1; + } + } + #endif + name++; + } + name = argnames; + while (name != first_kw_arg) { + PyObject *name_str = **name; + #if CYTHON_USE_UNICODE_INTERNALS + if (unlikely(key_hash == ((PyASCIIObject*)name_str)->hash)) { + if (__Pyx_UnicodeKeywordsEqual(name_str, key)) + goto arg_passed_twice; + } + #else + #if CYTHON_ASSUME_SAFE_SIZE + if (PyUnicode_GET_LENGTH(name_str) == PyUnicode_GET_LENGTH(key)) + #endif + { + if (unlikely(name_str == key)) goto arg_passed_twice; + int cmp = PyUnicode_Compare(name_str, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + } + #endif + name++; + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +bad: + return -1; +} +static int __Pyx_MatchKeywordArg_nostr( + PyObject *key, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + size_t *index_found, + const char *function_name) +{ + PyObject ** const *name; + if (unlikely(!PyUnicode_Check(key))) goto invalid_keyword_type; + name = first_kw_arg; + while (*name) { + int cmp = PyObject_RichCompareBool(**name, key, Py_EQ); + if (cmp == 1) { + *index_found = (size_t) (name - argnames); + return 1; + } + if (unlikely(cmp == -1)) goto bad; + name++; + } + name = argnames; + while (name != first_kw_arg) { + int cmp = PyObject_RichCompareBool(**name, key, Py_EQ); + if (unlikely(cmp != 0)) { + if (cmp == 1) goto arg_passed_twice; + else goto bad; + } + name++; + } + 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; +bad: + return -1; +} +static CYTHON_INLINE int __Pyx_MatchKeywordArg( + PyObject *key, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + size_t *index_found, + const char *function_name) +{ + return likely(PyUnicode_CheckExact(key)) ? + __Pyx_MatchKeywordArg_str(key, argnames, first_kw_arg, index_found, function_name) : + __Pyx_MatchKeywordArg_nostr(key, argnames, first_kw_arg, index_found, function_name); +} +static void __Pyx_RejectUnknownKeyword( + PyObject *kwds, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + const char *function_name) +{ + Py_ssize_t pos = 0; + PyObject *key = NULL; + __Pyx_BEGIN_CRITICAL_SECTION(kwds); + while (PyDict_Next(kwds, &pos, &key, NULL)) { + PyObject** const *name = first_kw_arg; + while (*name && (**name != key)) name++; + if (!*name) { + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(key); + #endif + size_t index_found = 0; + int cmp = __Pyx_MatchKeywordArg(key, argnames, first_kw_arg, &index_found, function_name); + if (cmp != 1) { + if (cmp == 0) { + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(key); + #endif + break; + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(key); + #endif + } + } + __Pyx_END_CRITICAL_SECTION(); + assert(PyErr_Occurred()); +} +static int __Pyx_ParseKeywordDict( + PyObject *kwds, + PyObject ** const argnames[], + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs) +{ + PyObject** const *name; + PyObject** const *first_kw_arg = argnames + num_pos_args; + Py_ssize_t extracted = 0; +#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) + if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return -1; +#endif + name = first_kw_arg; + while (*name && num_kwargs > extracted) { + PyObject * key = **name; + PyObject *value; + int found = 0; + #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + found = PyDict_GetItemRef(kwds, key, &value); + #else + value = PyDict_GetItemWithError(kwds, key); + if (value) { + Py_INCREF(value); + found = 1; + } else { + if (unlikely(PyErr_Occurred())) goto bad; + } + #endif + if (found) { + if (unlikely(found < 0)) goto bad; + values[name-argnames] = value; + extracted++; + } + name++; + } + if (num_kwargs > extracted) { + if (ignore_unknown_kwargs) { + if (unlikely(__Pyx_ValidateDuplicatePosArgs(kwds, argnames, first_kw_arg, function_name) == -1)) + goto bad; + } else { + __Pyx_RejectUnknownKeyword(kwds, argnames, first_kw_arg, function_name); + goto bad; + } + } + return 0; +bad: + return -1; +} +static int __Pyx_ParseKeywordDictToDict( + PyObject *kwds, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject** const *name; + PyObject** const *first_kw_arg = argnames + num_pos_args; + Py_ssize_t len; +#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) + if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return -1; +#endif + if (PyDict_Update(kwds2, kwds) < 0) goto bad; + name = first_kw_arg; + while (*name) { + PyObject *key = **name; + PyObject *value; +#if !CYTHON_COMPILING_IN_LIMITED_API && (PY_VERSION_HEX >= 0x030d00A2 || defined(PyDict_Pop)) + int found = PyDict_Pop(kwds2, key, &value); + if (found) { + if (unlikely(found < 0)) goto bad; + values[name-argnames] = value; + } +#elif __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + int found = PyDict_GetItemRef(kwds2, key, &value); + if (found) { + if (unlikely(found < 0)) goto bad; + values[name-argnames] = value; + if (unlikely(PyDict_DelItem(kwds2, key) < 0)) goto bad; + } +#else + #if CYTHON_COMPILING_IN_CPYTHON + value = _PyDict_Pop(kwds2, key, kwds2); + #else + value = __Pyx_CallUnboundCMethod2(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_pop, kwds2, key, kwds2); + #endif + if (value == kwds2) { + Py_DECREF(value); + } else { + if (unlikely(!value)) goto bad; + values[name-argnames] = value; + } +#endif + name++; + } + len = PyDict_Size(kwds2); + if (len > 0) { + return __Pyx_ValidateDuplicatePosArgs(kwds, argnames, first_kw_arg, function_name); + } else if (unlikely(len == -1)) { + goto bad; + } + return 0; +bad: + return -1; +} +static int __Pyx_ParseKeywordsTuple( + PyObject *kwds, + PyObject * const *kwvalues, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs) +{ + PyObject *key = NULL; + PyObject** const * name; + PyObject** const *first_kw_arg = argnames + num_pos_args; + for (Py_ssize_t pos = 0; pos < num_kwargs; pos++) { +#if CYTHON_AVOID_BORROWED_REFS + key = __Pyx_PySequence_ITEM(kwds, pos); +#else + key = __Pyx_PyTuple_GET_ITEM(kwds, pos); +#endif +#if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!key)) goto bad; +#endif + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + PyObject *value = kwvalues[pos]; + values[name-argnames] = __Pyx_NewRef(value); + } else { + size_t index_found = 0; + int cmp = __Pyx_MatchKeywordArg(key, argnames, first_kw_arg, &index_found, function_name); + if (cmp == 1) { + PyObject *value = kwvalues[pos]; + values[index_found] = __Pyx_NewRef(value); + } else { + if (unlikely(cmp == -1)) goto bad; + if (kwds2) { + PyObject *value = kwvalues[pos]; + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else if (!ignore_unknown_kwargs) { + goto invalid_keyword; + } + } + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(key); + key = NULL; + #endif + } + return 0; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + goto bad; +bad: + #if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(key); + #endif + return -1; +} +static int __Pyx_ParseKeywords( + PyObject *kwds, + PyObject * const *kwvalues, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs) +{ + if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds))) + return __Pyx_ParseKeywordsTuple(kwds, kwvalues, argnames, kwds2, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs); + else if (kwds2) + return __Pyx_ParseKeywordDictToDict(kwds, argnames, kwds2, values, num_pos_args, function_name); + else + return __Pyx_ParseKeywordDict(kwds, argnames, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs); +} + +/* 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); +} + +/* ArgTypeTest */ +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +{ + __Pyx_TypeName type_name; + __Pyx_TypeName obj_type_name; + PyObject *extra_info = __pyx_mstate_global->__pyx_empty_unicode; + int from_annotation_subclass = 0; + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + else if (!exact) { + if (likely(__Pyx_TypeCheck(obj, type))) return 1; + } else if (exact == 2) { + if (__Pyx_TypeCheck(obj, type)) { + from_annotation_subclass = 1; + extra_info = __pyx_mstate_global->__pyx_kp_u_Note_that_Cython_is_deliberately; + } + } + type_name = __Pyx_PyType_GetFullyQualifiedName(type); + obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME + ", got " __Pyx_FMT_TYPENAME ")" +#if __PYX_LIMITED_VERSION_HEX < 0x030C0000 + "%s%U" +#endif + , name, type_name, obj_type_name +#if __PYX_LIMITED_VERSION_HEX < 0x030C0000 + , (from_annotation_subclass ? ". " : ""), extra_info +#endif + ); +#if __PYX_LIMITED_VERSION_HEX >= 0x030C0000 + if (exact == 2 && from_annotation_subclass) { + PyObject *res; + PyObject *vargs[2]; + vargs[0] = PyErr_GetRaisedException(); + vargs[1] = extra_info; + res = PyObject_VectorcallMethod(__pyx_mstate_global->__pyx_kp_u_add_note, vargs, 2, NULL); + Py_XDECREF(res); + PyErr_SetRaisedException(vargs[0]); + } +#endif + __Pyx_DECREF_TypeName(type_name); + __Pyx_DECREF_TypeName(obj_type_name); + return 0; +} +/* Profile */ +#if CYTHON_PROFILE || CYTHON_TRACE +#if CYTHON_TRACE && !CYTHON_USE_SYS_MONITORING +static int __Pyx_call_line_trace_func(PyThreadState *tstate, PyFrameObject *frame, int line) { + int ret; + PyObject *type, *value, *traceback; + __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); + __Pyx_PyFrame_SetLineNumber(frame, line); + __Pyx_EnterTracing(tstate); + ret = tstate->c_tracefunc(tstate->c_traceobj, frame, PyTrace_LINE, NULL); + __Pyx_LeaveTracing(tstate); + if (likely(!ret)) { + __Pyx_ErrRestoreInState(tstate, type, value, traceback); + } else { + Py_XDECREF(type); + Py_XDECREF(value); + Py_XDECREF(traceback); + } + return ret; +} +#endif +CYTHON_UNUSED static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno) { + PyCodeObject *py_code = PyCode_NewEmpty(srcfile, funcname, firstlineno); + if (likely(py_code)) { + py_code->co_flags |= CO_OPTIMIZED | CO_NEWLOCALS; + } + return py_code; +} +#if CYTHON_USE_SYS_MONITORING +CYTHON_UNUSED static int __Pyx__TraceStartFunc(PyMonitoringState *state_array, PyObject *code_obj, int offset, int skip_event) { + int ret; + __pyx_monitoring_version_type version = 0; + ret = PyMonitoring_EnterScope(state_array, &version, __Pyx_MonitoringEventTypes, __Pyx_MonitoringEventTypes_CyFunc_count); + if (unlikely(ret == -1)) return -1; + return skip_event ? 0 : PyMonitoring_FirePyStartEvent(&state_array[__Pyx_Monitoring_PY_START], code_obj, offset); +} +CYTHON_UNUSED static int __Pyx__TraceStartGen(PyMonitoringState *state_array, __pyx_monitoring_version_type *version, PyObject *code_obj, int offset) { + int ret; + ret = PyMonitoring_EnterScope(state_array, version, __Pyx_MonitoringEventTypes, __Pyx_MonitoringEventTypes_CyGen_count); + if (unlikely(ret == -1)) return -1; + return PyMonitoring_FirePyStartEvent(&state_array[__Pyx_Monitoring_PY_START], code_obj, offset); +} +CYTHON_UNUSED static int __Pyx__TraceResumeGen(PyMonitoringState *state_array, __pyx_monitoring_version_type *version, PyObject *code_obj, int offset) { + int ret; + ret = PyMonitoring_EnterScope(state_array, version, __Pyx_MonitoringEventTypes, __Pyx_MonitoringEventTypes_CyGen_count); + if (unlikely(ret == -1)) return -1; + return PyMonitoring_FirePyResumeEvent(&state_array[__Pyx_Monitoring_PY_RESUME], code_obj, offset); +} +CYTHON_UNUSED static void __Pyx__TraceException(PyMonitoringState *monitoring_state, PyObject *code_obj, int offset, int reraised) { + if (reraised) { + (void) PyMonitoring_FireReraiseEvent(monitoring_state, code_obj, offset); + } else { + (void) PyMonitoring_FireRaiseEvent(monitoring_state, code_obj, offset); + } +} +#if CYTHON_TRACE +CYTHON_UNUSED static int __Pyx__TraceLine(PyMonitoringState *monitoring_state, PyObject *code_obj, int line, int offset) { + int ret; + PyObject *exc = PyErr_GetRaisedException(); + ret = PyMonitoring_FireLineEvent(monitoring_state, code_obj, offset, line); + if (exc) PyErr_SetRaisedException(exc); + return ret; +} +#endif +#else +static int __Pyx_TraceSetupAndCall(PyCodeObject** code, + PyFrameObject** frame, + PyThreadState* tstate, + const char *funcname, + const char *srcfile, + int firstlineno, + int skip_event) { + if (*frame == NULL || !CYTHON_PROFILE_REUSE_FRAME) { + int needs_new_code_obj = (*code == NULL); + if (needs_new_code_obj) { + *code = __Pyx_createFrameCodeObject(funcname, srcfile, firstlineno); + if (*code == NULL) return 0; + } + *frame = PyFrame_New( + tstate, /*PyThreadState *tstate*/ + *code, /*PyCodeObject *code*/ + __pyx_mstate_global->__pyx_d, /*PyObject *globals*/ + 0 /*PyObject *locals*/ + ); + if (needs_new_code_obj && !CYTHON_PROFILE_REUSE_CODEOBJ) + Py_CLEAR(*code); // otherwise the reference is owned externally + if (*frame == NULL) return 0; + if (CYTHON_TRACE && (*frame)->f_trace == NULL) { + Py_INCREF(Py_None); + (*frame)->f_trace = Py_None; + } + } + if (!skip_event) { + PyObject *type, *value, *traceback; + int retval = 1; + __Pyx_PyFrame_SetLineNumber(*frame, firstlineno); + __Pyx_EnterTracing(tstate); + __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); + #if CYTHON_TRACE + if (tstate->c_tracefunc) + retval = tstate->c_tracefunc(tstate->c_traceobj, *frame, PyTrace_CALL, NULL) == 0; + if (retval && tstate->c_profilefunc) + #endif + retval = tstate->c_profilefunc(tstate->c_profileobj, *frame, PyTrace_CALL, NULL) == 0; + __Pyx_LeaveTracing(tstate); + if (unlikely(!retval)) { + Py_XDECREF(type); + Py_XDECREF(value); + Py_XDECREF(traceback); + return -1; + } + __Pyx_ErrRestoreInState(tstate, type, value, traceback); + } + return __Pyx_IsTracing(tstate, 0, 0); +} +#endif +#endif - /* "(tree fragment)":1 - * def __pyx_unpickle_Or(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ - __Pyx_TraceLine(1,0,__PYX_ERR(2, 1, __pyx_L1_error)) - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6hunter_11_predicates_9__pyx_unpickle_Or, NULL, __pyx_n_s_hunter__predicates); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Or, __pyx_t_1) < 0) __PYX_ERR(2, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; +/* LimitedApiGetTypeDict */ +#if CYTHON_COMPILING_IN_LIMITED_API +static Py_ssize_t __Pyx_GetTypeDictOffset(void) { + PyObject *tp_dictoffset_o; + Py_ssize_t tp_dictoffset; + tp_dictoffset_o = PyObject_GetAttrString((PyObject*)(&PyType_Type), "__dictoffset__"); + if (unlikely(!tp_dictoffset_o)) return -1; + tp_dictoffset = PyLong_AsSsize_t(tp_dictoffset_o); + Py_DECREF(tp_dictoffset_o); + if (unlikely(tp_dictoffset == 0)) { + PyErr_SetString( + PyExc_TypeError, + "'type' doesn't have a dictoffset"); + return -1; + } else if (unlikely(tp_dictoffset < 0)) { + PyErr_SetString( + PyExc_TypeError, + "'type' has an unexpected negative dictoffset. " + "Please report this as Cython bug"); + return -1; + } + return tp_dictoffset; +} +static PyObject *__Pyx_GetTypeDict(PyTypeObject *tp) { + static Py_ssize_t tp_dictoffset = 0; + if (unlikely(tp_dictoffset == 0)) { + tp_dictoffset = __Pyx_GetTypeDictOffset(); + if (unlikely(tp_dictoffset == -1 && PyErr_Occurred())) { + tp_dictoffset = 0; // try again next time? + return NULL; + } + } + return *(PyObject**)((char*)tp + tp_dictoffset); +} +#endif - /* "(tree fragment)":11 - * __pyx_unpickle_Or__set_state( __pyx_result, __pyx_state) - * return __pyx_result - * cdef __pyx_unpickle_Or__set_state(Or __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< - * __pyx_result.predicates = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): - */ - __Pyx_TraceLine(11,0,__PYX_ERR(2, 11, __pyx_L1_error)) +/* SetItemOnTypeDict */ +static int __Pyx__SetItemOnTypeDict(PyTypeObject *tp, PyObject *k, PyObject *v) { + int result; + PyObject *tp_dict; +#if CYTHON_COMPILING_IN_LIMITED_API + tp_dict = __Pyx_GetTypeDict(tp); + if (unlikely(!tp_dict)) return -1; +#else + tp_dict = tp->tp_dict; +#endif + result = PyDict_SetItem(tp_dict, k, v); + if (likely(!result)) { + PyType_Modified(tp); + if (unlikely(PyObject_HasAttr(v, __pyx_mstate_global->__pyx_n_u_set_name))) { + PyObject *setNameResult = PyObject_CallMethodObjArgs(v, __pyx_mstate_global->__pyx_n_u_set_name, (PyObject *) tp, k, NULL); + if (!setNameResult) return -1; + Py_DECREF(setNameResult); + } + } + return result; +} +/* FixUpExtensionType */ +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) { +#if __PYX_LIMITED_VERSION_HEX > 0x030900B1 + CYTHON_UNUSED_VAR(spec); + CYTHON_UNUSED_VAR(type); + CYTHON_UNUSED_VAR(__Pyx__SetItemOnTypeDict); +#else + const PyType_Slot *slot = spec->slots; + int changed = 0; +#if !CYTHON_COMPILING_IN_LIMITED_API + while (slot && slot->slot && slot->slot != Py_tp_members) + slot++; + if (slot && slot->slot == Py_tp_members) { +#if !CYTHON_COMPILING_IN_CPYTHON + const +#endif // !CYTHON_COMPILING_IN_CPYTHON) + PyMemberDef *memb = (PyMemberDef*) slot->pfunc; + while (memb && memb->name) { + if (memb->name[0] == '_' && memb->name[1] == '_') { + if (strcmp(memb->name, "__weaklistoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_weaklistoffset = memb->offset; + changed = 1; + } + else if (strcmp(memb->name, "__dictoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_dictoffset = memb->offset; + changed = 1; + } +#if CYTHON_METH_FASTCALL + else if (strcmp(memb->name, "__vectorcalloffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); +#if PY_VERSION_HEX >= 0x030800b4 + type->tp_vectorcall_offset = memb->offset; +#else + type->tp_print = (printfunc) memb->offset; +#endif + changed = 1; + } +#endif // CYTHON_METH_FASTCALL +#if !CYTHON_COMPILING_IN_PYPY + else if (strcmp(memb->name, "__module__") == 0) { + PyObject *descr; + assert(memb->type == T_OBJECT); + assert(memb->flags == 0 || memb->flags == READONLY); + descr = PyDescr_NewMember(type, memb); + if (unlikely(!descr)) + return -1; + int set_item_result = PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr); + Py_DECREF(descr); + if (unlikely(set_item_result < 0)) { + return -1; + } + changed = 1; + } +#endif // !CYTHON_COMPILING_IN_PYPY + } + memb++; + } + } +#endif // !CYTHON_COMPILING_IN_LIMITED_API +#if !CYTHON_COMPILING_IN_PYPY + slot = spec->slots; + while (slot && slot->slot && slot->slot != Py_tp_getset) + slot++; + if (slot && slot->slot == Py_tp_getset) { + PyGetSetDef *getset = (PyGetSetDef*) slot->pfunc; + while (getset && getset->name) { + if (getset->name[0] == '_' && getset->name[1] == '_' && strcmp(getset->name, "__module__") == 0) { + PyObject *descr = PyDescr_NewGetSet(type, getset); + if (unlikely(!descr)) + return -1; + #if CYTHON_COMPILING_IN_LIMITED_API + PyObject *pyname = PyUnicode_FromString(getset->name); + if (unlikely(!pyname)) { + Py_DECREF(descr); + return -1; + } + int set_item_result = __Pyx_SetItemOnTypeDict(type, pyname, descr); + Py_DECREF(pyname); + #else + CYTHON_UNUSED_VAR(__Pyx__SetItemOnTypeDict); + int set_item_result = PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr); + #endif + Py_DECREF(descr); + if (unlikely(set_item_result < 0)) { + return -1; + } + changed = 1; + } + ++getset; + } + } +#endif // !CYTHON_COMPILING_IN_PYPY + if (changed) + PyType_Modified(type); +#endif // PY_VERSION_HEX > 0x030900B1 + return 0; +} - /* "(tree fragment)":1 - * def __pyx_unpickle_Not(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ - __Pyx_TraceLine(1,0,__PYX_ERR(2, 1, __pyx_L1_error)) - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6hunter_11_predicates_11__pyx_unpickle_Not, NULL, __pyx_n_s_hunter__predicates); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Not, __pyx_t_1) < 0) __PYX_ERR(2, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; +/* FetchSharedCythonModule */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void) { + return __Pyx_PyImport_AddModuleRef(__PYX_ABI_MODULE_NAME); +} - /* "(tree fragment)":11 - * __pyx_unpickle_Not__set_state( __pyx_result, __pyx_state) - * return __pyx_result - * cdef __pyx_unpickle_Not__set_state(Not __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< - * __pyx_result.predicate = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): - */ - __Pyx_TraceLine(11,0,__PYX_ERR(2, 11, __pyx_L1_error)) +/* dict_setdefault */ +static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value, + int is_safe_type) { + PyObject* value; + CYTHON_MAYBE_UNUSED_VAR(is_safe_type); +#if CYTHON_COMPILING_IN_LIMITED_API + value = PyObject_CallMethod(d, "setdefault", "OO", key, default_value); +#elif PY_VERSION_HEX >= 0x030d0000 + PyDict_SetDefaultRef(d, key, default_value, &value); +#else + value = PyDict_SetDefault(d, key, default_value); + if (unlikely(!value)) return NULL; + Py_INCREF(value); +#endif + return value; +} +/* FetchCommonType */ +#if __PYX_LIMITED_VERSION_HEX < 0x030C0000 +static PyObject* __Pyx_PyType_FromMetaclass(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *result = __Pyx_PyType_FromModuleAndSpec(module, spec, bases); + if (result && metaclass) { + PyObject *old_tp = (PyObject*)Py_TYPE(result); + Py_INCREF((PyObject*)metaclass); +#if __PYX_LIMITED_VERSION_HEX >= 0x03090000 + Py_SET_TYPE(result, metaclass); +#else + result->ob_type = metaclass; +#endif + Py_DECREF(old_tp); + } + return result; +} +#else +#define __Pyx_PyType_FromMetaclass(me, mo, s, b) PyType_FromMetaclass(me, mo, s, b) +#endif +static int __Pyx_VerifyCachedType(PyObject *cached_type, + const char *name, + Py_ssize_t expected_basicsize) { + Py_ssize_t basicsize; + if (!PyType_Check(cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", name); + return -1; + } + if (expected_basicsize == 0) { + return 0; // size is inherited, nothing useful to check + } +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_basicsize; + py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); + if (unlikely(!py_basicsize)) return -1; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = NULL; + if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) return -1; +#else + basicsize = ((PyTypeObject*) cached_type)->tp_basicsize; +#endif + if (basicsize != expected_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + name); + return -1; + } + return 0; +} +static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *abi_module = NULL, *cached_type = NULL, *abi_module_dict, *new_cached_type, *py_object_name; + int get_item_ref_result; + const char* object_name = strrchr(spec->name, '.'); + object_name = object_name ? object_name+1 : spec->name; + py_object_name = PyUnicode_FromString(object_name); + if (!py_object_name) return NULL; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) goto done; + abi_module_dict = PyModule_GetDict(abi_module); + if (!abi_module_dict) goto done; + get_item_ref_result = __Pyx_PyDict_GetItemRef(abi_module_dict, py_object_name, &cached_type); + if (get_item_ref_result == 1) { + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + spec->basicsize) < 0) { + goto bad; + } + goto done; + } else if (unlikely(get_item_ref_result == -1)) { + goto bad; + } + CYTHON_UNUSED_VAR(module); + cached_type = __Pyx_PyType_FromMetaclass(metaclass, abi_module, spec, bases); + if (unlikely(!cached_type)) goto bad; + if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad; + new_cached_type = __Pyx_PyDict_SetDefault(abi_module_dict, py_object_name, cached_type, 1); + if (unlikely(new_cached_type != cached_type)) { + if (unlikely(!new_cached_type)) goto bad; + Py_DECREF(cached_type); + cached_type = new_cached_type; + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + spec->basicsize) < 0) { + goto bad; + } + goto done; + } else { + Py_DECREF(new_cached_type); + } +done: + Py_XDECREF(abi_module); + Py_DECREF(py_object_name); + assert(cached_type == NULL || PyType_Check(cached_type)); + return (PyTypeObject *) cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} - /* "hunter/_predicates.pyx":1 - * # cython: linetrace=True, language_level=3str # <<<<<<<<<<<<<< - * from __future__ import absolute_import - * - */ - __Pyx_TraceLine(1,0,__PYX_ERR(0, 1, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_TraceReturn(Py_None, 0); +/* CommonTypesMetaclass */ +static PyObject* __pyx_CommonTypesMetaclass_get_module(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED void* context) { + return PyUnicode_FromString(__PYX_ABI_MODULE_NAME); +} +static PyGetSetDef __pyx_CommonTypesMetaclass_getset[] = { + {"__module__", __pyx_CommonTypesMetaclass_get_module, NULL, NULL, NULL}, + {0, 0, 0, 0, 0} +}; +static PyType_Slot __pyx_CommonTypesMetaclass_slots[] = { + {Py_tp_getset, (void *)__pyx_CommonTypesMetaclass_getset}, + {0, 0} +}; +static PyType_Spec __pyx_CommonTypesMetaclass_spec = { + __PYX_TYPE_MODULE_PREFIX "_common_types_metatype", + 0, + 0, +#if PY_VERSION_HEX >= 0x030A0000 + Py_TPFLAGS_IMMUTABLETYPE | + Py_TPFLAGS_DISALLOW_INSTANTIATION | +#endif + Py_TPFLAGS_DEFAULT, + __pyx_CommonTypesMetaclass_slots +}; +static int __pyx_CommonTypesMetaclass_init(PyObject *module) { + __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module); + PyObject *bases = PyTuple_Pack(1, &PyType_Type); + if (unlikely(!bases)) { + return -1; + } + mstate->__pyx_CommonTypesMetaclassType = __Pyx_FetchCommonTypeFromSpec(NULL, module, &__pyx_CommonTypesMetaclass_spec, bases); + if (unlikely(mstate->__pyx_CommonTypesMetaclassType == NULL)) { + return -1; + } + return 0; +} - /*--- Wrapped vars code ---*/ +/* CallTypeTraverse */ +#if !CYTHON_USE_TYPE_SPECS || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x03090000) +#else +static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg) { + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x03090000 + if (__Pyx_get_runtime_version() < 0x03090000) return 0; + #endif + if (!always_call) { + PyTypeObject *base = __Pyx_PyObject_GetSlot(o, tp_base, PyTypeObject*); + unsigned long flags = PyType_GetFlags(base); + if (flags & Py_TPFLAGS_HEAPTYPE) { + return 0; + } + } + Py_VISIT((PyObject*)Py_TYPE(o)); + return 0; +} +#endif - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - if (__pyx_m) { - if (__pyx_d) { - __Pyx_AddTraceback("init hunter._predicates", __pyx_clineno, __pyx_lineno, __pyx_filename); +/* PyMethodNew */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + PyObject *result; + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + #if __PYX_LIMITED_VERSION_HEX >= 0x030C0000 + { + PyObject *args[] = {func, self}; + result = PyObject_Vectorcall(__pyx_mstate_global->__Pyx_CachedMethodType, args, 2, NULL); } - Py_CLEAR(__pyx_m); - } else if (!PyErr_Occurred()) { - PyErr_SetString(PyExc_ImportError, "init hunter._predicates"); - } - __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 + #else + result = PyObject_CallFunctionObjArgs(__pyx_mstate_global->__Pyx_CachedMethodType, func, self, NULL); + #endif + return result; +} +#else +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + return PyMethod_New(func, self); } +#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(modname); - if (!m) goto end; - p = PyObject_GetAttrString(m, "RefNannyAPI"); - if (!p) goto end; - r = PyLong_AsVoidPtr(p); -end: - Py_XDECREF(p); - Py_XDECREF(m); - return (__Pyx_RefNannyAPIStruct *)r; +/* PyVectorcallFastCallDict */ +#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL) +static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) +{ + PyObject *res = NULL; + PyObject *kwnames; + PyObject **newargs; + PyObject **kwvalues; + Py_ssize_t i, pos; + size_t j; + PyObject *key, *value; + unsigned long keys_are_strings; + #if !CYTHON_ASSUME_SAFE_SIZE + Py_ssize_t nkw = PyDict_Size(kw); + if (unlikely(nkw == -1)) return NULL; + #else + Py_ssize_t nkw = PyDict_GET_SIZE(kw); + #endif + newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0])); + if (unlikely(newargs == NULL)) { + PyErr_NoMemory(); + return NULL; + } + for (j = 0; j < nargs; j++) newargs[j] = args[j]; + kwnames = PyTuple_New(nkw); + if (unlikely(kwnames == NULL)) { + PyMem_Free(newargs); + return NULL; + } + kwvalues = newargs + nargs; + pos = i = 0; + keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS; + while (PyDict_Next(kw, &pos, &key, &value)) { + keys_are_strings &= + #if CYTHON_COMPILING_IN_LIMITED_API + PyType_GetFlags(Py_TYPE(key)); + #else + Py_TYPE(key)->tp_flags; + #endif + Py_INCREF(key); + Py_INCREF(value); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(PyTuple_SetItem(kwnames, i, key) < 0)) goto cleanup; + #else + PyTuple_SET_ITEM(kwnames, i, key); + #endif + kwvalues[i] = value; + i++; + } + if (unlikely(!keys_are_strings)) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + goto cleanup; + } + res = vc(func, newargs, nargs, kwnames); +cleanup: + Py_DECREF(kwnames); + for (i = 0; i < nkw; i++) + Py_DECREF(kwvalues[i]); + PyMem_Free(newargs); + return res; +} +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) +{ + Py_ssize_t kw_size = + likely(kw == NULL) ? + 0 : +#if !CYTHON_ASSUME_SAFE_SIZE + PyDict_Size(kw); +#else + PyDict_GET_SIZE(kw); +#endif + if (kw_size == 0) { + return vc(func, args, nargs, NULL); + } +#if !CYTHON_ASSUME_SAFE_SIZE + else if (unlikely(kw_size == -1)) { + return NULL; + } +#endif + return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); } #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)); +/* CythonFunctionShared */ +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunctionNoMethod(PyObject *func, void (*cfunc)(void)) { + if (__Pyx_CyFunction_Check(func)) { + return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc; + } else if (PyCFunction_Check(func)) { + return PyCFunction_GetFunction(func) == (PyCFunction) cfunc; + } + return 0; +} +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) { + if ((PyObject*)Py_TYPE(func) == __pyx_mstate_global->__Pyx_CachedMethodType) { + int result; + PyObject *newFunc = PyObject_GetAttr(func, __pyx_mstate_global->__pyx_n_u_func); + if (unlikely(!newFunc)) { + PyErr_Clear(); // It's only an optimization, so don't throw an error + return 0; + } + result = __Pyx__IsSameCyOrCFunctionNoMethod(newFunc, cfunc); + Py_DECREF(newFunc); + return result; + } + return __Pyx__IsSameCyOrCFunctionNoMethod(func, cfunc); +} +#else +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) { + if (PyMethod_Check(func)) { + func = PyMethod_GET_FUNCTION(func); + } + return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +} +#endif +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) { +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + __Pyx_Py_XDECREF_SET( + __Pyx_CyFunction_GetClassObj(f), + ((classobj) ? __Pyx_NewRef(classobj) : NULL)); +#else + __Pyx_Py_XDECREF_SET( + ((PyCMethodObject *) (f))->mm_class, + (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL)); #endif - return PyObject_GetAttr(obj, attr_name); } +static PyObject * +__Pyx_CyFunction_get_doc_locked(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_doc == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_doc = PyObject_GetAttrString(op->func, "__doc__"); + if (unlikely(!op->func_doc)) return NULL; +#else + if (((PyCFunctionObject*)op)->m_ml->ml_doc) { + op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); + if (unlikely(op->func_doc == NULL)) + return NULL; + } else { + Py_INCREF(Py_None); + return Py_None; + } #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); + } + Py_INCREF(op->func_doc); + return op->func_doc; +} +static PyObject * +__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) { + PyObject *result; + CYTHON_UNUSED_VAR(closure); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_doc_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (value == NULL) { + value = Py_None; + } + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_doc, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_name_locked(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_name == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_name = PyObject_GetAttrString(op->func, "__name__"); #else - "name '%.200s' is not defined", PyString_AS_STRING(name)); + op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); #endif + if (unlikely(op->func_name == NULL)) + return NULL; } + Py_INCREF(op->func_name); + return op->func_name; +} +static PyObject * +__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) +{ + PyObject *result = NULL; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_name_locked(op); + __Pyx_END_CRITICAL_SECTION(); 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) +static int +__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context) { - 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"; + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; } - if (exact) { - more_or_less = "exactly"; + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_name, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + PyObject *result; + __Pyx_BEGIN_CRITICAL_SECTION(op); + Py_INCREF(op->func_qualname); + result = op->func_qualname; + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_qualname, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_dict_locked(__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 PyObject * +__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + PyObject *result; + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_dict_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + 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; + } + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_dict, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + Py_INCREF(op->func_globals); + return op->func_globals; +} +static PyObject * +__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(op); + CYTHON_UNUSED_VAR(context); + Py_INCREF(Py_None); + return Py_None; +} +static PyObject * +__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context) +{ + PyObject* result = (op->func_code) ? op->func_code : Py_None; + CYTHON_UNUSED_VAR(context); + 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 = __Pyx_PySequence_ITEM(res, 0); + if (unlikely(!op->defaults_tuple)) result = -1; + else { + op->defaults_kwdict = __Pyx_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, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyTuple_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__defaults__ must be set to a tuple object"); + return -1; + } + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->defaults_tuple, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_defaults_locked(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_tuple; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_tuple; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = NULL; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_defaults_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__kwdefaults__ must be set to a dict object"); + return -1; + } + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults_locked(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_kwdict; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_kwdict; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_kwdefaults_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value || value == Py_None) { + value = NULL; + } else if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__annotations__ must be set to a dict object"); + return -1; + } + Py_XINCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_annotations, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_annotations_locked(__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 PyObject * +__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { + PyObject *result; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_annotations_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static PyObject * +__Pyx_CyFunction_get_is_coroutine_value(__pyx_CyFunctionObject *op) { + int is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; + if (is_coroutine) { + PyObject *is_coroutine_value, *module, *fromlist, *marker = __pyx_mstate_global->__pyx_n_u_is_coroutine; + fromlist = PyList_New(1); + if (unlikely(!fromlist)) return NULL; + Py_INCREF(marker); +#if CYTHON_ASSUME_SAFE_MACROS + PyList_SET_ITEM(fromlist, 0, marker); +#else + if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) { + Py_DECREF(marker); + Py_DECREF(fromlist); + return NULL; + } +#endif + module = PyImport_ImportModuleLevelObject(__pyx_mstate_global->__pyx_n_u_asyncio_coroutines, NULL, NULL, fromlist, 0); + Py_DECREF(fromlist); + if (unlikely(!module)) goto ignore; + is_coroutine_value = __Pyx_PyObject_GetAttrStr(module, marker); + Py_DECREF(module); + if (likely(is_coroutine_value)) { + return is_coroutine_value; + } +ignore: + PyErr_Clear(); + } + return __Pyx_PyBool_FromLong(is_coroutine); +} +static PyObject * +__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { + PyObject *result; + CYTHON_UNUSED_VAR(context); + if (op->func_is_coroutine) { + return __Pyx_NewRef(op->func_is_coroutine); + } + result = __Pyx_CyFunction_get_is_coroutine_value(op); + if (unlikely(!result)) + return NULL; + __Pyx_BEGIN_CRITICAL_SECTION(op); + if (op->func_is_coroutine) { + Py_DECREF(result); + result = __Pyx_NewRef(op->func_is_coroutine); + } else { + op->func_is_coroutine = __Pyx_NewRef(result); } + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static void __Pyx_CyFunction_raise_argument_count_error(__pyx_CyFunctionObject *func, const char* message, Py_ssize_t size) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_name = __Pyx_CyFunction_get_name(func, NULL); + if (!py_name) return; 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); + "%.200S() %s (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, message, size); + Py_DECREF(py_name); +#else + const char* name = ((PyCFunctionObject*)func)->m_ml->ml_name; + PyErr_Format(PyExc_TypeError, + "%.200s() %s (%" CYTHON_FORMAT_SSIZE_T "d given)", + name, message, size); +#endif } - -/* KeywordStringCheck */ -static int __Pyx_CheckKeywordStrings( - PyObject *kwdict, - const char* function_name, - int kw_allowed) +static void __Pyx_CyFunction_raise_type_error(__pyx_CyFunctionObject *func, const char* message) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_name = __Pyx_CyFunction_get_name(func, NULL); + if (!py_name) return; + PyErr_Format(PyExc_TypeError, + "%.200S() %s", + py_name, message); + Py_DECREF(py_name); +#else + const char* name = ((PyCFunctionObject*)func)->m_ml->ml_name; + PyErr_Format(PyExc_TypeError, + "%.200s() %s", + name, message); +#endif +} +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject * +__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_GetAttrString(op->func, "__module__"); +} +static int +__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_SetAttrString(op->func, "__module__", value); +} +#endif +static PyGetSetDef __pyx_CyFunction_getsets[] = { + {"func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {"__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {"func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {"__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {"__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, + {"func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {"__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {"func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {"__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {"func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {"__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {"func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {"__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {"func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {"__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {"__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {"__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {"_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0}, +#if CYTHON_COMPILING_IN_LIMITED_API + {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0}, +#endif + {0, 0, 0, 0, 0} +}; +static PyMemberDef __pyx_CyFunction_members[] = { +#if !CYTHON_COMPILING_IN_LIMITED_API + {"__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, +#endif + {"__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, +#if CYTHON_METH_FASTCALL +#if CYTHON_BACKPORT_VECTORCALL || CYTHON_COMPILING_IN_LIMITED_API + {"__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, +#else + {"__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + {"__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, +#else + {"__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, +#endif +#endif + {0, 0, 0, 0, 0} +}; +static PyObject * +__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args) +{ + PyObject *result = NULL; + CYTHON_UNUSED_VAR(args); + __Pyx_BEGIN_CRITICAL_SECTION(m); + Py_INCREF(m->func_qualname); + result = m->func_qualname; + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} +}; +#if CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) +#else +#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist) +#endif +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { +#if !CYTHON_COMPILING_IN_LIMITED_API + PyCFunctionObject *cf = (PyCFunctionObject*) op; +#endif + if (unlikely(op == NULL)) + return NULL; +#if CYTHON_COMPILING_IN_LIMITED_API + op->func = PyCFunction_NewEx(ml, (PyObject*)op, module); + if (unlikely(!op->func)) return NULL; +#endif + op->flags = flags; + __Pyx_CyFunction_weakreflist(op) = NULL; +#if !CYTHON_COMPILING_IN_LIMITED_API + cf->m_ml = ml; + cf->m_self = (PyObject *) op; +#endif + Py_XINCREF(closure); + op->func_closure = closure; +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_XINCREF(module); + cf->m_module = module; +#endif + op->func_dict = NULL; + op->func_name = NULL; + Py_INCREF(qualname); + op->func_qualname = qualname; + op->func_doc = NULL; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + op->func_classobj = NULL; +#else + ((PyCMethodObject*)op)->mm_class = NULL; +#endif + op->func_globals = globals; + Py_INCREF(op->func_globals); + Py_XINCREF(code); + op->func_code = code; + op->defaults = NULL; + op->defaults_tuple = NULL; + op->defaults_kwdict = NULL; + op->defaults_getter = NULL; + op->func_annotations = NULL; + op->func_is_coroutine = NULL; +#if CYTHON_METH_FASTCALL + switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) { + case METH_NOARGS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS; + break; + case METH_O: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O; + break; + case METH_METHOD | METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD; + break; + case METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS; + break; + case METH_VARARGS | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = NULL; + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + Py_DECREF(op); + return NULL; + } +#endif + return (PyObject *) op; +} +static int +__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) { - PyObject* key = 0; - Py_ssize_t pos = 0; -#if CYTHON_COMPILING_IN_PYPY - if (!kw_allowed && PyDict_Next(kwdict, &pos, &key, 0)) - goto invalid_keyword; - return 1; + Py_CLEAR(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_CLEAR(m->func); #else - while (PyDict_Next(kwdict, &pos, &key, 0)) { - #if PY_MAJOR_VERSION < 3 - if (unlikely(!PyString_Check(key))) - #endif - if (unlikely(!PyUnicode_Check(key))) - goto invalid_keyword_type; + Py_CLEAR(((PyCFunctionObject*)m)->m_module); +#endif + 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); +#if !CYTHON_COMPILING_IN_LIMITED_API +#if PY_VERSION_HEX < 0x030900B1 + Py_CLEAR(__Pyx_CyFunction_GetClassObj(m)); +#else + { + PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class; + ((PyCMethodObject *) (m))->mm_class = NULL; + Py_XDECREF(cls); } - if ((!kw_allowed) && unlikely(key)) - goto invalid_keyword; - return 1; -invalid_keyword_type: - PyErr_Format(PyExc_TypeError, - "%.200s() keywords must be strings", function_name); - return 0; #endif -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 +#endif + Py_CLEAR(m->defaults_tuple); + Py_CLEAR(m->defaults_kwdict); + Py_CLEAR(m->func_annotations); + Py_CLEAR(m->func_is_coroutine); + Py_CLEAR(m->defaults); return 0; } - -/* 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 void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + if (__Pyx_CyFunction_weakreflist(m) != NULL) + PyObject_ClearWeakRefs((PyObject *) m); + __Pyx_CyFunction_clear(m); + __Pyx_PyHeapTypeObject_GC_Del(m); } -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; +static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + PyObject_GC_UnTrack(m); + __Pyx__CyFunction_dealloc(m); } -#endif - -/* Profile */ -#if CYTHON_PROFILE -static int __Pyx_TraceSetupAndCall(PyCodeObject** code, - PyFrameObject** frame, - PyThreadState* tstate, - const char *funcname, - const char *srcfile, - int firstlineno) { - PyObject *type, *value, *traceback; - int retval; - if (*frame == NULL || !CYTHON_PROFILE_REUSE_FRAME) { - if (*code == NULL) { - *code = __Pyx_createFrameCodeObject(funcname, srcfile, firstlineno); - if (*code == NULL) return 0; +static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) +{ + { + int e = __Pyx_call_type_traverse((PyObject*)m, 1, visit, arg); + if (e) return e; + } + Py_VISIT(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(m->func); +#else + Py_VISIT(((PyCFunctionObject*)m)->m_module); +#endif + Py_VISIT(m->func_dict); + __Pyx_VISIT_CONST(m->func_name); + __Pyx_VISIT_CONST(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + __Pyx_VISIT_CONST(m->func_code); +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(__Pyx_CyFunction_GetClassObj(m)); +#endif + Py_VISIT(m->defaults_tuple); + Py_VISIT(m->defaults_kwdict); + Py_VISIT(m->func_is_coroutine); + Py_VISIT(m->defaults); + return 0; +} +static PyObject* +__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) +{ + PyObject *repr; + __Pyx_BEGIN_CRITICAL_SECTION(op); + repr = PyUnicode_FromFormat("", + op->func_qualname, (void *)op); + __Pyx_END_CRITICAL_SECTION(); + return repr; +} +static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *f = ((__pyx_CyFunctionObject*)func)->func; + PyCFunction meth; + int flags; + meth = PyCFunction_GetFunction(f); + if (unlikely(!meth)) return NULL; + flags = PyCFunction_GetFlags(f); + if (unlikely(flags < 0)) return NULL; +#else + PyCFunctionObject* f = (PyCFunctionObject*)func; + PyCFunction meth = f->m_ml->ml_meth; + int flags = f->m_ml->ml_flags; +#endif + Py_ssize_t size; + switch (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)(void(*)(void))meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_SIZE + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 0)) + return (*meth)(self, NULL); + __Pyx_CyFunction_raise_argument_count_error( + (__pyx_CyFunctionObject*)func, + "takes no arguments", size); + return NULL; } - *frame = PyFrame_New( - tstate, /*PyThreadState *tstate*/ - *code, /*PyCodeObject *code*/ - __pyx_d, /*PyObject *globals*/ - 0 /*PyObject *locals*/ - ); - if (*frame == NULL) return 0; - if (CYTHON_TRACE && (*frame)->f_trace == NULL) { - Py_INCREF(Py_None); - (*frame)->f_trace = Py_None; + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_SIZE + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 1)) { + PyObject *result, *arg0; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + arg0 = PyTuple_GET_ITEM(arg, 0); + #else + arg0 = __Pyx_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; + } + __Pyx_CyFunction_raise_argument_count_error( + (__pyx_CyFunctionObject*)func, + "takes exactly one argument", size); + return NULL; } -#if PY_VERSION_HEX < 0x030400B1 - } else { - (*frame)->f_tstate = tstate; -#endif - } - __Pyx_PyFrame_SetLineNumber(*frame, firstlineno); - retval = 1; - tstate->tracing++; - tstate->use_tracing = 0; - __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); - #if CYTHON_TRACE - if (tstate->c_tracefunc) - retval = tstate->c_tracefunc(tstate->c_traceobj, *frame, PyTrace_CALL, NULL) == 0; - if (retval && tstate->c_profilefunc) - #endif - retval = tstate->c_profilefunc(tstate->c_profileobj, *frame, PyTrace_CALL, NULL) == 0; - tstate->use_tracing = (tstate->c_profilefunc || - (CYTHON_TRACE && tstate->c_tracefunc)); - tstate->tracing--; - if (retval) { - __Pyx_ErrRestoreInState(tstate, type, value, traceback); - return tstate->use_tracing && retval; - } else { - Py_XDECREF(type); - Py_XDECREF(value); - Py_XDECREF(traceback); - return -1; + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + return NULL; } + __Pyx_CyFunction_raise_type_error( + (__pyx_CyFunctionObject*)func, "takes no keyword arguments"); + return NULL; } -static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno) { - PyCodeObject *py_code = 0; -#if PY_MAJOR_VERSION >= 3 - py_code = PyCode_NewEmpty(srcfile, funcname, firstlineno); - if (likely(py_code)) { - py_code->co_flags |= CO_OPTIMIZED | CO_NEWLOCALS; - } +static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *self, *result; +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; #else - PyObject *py_srcfile = 0; - PyObject *py_funcname = 0; - py_funcname = PyString_FromString(funcname); - if (unlikely(!py_funcname)) goto bad; - py_srcfile = PyString_FromString(srcfile); - if (unlikely(!py_srcfile)) goto bad; - py_code = PyCode_New( - 0, - 0, - 0, - CO_OPTIMIZED | CO_NEWLOCALS, - __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,*/ - firstlineno, - __pyx_empty_bytes /*PyObject *lnotab*/ - ); -bad: - Py_XDECREF(py_srcfile); - Py_XDECREF(py_funcname); + self = ((PyCFunctionObject*)func)->m_self; #endif - return py_code; + result = __Pyx_CyFunction_CallMethod(func, self, arg, kw); + return result; } +static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { + PyObject *result; + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; +#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL) + __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); + if (vc) { +#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE + return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw); +#else + (void) &__Pyx_PyVectorcall_FastCallDict; + return PyVectorcall_Call(func, args, kw); #endif - -/* 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; +#endif + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + Py_ssize_t argc; + PyObject *new_args; + PyObject *self; +#if CYTHON_ASSUME_SAFE_SIZE + argc = PyTuple_GET_SIZE(args); #else - if (unlikely(PyErr_Occurred())) { - if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { - PyErr_Clear(); - return 0; - } else { - return -1; + argc = PyTuple_Size(args); + if (unlikely(argc < 0)) return NULL; +#endif + 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); + PyErr_Format(PyExc_TypeError, + "unbound method %.200S() needs an argument", + cyfunc->func_qualname); + return NULL; } + result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); + Py_DECREF(new_args); + } else { + result = __Pyx_CyFunction_Call(func, args, kw); } - return 0; -#endif + return result; } - -/* PyFunctionFastCall */ -#if CYTHON_FAST_PYCALL -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; +#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL) +static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames) +{ + int ret = 0; + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + if (unlikely(nargs < 1)) { + __Pyx_CyFunction_raise_type_error( + cyfunc, "needs an argument"); + return -1; + } + ret = 1; } - fastlocals = __Pyx_PyFrame_GetLocalsplus(f); - for (i = 0; i < na; i++) { - Py_INCREF(*args); - fastlocals[i] = *args++; + if (unlikely(kwnames) && unlikely(__Pyx_PyTuple_GET_SIZE(kwnames))) { + __Pyx_CyFunction_raise_type_error( + cyfunc, "takes no keyword arguments"); + return -1; } - result = PyEval_EvalFrameEx(f,0); - ++tstate->recursion_depth; - Py_DECREF(f); - --tstate->recursion_depth; - return result; + return ret; } -#if 1 || PY_VERSION_HEX < 0x030600B1 -static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t 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; +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); #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 && + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; #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; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif + break; + default: + return NULL; } - else { - kwtuple = NULL; - k = NULL; + if (unlikely(nargs != 0)) { + __Pyx_CyFunction_raise_argument_count_error( + cyfunc, "takes no arguments", nargs); + return NULL; } - closure = PyFunction_GET_CLOSURE(func); -#if PY_MAJOR_VERSION >= 3 - kwdefs = PyFunction_GET_KW_DEFAULTS(func); + return meth(self, NULL); +} +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); #endif - if (argdefs != NULL) { - d = &PyTuple_GET_ITEM(argdefs, 0); - nd = Py_SIZE(argdefs); + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif + break; + default: + return NULL; } - else { - d = NULL; - nd = 0; + if (unlikely(nargs != 1)) { + __Pyx_CyFunction_raise_argument_count_error( + cyfunc, "takes exactly one argument", nargs); + return NULL; } -#if PY_MAJOR_VERSION >= 3 - result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, kwdefs, closure); + return meth(self, args[0]); +} +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; #else - result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, closure); + self = ((PyCFunctionObject*)cyfunc)->m_self; #endif - Py_XDECREF(kwtuple); -done: - Py_LeaveRecursiveCall(); - return result; + break; + default: + return NULL; + } + return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))meth)(self, args, nargs, kwnames); } +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc); +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); #endif + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; #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"))) + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif + break; + default: 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; + return ((__Pyx_PyCMethod)(void(*)(void))meth)(self, cls, args, (size_t)nargs, kwnames); } #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"))) +static PyType_Slot __pyx_CyFunctionType_slots[] = { + {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc}, + {Py_tp_repr, (void *)__Pyx_CyFunction_repr}, + {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod}, + {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse}, + {Py_tp_clear, (void *)__Pyx_CyFunction_clear}, + {Py_tp_methods, (void *)__pyx_CyFunction_methods}, + {Py_tp_members, (void *)__pyx_CyFunction_members}, + {Py_tp_getset, (void *)__pyx_CyFunction_getsets}, + {Py_tp_descr_get, (void *)__Pyx_PyMethod_New}, + {0, 0}, +}; +static PyType_Spec __pyx_CyFunctionType_spec = { + __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, +#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR + Py_TPFLAGS_METHOD_DESCRIPTOR | +#endif +#if CYTHON_METH_FASTCALL +#if defined(Py_TPFLAGS_HAVE_VECTORCALL) + Py_TPFLAGS_HAVE_VECTORCALL | +#elif defined(_Py_TPFLAGS_HAVE_VECTORCALL) + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif +#endif // CYTHON_METH_FASTCALL +#if PY_VERSION_HEX >= 0x030A0000 + Py_TPFLAGS_IMMUTABLETYPE | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + __pyx_CyFunctionType_slots +}; +static int __pyx_CyFunction_init(PyObject *module) { + __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module); + mstate->__pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec( + mstate->__pyx_CommonTypesMetaclassType, module, &__pyx_CyFunctionType_spec, NULL); + if (unlikely(mstate->__pyx_CyFunctionType == NULL)) { + return -1; + } + return 0; +} +static CYTHON_INLINE PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func, PyTypeObject *defaults_type) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults = PyObject_CallObject((PyObject*)defaults_type, NULL); // _PyObject_New(defaults_type); + if (unlikely(!m->defaults)) 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 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); +} + +/* CythonFunction */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + PyObject *op = __Pyx_CyFunction_Init( + PyObject_GC_New(__pyx_CyFunctionObject, __pyx_mstate_global->__pyx_CyFunctionType), + ml, flags, qualname, closure, module, globals, code + ); + if (likely(op)) { + PyObject_GC_Track(op); } - return result; + return op; } -#endif -/* PyObjectCallNoArg */ +/* PyObjectCall2Args */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { + PyObject *args[3] = {NULL, arg1, arg2}; + return __Pyx_PyObject_FastCall(function, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} + +/* CallUnboundCMethod1 */ #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); +static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg) { + int was_initialized = __Pyx_CachedCFunction_GetAndSetInitializing(cfunc); + if (likely(was_initialized == 2 && cfunc->func)) { + int flag = cfunc->flag; + if (flag == METH_O) { + return __Pyx_CallCFunction(cfunc, self, arg); + } else if (flag == METH_FASTCALL) { + return __Pyx_CallCFunctionFast(cfunc, self, &arg, 1); + } else if (flag == (METH_FASTCALL | METH_KEYWORDS)) { + return __Pyx_CallCFunctionFastWithKeywords(cfunc, self, &arg, 1, NULL); + } } +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + else if (unlikely(was_initialized == 1)) { + __Pyx_CachedCFunction tmp_cfunc = { +#ifndef __cplusplus + 0 #endif -#ifdef __Pyx_CyFunction_USED - if (likely(PyCFunction_Check(func) || __Pyx_CyFunction_Check(func))) -#else - if (likely(PyCFunction_Check(func))) + }; + tmp_cfunc.type = cfunc->type; + tmp_cfunc.method_name = cfunc->method_name; + return __Pyx__CallUnboundCMethod1(&tmp_cfunc, self, arg); + } +#endif + PyObject* result = __Pyx__CallUnboundCMethod1(cfunc, self, arg); + __Pyx_CachedCFunction_SetFinishedInitializing(cfunc); + return result; +} +#endif +static PyObject* __Pyx__CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg){ + PyObject *result = NULL; + if (unlikely(!cfunc->func && !cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; +#if CYTHON_COMPILING_IN_CPYTHON + if (cfunc->func && (cfunc->flag & METH_VARARGS)) { + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + if (cfunc->flag & METH_KEYWORDS) + result = __Pyx_CallCFunctionWithKeywords(cfunc, self, args, NULL); + else + result = __Pyx_CallCFunction(cfunc, self, args); + Py_DECREF(args); + } else #endif { - if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { - return __Pyx_PyObject_CallMethO(func, NULL); - } + result = __Pyx_PyObject_Call2Args(cfunc->method, self, arg); } - return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); -} -#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 | METH_STACKLESS))); - 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)(void*)meth)) (self, args, nargs, NULL); + return result; +} + +/* RejectKeywords */ +static void __Pyx_RejectKeywords(const char* function_name, PyObject *kwds) { + PyObject *key = NULL; + if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds))) { + key = __Pyx_PySequence_ITEM(kwds, 0); } else { - return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); + Py_ssize_t pos = 0; +#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) + if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return; +#endif + PyDict_Next(kwds, &pos, &key, NULL); + Py_INCREF(key); + } + if (likely(key)) { + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + Py_DECREF(key); } } -#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); +/* RaiseException */ +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; } -#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 + 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 PY_VERSION_HEX >= 0x030C00A6 + PyException_SetTraceback(value, tb); +#elif CYTHON_FAST_THREAD_STATE + 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); } +#else + 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); +#endif } - return __Pyx__PyObject_CallOneArg(func, arg); +bad: + Py_XDECREF(owned_instance); + return; } + +/* KeywordStringCheck */ +static int __Pyx_CheckKeywordStrings( + const char* function_name, + PyObject *kw) +{ +#if CYTHON_COMPILING_IN_PYPY && !defined(PyArg_ValidateKeywordArguments) + CYTHON_UNUSED_VAR(function_name); + CYTHON_UNUSED_VAR(kw); + return 0; +#else + if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) { +#if PY_VERSION_HEX >= 0x03090000 + CYTHON_UNUSED_VAR(function_name); #else + Py_ssize_t kwsize; + #if CYTHON_ASSUME_SAFE_SIZE + kwsize = PyTuple_GET_SIZE(kw); + #else + kwsize = PyTuple_Size(kw); + if (unlikely(kwsize < 0)) return -1; + #endif + for (Py_ssize_t pos = 0; pos < kwsize; pos++) { + PyObject* key = NULL; + #if CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kw, pos); + #else + key = PyTuple_GetItem(kw, pos); + if (unlikely(!key)) return -1; + #endif + if (unlikely(!PyUnicode_Check(key))) { + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + return -1; + } + } +#endif + } else { + if (unlikely(!PyArg_ValidateKeywordArguments(kw))) return -1; + } + return 0; +#endif +} + +/* IterFinish */ +static CYTHON_INLINE int __Pyx_IterFinish(void) { + PyObject* exc_type; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + exc_type = __Pyx_PyErr_CurrentExceptionType(); + if (unlikely(exc_type)) { + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) + return -1; + __Pyx_PyErr_Clear(); + return 0; + } + return 0; +} + +/* PyObjectCallNoArg */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { + PyObject *arg[2] = {NULL, NULL}; + return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} + +/* PyObjectCallOneArg */ 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; + PyObject *args[2] = {NULL, arg}; + return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); } -#endif /* PyObjectGetMethod */ static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { PyObject *attr; #if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP + __Pyx_TypeName type_name; PyTypeObject *tp = Py_TYPE(obj); PyObject *descr; descrgetfunc f = NULL; @@ -23325,17 +37638,13 @@ static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **me descr = _PyType_Lookup(tp, name); if (likely(descr != NULL)) { Py_INCREF(descr); -#if PY_MAJOR_VERSION >= 3 - #ifdef __Pyx_CyFunction_USED - if (likely(PyFunction_Check(descr) || (Py_TYPE(descr) == &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) - #else - if (likely(PyFunction_Check(descr) || (Py_TYPE(descr) == &PyMethodDescr_Type))) - #endif +#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR + if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)) #else #ifdef __Pyx_CyFunction_USED - if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr))) + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) #else - if (likely(PyFunction_Check(descr))) + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type))) #endif #endif { @@ -23370,18 +37679,15 @@ static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **me Py_DECREF(descr); goto try_unpack; } - if (descr != NULL) { + if (likely(descr != NULL)) { *method = descr; return 0; } + type_name = __Pyx_PyType_GetFullyQualifiedName(tp); PyErr_Format(PyExc_AttributeError, -#if PY_MAJOR_VERSION >= 3 - "'%.50s' object has no attribute '%U'", - tp->tp_name, name); -#else - "'%.50s' object has no attribute '%.400s'", - tp->tp_name, PyString_AS_STRING(name)); -#endif + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, name); + __Pyx_DECREF_TypeName(type_name); return 0; #else attr = __Pyx_PyObject_GetAttrStr(obj, name); @@ -23403,6 +37709,13 @@ static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **me /* PyObjectCallMethod0 */ static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { +#if CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000)) + PyObject *args[1] = {obj}; + (void) __Pyx_PyObject_GetMethod; + (void) __Pyx_PyObject_CallOneArg; + (void) __Pyx_PyObject_CallNoArg; + return PyObject_VectorcallMethod(method_name, args, 1 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); +#else PyObject *method = NULL, *result = NULL; int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); if (likely(is_method)) { @@ -23415,6 +37728,7 @@ static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name Py_DECREF(method); bad: return result; +#endif } /* RaiseNeedMoreValuesToUnpack */ @@ -23436,10 +37750,8 @@ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { Py_DECREF(retval); __Pyx_RaiseTooManyValuesError(expected); return -1; - } else { - return __Pyx_IterFinish(); } - return 0; + return __Pyx_IterFinish(); } /* RaiseNoneIterError */ @@ -23451,20 +37763,45 @@ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { 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); + Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(t); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(size < 0)) return; + #endif + if (size < index) { + __Pyx_RaiseNeedMoreValuesError(size); + } else { + __Pyx_RaiseTooManyValuesError(index); + } } } /* UnpackTuple2 */ +static CYTHON_INLINE int __Pyx_unpack_tuple2( + PyObject* tuple, PyObject** value1, PyObject** value2, int is_tuple, int has_known_size, int decref_tuple) { + if (likely(is_tuple || PyTuple_Check(tuple))) { + Py_ssize_t size; + if (has_known_size) { + return __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple); + } + size = __Pyx_PyTuple_GET_SIZE(tuple); + if (likely(size == 2)) { + return __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple); + } + if (size >= 0) { + __Pyx_UnpackTupleError(tuple, 2); + } + return -1; + } else { + return __Pyx_unpack_tuple2_generic(tuple, value1, value2, has_known_size, decref_tuple); + } +} 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; +#if CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS + value1 = __Pyx_PySequence_ITEM(tuple, 0); if (unlikely(!value1)) goto bad; + value2 = __Pyx_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); @@ -23475,7 +37812,7 @@ static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( *pvalue1 = value1; *pvalue2 = value2; return 0; -#if CYTHON_COMPILING_IN_PYPY +#if CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS bad: Py_XDECREF(value1); Py_XDECREF(value2); @@ -23491,7 +37828,7 @@ static int __Pyx_unpack_tuple2_generic(PyObject* tuple, PyObject** pvalue1, PyOb iter = PyObject_GetIter(tuple); if (unlikely(!iter)) goto bad; if (decref_tuple) { Py_DECREF(tuple); tuple = NULL; } - iternext = Py_TYPE(iter)->tp_iternext; + iternext = __Pyx_PyObject_GetIterNextFunc(iter); 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; @@ -23511,6 +37848,9 @@ static int __Pyx_unpack_tuple2_generic(PyObject* tuple, PyObject** pvalue1, PyOb } /* dict_iter */ +#if CYTHON_COMPILING_IN_PYPY +#include +#endif 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)); @@ -23520,7 +37860,7 @@ static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_di *p_orig_length = PyDict_Size(iterable); Py_INCREF(iterable); return iterable; -#elif PY_MAJOR_VERSION >= 3 +#else static PyObject *py_items = NULL, *py_keys = NULL, *py_values = NULL; PyObject **pp = NULL; if (method_name) { @@ -23534,429 +37874,246 @@ static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_di 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; -} - -/* PyObjectCall2Args */ -static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { - PyObject *args, *result = NULL; - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(function)) { - PyObject *args[2] = {arg1, arg2}; - return __Pyx_PyFunction_FastCall(function, args, 2); - } - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(function)) { - PyObject *args[2] = {arg1, arg2}; - return __Pyx_PyCFunction_FastCall(function, args, 2); - } - #endif - args = PyTuple_New(2); - if (unlikely(!args)) goto done; - Py_INCREF(arg1); - PyTuple_SET_ITEM(args, 0, arg1); - Py_INCREF(arg2); - PyTuple_SET_ITEM(args, 1, arg2); - Py_INCREF(function); - result = __Pyx_PyObject_Call(function, args, NULL); - Py_DECREF(args); - Py_DECREF(function); -done: - return result; -} - -/* 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 - -/* BytesEquals */ -static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { -#if CYTHON_COMPILING_IN_PYPY - return PyObject_RichCompareBool(s1, s2, equals); -#else - if (s1 == s2) { - return (equals == Py_EQ); - } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { - const char *ps1, *ps2; - Py_ssize_t length = PyBytes_GET_SIZE(s1); - if (length != PyBytes_GET_SIZE(s2)) - return (equals == Py_NE); - ps1 = PyBytes_AS_STRING(s1); - ps2 = PyBytes_AS_STRING(s2); - if (ps1[0] != ps2[0]) { - return (equals == Py_NE); - } else if (length == 1) { - return (equals == Py_EQ); - } else { - int result; -#if CYTHON_USE_UNICODE_INTERNALS - Py_hash_t hash1, hash2; - hash1 = ((PyBytesObject*)s1)->ob_shash; - hash2 = ((PyBytesObject*)s2)->ob_shash; - if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { - return (equals == Py_NE); - } -#endif - result = memcmp(ps1, ps2, (size_t)length); - return (equals == Py_EQ) ? (result == 0) : (result != 0); + method_name = *pp; + } } - } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { - return (equals == Py_NE); - } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { - return (equals == Py_NE); - } else { - int result; - PyObject* py_result = PyObject_RichCompare(s1, s2, equals); - if (!py_result) - return -1; - result = __Pyx_PyObject_IsTrue(py_result); - Py_DECREF(py_result); - return result; +#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); } - -/* UnicodeEquals */ -static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { -#if CYTHON_COMPILING_IN_PYPY - return PyObject_RichCompareBool(s1, s2, equals); -#else -#if PY_MAJOR_VERSION < 3 - PyObject* owned_ref = NULL; -#endif - int s1_is_unicode, s2_is_unicode; - if (s1 == s2) { - goto return_eq; +#if !CYTHON_COMPILING_IN_PYPY +static CYTHON_INLINE int __Pyx_dict_iter_next_source_is_dict( + PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos, + PyObject** pkey, PyObject** pvalue, PyObject** pitem) { + PyObject *key, *value; + if (unlikely(orig_length != PyDict_Size(iter_obj))) { + PyErr_SetString(PyExc_RuntimeError, "dictionary changed size during iteration"); + return -1; } - s1_is_unicode = PyUnicode_CheckExact(s1); - s2_is_unicode = PyUnicode_CheckExact(s2); -#if PY_MAJOR_VERSION < 3 - if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { - owned_ref = PyUnicode_FromObject(s2); - if (unlikely(!owned_ref)) - return -1; - s2 = owned_ref; - s2_is_unicode = 1; - } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { - owned_ref = PyUnicode_FromObject(s1); - if (unlikely(!owned_ref)) - return -1; - s1 = owned_ref; - s1_is_unicode = 1; - } else if (((!s2_is_unicode) & (!s1_is_unicode))) { - return __Pyx_PyBytes_Equals(s1, s2, equals); + if (unlikely(!PyDict_Next(iter_obj, ppos, &key, &value))) { + return 0; } -#endif - if (s1_is_unicode & s2_is_unicode) { - Py_ssize_t length; - int kind; - void *data1, *data2; - if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) + if (pitem) { + PyObject* tuple = PyTuple_New(2); + if (unlikely(!tuple)) { return -1; - length = __Pyx_PyUnicode_GET_LENGTH(s1); - if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { - goto return_ne; } -#if CYTHON_USE_UNICODE_INTERNALS - { - Py_hash_t hash1, hash2; - #if CYTHON_PEP393_ENABLED - hash1 = ((PyASCIIObject*)s1)->hash; - hash2 = ((PyASCIIObject*)s2)->hash; + Py_INCREF(key); + Py_INCREF(value); + #if CYTHON_ASSUME_SAFE_MACROS + PyTuple_SET_ITEM(tuple, 0, key); + PyTuple_SET_ITEM(tuple, 1, value); #else - hash1 = ((PyUnicodeObject*)s1)->hash; - hash2 = ((PyUnicodeObject*)s2)->hash; + if (unlikely(PyTuple_SetItem(tuple, 0, key) < 0)) { + Py_DECREF(value); + Py_DECREF(tuple); + return -1; + } + if (unlikely(PyTuple_SetItem(tuple, 1, value) < 0)) { + Py_DECREF(tuple); + return -1; + } #endif - if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { - goto return_ne; - } + *pitem = tuple; + } else { + if (pkey) { + Py_INCREF(key); + *pkey = key; + } + if (pvalue) { + Py_INCREF(value); + *pvalue = value; } + } + return 1; +} #endif - kind = __Pyx_PyUnicode_KIND(s1); - if (kind != __Pyx_PyUnicode_KIND(s2)) { - goto return_ne; +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) { + int result; +#if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_BEGIN_CRITICAL_SECTION(iter_obj); +#endif + result = __Pyx_dict_iter_next_source_is_dict(iter_obj, orig_length, ppos, pkey, pvalue, pitem); +#if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_END_CRITICAL_SECTION(); +#endif + return result; + } else if (PyTuple_CheckExact(iter_obj)) { + Py_ssize_t pos = *ppos; + Py_ssize_t tuple_size = __Pyx_PyTuple_GET_SIZE(iter_obj); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(tuple_size < 0)) return -1; + #endif + if (unlikely(pos >= tuple_size)) return 0; + *ppos = pos + 1; + #if CYTHON_ASSUME_SAFE_MACROS + next_item = PyTuple_GET_ITEM(iter_obj, pos); + #else + next_item = PyTuple_GetItem(iter_obj, pos); + if (unlikely(!next_item)) return -1; + #endif + Py_INCREF(next_item); + } else if (PyList_CheckExact(iter_obj)) { + Py_ssize_t pos = *ppos; + Py_ssize_t list_size = __Pyx_PyList_GET_SIZE(iter_obj); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(list_size < 0)) return -1; + #endif + if (unlikely(pos >= list_size)) return 0; + *ppos = pos + 1; + #if CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + next_item = PyList_GetItemRef(iter_obj, pos); + if (unlikely(!next_item)) return -1; + #elif CYTHON_ASSUME_SAFE_MACROS + next_item = PyList_GET_ITEM(iter_obj, pos); + Py_INCREF(next_item); + #else + next_item = PyList_GetItem(iter_obj, pos); + if (unlikely(!next_item)) return -1; + Py_INCREF(next_item); + #endif + } else +#endif + { + next_item = PyIter_Next(iter_obj); + if (unlikely(!next_item)) { + return __Pyx_IterFinish(); } - data1 = __Pyx_PyUnicode_DATA(s1); - data2 = __Pyx_PyUnicode_DATA(s2); - if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { - goto return_ne; - } else if (length == 1) { - goto return_eq; + } + 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; +} + +/* PyObjectFastCallMethod */ +#if !CYTHON_VECTORCALL || PY_VERSION_HEX < 0x03090000 +static PyObject *__Pyx_PyObject_FastCallMethod(PyObject *name, PyObject *const *args, size_t nargsf) { + PyObject *result; + PyObject *attr = PyObject_GetAttr(args[0], name); + if (unlikely(!attr)) + return NULL; + result = __Pyx_PyObject_FastCall(attr, args+1, nargsf - 1); + Py_DECREF(attr); + return result; +} +#endif + +/* PyObjectFormatAndDecref */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f) { + if (unlikely(!s)) return NULL; + if (likely(PyUnicode_CheckExact(s))) return s; + return __Pyx_PyObject_FormatAndDecref(s, f); +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f) { + PyObject *result; + if (unlikely(!s)) return NULL; + result = PyObject_Format(s, f); + Py_DECREF(s); + return result; +} + +/* JoinPyUnicode */ +static PyObject* __Pyx_PyUnicode_Join(PyObject** values, Py_ssize_t value_count, Py_ssize_t result_ulength, + Py_UCS4 max_char) { +#if CYTHON_USE_UNICODE_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + PyObject *result_uval; + int result_ukind, kind_shift; + Py_ssize_t i, char_pos; + void *result_udata; + if (max_char > 1114111) max_char = 1114111; + result_uval = PyUnicode_New(result_ulength, max_char); + if (unlikely(!result_uval)) return NULL; + result_ukind = (max_char <= 255) ? PyUnicode_1BYTE_KIND : (max_char <= 65535) ? PyUnicode_2BYTE_KIND : PyUnicode_4BYTE_KIND; + kind_shift = (result_ukind == PyUnicode_4BYTE_KIND) ? 2 : result_ukind - 1; + result_udata = PyUnicode_DATA(result_uval); + assert(kind_shift == 2 || kind_shift == 1 || kind_shift == 0); + if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - result_ulength < 0)) + goto overflow; + char_pos = 0; + for (i=0; i < value_count; i++) { + int ukind; + Py_ssize_t ulength; + void *udata; + PyObject *uval = values[i]; + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_PyUnicode_READY(uval) == (-1)) + goto bad; + #endif + ulength = __Pyx_PyUnicode_GET_LENGTH(uval); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(ulength < 0)) goto bad; + #endif + if (unlikely(!ulength)) + continue; + if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - ulength < char_pos)) + goto overflow; + ukind = __Pyx_PyUnicode_KIND(uval); + udata = __Pyx_PyUnicode_DATA(uval); + if (ukind == result_ukind) { + memcpy((char *)result_udata + (char_pos << kind_shift), udata, (size_t) (ulength << kind_shift)); } else { - int result = memcmp(data1, data2, (size_t)(length * kind)); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); + #if PY_VERSION_HEX >= 0x030d0000 + if (unlikely(PyUnicode_CopyCharacters(result_uval, char_pos, uval, 0, ulength) < 0)) goto bad; + #elif CYTHON_COMPILING_IN_CPYTHON || defined(_PyUnicode_FastCopyCharacters) + _PyUnicode_FastCopyCharacters(result_uval, char_pos, uval, 0, ulength); + #else + Py_ssize_t j; + for (j=0; j < ulength; j++) { + Py_UCS4 uchar = __Pyx_PyUnicode_READ(ukind, udata, j); + __Pyx_PyUnicode_WRITE(result_ukind, result_udata, char_pos+j, uchar); + } #endif - return (equals == Py_EQ) ? (result == 0) : (result != 0); } - } else if ((s1 == Py_None) & s2_is_unicode) { - goto return_ne; - } else if ((s2 == Py_None) & s1_is_unicode) { - goto return_ne; - } else { - int result; - PyObject* py_result = PyObject_RichCompare(s1, s2, equals); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - if (!py_result) - return -1; - result = __Pyx_PyObject_IsTrue(py_result); - Py_DECREF(py_result); - return result; + char_pos += ulength; } -return_eq: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - return (equals == Py_EQ); -return_ne: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - return (equals == Py_NE); + return result_uval; +overflow: + PyErr_SetString(PyExc_OverflowError, "join() result is too long for a Python string"); +bad: + Py_DECREF(result_uval); + return NULL; +#else + Py_ssize_t i; + PyObject *result = NULL; + PyObject *value_tuple = PyTuple_New(value_count); + if (unlikely(!value_tuple)) return NULL; + CYTHON_UNUSED_VAR(max_char); + CYTHON_UNUSED_VAR(result_ulength); + for (i=0; i__pyx_empty_unicode, value_tuple); +bad: + Py_DECREF(value_tuple); + return result; #endif } @@ -23992,288 +38149,660 @@ static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_ve #else static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) #endif -{ - PyObject *result; -#if !CYTHON_AVOID_BORROWED_REFS -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 - result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } else if (unlikely(PyErr_Occurred())) { - return NULL; +{ + PyObject *result; +#if CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(!__pyx_m)) { + if (!PyErr_Occurred()) + PyErr_SetNone(PyExc_NameError); + return NULL; + } + result = PyObject_GetAttr(__pyx_m, name); + if (likely(result)) { + return result; + } + PyErr_Clear(); +#elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + if (unlikely(__Pyx_PyDict_GetItemRef(__pyx_mstate_global->__pyx_d, name, &result) == -1)) PyErr_Clear(); + __PYX_UPDATE_DICT_CACHE(__pyx_mstate_global->__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return result; + } +#else + result = _PyDict_GetItem_KnownHash(__pyx_mstate_global->__pyx_d, name, ((PyASCIIObject *) name)->hash); + __PYX_UPDATE_DICT_CACHE(__pyx_mstate_global->__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } + PyErr_Clear(); +#endif + return __Pyx_GetBuiltinName(name); +} + +/* CallUnboundCMethod0 */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) { + int was_initialized = __Pyx_CachedCFunction_GetAndSetInitializing(cfunc); + if (likely(was_initialized == 2 && cfunc->func)) { + if (likely(cfunc->flag == METH_NOARGS)) + return __Pyx_CallCFunction(cfunc, self, NULL); + if (likely(cfunc->flag == METH_FASTCALL)) + return __Pyx_CallCFunctionFast(cfunc, self, NULL, 0); + if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS)) + return __Pyx_CallCFunctionFastWithKeywords(cfunc, self, NULL, 0, NULL); + if (likely(cfunc->flag == (METH_VARARGS | METH_KEYWORDS))) + return __Pyx_CallCFunctionWithKeywords(cfunc, self, __pyx_mstate_global->__pyx_empty_tuple, NULL); + if (cfunc->flag == METH_VARARGS) + return __Pyx_CallCFunction(cfunc, self, __pyx_mstate_global->__pyx_empty_tuple); + return __Pyx__CallUnboundCMethod0(cfunc, self); + } +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + else if (unlikely(was_initialized == 1)) { + __Pyx_CachedCFunction tmp_cfunc = { +#ifndef __cplusplus + 0 +#endif + }; + tmp_cfunc.type = cfunc->type; + tmp_cfunc.method_name = cfunc->method_name; + return __Pyx__CallUnboundCMethod0(&tmp_cfunc, self); + } +#endif + PyObject *result = __Pyx__CallUnboundCMethod0(cfunc, self); + __Pyx_CachedCFunction_SetFinishedInitializing(cfunc); + return result; +} +#endif +static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) { + PyObject *result; + if (unlikely(!cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; + result = __Pyx_PyObject_CallOneArg(cfunc->method, self); + return result; +} + +/* py_dict_items */ +static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d) { + return __Pyx_CallUnboundCMethod0(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_items, d); +} + +/* RaiseUnboundLocalError */ +static void __Pyx_RaiseUnboundLocalError(const char *varname) { + PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); +} + +/* RaiseClosureNameError */ +static void __Pyx_RaiseClosureNameError(const char *varname) { + PyErr_Format(PyExc_NameError, "free variable '%s' referenced before assignment in enclosing scope", varname); +} + +/* GetException */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) +#endif +{ + PyObject *local_type = NULL, *local_value, *local_tb = NULL; +#if CYTHON_FAST_THREAD_STATE + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if PY_VERSION_HEX >= 0x030C0000 + local_value = tstate->current_exception; + tstate->current_exception = 0; + #else + local_type = tstate->curexc_type; + local_value = tstate->curexc_value; + local_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; + #endif +#elif __PYX_LIMITED_VERSION_HEX > 0x030C0000 + local_value = PyErr_GetRaisedException(); +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); +#endif +#if __PYX_LIMITED_VERSION_HEX > 0x030C0000 + if (likely(local_value)) { + local_type = (PyObject*) Py_TYPE(local_value); + Py_INCREF(local_type); + local_tb = PyException_GetTraceback(local_value); + } +#else + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) +#else + if (unlikely(PyErr_Occurred())) +#endif + goto bad; + if (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; + } +#endif // __PYX_LIMITED_VERSION_HEX > 0x030C0000 + Py_XINCREF(local_tb); + Py_XINCREF(local_type); + Py_XINCREF(local_value); + *type = local_type; + *value = local_value; + *tb = local_tb; +#if CYTHON_FAST_THREAD_STATE + #if CYTHON_USE_EXC_INFO_STACK + { + _PyErr_StackItem *exc_info = tstate->exc_info; + #if PY_VERSION_HEX >= 0x030B00a4 + tmp_value = exc_info->exc_value; + exc_info->exc_value = local_value; + tmp_type = NULL; + tmp_tb = NULL; + Py_XDECREF(local_type); + Py_XDECREF(local_tb); + #else + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = local_type; + exc_info->exc_value = local_value; + exc_info->exc_traceback = local_tb; + #endif + } + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = local_type; + tstate->exc_value = local_value; + tstate->exc_traceback = local_tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#elif __PYX_LIMITED_VERSION_HEX >= 0x030b0000 + PyErr_SetHandledException(local_value); + Py_XDECREF(local_value); + Py_XDECREF(local_type); + Py_XDECREF(local_tb); +#else + PyErr_SetExcInfo(local_type, local_value, local_tb); +#endif + return 0; +#if __PYX_LIMITED_VERSION_HEX <= 0x030C0000 +bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); + return -1; +#endif +} + +/* pep479 */ +static void __Pyx_Generator_Replace_StopIteration(int in_async_gen) { + PyObject *exc, *val, *tb, *cur_exc, *new_exc; + __Pyx_PyThreadState_declare + int is_async_stopiteration = 0; + CYTHON_MAYBE_UNUSED_VAR(in_async_gen); + __Pyx_PyThreadState_assign + cur_exc = __Pyx_PyErr_CurrentExceptionType(); + if (likely(!__Pyx_PyErr_GivenExceptionMatches(cur_exc, PyExc_StopIteration))) { + if (in_async_gen && unlikely(__Pyx_PyErr_GivenExceptionMatches(cur_exc, PyExc_StopAsyncIteration))) { + is_async_stopiteration = 1; + } else { + return; + } } -#else - result = PyDict_GetItem(__pyx_d, name); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); + __Pyx_GetException(&exc, &val, &tb); + Py_XDECREF(exc); + Py_XDECREF(tb); + new_exc = PyObject_CallFunction(PyExc_RuntimeError, "s", + is_async_stopiteration ? "async generator raised StopAsyncIteration" : + in_async_gen ? "async generator raised StopIteration" : + "generator raised StopIteration"); + if (!new_exc) { + Py_XDECREF(val); + return; } + PyException_SetCause(new_exc, val); // steals ref to val + PyErr_SetObject(PyExc_RuntimeError, new_exc); +} + +/* GetAttr3 */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d0000 +static PyObject *__Pyx_GetAttr3Default(PyObject *d) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + return NULL; + __Pyx_PyErr_Clear(); + Py_INCREF(d); + return d; +} #endif +static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { + PyObject *r; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + int res = PyObject_GetOptionalAttr(o, n, &r); + return (res != 0) ? r : __Pyx_NewRef(d); #else - result = PyObject_GetItem(__pyx_d, name); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); + #if CYTHON_USE_TYPE_SLOTS + if (likely(PyUnicode_Check(n))) { + r = __Pyx_PyObject_GetAttrStrNoError(o, n); + if (unlikely(!r) && likely(!PyErr_Occurred())) { + r = __Pyx_NewRef(d); + } + return r; } - PyErr_Clear(); + #endif + r = PyObject_GetAttr(o, n); + return (likely(r)) ? r : __Pyx_GetAttr3Default(d); #endif - return __Pyx_GetBuiltinName(name); } -/* UnpackUnboundCMethod */ -static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) { - PyObject *method; - method = __Pyx_PyObject_GetAttrStr(target->type, *target->method_name); - if (unlikely(!method)) - return -1; - target->method = method; -#if CYTHON_COMPILING_IN_CPYTHON - #if PY_MAJOR_VERSION >= 3 - if (likely(__Pyx_TypeCheck(method, &PyMethodDescr_Type))) +/* RaiseUnexpectedTypeError */ +static int +__Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj) +{ + __Pyx_TypeName obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, "Expected %s, got " __Pyx_FMT_TYPENAME, + expected, obj_type_name); + __Pyx_DECREF_TypeName(obj_type_name); + return 0; +} + +/* unicode_tailmatch */ +static int __Pyx_PyUnicode_TailmatchTuple(PyObject* s, PyObject* substrings, + Py_ssize_t start, Py_ssize_t end, int direction) { + Py_ssize_t i, count = __Pyx_PyTuple_GET_SIZE(substrings); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(count < 0)) return -1; #endif - { - PyMethodDescrObject *descr = (PyMethodDescrObject*) method; - target->func = descr->d_method->ml_meth; - target->flag = descr->d_method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_STACKLESS); - } + for (i = 0; i < count; i++) { + Py_ssize_t result; +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + result = PyUnicode_Tailmatch(s, PyTuple_GET_ITEM(substrings, i), + start, end, direction); +#else + PyObject* sub = __Pyx_PySequence_ITEM(substrings, i); + if (unlikely(!sub)) return -1; + result = PyUnicode_Tailmatch(s, sub, start, end, direction); + Py_DECREF(sub); #endif + if (result) { + return (int) result; + } + } return 0; } +static int __Pyx_PyUnicode_Tailmatch(PyObject* s, PyObject* substr, + Py_ssize_t start, Py_ssize_t end, int direction) { + if (unlikely(PyTuple_Check(substr))) { + return __Pyx_PyUnicode_TailmatchTuple(s, substr, start, end, direction); + } + return (int) PyUnicode_Tailmatch(s, substr, start, end, direction); +} + +/* CIntToDigits */ +static const char DIGIT_PAIRS_10[2*10*10+1] = { + "00010203040506070809" + "10111213141516171819" + "20212223242526272829" + "30313233343536373839" + "40414243444546474849" + "50515253545556575859" + "60616263646566676869" + "70717273747576777879" + "80818283848586878889" + "90919293949596979899" +}; +static const char DIGIT_PAIRS_8[2*8*8+1] = { + "0001020304050607" + "1011121314151617" + "2021222324252627" + "3031323334353637" + "4041424344454647" + "5051525354555657" + "6061626364656667" + "7071727374757677" +}; +static const char DIGITS_HEX[2*16+1] = { + "0123456789abcdef" + "0123456789ABCDEF" +}; -/* CallUnboundCMethod0 */ -static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) { - PyObject *args, *result = NULL; - if (unlikely(!cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; -#if CYTHON_ASSUME_SAFE_MACROS - args = PyTuple_New(1); - if (unlikely(!args)) goto bad; - Py_INCREF(self); - PyTuple_SET_ITEM(args, 0, self); +/* BuildPyUnicode */ +static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, const char* chars, int clength, + int prepend_sign, char padding_char) { + PyObject *uval; + Py_ssize_t uoffset = ulength - clength; +#if CYTHON_USE_UNICODE_INTERNALS + Py_ssize_t i; + void *udata; + uval = PyUnicode_New(ulength, 127); + if (unlikely(!uval)) return NULL; + udata = PyUnicode_DATA(uval); + if (uoffset > 0) { + i = 0; + if (prepend_sign) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, 0, '-'); + i++; + } + for (; i < uoffset; i++) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, i, padding_char); + } + } + for (i=0; i < clength; i++) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, uoffset+i, chars[i]); + } #else - args = PyTuple_Pack(1, self); - if (unlikely(!args)) goto bad; + { + PyObject *sign = NULL, *padding = NULL; + uval = NULL; + if (uoffset > 0) { + prepend_sign = !!prepend_sign; + if (uoffset > prepend_sign) { + padding = PyUnicode_FromOrdinal(padding_char); + if (likely(padding) && uoffset > prepend_sign + 1) { + PyObject *tmp = PySequence_Repeat(padding, uoffset - prepend_sign); + Py_DECREF(padding); + padding = tmp; + } + if (unlikely(!padding)) goto done_or_error; + } + if (prepend_sign) { + sign = PyUnicode_FromOrdinal('-'); + if (unlikely(!sign)) goto done_or_error; + } + } + uval = PyUnicode_DecodeASCII(chars, clength, NULL); + if (likely(uval) && padding) { + PyObject *tmp = PyUnicode_Concat(padding, uval); + Py_DECREF(uval); + uval = tmp; + } + if (likely(uval) && sign) { + PyObject *tmp = PyUnicode_Concat(sign, uval); + Py_DECREF(uval); + uval = tmp; + } +done_or_error: + Py_XDECREF(padding); + Py_XDECREF(sign); + } #endif - result = __Pyx_PyObject_Call(cfunc->method, args, NULL); - Py_DECREF(args); -bad: - return result; + return uval; } -/* py_dict_items */ -static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d) { - if (PY_MAJOR_VERSION >= 3) - return __Pyx_CallUnboundCMethod0(&__pyx_umethod_PyDict_Type_items, d); - else - return PyDict_Items(d); +/* COrdinalToPyUnicode */ +static CYTHON_INLINE int __Pyx_CheckUnicodeValue(int value) { + return value <= 1114111; } - -/* None */ -static CYTHON_INLINE void __Pyx_RaiseClosureNameError(const char *varname) { - PyErr_Format(PyExc_NameError, "free variable '%s' referenced before assignment in enclosing scope", varname); +static PyObject* __Pyx_PyUnicode_FromOrdinal_Padded(int value, Py_ssize_t ulength, char padding_char) { + if (likely(ulength <= 250)) { + char chars[256]; + if (value <= 255) { + memset(chars, padding_char, (size_t) (ulength - 1)); + chars[ulength-1] = (char) value; + return PyUnicode_DecodeLatin1(chars, ulength, NULL); + } + char *cpos = chars + sizeof(chars); + if (value < 0x800) { + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0xc0 | (value & 0x1f)); + } else if (value < 0x10000) { + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0xe0 | (value & 0x0f)); + } else { + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0xf0 | (value & 0x07)); + } + cpos -= ulength; + memset(cpos, padding_char, (size_t) (ulength - 1)); + return PyUnicode_DecodeUTF8(cpos, chars + sizeof(chars) - cpos, NULL); + } + if (value <= 127 && CYTHON_USE_UNICODE_INTERNALS) { + const char chars[1] = {(char) value}; + return __Pyx_PyUnicode_BuildFromAscii(ulength, chars, 1, 0, padding_char); + } + { + PyObject *uchar, *padding_uchar, *padding, *result; + padding_uchar = PyUnicode_FromOrdinal(padding_char); + if (unlikely(!padding_uchar)) return NULL; + padding = PySequence_Repeat(padding_uchar, ulength - 1); + Py_DECREF(padding_uchar); + if (unlikely(!padding)) return NULL; + uchar = PyUnicode_FromOrdinal(value); + if (unlikely(!uchar)) { + Py_DECREF(padding); + return NULL; + } + result = PyUnicode_Concat(padding, uchar); + Py_DECREF(padding); + Py_DECREF(uchar); + return result; + } } -/* StringJoin */ -#if !CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyBytes_Join(PyObject* sep, PyObject* values) { - return PyObject_CallMethodObjArgs(sep, __pyx_n_s_join, values, NULL); -} +/* CIntToPyUnicode */ +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char, char format_char) { + char digits[sizeof(int)*3+2]; + char *dpos, *end = digits + sizeof(int)*3+2; + const char *hex_digits = DIGITS_HEX; + Py_ssize_t length, ulength; + int prepend_sign, last_one_off; + int remaining; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" #endif - -/* 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; + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (format_char == 'c') { + if (unlikely(!(is_unsigned || value == 0 || value > 0) || + !(sizeof(value) <= 2 || value & ~ (int) 0x01fffff || __Pyx_CheckUnicodeValue((int) value)))) { + PyErr_SetString(PyExc_OverflowError, "%c arg not in range(0x110000)"); + return NULL; } - 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; + if (width <= 1) { + return PyUnicode_FromOrdinal((int) value); + } + return __Pyx_PyUnicode_FromOrdinal_Padded((int) value, width, padding_char); + } + if (format_char == 'X') { + hex_digits += 16; + format_char = 'x'; + } + remaining = value; + last_one_off = 0; + dpos = end; + do { + int digit_pos; + switch (format_char) { + case 'o': + digit_pos = abs((int)(remaining % (8*8))); + remaining = (int) (remaining / (8*8)); + dpos -= 2; + memcpy(dpos, DIGIT_PAIRS_8 + digit_pos * 2, 2); + last_one_off = (digit_pos < 8); + break; + case 'd': + digit_pos = abs((int)(remaining % (10*10))); + remaining = (int) (remaining / (10*10)); + dpos -= 2; + memcpy(dpos, DIGIT_PAIRS_10 + digit_pos * 2, 2); + last_one_off = (digit_pos < 10); + break; + case 'x': + *(--dpos) = hex_digits[abs((int)(remaining % 16))]; + remaining = (int) (remaining / 16); + break; + default: + assert(0); + break; + } + } while (unlikely(remaining != 0)); + assert(!last_one_off || *dpos == '0'); + dpos += last_one_off; + length = end - dpos; + ulength = length; + prepend_sign = 0; + if (!is_unsigned && value <= neg_one) { + if (padding_char == ' ' || width <= length + 1) { + *(--dpos) = '-'; + ++length; } else { - goto invalid_keyword; + prepend_sign = 1; } + ++ulength; + } + if (width > ulength) { + ulength = width; + } + if (ulength == 1) { + return PyUnicode_FromOrdinal(*dpos); } + return __Pyx_PyUnicode_BuildFromAscii(ulength, dpos, (int) length, prepend_sign, padding_char); +} + +/* PyObjectVectorCallKwBuilder */ +#if CYTHON_VECTORCALL +static int __Pyx_VectorcallBuilder_AddArg(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n) { + (void)__Pyx_PyObject_FastCallDict; + if (__Pyx_PyTuple_SET_ITEM(builder, n, key) != (0)) return -1; + Py_INCREF(key); + args[n] = value; 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; } +CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n) { + (void)__Pyx_VectorcallBuilder_AddArgStr; + if (unlikely(!PyUnicode_Check(key))) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + return -1; + } + return __Pyx_VectorcallBuilder_AddArg(key, value, builder, args, n); +} +static int __Pyx_VectorcallBuilder_AddArgStr(const char *key, PyObject *value, PyObject *builder, PyObject **args, int n) { + PyObject *pyKey = PyUnicode_FromString(key); + if (!pyKey) return -1; + return __Pyx_VectorcallBuilder_AddArg(pyKey, value, builder, args, n); +} +#else // CYTHON_VECTORCALL +CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, CYTHON_UNUSED PyObject **args, CYTHON_UNUSED int n) { + if (unlikely(!PyUnicode_Check(key))) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + return -1; + } + return PyDict_SetItem(builder, key, value); +} +#endif -/* ArgTypeTest */ -static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) -{ +/* ExtTypeTest */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + __Pyx_TypeName obj_type_name; + __Pyx_TypeName type_name; if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } - else if (exact) { - #if PY_MAJOR_VERSION == 2 - if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; - #endif - } - else { - if (likely(__Pyx_TypeCheck(obj, type))) return 1; - } + if (likely(__Pyx_TypeCheck(obj, type))) + return 1; + obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); + type_name = __Pyx_PyType_GetFullyQualifiedName(type); PyErr_Format(PyExc_TypeError, - "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", - name, type->tp_name, Py_TYPE(obj)->tp_name); + "Cannot convert " __Pyx_FMT_TYPENAME " to " __Pyx_FMT_TYPENAME, + obj_type_name, type_name); + __Pyx_DECREF_TypeName(obj_type_name); + __Pyx_DECREF_TypeName(type_name); return 0; } -/* PyErrExceptionMatches */ -#if CYTHON_FAST_THREAD_STATE -static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { - Py_ssize_t i, n; - n = PyTuple_GET_SIZE(tuple); -#if PY_MAJOR_VERSION >= 3 - for (i=0; i__pyx_d, empty_dict, from_list, 1); + if (unlikely(!module)) { + if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError))) + goto bad; + PyErr_Clear(); + } + } + level = 0; } -#endif - for (i=0; i__pyx_d, empty_dict, from_list, level); } - return 0; -} -static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) { - PyObject *exc_type = tstate->curexc_type; - if (exc_type == err) return 1; - if (unlikely(!exc_type)) return 0; - if (unlikely(PyTuple_Check(err))) - return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); - return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); -} -#endif - -/* GetAttr */ -static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { -#if CYTHON_USE_TYPE_SLOTS -#if PY_MAJOR_VERSION >= 3 - if (likely(PyUnicode_Check(n))) -#else - if (likely(PyString_Check(n))) -#endif - return __Pyx_PyObject_GetAttrStr(o, n); -#endif - return PyObject_GetAttr(o, n); +bad: + Py_XDECREF(empty_dict); + Py_XDECREF(empty_list); + return module; } -/* GetAttr3 */ -static PyObject *__Pyx_GetAttr3Default(PyObject *d) { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) - return NULL; - __Pyx_PyErr_Clear(); - Py_INCREF(d); - return d; -} -static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { - PyObject *r = __Pyx_GetAttr(o, n); - return (likely(r)) ? r : __Pyx_GetAttr3Default(d); +/* ImportFrom */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { + PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); + if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { + const char* module_name_str = 0; + PyObject* module_name = 0; + PyObject* module_dot = 0; + PyObject* full_name = 0; + PyErr_Clear(); + module_name_str = PyModule_GetName(module); + if (unlikely(!module_name_str)) { goto modbad; } + module_name = PyUnicode_FromString(module_name_str); + if (unlikely(!module_name)) { goto modbad; } + module_dot = PyUnicode_Concat(module_name, __pyx_mstate_global->__pyx_kp_u__2); + if (unlikely(!module_dot)) { goto modbad; } + full_name = PyUnicode_Concat(module_dot, name); + if (unlikely(!full_name)) { goto modbad; } + #if (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) ||\ + CYTHON_COMPILING_IN_GRAAL + { + PyObject *modules = PyImport_GetModuleDict(); + if (unlikely(!modules)) + goto modbad; + value = PyObject_GetItem(modules, full_name); + } + #else + value = PyImport_GetModule(full_name); + #endif + modbad: + Py_XDECREF(full_name); + Py_XDECREF(module_dot); + Py_XDECREF(module_name); + } + if (unlikely(!value)) { + PyErr_Format(PyExc_ImportError, "cannot import name %S", name); + } + return value; } /* GetItemInt */ static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { PyObject *r; - if (!j) return NULL; + if (unlikely(!j)) return NULL; r = PyObject_GetItem(o, j); Py_DECREF(j); return r; @@ -24281,7 +38810,7 @@ static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { 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 +#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE && !CYTHON_AVOID_BORROWED_REFS && !CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { wrapped_i += PyList_GET_SIZE(o); @@ -24291,7 +38820,7 @@ static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_ Py_INCREF(r); return r; } - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); + return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif @@ -24299,7 +38828,7 @@ static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_ 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 +#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE && !CYTHON_AVOID_BORROWED_REFS Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { wrapped_i += PyTuple_GET_SIZE(o); @@ -24309,7 +38838,7 @@ static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize Py_INCREF(r); return r; } - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); + return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif @@ -24317,13 +38846,11 @@ static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize 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 CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE && !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(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { - PyObject *r = PyList_GET_ITEM(o, n); - Py_INCREF(r); - return r; + return __Pyx_PyList_GetItemRef(o, n); } } else if (PyTuple_CheckExact(o)) { @@ -24334,10 +38861,18 @@ static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, 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); + PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping; + PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence; + if (mm && mm->mp_subscript) { + PyObject *r, *key = PyLong_FromSsize_t(i); + if (unlikely(!key)) return NULL; + r = mm->mp_subscript(o, key); + Py_DECREF(key); + return r; + } + if (likely(sm && sm->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) { + Py_ssize_t l = sm->sq_length(o); if (likely(l >= 0)) { i += l; } else { @@ -24346,188 +38881,267 @@ static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, PyErr_Clear(); } } - return m->sq_item(o, i); + return sm->sq_item(o, i); } } #else - if (is_list || PySequence_Check(o)) { + if (is_list || !PyMapping_Check(o)) { return PySequence_GetItem(o, i); } #endif - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); + return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i)); } -/* ObjectGetItem */ -#if CYTHON_USE_TYPE_SLOTS -static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject* index) { - PyObject *runerr; - Py_ssize_t key_value; - PySequenceMethods *m = Py_TYPE(obj)->tp_as_sequence; - if (unlikely(!(m && m->sq_item))) { - PyErr_Format(PyExc_TypeError, "'%.200s' object is not subscriptable", Py_TYPE(obj)->tp_name); - return NULL; - } - key_value = __Pyx_PyIndex_AsSsize_t(index); - if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) { - return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1); - } - if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { - PyErr_Clear(); - PyErr_Format(PyExc_IndexError, "cannot fit '%.200s' into an index-sized integer", Py_TYPE(index)->tp_name); - } - return NULL; -} -static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key) { - PyMappingMethods *m = Py_TYPE(obj)->tp_as_mapping; - if (likely(m && m->mp_subscript)) { - return m->mp_subscript(obj, key); - } - return __Pyx_PyObject_GetIndex(obj, key); +/* PyObjectCallMethod1 */ +#if !(CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000))) +static PyObject* __Pyx__PyObject_CallMethod1(PyObject* method, PyObject* arg) { + PyObject *result = __Pyx_PyObject_CallOneArg(method, arg); + Py_DECREF(method); + return result; } #endif - -/* 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, (PyObject *)NULL); - Py_DECREF(py_level); - #else - module = PyImport_ImportModuleLevelObject( - name, global_dict, empty_dict, list, level); - #endif - } +static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) { +#if CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000)) + PyObject *args[2] = {obj, arg}; + (void) __Pyx_PyObject_GetMethod; + (void) __Pyx_PyObject_CallOneArg; + (void) __Pyx_PyObject_Call2Args; + return PyObject_VectorcallMethod(method_name, args, 2 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); +#else + PyObject *method = NULL, *result; + int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); + if (likely(is_method)) { + result = __Pyx_PyObject_Call2Args(method, obj, arg); + Py_DECREF(method); + return result; } -bad: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(py_import); - #endif - Py_XDECREF(empty_list); - Py_XDECREF(empty_dict); - return module; + if (unlikely(!method)) return NULL; + return __Pyx__PyObject_CallMethod1(method, arg); +#endif } -/* ImportFrom */ -static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { - PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); - if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { - PyErr_Format(PyExc_ImportError, - #if PY_MAJOR_VERSION < 3 - "cannot import name %.230s", PyString_AS_STRING(name)); - #else - "cannot import name %S", name); - #endif +/* append */ +static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x) { + if (likely(PyList_CheckExact(L))) { + if (unlikely(__Pyx_PyList_Append(L, x) < 0)) return -1; + } else { + PyObject* retval = __Pyx_PyObject_CallMethod1(L, __pyx_mstate_global->__pyx_n_u_append, x); + if (unlikely(!retval)) + return -1; + Py_DECREF(retval); } - return value; + return 0; } /* HasAttr */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d0000 static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { PyObject *r; - if (unlikely(!__Pyx_PyBaseString_Check(n))) { + if (unlikely(!PyUnicode_Check(n))) { PyErr_SetString(PyExc_TypeError, "hasattr(): attribute name must be string"); return -1; } - r = __Pyx_GetAttr(o, n); - if (unlikely(!r)) { - PyErr_Clear(); - return 0; + r = __Pyx_PyObject_GetAttrStrNoError(o, n); + if (!r) { + return (unlikely(PyErr_Occurred())) ? -1 : 0; } else { Py_DECREF(r); return 1; } } +#endif -/* PyObject_GenericGetAttrNoDict */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { - PyErr_Format(PyExc_AttributeError, -#if PY_MAJOR_VERSION >= 3 - "'%.50s' object has no attribute '%U'", - tp->tp_name, attr_name); +/* ValidateBasesTuple */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) { + Py_ssize_t i, n; +#if CYTHON_ASSUME_SAFE_SIZE + n = PyTuple_GET_SIZE(bases); #else - "'%.50s' object has no attribute '%.400s'", - tp->tp_name, PyString_AS_STRING(attr_name)); + n = PyTuple_Size(bases); + if (unlikely(n < 0)) return -1; #endif - return NULL; + for (i = 1; i < n; i++) + { + PyTypeObject *b; +#if CYTHON_AVOID_BORROWED_REFS + PyObject *b0 = PySequence_GetItem(bases, i); + if (!b0) return -1; +#elif CYTHON_ASSUME_SAFE_MACROS + PyObject *b0 = PyTuple_GET_ITEM(bases, i); +#else + PyObject *b0 = PyTuple_GetItem(bases, i); + if (!b0) return -1; +#endif + b = (PyTypeObject*) b0; + if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) + { + __Pyx_TypeName b_name = __Pyx_PyType_GetFullyQualifiedName(b); + PyErr_Format(PyExc_TypeError, + "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name); + __Pyx_DECREF_TypeName(b_name); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } + if (dictoffset == 0) + { + Py_ssize_t b_dictoffset = 0; +#if CYTHON_USE_TYPE_SLOTS + b_dictoffset = b->tp_dictoffset; +#else + PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__"); + if (!py_b_dictoffset) goto dictoffset_return; + b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset); + Py_DECREF(py_b_dictoffset); + if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return; +#endif + if (b_dictoffset) { + { + __Pyx_TypeName b_name = __Pyx_PyType_GetFullyQualifiedName(b); + PyErr_Format(PyExc_TypeError, + "extension type '%.200s' has no __dict__ slot, " + "but base type '" __Pyx_FMT_TYPENAME "' has: " + "either add 'cdef dict __dict__' to the extension type " + "or add '__slots__ = [...]' to the base type", + type_name, b_name); + __Pyx_DECREF_TypeName(b_name); + } +#if !CYTHON_USE_TYPE_SLOTS + dictoffset_return: +#endif +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } + } +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + } + return 0; } -static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { - PyObject *descr; - PyTypeObject *tp = Py_TYPE(obj); - if (unlikely(!PyString_Check(attr_name))) { - return PyObject_GenericGetAttr(obj, attr_name); +#endif + +/* PyType_Ready */ +CYTHON_UNUSED static int __Pyx_PyType_HasMultipleInheritance(PyTypeObject *t) { + while (t) { + PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); + if (bases) { + return 1; + } + t = __Pyx_PyType_GetSlot(t, tp_base, PyTypeObject*); } - assert(!tp->tp_dictoffset); - descr = _PyType_Lookup(tp, attr_name); - if (unlikely(!descr)) { - return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); + return 0; +} +static int __Pyx_PyType_Ready(PyTypeObject *t) { +#if CYTHON_USE_TYPE_SPECS || !CYTHON_COMPILING_IN_CPYTHON || defined(PYSTON_MAJOR_VERSION) + (void)__Pyx_PyObject_CallMethod0; +#if CYTHON_USE_TYPE_SPECS + (void)__Pyx_validate_bases_tuple; +#endif + return PyType_Ready(t); +#else + int r; + if (!__Pyx_PyType_HasMultipleInheritance(t)) { + return PyType_Ready(t); } - Py_INCREF(descr); - #if PY_MAJOR_VERSION < 3 - if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) - #endif + PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); + if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1)) + return -1; +#if !defined(PYSTON_MAJOR_VERSION) { - descrgetfunc f = Py_TYPE(descr)->tp_descr_get; - if (unlikely(f)) { - PyObject *res = f(descr, obj, (PyObject *)tp); - Py_DECREF(descr); - return res; + int gc_was_enabled; + #if PY_VERSION_HEX >= 0x030A00b1 + gc_was_enabled = PyGC_Disable(); + (void)__Pyx_PyObject_CallMethod0; + #else + PyObject *ret, *py_status; + PyObject *gc = NULL; + #if (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) &&\ + !CYTHON_COMPILING_IN_GRAAL + gc = PyImport_GetModule(__pyx_mstate_global->__pyx_kp_u_gc); + #endif + if (unlikely(!gc)) gc = PyImport_Import(__pyx_mstate_global->__pyx_kp_u_gc); + if (unlikely(!gc)) return -1; + py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_isenabled); + if (unlikely(!py_status)) { + Py_DECREF(gc); + return -1; + } + gc_was_enabled = __Pyx_PyObject_IsTrue(py_status); + Py_DECREF(py_status); + if (gc_was_enabled > 0) { + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_disable); + if (unlikely(!ret)) { + Py_DECREF(gc); + return -1; + } + Py_DECREF(ret); + } else if (unlikely(gc_was_enabled == -1)) { + Py_DECREF(gc); + return -1; + } + #endif + t->tp_flags |= Py_TPFLAGS_HEAPTYPE; +#if PY_VERSION_HEX >= 0x030A0000 + t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE; +#endif +#else + (void)__Pyx_PyObject_CallMethod0; +#endif + r = PyType_Ready(t); +#if !defined(PYSTON_MAJOR_VERSION) + t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE; + #if PY_VERSION_HEX >= 0x030A00b1 + if (gc_was_enabled) + PyGC_Enable(); + #else + if (gc_was_enabled) { + PyObject *tp, *v, *tb; + PyErr_Fetch(&tp, &v, &tb); + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_enable); + if (likely(ret || r == -1)) { + Py_XDECREF(ret); + PyErr_Restore(tp, v, tb); + } else { + Py_XDECREF(tp); + Py_XDECREF(v); + Py_XDECREF(tb); + r = -1; + } } + Py_DECREF(gc); + #endif } - return descr; +#endif + return r; +#endif } + +/* DelItemOnTypeDict */ +static int __Pyx__DelItemOnTypeDict(PyTypeObject *tp, PyObject *k) { + int result; + PyObject *tp_dict; +#if CYTHON_COMPILING_IN_LIMITED_API + tp_dict = __Pyx_GetTypeDict(tp); + if (unlikely(!tp_dict)) return -1; +#else + tp_dict = tp->tp_dict; #endif + result = PyDict_DelItem(tp_dict, k); + if (likely(!result)) PyType_Modified(tp); + return result; +} /* SetupReduce */ static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { int ret; PyObject *name_attr; - name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name); + name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_mstate_global->__pyx_n_u_name_2); if (likely(name_attr)) { ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); } else { @@ -24543,53 +39157,86 @@ static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { static int __Pyx_setup_reduce(PyObject* type_obj) { int ret = 0; PyObject *object_reduce = NULL; + PyObject *object_getstate = NULL; PyObject *object_reduce_ex = NULL; PyObject *reduce = NULL; PyObject *reduce_ex = NULL; PyObject *reduce_cython = NULL; PyObject *setstate = NULL; PyObject *setstate_cython = NULL; + PyObject *getstate = NULL; #if CYTHON_USE_PYTYPE_LOOKUP - if (_PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate)) goto GOOD; + getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_getstate); #else - if (PyObject_HasAttr(type_obj, __pyx_n_s_getstate)) goto GOOD; + getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_getstate); + if (!getstate && PyErr_Occurred()) { + goto __PYX_BAD; + } #endif + if (getstate) { #if CYTHON_USE_PYTYPE_LOOKUP - object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto BAD; + object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_getstate); #else - object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto BAD; + object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_getstate); + if (!object_getstate && PyErr_Occurred()) { + goto __PYX_BAD; + } #endif - reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto BAD; - if (reduce_ex == object_reduce_ex) { + if (object_getstate != getstate) { + goto __PYX_GOOD; + } + } #if CYTHON_USE_PYTYPE_LOOKUP - object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto BAD; + object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; #else - object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto BAD; + object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; #endif - reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto BAD; - if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { - reduce_cython = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_cython); if (unlikely(!reduce_cython)) goto BAD; - ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto BAD; - ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto BAD; - setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate); + reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_mstate_global->__pyx_n_u_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; + if (reduce_ex == object_reduce_ex) { +#if CYTHON_USE_PYTYPE_LOOKUP + object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_reduce); if (!object_reduce) goto __PYX_BAD; +#else + object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_reduce); if (!object_reduce) goto __PYX_BAD; +#endif + reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_mstate_global->__pyx_n_u_reduce); if (unlikely(!reduce)) goto __PYX_BAD; + if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_mstate_global->__pyx_n_u_reduce_cython)) { + reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_reduce_cython); + if (likely(reduce_cython)) { + ret = __Pyx_SetItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = __Pyx_DelItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + } else if (reduce == object_reduce || PyErr_Occurred()) { + goto __PYX_BAD; + } + setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_setstate); if (!setstate) PyErr_Clear(); - if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { - setstate_cython = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate_cython); if (unlikely(!setstate_cython)) goto BAD; - ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto BAD; - ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto BAD; + if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_mstate_global->__pyx_n_u_setstate_cython)) { + setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_setstate_cython); + if (likely(setstate_cython)) { + ret = __Pyx_SetItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = __Pyx_DelItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + } else if (!setstate || PyErr_Occurred()) { + goto __PYX_BAD; + } } PyType_Modified((PyTypeObject*)type_obj); } } - goto GOOD; -BAD: - if (!PyErr_Occurred()) - PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name); + goto __PYX_GOOD; +__PYX_BAD: + if (!PyErr_Occurred()) { + __Pyx_TypeName type_obj_name = + __Pyx_PyType_GetFullyQualifiedName((PyTypeObject*)type_obj); + PyErr_Format(PyExc_RuntimeError, + "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name); + __Pyx_DECREF_TypeName(type_obj_name); + } ret = -1; -GOOD: +__PYX_GOOD: #if !CYTHON_USE_PYTYPE_LOOKUP Py_XDECREF(object_reduce); Py_XDECREF(object_reduce_ex); + Py_XDECREF(object_getstate); + Py_XDECREF(getstate); #endif Py_XDECREF(reduce); Py_XDECREF(reduce_ex); @@ -24600,16 +39247,17 @@ static int __Pyx_setup_reduce(PyObject* type_obj) { } /* TypeImport */ -#ifndef __PYX_HAVE_RT_ImportType -#define __PYX_HAVE_RT_ImportType -static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, - size_t size, enum __Pyx_ImportType_CheckSize check_size) +#ifndef __PYX_HAVE_RT_ImportType_3_1_3 +#define __PYX_HAVE_RT_ImportType_3_1_3 +static PyTypeObject *__Pyx_ImportType_3_1_3(PyObject *module, const char *module_name, const char *class_name, + size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_1_3 check_size) { PyObject *result = 0; - char warning[200]; Py_ssize_t basicsize; -#ifdef Py_LIMITED_API + Py_ssize_t itemsize; +#if CYTHON_COMPILING_IN_LIMITED_API PyObject *py_basicsize; + PyObject *py_itemsize; #endif result = PyObject_GetAttrString(module, class_name); if (!result) @@ -24620,9 +39268,13 @@ static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, module_name, class_name); goto bad; } -#ifndef Py_LIMITED_API +#if !CYTHON_COMPILING_IN_LIMITED_API basicsize = ((PyTypeObject *)result)->tp_basicsize; + itemsize = ((PyTypeObject *)result)->tp_itemsize; #else + if (size == 0) { + return (PyTypeObject *)result; + } py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); if (!py_basicsize) goto bad; @@ -24631,27 +39283,44 @@ static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, py_basicsize = 0; if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) goto bad; + py_itemsize = PyObject_GetAttrString(result, "__itemsize__"); + if (!py_itemsize) + goto bad; + itemsize = PyLong_AsSsize_t(py_itemsize); + Py_DECREF(py_itemsize); + py_itemsize = 0; + if (itemsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; #endif - if ((size_t)basicsize < size) { + if (itemsize) { + if (size % alignment) { + alignment = size % alignment; + } + if (itemsize < (Py_ssize_t)alignment) + itemsize = (Py_ssize_t)alignment; + } + if ((size_t)(basicsize + itemsize) < size) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", - module_name, class_name, size, basicsize); + module_name, class_name, size, basicsize+itemsize); goto bad; } - if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) { + if (check_size == __Pyx_ImportType_CheckSize_Error_3_1_3 && + ((size_t)basicsize > size || (size_t)(basicsize + itemsize) < size)) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " - "Expected %zd from C header, got %zd from PyObject", - module_name, class_name, size, basicsize); + "Expected %zd from C header, got %zd-%zd from PyObject", + module_name, class_name, size, basicsize, basicsize+itemsize); goto bad; } - else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) { - PyOS_snprintf(warning, sizeof(warning), - "%s.%s size changed, may indicate binary incompatibility. " - "Expected %zd from C header, got %zd from PyObject", - module_name, class_name, size, basicsize); - if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; + else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_1_3 && (size_t)basicsize > size) { + if (PyErr_WarnFormat(NULL, 0, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize) < 0) { + goto bad; + } } return (PyTypeObject *)result; bad: @@ -24661,16 +39330,16 @@ static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, #endif /* GetVTable */ -static void* __Pyx_GetVtable(PyObject *dict) { +static void* __Pyx_GetVtable(PyTypeObject *type) { void* ptr; - PyObject *ob = PyObject_GetItem(dict, __pyx_n_s_pyx_vtable); +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *ob = PyObject_GetAttr((PyObject *)type, __pyx_mstate_global->__pyx_n_u_pyx_vtable); +#else + PyObject *ob = PyObject_GetItem(type->tp_dict, __pyx_mstate_global->__pyx_n_u_pyx_vtable); +#endif if (!ob) goto bad; -#if PY_VERSION_HEX >= 0x02070000 ptr = PyCapsule_GetPointer(ob, 0); -#else - ptr = PyCObject_AsVoidPtr(ob); -#endif if (!ptr && !PyErr_Occurred()) PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type"); Py_DECREF(ob); @@ -24680,95 +39349,54 @@ static void* __Pyx_GetVtable(PyObject *dict) { return NULL; } -/* PatchModuleWithCoroutine */ -static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code) { -#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) - int result; - PyObject *globals, *result_obj; - globals = PyDict_New(); if (unlikely(!globals)) goto ignore; - result = PyDict_SetItemString(globals, "_cython_coroutine_type", - #ifdef __Pyx_Coroutine_USED - (PyObject*)__pyx_CoroutineType); - #else - Py_None); - #endif - if (unlikely(result < 0)) goto ignore; - result = PyDict_SetItemString(globals, "_cython_generator_type", - #ifdef __Pyx_Generator_USED - (PyObject*)__pyx_GeneratorType); - #else - Py_None); - #endif - if (unlikely(result < 0)) goto ignore; - if (unlikely(PyDict_SetItemString(globals, "_module", module) < 0)) goto ignore; - if (unlikely(PyDict_SetItemString(globals, "__builtins__", __pyx_b) < 0)) goto ignore; - result_obj = PyRun_String(py_code, Py_file_input, globals, globals); - if (unlikely(!result_obj)) goto ignore; - Py_DECREF(result_obj); - Py_DECREF(globals); - return module; -ignore: - Py_XDECREF(globals); - PyErr_WriteUnraisable(module); - if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, "Cython module failed to patch module with custom type", 1) < 0)) { - Py_DECREF(module); - module = NULL; - } -#else - py_code++; -#endif - return module; -} - -/* PatchInspect */ -static PyObject* __Pyx_patch_inspect(PyObject* module) { -#if defined(__Pyx_Generator_USED) && (!defined(CYTHON_PATCH_INSPECT) || CYTHON_PATCH_INSPECT) - static int inspect_patched = 0; - if (unlikely((!inspect_patched) && module)) { - module = __Pyx_Coroutine_patch_module( - module, "" -"old_types = getattr(_module.isgenerator, '_cython_generator_types', None)\n" -"if old_types is None or not isinstance(old_types, set):\n" -" old_types = set()\n" -" def cy_wrap(orig_func, type=type, cython_generator_types=old_types):\n" -" def cy_isgenerator(obj): return type(obj) in cython_generator_types or orig_func(obj)\n" -" cy_isgenerator._cython_generator_types = cython_generator_types\n" -" return cy_isgenerator\n" -" _module.isgenerator = cy_wrap(_module.isgenerator)\n" -"old_types.add(_cython_generator_type)\n" - ); - inspect_patched = 1; +/* ListPack */ +static PyObject *__Pyx_PyList_Pack(Py_ssize_t n, ...) { + va_list va; + PyObject *l = PyList_New(n); + va_start(va, n); + if (unlikely(!l)) goto end; + for (Py_ssize_t i=0; i__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); + cython_runtime_dict = _PyObject_GetDictPtr(__pyx_mstate_global->__pyx_cython_runtime); if (likely(cython_runtime_dict)) { + __Pyx_BEGIN_CRITICAL_SECTION(*cython_runtime_dict); __PYX_PY_DICT_LOOKUP_IF_MODIFIED( use_cline, *cython_runtime_dict, - __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) + __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_mstate_global->__pyx_n_u_cline_in_traceback)) + Py_XINCREF(use_cline); + __Pyx_END_CRITICAL_SECTION(); } else #endif { - PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_mstate_global->__pyx_cython_runtime, __pyx_mstate_global->__pyx_n_u_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; + Py_INCREF(use_cline); Py_DECREF(use_cline_obj); } else { PyErr_Clear(); @@ -24777,11 +39405,12 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { } if (!use_cline) { c_line = 0; - PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); + (void) PyObject_SetAttr(__pyx_mstate_global->__pyx_cython_runtime, __pyx_mstate_global->__pyx_n_u_cline_in_traceback, Py_False); } else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { c_line = 0; } + Py_XDECREF(use_cline); __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); return c_line; } @@ -24809,117 +39438,195 @@ static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int co return mid + 1; } } -static PyCodeObject *__pyx_find_code_object(int code_line) { - PyCodeObject* code_object; +static __Pyx_CachedCodeObjectType *__pyx__find_code_object(struct __Pyx_CodeObjectCache *code_cache, int code_line) { + __Pyx_CachedCodeObjectType* code_object; int pos; - if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + if (unlikely(!code_line) || unlikely(!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)) { + pos = __pyx_bisect_code_objects(code_cache->entries, code_cache->count, code_line); + if (unlikely(pos >= code_cache->count) || unlikely(code_cache->entries[pos].code_line != code_line)) { return NULL; } - code_object = __pyx_code_cache.entries[pos].code_object; + code_object = 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) { +static __Pyx_CachedCodeObjectType *__pyx_find_code_object(int code_line) { +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && !CYTHON_ATOMICS + (void)__pyx__find_code_object; + return NULL; // Most implementation should have atomics. But otherwise, don't make it thread-safe, just miss. +#else + struct __Pyx_CodeObjectCache *code_cache = &__pyx_mstate_global->__pyx_code_cache; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_nonatomic_int_type old_count = __pyx_atomic_incr_acq_rel(&code_cache->accessor_count); + if (old_count < 0) { + __pyx_atomic_decr_acq_rel(&code_cache->accessor_count); + return NULL; + } +#endif + __Pyx_CachedCodeObjectType *result = __pyx__find_code_object(code_cache, code_line); +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_atomic_decr_acq_rel(&code_cache->accessor_count); +#endif + return result; +#endif +} +static void __pyx__insert_code_object(struct __Pyx_CodeObjectCache *code_cache, int code_line, __Pyx_CachedCodeObjectType* code_object) +{ int pos, i; - __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + __Pyx_CodeObjectCacheEntry* entries = 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; + code_cache->entries = entries; + code_cache->max_count = 64; + 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; + pos = __pyx_bisect_code_objects(code_cache->entries, code_cache->count, code_line); + if ((pos < code_cache->count) && unlikely(code_cache->entries[pos].code_line == code_line)) { + __Pyx_CachedCodeObjectType* tmp = entries[pos].code_object; entries[pos].code_object = code_object; + Py_INCREF(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; + if (code_cache->count == code_cache->max_count) { + int new_max = code_cache->max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( - __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); + 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; + code_cache->entries = entries; + code_cache->max_count = new_max; } - for (i=__pyx_code_cache.count; i>pos; i--) { + for (i=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++; + code_cache->count++; Py_INCREF(code_object); } +static void __pyx_insert_code_object(int code_line, __Pyx_CachedCodeObjectType* code_object) { +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && !CYTHON_ATOMICS + (void)__pyx__insert_code_object; + return; // Most implementation should have atomics. But otherwise, don't make it thread-safe, just fail. +#else + struct __Pyx_CodeObjectCache *code_cache = &__pyx_mstate_global->__pyx_code_cache; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_nonatomic_int_type expected = 0; + if (!__pyx_atomic_int_cmp_exchange(&code_cache->accessor_count, &expected, INT_MIN)) { + return; + } +#endif + __pyx__insert_code_object(code_cache, code_line, code_object); +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_atomic_sub(&code_cache->accessor_count, INT_MIN); +#endif +#endif +} /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API && !defined(PYPY_VERSION) + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict, + PyObject *firstlineno, PyObject *name) { + PyObject *replace = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL; + replace = PyObject_GetAttrString(code, "replace"); + if (likely(replace)) { + PyObject *result = PyObject_Call(replace, __pyx_mstate_global->__pyx_empty_tuple, scratch_dict); + Py_DECREF(replace); + return result; + } + PyErr_Clear(); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL; + PyObject *replace = NULL, *getframe = NULL, *frame = NULL; + PyObject *exc_type, *exc_value, *exc_traceback; + int success = 0; + if (c_line) { + (void) __pyx_cfilenm; + (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); + } + PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); + code_object = __pyx_find_code_object(c_line ? -c_line : py_line); + if (!code_object) { + code_object = Py_CompileString("_getframe()", filename, Py_eval_input); + if (unlikely(!code_object)) goto bad; + py_py_line = PyLong_FromLong(py_line); + if (unlikely(!py_py_line)) goto bad; + py_funcname = PyUnicode_FromString(funcname); + if (unlikely(!py_funcname)) goto bad; + dict = PyDict_New(); + if (unlikely(!dict)) goto bad; + { + PyObject *old_code_object = code_object; + code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname); + Py_DECREF(old_code_object); + } + if (unlikely(!code_object)) goto bad; + __pyx_insert_code_object(c_line ? -c_line : py_line, code_object); + } else { + dict = PyDict_New(); + } + getframe = PySys_GetObject("_getframe"); + if (unlikely(!getframe)) goto bad; + if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad; + frame = PyEval_EvalCode(code_object, dict, dict); + if (unlikely(!frame) || frame == Py_None) goto bad; + success = 1; + bad: + PyErr_Restore(exc_type, exc_value, exc_traceback); + Py_XDECREF(code_object); + Py_XDECREF(py_py_line); + Py_XDECREF(py_funcname); + Py_XDECREF(dict); + Py_XDECREF(replace); + if (success) { + PyTraceBack_Here( + (struct _frame*)frame); + } + Py_XDECREF(frame); +} +#else 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; + PyCodeObject *py_code = NULL; + PyObject *py_funcname = NULL; 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; + funcname = PyUnicode_AsUTF8(py_funcname); + if (!funcname) goto bad; } - 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); + py_code = PyCode_NewEmpty(filename, funcname, py_line); + Py_XDECREF(py_funcname); return py_code; bad: - Py_XDECREF(py_srcfile); Py_XDECREF(py_funcname); return NULL; } @@ -24928,20 +39635,30 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, PyCodeObject *py_code = 0; PyFrameObject *py_frame = 0; PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject *ptype, *pvalue, *ptraceback; 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) { + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); py_code = __Pyx_CreateCodeObjectForTraceback( funcname, c_line, py_line, filename); - if (!py_code) goto bad; + if (!py_code) { + /* If the code object creation fails, then we should clear the + fetched exception references and propagate the new exception */ + Py_XDECREF(ptype); + Py_XDECREF(pvalue); + Py_XDECREF(ptraceback); + goto bad; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); __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,*/ + __pyx_mstate_global->__pyx_d, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); if (!py_frame) goto bad; @@ -24951,37 +39668,7 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, Py_XDECREF(py_code); Py_XDECREF(py_frame); } - -/* CIntToPy */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { - const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; - const int is_unsigned = neg_one > const_zero; - if (is_unsigned) { - if (sizeof(int) < sizeof(long)) { - return PyInt_FromLong((long) value); - } else if (sizeof(int) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { - return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); -#endif - } - } else { - if (sizeof(int) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= 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(int), - little, !is_unsigned); - } -} /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ @@ -25006,213 +39693,318 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { } /* CIntToPy */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { - const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_int(int value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif 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)) { + if (sizeof(int) < sizeof(long)) { + return PyLong_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { +#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY + } else if (sizeof(int) <= 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); + if (sizeof(int) <= sizeof(long)) { + return PyLong_FromLong((long) value); #ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + } else if (sizeof(int) <= 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), +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 + if (is_unsigned) { + return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); + } else { + return PyLong_FromNativeBytes(bytes, sizeof(value), -1); + } +#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 + int one = 1; int little = (int)*(unsigned char *)&one; + return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); +#else + int one = 1; int little = (int)*(unsigned char *)&one; + PyObject *from_bytes, *result = NULL, *kwds = NULL; + PyObject *py_bytes = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + { + PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str }; + if (!is_unsigned) { + kwds = __Pyx_MakeVectorcallBuilderKwds(1); + if (!kwds) goto limited_bad; + if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad; + } + result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); + } + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif } } /* CIntFromPy */ -static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { - const int neg_one = (int) ((int) 0 - (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 +static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" #endif - if (likely(PyLong_Check(x))) { - if (is_unsigned) { + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (unlikely(!PyLong_Check(x))) { + int val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (int) -1; + val = __Pyx_PyLong_As_int(tmp); + Py_DECREF(tmp); + return val; + } + 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]) + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { case 2: - if (8 * sizeof(int) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + 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) { + } 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) { + 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) { + } 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) { + 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) { + } 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; - } +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 + 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; - } + { + 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)) + 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)) + } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif - } - } else { + } + } 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]) + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { case -2: - if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + 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) { + } 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) { + 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) { + } 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) { + 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) { + } 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) { + 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) { + } 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) { + 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) { + } 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) { + 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) { + } 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)) + 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)) + } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif - } + } + } + { + int val; + int ret = -1; +#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } +#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (int) -1; + assert(PyLong_CheckExact(v)); } { -#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); + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { Py_DECREF(v); - if (likely(!ret)) - return val; + return (int) -1; } + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (int) -1; + } else { + stepval = v; + } + v = NULL; + val = (int) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((int) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((int) idigit) << bits; + } + if (!is_unsigned) { + if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); #endif + if (unlikely(ret)) 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: @@ -25226,182 +40018,247 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { } /* CIntFromPy */ -static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { - const long neg_one = (long) ((long) 0 - (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 +static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" #endif - if (likely(PyLong_Check(x))) { - if (is_unsigned) { + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (unlikely(!PyLong_Check(x))) { + long val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (long) -1; + val = __Pyx_PyLong_As_long(tmp); + Py_DECREF(tmp); + return val; + } + 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]) + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { case 2: - if (8 * sizeof(long) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + 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) { + } 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) { + 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) { + } 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) { + 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) { + } 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; - } +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 + 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; - } + { + 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)) + 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)) + } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif - } - } else { + } + } 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]) + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { case -2: - if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + 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) { + } 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) { + 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) { + } 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) { + 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) { + } 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) { + 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) { + } 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) { + 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) { + } 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) { + 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) { + } 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)) + 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)) + } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif - } + } + } + { + long val; + int ret = -1; +#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } +#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (long) -1; + assert(PyLong_CheckExact(v)); } { -#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); + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { Py_DECREF(v); - if (likely(!ret)) - return val; + return (long) -1; } + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (long) -1; + } else { + stepval = v; + } + v = NULL; + val = (long) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((long) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((long) idigit) << bits; + } + if (!is_unsigned) { + if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); #endif + if (unlikely(ret)) 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: @@ -25414,11 +40271,121 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { return (long) -1; } +/* CIntToPy */ +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyLong_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY + } 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 PyLong_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 + if (is_unsigned) { + return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); + } else { + return PyLong_FromNativeBytes(bytes, sizeof(value), -1); + } +#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 + int one = 1; int little = (int)*(unsigned char *)&one; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); +#else + int one = 1; int little = (int)*(unsigned char *)&one; + PyObject *from_bytes, *result = NULL, *kwds = NULL; + PyObject *py_bytes = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + { + PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str }; + if (!is_unsigned) { + kwds = __Pyx_MakeVectorcallBuilderKwds(1); + if (!kwds) goto limited_bad; + if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad; + } + result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); + } + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif + } +} + +/* FormatTypeName */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 +static __Pyx_TypeName +__Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp) +{ + PyObject *module = NULL, *name = NULL, *result = NULL; + #if __PYX_LIMITED_VERSION_HEX < 0x030b0000 + name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_mstate_global->__pyx_n_u_qualname); + #else + name = PyType_GetQualName(tp); + #endif + if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) goto bad; + module = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_mstate_global->__pyx_n_u_module_2); + if (unlikely(module == NULL) || unlikely(!PyUnicode_Check(module))) goto bad; + if (PyUnicode_CompareWithASCIIString(module, "builtins") == 0) { + result = name; + name = NULL; + goto done; + } + result = PyUnicode_FromFormat("%U.%U", module, name); + if (unlikely(result == NULL)) goto bad; + done: + Py_XDECREF(name); + Py_XDECREF(module); + return result; + bad: + PyErr_Clear(); + if (name) { + result = name; + name = NULL; + } else { + result = __Pyx_NewRef(__pyx_mstate_global->__pyx_kp_u__9); + } + goto done; +} +#endif + /* FastTypeChecks */ #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { - a = a->tp_base; + a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*); if (a == b) return 1; } @@ -25439,51 +40406,38 @@ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { } 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; +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (cls == a || cls == b) return 1; + mro = cls->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + PyObject *base = PyTuple_GET_ITEM(mro, i); + if (base == (PyObject *)a || base == (PyObject *)b) + return 1; } + return 0; } - __Pyx_ErrRestore(exception, value, tb); - return res; + return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b); } -#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); + if (exc_type1) { + return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2); + } else { + return __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; itp_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; -} - /* GetTopmostException */ -#if CYTHON_USE_EXC_INFO_STACK +#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate) { _PyErr_StackItem *exc_info = tstate->exc_info; - while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && + while ((exc_info->exc_value == NULL || exc_info->exc_value == Py_None) && exc_info->previous_item != NULL) { exc_info = exc_info->previous_item; @@ -25571,21 +40486,46 @@ __Pyx_PyErr_GetTopmostException(PyThreadState *tstate) /* SaveResetException */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { - #if CYTHON_USE_EXC_INFO_STACK + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + PyObject *exc_value = exc_info->exc_value; + if (exc_value == NULL || exc_value == Py_None) { + *value = NULL; + *type = NULL; + *tb = NULL; + } else { + *value = exc_value; + Py_INCREF(*value); + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + *tb = PyException_GetTraceback(exc_value); + } + #elif CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); *type = exc_info->exc_type; *value = exc_info->exc_value; *tb = exc_info->exc_traceback; - #else + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); + #else *type = tstate->exc_type; *value = tstate->exc_value; *tb = tstate->exc_traceback; - #endif Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); + #endif } static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = tstate->exc_info; + PyObject *tmp_value = exc_info->exc_value; + exc_info->exc_value = value; + Py_XDECREF(tmp_value); + Py_XDECREF(type); + Py_XDECREF(tb); + #else PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; @@ -25606,6 +40546,7 @@ static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); + #endif } #endif @@ -25613,7 +40554,26 @@ static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; - #if CYTHON_USE_EXC_INFO_STACK + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_value = exc_info->exc_value; + exc_info->exc_value = *value; + if (tmp_value == NULL || tmp_value == Py_None) { + Py_XDECREF(tmp_value); + tmp_value = NULL; + tmp_type = NULL; + tmp_tb = NULL; + } else { + tmp_type = (PyObject*) Py_TYPE(tmp_value); + Py_INCREF(tmp_type); + #if CYTHON_COMPILING_IN_CPYTHON + tmp_tb = ((PyBaseExceptionObject*) tmp_value)->traceback; + Py_XINCREF(tmp_tb); + #else + tmp_tb = PyException_GetTraceback(tmp_value); + #endif + } + #elif CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; @@ -25621,14 +40581,14 @@ static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject * exc_info->exc_type = *type; exc_info->exc_value = *value; exc_info->exc_traceback = *tb; - #else + #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = *type; tstate->exc_value = *value; tstate->exc_traceback = *tb; - #endif + #endif *type = tmp_type; *value = tmp_value; *tb = tmp_tb; @@ -25643,32 +40603,105 @@ static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, *tb = tmp_tb; } #endif - -/* PyObjectCallMethod1 */ -static PyObject* __Pyx__PyObject_CallMethod1(PyObject* method, PyObject* arg) { - PyObject *result = __Pyx_PyObject_CallOneArg(method, arg); - Py_DECREF(method); + +/* IterNextPlain */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 +static PyObject *__Pyx_GetBuiltinNext_LimitedAPI(void) { + if (unlikely(!__pyx_mstate_global->__Pyx_GetBuiltinNext_LimitedAPI_cache)) + __pyx_mstate_global->__Pyx_GetBuiltinNext_LimitedAPI_cache = __Pyx_GetBuiltinName(__pyx_mstate_global->__pyx_n_u_next); + return __pyx_mstate_global->__Pyx_GetBuiltinNext_LimitedAPI_cache; +} +#endif +static CYTHON_INLINE PyObject *__Pyx_PyIter_Next_Plain(PyObject *iterator) { +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + PyObject *result; + PyObject *next = __Pyx_GetBuiltinNext_LimitedAPI(); + if (unlikely(!next)) return NULL; + result = PyObject_CallFunctionObjArgs(next, iterator, NULL); return result; +#else + (void)__Pyx_GetBuiltinName; // only for early limited API + iternextfunc iternext = __Pyx_PyObject_GetIterNextFunc(iterator); + assert(iternext); + return iternext(iterator); +#endif } -static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) { - PyObject *method = NULL, *result; - int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); - if (likely(is_method)) { - result = __Pyx_PyObject_Call2Args(method, obj, arg); - Py_DECREF(method); - return result; + +/* ReturnWithStopIteration */ +static void __Pyx__ReturnWithStopIteration(PyObject* value, int async); +static CYTHON_INLINE void __Pyx_ReturnWithStopIteration(PyObject* value, int async, int iternext) { + if (value == Py_None) { + if (async || !iternext) + PyErr_SetNone(async ? PyExc_StopAsyncIteration : PyExc_StopIteration); + return; } - if (unlikely(!method)) return NULL; - return __Pyx__PyObject_CallMethod1(method, arg); + __Pyx__ReturnWithStopIteration(value, async); +} +static void __Pyx__ReturnWithStopIteration(PyObject* value, int async) { +#if CYTHON_COMPILING_IN_CPYTHON + __Pyx_PyThreadState_declare +#endif + PyObject *exc; + PyObject *exc_type = async ? PyExc_StopAsyncIteration : PyExc_StopIteration; +#if CYTHON_COMPILING_IN_CPYTHON + if ((PY_VERSION_HEX >= (0x030C00A6)) || unlikely(PyTuple_Check(value) || PyExceptionInstance_Check(value))) { + if (PY_VERSION_HEX >= (0x030e00A1)) { + exc = __Pyx_PyObject_CallOneArg(exc_type, value); + } else { + PyObject *args_tuple = PyTuple_New(1); + if (unlikely(!args_tuple)) return; + Py_INCREF(value); + PyTuple_SET_ITEM(args_tuple, 0, value); + exc = PyObject_Call(exc_type, args_tuple, NULL); + Py_DECREF(args_tuple); + } + if (unlikely(!exc)) return; + } else { + Py_INCREF(value); + exc = value; + } + #if CYTHON_FAST_THREAD_STATE + __Pyx_PyThreadState_assign + #if CYTHON_USE_EXC_INFO_STACK + if (!__pyx_tstate->exc_info->exc_value) + #else + if (!__pyx_tstate->exc_type) + #endif + { + Py_INCREF(exc_type); + __Pyx_ErrRestore(exc_type, exc, NULL); + return; + } + #endif +#else + exc = __Pyx_PyObject_CallOneArg(exc_type, value); + if (unlikely(!exc)) return; +#endif + PyErr_SetObject(exc_type, exc); + Py_DECREF(exc); } /* CoroutineBase */ -#include +#if !CYTHON_COMPILING_IN_LIMITED_API #include -#define __Pyx_Coroutine_Undelegate(gen) Py_CLEAR((gen)->yieldfrom) -static int __Pyx_PyGen__FetchStopIterationValue(CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject **pvalue) { +#if PY_VERSION_HEX >= 0x030b00a6 && !defined(PYPY_VERSION) + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif +#endif // CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE void +__Pyx_Coroutine_Undelegate(__pyx_CoroutineObject *gen) { +#if CYTHON_USE_AM_SEND + gen->yieldfrom_am_send = NULL; +#endif + Py_CLEAR(gen->yieldfrom); +} +static int __Pyx_PyGen__FetchStopIterationValue(PyThreadState *__pyx_tstate, PyObject **pvalue) { PyObject *et, *ev, *tb; PyObject *value = NULL; + CYTHON_UNUSED_VAR(__pyx_tstate); __Pyx_ErrFetch(&et, &ev, &tb); if (!et) { Py_XDECREF(tb); @@ -25682,20 +40715,35 @@ static int __Pyx_PyGen__FetchStopIterationValue(CYTHON_UNUSED PyThreadState *__p Py_INCREF(Py_None); value = Py_None; } -#if PY_VERSION_HEX >= 0x030300A0 - else if (Py_TYPE(ev) == (PyTypeObject*)PyExc_StopIteration) { + else if (likely(__Pyx_IS_TYPE(ev, (PyTypeObject*)PyExc_StopIteration))) { + #if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL + value = PyObject_GetAttr(ev, __pyx_mstate_global->__pyx_n_u_value); + if (unlikely(!value)) goto limited_api_failure; + #else value = ((PyStopIterationObject *)ev)->value; Py_INCREF(value); + #endif Py_DECREF(ev); } -#endif else if (unlikely(PyTuple_Check(ev))) { - if (PyTuple_GET_SIZE(ev) >= 1) { + Py_ssize_t tuple_size = __Pyx_PyTuple_GET_SIZE(ev); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(tuple_size < 0)) { + Py_XDECREF(tb); + Py_DECREF(ev); + Py_DECREF(et); + return -1; + } + #endif + if (tuple_size >= 1) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS value = PyTuple_GET_ITEM(ev, 0); Py_INCREF(value); -#else +#elif CYTHON_ASSUME_SAFE_MACROS value = PySequence_ITEM(ev, 0); +#else + value = PySequence_GetItem(ev, 0); + if (!value) goto limited_api_failure; #endif } else { Py_INCREF(Py_None); @@ -25723,30 +40771,41 @@ static int __Pyx_PyGen__FetchStopIterationValue(CYTHON_UNUSED PyThreadState *__p } Py_XDECREF(tb); Py_DECREF(et); -#if PY_VERSION_HEX >= 0x030300A0 +#if CYTHON_COMPILING_IN_LIMITED_API + value = PyObject_GetAttr(ev, __pyx_mstate_global->__pyx_n_u_value); +#else value = ((PyStopIterationObject *)ev)->value; Py_INCREF(value); +#endif Py_DECREF(ev); -#else - { - PyObject* args = __Pyx_PyObject_GetAttrStr(ev, __pyx_n_s_args); - Py_DECREF(ev); - if (likely(args)) { - value = PySequence_GetItem(args, 0); - Py_DECREF(args); - } - if (unlikely(!value)) { - __Pyx_ErrRestore(NULL, NULL, NULL); - Py_INCREF(Py_None); - value = Py_None; - } - } +#if CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(!value)) return -1; #endif *pvalue = value; return 0; +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL || !CYTHON_ASSUME_SAFE_MACROS + limited_api_failure: + Py_XDECREF(et); + Py_XDECREF(tb); + Py_XDECREF(ev); + return -1; +#endif +} +static CYTHON_INLINE +__Pyx_PySendResult __Pyx_Coroutine_status_from_result(PyObject **retval) { + if (*retval) { + return PYGEN_NEXT; + } else if (likely(__Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, retval) == 0)) { + return PYGEN_RETURN; + } else { + return PYGEN_ERROR; + } } static CYTHON_INLINE void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *exc_state) { +#if PY_VERSION_HEX >= 0x030B00a4 + Py_CLEAR(exc_state->exc_value); +#else PyObject *t, *v, *tb; t = exc_state->exc_type; v = exc_state->exc_value; @@ -25757,10 +40816,12 @@ void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *exc_state) { Py_XDECREF(t); Py_XDECREF(v); Py_XDECREF(tb); +#endif } #define __Pyx_Coroutine_AlreadyRunningError(gen) (__Pyx__Coroutine_AlreadyRunningError(gen), (PyObject*)NULL) -static void __Pyx__Coroutine_AlreadyRunningError(CYTHON_UNUSED __pyx_CoroutineObject *gen) { +static void __Pyx__Coroutine_AlreadyRunningError(__pyx_CoroutineObject *gen) { const char *msg; + CYTHON_MAYBE_UNUSED_VAR(gen); if ((0)) { #ifdef __Pyx_Coroutine_USED } else if (__Pyx_Coroutine_Check((PyObject*)gen)) { @@ -25775,25 +40836,9 @@ static void __Pyx__Coroutine_AlreadyRunningError(CYTHON_UNUSED __pyx_CoroutineOb } PyErr_SetString(PyExc_ValueError, msg); } -#define __Pyx_Coroutine_NotStartedError(gen) (__Pyx__Coroutine_NotStartedError(gen), (PyObject*)NULL) -static void __Pyx__Coroutine_NotStartedError(CYTHON_UNUSED PyObject *gen) { - const char *msg; - if ((0)) { - #ifdef __Pyx_Coroutine_USED - } else if (__Pyx_Coroutine_Check(gen)) { - msg = "can't send non-None value to a just-started coroutine"; - #endif - #ifdef __Pyx_AsyncGen_USED - } else if (__Pyx_AsyncGen_CheckExact(gen)) { - msg = "can't send non-None value to a just-started async generator"; - #endif - } else { - msg = "can't send non-None value to a just-started generator"; - } - PyErr_SetString(PyExc_TypeError, msg); -} -#define __Pyx_Coroutine_AlreadyTerminatedError(gen, value, closing) (__Pyx__Coroutine_AlreadyTerminatedError(gen, value, closing), (PyObject*)NULL) -static void __Pyx__Coroutine_AlreadyTerminatedError(CYTHON_UNUSED PyObject *gen, PyObject *value, CYTHON_UNUSED int closing) { +static void __Pyx_Coroutine_AlreadyTerminatedError(PyObject *gen, PyObject *value, int closing) { + CYTHON_MAYBE_UNUSED_VAR(gen); + CYTHON_MAYBE_UNUSED_VAR(closing); #ifdef __Pyx_Coroutine_USED if (!closing && __Pyx_Coroutine_Check(gen)) { PyErr_SetString(PyExc_RuntimeError, "cannot reuse already awaited coroutine"); @@ -25802,26 +40847,22 @@ static void __Pyx__Coroutine_AlreadyTerminatedError(CYTHON_UNUSED PyObject *gen, if (value) { #ifdef __Pyx_AsyncGen_USED if (__Pyx_AsyncGen_CheckExact(gen)) - PyErr_SetNone(__Pyx_PyExc_StopAsyncIteration); + PyErr_SetNone(PyExc_StopAsyncIteration); else #endif PyErr_SetNone(PyExc_StopIteration); } } static -PyObject *__Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value, int closing) { +__Pyx_PySendResult __Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value, PyObject **result, int closing) { __Pyx_PyThreadState_declare PyThreadState *tstate; __Pyx_ExcInfoStruct *exc_state; PyObject *retval; - assert(!self->is_running); - if (unlikely(self->resume_label == 0)) { - if (unlikely(value && value != Py_None)) { - return __Pyx_Coroutine_NotStartedError((PyObject*)self); - } - } + assert(__Pyx_Coroutine_get_is_running(self)); // Callers should ensure is_running if (unlikely(self->resume_label == -1)) { - return __Pyx_Coroutine_AlreadyTerminatedError((PyObject*)self, value, closing); + __Pyx_Coroutine_AlreadyTerminatedError((PyObject*)self, value, closing); + return PYGEN_ERROR; } #if CYTHON_FAST_THREAD_STATE __Pyx_PyThreadState_assign @@ -25830,15 +40871,30 @@ PyObject *__Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value, i tstate = __Pyx_PyThreadState_Current; #endif exc_state = &self->gi_exc_state; - if (exc_state->exc_type) { - #if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_PYSTON + if (exc_state->exc_value) { + #if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + #else + PyObject *exc_tb; + #if PY_VERSION_HEX >= 0x030B00a4 && !CYTHON_COMPILING_IN_CPYTHON + exc_tb = PyException_GetTraceback(exc_state->exc_value); + #elif PY_VERSION_HEX >= 0x030B00a4 + exc_tb = ((PyBaseExceptionObject*) exc_state->exc_value)->traceback; #else - if (exc_state->exc_traceback) { - PyTracebackObject *tb = (PyTracebackObject *) exc_state->exc_traceback; + exc_tb = exc_state->exc_traceback; + #endif + if (exc_tb) { + PyTracebackObject *tb = (PyTracebackObject *) exc_tb; PyFrameObject *f = tb->tb_frame; - Py_XINCREF(tstate->frame); assert(f->f_back == NULL); + #if PY_VERSION_HEX >= 0x030B00A1 + f->f_back = PyThreadState_GetFrame(tstate); + #else + Py_XINCREF(tstate->frame); f->f_back = tstate->frame; + #endif + #if PY_VERSION_HEX >= 0x030B00a4 && !CYTHON_COMPILING_IN_CPYTHON + Py_DECREF(exc_tb); + #endif } #endif } @@ -25853,63 +40909,144 @@ PyObject *__Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value, i __Pyx_ExceptionSave(&exc_state->exc_type, &exc_state->exc_value, &exc_state->exc_traceback); } #endif - self->is_running = 1; - retval = self->body((PyObject *) self, tstate, value); - self->is_running = 0; + retval = self->body(self, tstate, value); #if CYTHON_USE_EXC_INFO_STACK exc_state = &self->gi_exc_state; tstate->exc_info = exc_state->previous_item; exc_state->previous_item = NULL; __Pyx_Coroutine_ResetFrameBackpointer(exc_state); #endif - return retval; + *result = retval; + if (self->resume_label == -1) { + return likely(retval) ? PYGEN_RETURN : PYGEN_ERROR; + } + return PYGEN_NEXT; } static CYTHON_INLINE void __Pyx_Coroutine_ResetFrameBackpointer(__Pyx_ExcInfoStruct *exc_state) { - PyObject *exc_tb = exc_state->exc_traceback; - if (likely(exc_tb)) { -#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_PYSTON +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API + CYTHON_UNUSED_VAR(exc_state); #else + PyObject *exc_tb; + #if PY_VERSION_HEX >= 0x030B00a4 + if (!exc_state->exc_value) return; + exc_tb = PyException_GetTraceback(exc_state->exc_value); + #else + exc_tb = exc_state->exc_traceback; + #endif + if (likely(exc_tb)) { PyTracebackObject *tb = (PyTracebackObject *) exc_tb; PyFrameObject *f = tb->tb_frame; Py_CLEAR(f->f_back); + #if PY_VERSION_HEX >= 0x030B00a4 + Py_DECREF(exc_tb); + #endif + } #endif +} +#define __Pyx_Coroutine_MethodReturnFromResult(gen, result, retval, iternext)\ + ((result) == PYGEN_NEXT ? (retval) : __Pyx__Coroutine_MethodReturnFromResult(gen, result, retval, iternext)) +static PyObject * +__Pyx__Coroutine_MethodReturnFromResult(PyObject* gen, __Pyx_PySendResult result, PyObject *retval, int iternext) { + CYTHON_MAYBE_UNUSED_VAR(gen); + if (likely(result == PYGEN_RETURN)) { + int is_async = 0; + #ifdef __Pyx_AsyncGen_USED + is_async = __Pyx_AsyncGen_CheckExact(gen); + #endif + __Pyx_ReturnWithStopIteration(retval, is_async, iternext); + Py_XDECREF(retval); } + return NULL; } +#if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE -PyObject *__Pyx_Coroutine_MethodReturn(CYTHON_UNUSED PyObject* gen, PyObject *retval) { - if (unlikely(!retval)) { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - if (!__Pyx_PyErr_Occurred()) { - PyObject *exc = PyExc_StopIteration; - #ifdef __Pyx_AsyncGen_USED - if (__Pyx_AsyncGen_CheckExact(gen)) - exc = __Pyx_PyExc_StopAsyncIteration; - #endif - __Pyx_PyErr_SetNone(exc); +PyObject *__Pyx_PyGen_Send(PyGenObject *gen, PyObject *arg) { +#if PY_VERSION_HEX <= 0x030A00A1 + return _PyGen_Send(gen, arg); +#else + PyObject *result; + if (PyIter_Send((PyObject*)gen, arg ? arg : Py_None, &result) == PYGEN_RETURN) { + if (PyAsyncGen_CheckExact(gen)) { + assert(result == Py_None); + PyErr_SetNone(PyExc_StopAsyncIteration); } + else if (result == Py_None) { + PyErr_SetNone(PyExc_StopIteration); + } + else { +#if PY_VERSION_HEX < 0x030d00A1 + _PyGen_SetStopIterationValue(result); +#else + if (!PyTuple_Check(result) && !PyExceptionInstance_Check(result)) { + PyErr_SetObject(PyExc_StopIteration, result); + } else { + PyObject *exc = __Pyx_PyObject_CallOneArg(PyExc_StopIteration, result); + if (likely(exc != NULL)) { + PyErr_SetObject(PyExc_StopIteration, exc); + Py_DECREF(exc); + } + } +#endif + } + Py_DECREF(result); + result = NULL; } - return retval; + return result; +#endif } -static CYTHON_INLINE -PyObject *__Pyx_Coroutine_FinishDelegation(__pyx_CoroutineObject *gen) { - PyObject *ret; +#endif +static CYTHON_INLINE __Pyx_PySendResult +__Pyx_Coroutine_FinishDelegation(__pyx_CoroutineObject *gen, PyObject** retval) { + __Pyx_PySendResult result; PyObject *val = NULL; + assert(__Pyx_Coroutine_get_is_running(gen)); __Pyx_Coroutine_Undelegate(gen); __Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, &val); - ret = __Pyx_Coroutine_SendEx(gen, val, 0); + result = __Pyx_Coroutine_SendEx(gen, val, retval, 0); Py_XDECREF(val); - return ret; + return result; +} +#if CYTHON_USE_AM_SEND +static __Pyx_PySendResult +__Pyx_Coroutine_SendToDelegate(__pyx_CoroutineObject *gen, __Pyx_pyiter_sendfunc gen_am_send, PyObject *value, PyObject **retval) { + PyObject *ret = NULL; + __Pyx_PySendResult delegate_result, result; + assert(__Pyx_Coroutine_get_is_running(gen)); + delegate_result = gen_am_send(gen->yieldfrom, value, &ret); + if (delegate_result == PYGEN_NEXT) { + assert (ret != NULL); + *retval = ret; + return PYGEN_NEXT; + } + assert (delegate_result != PYGEN_ERROR || ret == NULL); + __Pyx_Coroutine_Undelegate(gen); + result = __Pyx_Coroutine_SendEx(gen, ret, retval, 0); + Py_XDECREF(ret); + return result; } +#endif static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value) { - PyObject *retval; + PyObject *retval = NULL; + __Pyx_PySendResult result = __Pyx_Coroutine_AmSend(self, value, &retval); + return __Pyx_Coroutine_MethodReturnFromResult(self, result, retval, 0); +} +static __Pyx_PySendResult +__Pyx_Coroutine_AmSend(PyObject *self, PyObject *value, PyObject **retval) { + __Pyx_PySendResult result; __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; - PyObject *yf = gen->yieldfrom; - if (unlikely(gen->is_running)) - return __Pyx_Coroutine_AlreadyRunningError(gen); - if (yf) { + if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) { + *retval = __Pyx_Coroutine_AlreadyRunningError(gen); + return PYGEN_ERROR; + } + #if CYTHON_USE_AM_SEND + if (gen->yieldfrom_am_send) { + result = __Pyx_Coroutine_SendToDelegate(gen, gen->yieldfrom_am_send, value, retval); + } else + #endif + if (gen->yieldfrom) { + PyObject *yf = gen->yieldfrom; PyObject *ret; - gen->is_running = 1; + #if !CYTHON_USE_AM_SEND #ifdef __Pyx_Generator_USED if (__Pyx_Generator_CheckExact(yf)) { ret = __Pyx_Coroutine_Send(yf, value); @@ -25925,124 +41062,145 @@ static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value) { ret = __Pyx_async_gen_asend_send(yf, value); } else #endif - #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03030000 && (defined(__linux__) || PY_VERSION_HEX >= 0x030600B3) + #if CYTHON_COMPILING_IN_CPYTHON if (PyGen_CheckExact(yf)) { - ret = _PyGen_Send((PyGenObject*)yf, value == Py_None ? NULL : value); + ret = __Pyx_PyGen_Send((PyGenObject*)yf, value == Py_None ? NULL : value); } else - #endif - #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03050000 && defined(PyCoro_CheckExact) && (defined(__linux__) || PY_VERSION_HEX >= 0x030600B3) if (PyCoro_CheckExact(yf)) { - ret = _PyGen_Send((PyGenObject*)yf, value == Py_None ? NULL : value); + ret = __Pyx_PyGen_Send((PyGenObject*)yf, value == Py_None ? NULL : value); } else #endif + #endif { - if (value == Py_None) - ret = Py_TYPE(yf)->tp_iternext(yf); + #if !CYTHON_COMPILING_IN_LIMITED_API || __PYX_LIMITED_VERSION_HEX >= 0x03080000 + if (value == Py_None && PyIter_Check(yf)) + ret = __Pyx_PyIter_Next_Plain(yf); else - ret = __Pyx_PyObject_CallMethod1(yf, __pyx_n_s_send, value); + #endif + ret = __Pyx_PyObject_CallMethod1(yf, __pyx_mstate_global->__pyx_n_u_send, value); } - gen->is_running = 0; if (likely(ret)) { - return ret; + __Pyx_Coroutine_unset_is_running(gen); + *retval = ret; + return PYGEN_NEXT; } - retval = __Pyx_Coroutine_FinishDelegation(gen); + result = __Pyx_Coroutine_FinishDelegation(gen, retval); } else { - retval = __Pyx_Coroutine_SendEx(gen, value, 0); + result = __Pyx_Coroutine_SendEx(gen, value, retval, 0); } - return __Pyx_Coroutine_MethodReturn(self, retval); + __Pyx_Coroutine_unset_is_running(gen); + return result; } static int __Pyx_Coroutine_CloseIter(__pyx_CoroutineObject *gen, PyObject *yf) { + __Pyx_PySendResult result; PyObject *retval = NULL; - int err = 0; + CYTHON_UNUSED_VAR(gen); + assert(__Pyx_Coroutine_get_is_running(gen)); #ifdef __Pyx_Generator_USED if (__Pyx_Generator_CheckExact(yf)) { - retval = __Pyx_Coroutine_Close(yf); - if (!retval) - return -1; + result = __Pyx_Coroutine_Close(yf, &retval); } else #endif #ifdef __Pyx_Coroutine_USED if (__Pyx_Coroutine_Check(yf)) { - retval = __Pyx_Coroutine_Close(yf); - if (!retval) - return -1; + result = __Pyx_Coroutine_Close(yf, &retval); } else if (__Pyx_CoroutineAwait_CheckExact(yf)) { - retval = __Pyx_CoroutineAwait_Close((__pyx_CoroutineAwaitObject*)yf, NULL); - if (!retval) - return -1; + result = __Pyx_CoroutineAwait_Close((__pyx_CoroutineAwaitObject*)yf); } else #endif #ifdef __Pyx_AsyncGen_USED if (__pyx_PyAsyncGenASend_CheckExact(yf)) { retval = __Pyx_async_gen_asend_close(yf, NULL); + result = PYGEN_RETURN; } else if (__pyx_PyAsyncGenAThrow_CheckExact(yf)) { retval = __Pyx_async_gen_athrow_close(yf, NULL); + result = PYGEN_RETURN; } else #endif { PyObject *meth; - gen->is_running = 1; - meth = __Pyx_PyObject_GetAttrStr(yf, __pyx_n_s_close); + result = PYGEN_RETURN; + meth = __Pyx_PyObject_GetAttrStrNoError(yf, __pyx_mstate_global->__pyx_n_u_close); if (unlikely(!meth)) { - if (!PyErr_ExceptionMatches(PyExc_AttributeError)) { + if (unlikely(PyErr_Occurred())) { PyErr_WriteUnraisable(yf); } - PyErr_Clear(); } else { - retval = PyObject_CallFunction(meth, NULL); + retval = __Pyx_PyObject_CallNoArg(meth); Py_DECREF(meth); - if (!retval) - err = -1; + if (unlikely(!retval)) { + result = PYGEN_ERROR; + } } - gen->is_running = 0; } Py_XDECREF(retval); - return err; + return result == PYGEN_ERROR ? -1 : 0; } static PyObject *__Pyx_Generator_Next(PyObject *self) { + __Pyx_PySendResult result; + PyObject *retval = NULL; __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; - PyObject *yf = gen->yieldfrom; - if (unlikely(gen->is_running)) + if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) { return __Pyx_Coroutine_AlreadyRunningError(gen); - if (yf) { + } + #if CYTHON_USE_AM_SEND + if (gen->yieldfrom_am_send) { + result = __Pyx_Coroutine_SendToDelegate(gen, gen->yieldfrom_am_send, Py_None, &retval); + } else + #endif + if (gen->yieldfrom) { + PyObject *yf = gen->yieldfrom; PyObject *ret; - gen->is_running = 1; #ifdef __Pyx_Generator_USED if (__Pyx_Generator_CheckExact(yf)) { ret = __Pyx_Generator_Next(yf); } else #endif - #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03030000 && (defined(__linux__) || PY_VERSION_HEX >= 0x030600B3) - if (PyGen_CheckExact(yf)) { - ret = _PyGen_Send((PyGenObject*)yf, NULL); - } else - #endif #ifdef __Pyx_Coroutine_USED - if (__Pyx_Coroutine_Check(yf)) { + if (__Pyx_Coroutine_CheckExact(yf)) { ret = __Pyx_Coroutine_Send(yf, Py_None); } else #endif - ret = Py_TYPE(yf)->tp_iternext(yf); - gen->is_running = 0; + #if CYTHON_COMPILING_IN_CPYTHON && (PY_VERSION_HEX < 0x030A00A3 || !CYTHON_USE_AM_SEND) + if (PyGen_CheckExact(yf)) { + ret = __Pyx_PyGen_Send((PyGenObject*)yf, NULL); + } else + #endif + ret = __Pyx_PyIter_Next_Plain(yf); if (likely(ret)) { + __Pyx_Coroutine_unset_is_running(gen); return ret; } - return __Pyx_Coroutine_FinishDelegation(gen); + result = __Pyx_Coroutine_FinishDelegation(gen, &retval); + } else { + result = __Pyx_Coroutine_SendEx(gen, Py_None, &retval, 0); } - return __Pyx_Coroutine_SendEx(gen, Py_None, 0); + __Pyx_Coroutine_unset_is_running(gen); + return __Pyx_Coroutine_MethodReturnFromResult(self, result, retval, 1); } -static PyObject *__Pyx_Coroutine_Close_Method(PyObject *self, CYTHON_UNUSED PyObject *arg) { - return __Pyx_Coroutine_Close(self); +static PyObject *__Pyx_Coroutine_Close_Method(PyObject *self, PyObject *arg) { + PyObject *retval = NULL; + __Pyx_PySendResult result; + CYTHON_UNUSED_VAR(arg); + result = __Pyx_Coroutine_Close(self, &retval); + if (unlikely(result == PYGEN_ERROR)) + return NULL; + Py_XDECREF(retval); + Py_RETURN_NONE; } -static PyObject *__Pyx_Coroutine_Close(PyObject *self) { +static __Pyx_PySendResult +__Pyx_Coroutine_Close(PyObject *self, PyObject **retval) { __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; - PyObject *retval, *raised_exception; - PyObject *yf = gen->yieldfrom; + __Pyx_PySendResult result; + PyObject *yf; int err = 0; - if (unlikely(gen->is_running)) - return __Pyx_Coroutine_AlreadyRunningError(gen); + if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) { + *retval = __Pyx_Coroutine_AlreadyRunningError(gen); + return PYGEN_ERROR; + } + yf = gen->yieldfrom; if (yf) { Py_INCREF(yf); err = __Pyx_Coroutine_CloseIter(gen, yf); @@ -26051,10 +41209,25 @@ static PyObject *__Pyx_Coroutine_Close(PyObject *self) { } if (err == 0) PyErr_SetNone(PyExc_GeneratorExit); - retval = __Pyx_Coroutine_SendEx(gen, NULL, 1); - if (unlikely(retval)) { + result = __Pyx_Coroutine_SendEx(gen, NULL, retval, 1); + if (result == PYGEN_ERROR) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_Coroutine_unset_is_running(gen); + if (!__Pyx_PyErr_Occurred()) { + return PYGEN_RETURN; + } else if (likely(__Pyx_PyErr_ExceptionMatches2(PyExc_GeneratorExit, PyExc_StopIteration))) { + __Pyx_PyErr_Clear(); + return PYGEN_RETURN; + } + return PYGEN_ERROR; + } else if (likely(result == PYGEN_RETURN && *retval == Py_None)) { + __Pyx_Coroutine_unset_is_running(gen); + return PYGEN_RETURN; + } else { const char *msg; - Py_DECREF(retval); + Py_DECREF(*retval); + *retval = NULL; if ((0)) { #ifdef __Pyx_Coroutine_USED } else if (__Pyx_Coroutine_Check(self)) { @@ -26062,33 +41235,25 @@ static PyObject *__Pyx_Coroutine_Close(PyObject *self) { #endif #ifdef __Pyx_AsyncGen_USED } else if (__Pyx_AsyncGen_CheckExact(self)) { -#if PY_VERSION_HEX < 0x03060000 - msg = "async generator ignored GeneratorExit - might require Python 3.6+ finalisation (PEP 525)"; -#else msg = "async generator ignored GeneratorExit"; -#endif #endif } else { msg = "generator ignored GeneratorExit"; } PyErr_SetString(PyExc_RuntimeError, msg); - return NULL; - } - raised_exception = PyErr_Occurred(); - if (likely(!raised_exception || __Pyx_PyErr_GivenExceptionMatches2(raised_exception, PyExc_GeneratorExit, PyExc_StopIteration))) { - if (raised_exception) PyErr_Clear(); - Py_INCREF(Py_None); - return Py_None; + __Pyx_Coroutine_unset_is_running(gen); + return PYGEN_ERROR; } - return NULL; } static PyObject *__Pyx__Coroutine_Throw(PyObject *self, PyObject *typ, PyObject *val, PyObject *tb, PyObject *args, int close_on_genexit) { __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; - PyObject *yf = gen->yieldfrom; - if (unlikely(gen->is_running)) + PyObject *yf; + if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) return __Pyx_Coroutine_AlreadyRunningError(gen); + yf = gen->yieldfrom; if (yf) { + __Pyx_PySendResult result; PyObject *ret; Py_INCREF(yf); if (__Pyx_PyErr_GivenExceptionMatches(typ, PyExc_GeneratorExit) && close_on_genexit) { @@ -26096,10 +41261,9 @@ static PyObject *__Pyx__Coroutine_Throw(PyObject *self, PyObject *typ, PyObject Py_DECREF(yf); __Pyx_Coroutine_Undelegate(gen); if (err < 0) - return __Pyx_Coroutine_MethodReturn(self, __Pyx_Coroutine_SendEx(gen, NULL, 0)); + goto propagate_exception; goto throw_here; } - gen->is_running = 1; if (0 #ifdef __Pyx_Generator_USED || __Pyx_Generator_CheckExact(yf) @@ -26114,51 +41278,66 @@ static PyObject *__Pyx__Coroutine_Throw(PyObject *self, PyObject *typ, PyObject ret = __Pyx__Coroutine_Throw(((__pyx_CoroutineAwaitObject*)yf)->coroutine, typ, val, tb, args, close_on_genexit); #endif } else { - PyObject *meth = __Pyx_PyObject_GetAttrStr(yf, __pyx_n_s_throw); + PyObject *meth = __Pyx_PyObject_GetAttrStrNoError(yf, __pyx_mstate_global->__pyx_n_u_throw); if (unlikely(!meth)) { Py_DECREF(yf); - if (!PyErr_ExceptionMatches(PyExc_AttributeError)) { - gen->is_running = 0; + if (unlikely(PyErr_Occurred())) { + __Pyx_Coroutine_unset_is_running(gen); return NULL; } - PyErr_Clear(); __Pyx_Coroutine_Undelegate(gen); - gen->is_running = 0; goto throw_here; } if (likely(args)) { - ret = PyObject_CallObject(meth, args); + ret = __Pyx_PyObject_Call(meth, args, NULL); } else { - ret = PyObject_CallFunctionObjArgs(meth, typ, val, tb, NULL); + PyObject *cargs[4] = {NULL, typ, val, tb}; + ret = __Pyx_PyObject_FastCall(meth, cargs+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); } Py_DECREF(meth); } - gen->is_running = 0; Py_DECREF(yf); - if (!ret) { - ret = __Pyx_Coroutine_FinishDelegation(gen); + if (ret) { + __Pyx_Coroutine_unset_is_running(gen); + return ret; } - return __Pyx_Coroutine_MethodReturn(self, ret); + result = __Pyx_Coroutine_FinishDelegation(gen, &ret); + __Pyx_Coroutine_unset_is_running(gen); + return __Pyx_Coroutine_MethodReturnFromResult(self, result, ret, 0); } throw_here: __Pyx_Raise(typ, val, tb, NULL); - return __Pyx_Coroutine_MethodReturn(self, __Pyx_Coroutine_SendEx(gen, NULL, 0)); +propagate_exception: + { + PyObject *retval = NULL; + __Pyx_PySendResult result = __Pyx_Coroutine_SendEx(gen, NULL, &retval, 0); + __Pyx_Coroutine_unset_is_running(gen); + return __Pyx_Coroutine_MethodReturnFromResult(self, result, retval, 0); + } } static PyObject *__Pyx_Coroutine_Throw(PyObject *self, PyObject *args) { PyObject *typ; PyObject *val = NULL; PyObject *tb = NULL; - if (!PyArg_UnpackTuple(args, (char *)"throw", 1, 3, &typ, &val, &tb)) + if (unlikely(!PyArg_UnpackTuple(args, "throw", 1, 3, &typ, &val, &tb))) return NULL; return __Pyx__Coroutine_Throw(self, typ, val, tb, args, 1); } static CYTHON_INLINE int __Pyx_Coroutine_traverse_excstate(__Pyx_ExcInfoStruct *exc_state, visitproc visit, void *arg) { +#if PY_VERSION_HEX >= 0x030B00a4 + Py_VISIT(exc_state->exc_value); +#else Py_VISIT(exc_state->exc_type); Py_VISIT(exc_state->exc_value); Py_VISIT(exc_state->exc_traceback); +#endif return 0; } static int __Pyx_Coroutine_traverse(__pyx_CoroutineObject *gen, visitproc visit, void *arg) { + { + int e = __Pyx_call_type_traverse((PyObject*)gen, 1, visit, arg); + if (e) return e; + } Py_VISIT(gen->closure); Py_VISIT(gen->classobj); Py_VISIT(gen->yieldfrom); @@ -26168,7 +41347,7 @@ static int __Pyx_Coroutine_clear(PyObject *self) { __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; Py_CLEAR(gen->closure); Py_CLEAR(gen->classobj); - Py_CLEAR(gen->yieldfrom); + __Pyx_Coroutine_Undelegate(gen); __Pyx_Coroutine_ExceptionClear(&gen->gi_exc_state); #ifdef __Pyx_AsyncGen_USED if (__Pyx_AsyncGen_CheckExact(self)) { @@ -26176,6 +41355,7 @@ static int __Pyx_Coroutine_clear(PyObject *self) { } #endif Py_CLEAR(gen->gi_code); + Py_CLEAR(gen->gi_frame); Py_CLEAR(gen->gi_name); Py_CLEAR(gen->gi_qualname); Py_CLEAR(gen->gi_modulename); @@ -26188,11 +41368,14 @@ static void __Pyx_Coroutine_dealloc(PyObject *self) { PyObject_ClearWeakRefs(self); if (gen->resume_label >= 0) { PyObject_GC_Track(self); -#if PY_VERSION_HEX >= 0x030400a1 && CYTHON_USE_TP_FINALIZE - if (PyObject_CallFinalizerFromDealloc(self)) +#if CYTHON_USE_TP_FINALIZE + if (unlikely(PyObject_CallFinalizerFromDealloc(self))) #else - Py_TYPE(gen)->tp_del(self); - if (self->ob_refcnt > 0) + { + destructor del = __Pyx_PyObject_GetSlot(gen, tp_del, destructor); + if (del) del(self); + } + if (unlikely(Py_REFCNT(self) > 0)) #endif { return; @@ -26208,8 +41391,9 @@ static void __Pyx_Coroutine_dealloc(PyObject *self) { } #endif __Pyx_Coroutine_clear(self); - PyObject_GC_Del(gen); + __Pyx_PyHeapTypeObject_GC_Del(gen); } +#if CYTHON_USE_TP_FINALIZE static void __Pyx_Coroutine_del(PyObject *self) { PyObject *error_type, *error_value, *error_traceback; __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; @@ -26217,10 +41401,6 @@ static void __Pyx_Coroutine_del(PyObject *self) { if (gen->resume_label < 0) { return; } -#if !CYTHON_USE_TP_FINALIZE - assert(self->ob_refcnt == 0); - self->ob_refcnt = 1; -#endif __Pyx_PyThreadState_assign __Pyx_ErrFetch(&error_type, &error_value, &error_traceback); #ifdef __Pyx_AsyncGen_USED @@ -26246,122 +41426,116 @@ static void __Pyx_Coroutine_del(PyObject *self) { #endif { PyObject_GC_UnTrack(self); -#if PY_MAJOR_VERSION >= 3 || defined(PyErr_WarnFormat) if (unlikely(PyErr_WarnFormat(PyExc_RuntimeWarning, 1, "coroutine '%.50S' was never awaited", gen->gi_qualname) < 0)) PyErr_WriteUnraisable(self); -#else - {PyObject *msg; - char *cmsg; - #if CYTHON_COMPILING_IN_PYPY - msg = NULL; - cmsg = (char*) "coroutine was never awaited"; - #else - char *cname; - PyObject *qualname; - qualname = gen->gi_qualname; - cname = PyString_AS_STRING(qualname); - msg = PyString_FromFormat("coroutine '%.50s' was never awaited", cname); - if (unlikely(!msg)) { - PyErr_Clear(); - cmsg = (char*) "coroutine was never awaited"; - } else { - cmsg = PyString_AS_STRING(msg); - } - #endif - if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, cmsg, 1) < 0)) - PyErr_WriteUnraisable(self); - Py_XDECREF(msg);} -#endif PyObject_GC_Track(self); } #endif } else { - PyObject *res = __Pyx_Coroutine_Close(self); - if (unlikely(!res)) { - if (PyErr_Occurred()) - PyErr_WriteUnraisable(self); + PyObject *retval = NULL; + __Pyx_PySendResult result = __Pyx_Coroutine_Close(self, &retval); + if (result == PYGEN_ERROR) { + PyErr_WriteUnraisable(self); } else { - Py_DECREF(res); + Py_XDECREF(retval); } } __Pyx_ErrRestore(error_type, error_value, error_traceback); -#if !CYTHON_USE_TP_FINALIZE - assert(self->ob_refcnt > 0); - if (--self->ob_refcnt == 0) { - return; - } - { - Py_ssize_t refcnt = self->ob_refcnt; - _Py_NewReference(self); - self->ob_refcnt = refcnt; - } -#if CYTHON_COMPILING_IN_CPYTHON - assert(PyType_IS_GC(self->ob_type) && - _Py_AS_GC(self)->gc.gc_refs != _PyGC_REFS_UNTRACKED); - _Py_DEC_REFTOTAL; -#endif -#ifdef COUNT_ALLOCS - --Py_TYPE(self)->tp_frees; - --Py_TYPE(self)->tp_allocs; -#endif -#endif } +#endif static PyObject * -__Pyx_Coroutine_get_name(__pyx_CoroutineObject *self, CYTHON_UNUSED void *context) +__Pyx_Coroutine_get_name(__pyx_CoroutineObject *self, void *context) { PyObject *name = self->gi_name; + CYTHON_UNUSED_VAR(context); if (unlikely(!name)) name = Py_None; Py_INCREF(name); return name; } static int -__Pyx_Coroutine_set_name(__pyx_CoroutineObject *self, PyObject *value, CYTHON_UNUSED void *context) +__Pyx_Coroutine_set_name(__pyx_CoroutineObject *self, PyObject *value, void *context) { - PyObject *tmp; -#if PY_MAJOR_VERSION >= 3 - if (unlikely(value == NULL || !PyUnicode_Check(value))) -#else - if (unlikely(value == NULL || !PyString_Check(value))) -#endif - { + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { PyErr_SetString(PyExc_TypeError, "__name__ must be set to a string object"); return -1; } - tmp = self->gi_name; Py_INCREF(value); - self->gi_name = value; - Py_XDECREF(tmp); + __Pyx_Py_XDECREF_SET(self->gi_name, value); return 0; } static PyObject * -__Pyx_Coroutine_get_qualname(__pyx_CoroutineObject *self, CYTHON_UNUSED void *context) +__Pyx_Coroutine_get_qualname(__pyx_CoroutineObject *self, void *context) { PyObject *name = self->gi_qualname; + CYTHON_UNUSED_VAR(context); if (unlikely(!name)) name = Py_None; Py_INCREF(name); return name; } static int -__Pyx_Coroutine_set_qualname(__pyx_CoroutineObject *self, PyObject *value, CYTHON_UNUSED void *context) +__Pyx_Coroutine_set_qualname(__pyx_CoroutineObject *self, PyObject *value, void *context) { - PyObject *tmp; -#if PY_MAJOR_VERSION >= 3 - if (unlikely(value == NULL || !PyUnicode_Check(value))) -#else - if (unlikely(value == NULL || !PyString_Check(value))) -#endif - { + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { PyErr_SetString(PyExc_TypeError, "__qualname__ must be set to a string object"); return -1; } - tmp = self->gi_qualname; Py_INCREF(value); - self->gi_qualname = value; - Py_XDECREF(tmp); + __Pyx_Py_XDECREF_SET(self->gi_qualname, value); return 0; } +static PyObject * +__Pyx__Coroutine_get_frame(__pyx_CoroutineObject *self) +{ +#if !CYTHON_COMPILING_IN_LIMITED_API + PyObject *frame; + #if PY_VERSION_HEX >= 0x030d0000 + Py_BEGIN_CRITICAL_SECTION(self); + #endif + frame = self->gi_frame; + if (!frame) { + if (unlikely(!self->gi_code)) { + Py_RETURN_NONE; + } + PyObject *globals = PyDict_New(); + if (unlikely(!globals)) return NULL; + frame = (PyObject *) PyFrame_New( + PyThreadState_Get(), /*PyThreadState *tstate,*/ + (PyCodeObject*) self->gi_code, /*PyCodeObject *code,*/ + globals, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + Py_DECREF(globals); + if (unlikely(!frame)) + return NULL; + if (unlikely(self->gi_frame)) { + Py_DECREF(frame); + frame = self->gi_frame; + } else { + self->gi_frame = frame; + } + } + Py_INCREF(frame); + #if PY_VERSION_HEX >= 0x030d0000 + Py_END_CRITICAL_SECTION(); + #endif + return frame; +#else + CYTHON_UNUSED_VAR(self); + Py_RETURN_NONE; +#endif +} +static PyObject * +__Pyx_Coroutine_get_frame(__pyx_CoroutineObject *self, void *context) { + CYTHON_UNUSED_VAR(context); + PyObject *frame = self->gi_frame; + if (frame) + return __Pyx_NewRef(frame); + return __Pyx__Coroutine_get_frame(self); +} static __pyx_CoroutineObject *__Pyx__Coroutine_New( PyTypeObject* type, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, PyObject *name, PyObject *qualname, PyObject *module_name) { @@ -26380,9 +41554,14 @@ static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit( gen->resume_label = 0; gen->classobj = NULL; gen->yieldfrom = NULL; + gen->yieldfrom_am_send = NULL; + #if PY_VERSION_HEX >= 0x030B00a4 && !CYTHON_COMPILING_IN_LIMITED_API + gen->gi_exc_state.exc_value = NULL; + #else gen->gi_exc_state.exc_type = NULL; gen->gi_exc_state.exc_value = NULL; gen->gi_exc_state.exc_traceback = NULL; + #endif #if CYTHON_USE_EXC_INFO_STACK gen->gi_exc_state.previous_item = NULL; #endif @@ -26395,179 +41574,206 @@ static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit( gen->gi_modulename = module_name; Py_XINCREF(code); gen->gi_code = code; + gen->gi_frame = NULL; PyObject_GC_Track(gen); return gen; } - -/* PatchGeneratorABC */ -#ifndef CYTHON_REGISTER_ABCS -#define CYTHON_REGISTER_ABCS 1 -#endif -#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) -static PyObject* __Pyx_patch_abc_module(PyObject *module); -static PyObject* __Pyx_patch_abc_module(PyObject *module) { - module = __Pyx_Coroutine_patch_module( - module, "" -"if _cython_generator_type is not None:\n" -" try: Generator = _module.Generator\n" -" except AttributeError: pass\n" -" else: Generator.register(_cython_generator_type)\n" -"if _cython_coroutine_type is not None:\n" -" try: Coroutine = _module.Coroutine\n" -" except AttributeError: pass\n" -" else: Coroutine.register(_cython_coroutine_type)\n" - ); - return module; +static char __Pyx_Coroutine_test_and_set_is_running(__pyx_CoroutineObject *gen) { + char result; + #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_BEGIN_CRITICAL_SECTION(gen); + #endif + result = gen->is_running; + gen->is_running = 1; + #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_END_CRITICAL_SECTION(); + #endif + return result; +} +static void __Pyx_Coroutine_unset_is_running(__pyx_CoroutineObject *gen) { + #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_BEGIN_CRITICAL_SECTION(gen); + #endif + assert(gen->is_running); + gen->is_running = 0; + #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_END_CRITICAL_SECTION(); + #endif +} +static char __Pyx_Coroutine_get_is_running(__pyx_CoroutineObject *gen) { + char result; + #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_BEGIN_CRITICAL_SECTION(gen); + #endif + result = gen->is_running; + #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_END_CRITICAL_SECTION(); + #endif + return result; +} +static PyObject *__Pyx_Coroutine_get_is_running_getter(PyObject *gen, void *closure) { + CYTHON_UNUSED_VAR(closure); + char result = __Pyx_Coroutine_get_is_running((__pyx_CoroutineObject*)gen); + if (result) Py_RETURN_TRUE; + else Py_RETURN_FALSE; } -#endif -static int __Pyx_patch_abc(void) { -#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) - static int abc_patched = 0; - if (CYTHON_REGISTER_ABCS && !abc_patched) { - PyObject *module; - module = PyImport_ImportModule((PY_MAJOR_VERSION >= 3) ? "collections.abc" : "collections"); - if (!module) { - PyErr_WriteUnraisable(NULL); - if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, - ((PY_MAJOR_VERSION >= 3) ? - "Cython module failed to register with collections.abc module" : - "Cython module failed to register with collections module"), 1) < 0)) { - return -1; - } - } else { - module = __Pyx_patch_abc_module(module); - abc_patched = 1; - if (unlikely(!module)) - return -1; - Py_DECREF(module); - } - module = PyImport_ImportModule("backports_abc"); - if (module) { - module = __Pyx_patch_abc_module(module); - Py_XDECREF(module); - } - if (!module) { - PyErr_Clear(); - } +#if __PYX_HAS_PY_AM_SEND == 2 +static void __Pyx_SetBackportTypeAmSend(PyTypeObject *type, __Pyx_PyAsyncMethodsStruct *static_amsend_methods, __Pyx_pyiter_sendfunc am_send) { + Py_ssize_t ptr_offset = (char*)(type->tp_as_async) - (char*)type; + if (ptr_offset < 0 || ptr_offset > type->tp_basicsize) { + return; } -#else - if ((0)) __Pyx_Coroutine_patch_module(NULL, NULL); + memcpy((void*)static_amsend_methods, (void*)(type->tp_as_async), sizeof(*type->tp_as_async)); + static_amsend_methods->am_send = am_send; + type->tp_as_async = __Pyx_SlotTpAsAsync(static_amsend_methods); +} #endif - return 0; +static PyObject *__Pyx_Coroutine_fail_reduce_ex(PyObject *self, PyObject *arg) { + CYTHON_UNUSED_VAR(arg); + __Pyx_TypeName self_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE((PyObject*)self)); + PyErr_Format(PyExc_TypeError, "cannot pickle '" __Pyx_FMT_TYPENAME "' object", + self_type_name); + __Pyx_DECREF_TypeName(self_type_name); + return NULL; } /* Generator */ static PyMethodDef __pyx_Generator_methods[] = { {"send", (PyCFunction) __Pyx_Coroutine_Send, METH_O, - (char*) PyDoc_STR("send(arg) -> send 'arg' into generator,\nreturn next yielded value or raise StopIteration.")}, + PyDoc_STR("send(arg) -> send 'arg' into generator,\nreturn next yielded value or raise StopIteration.")}, {"throw", (PyCFunction) __Pyx_Coroutine_Throw, METH_VARARGS, - (char*) PyDoc_STR("throw(typ[,val[,tb]]) -> raise exception in generator,\nreturn next yielded value or raise StopIteration.")}, + PyDoc_STR("throw(typ[,val[,tb]]) -> raise exception in generator,\nreturn next yielded value or raise StopIteration.")}, {"close", (PyCFunction) __Pyx_Coroutine_Close_Method, METH_NOARGS, - (char*) PyDoc_STR("close() -> raise GeneratorExit inside generator.")}, + PyDoc_STR("close() -> raise GeneratorExit inside generator.")}, + {"__reduce_ex__", (PyCFunction) __Pyx_Coroutine_fail_reduce_ex, METH_O, 0}, + {"__reduce__", (PyCFunction) __Pyx_Coroutine_fail_reduce_ex, METH_NOARGS, 0}, {0, 0, 0, 0} }; static PyMemberDef __pyx_Generator_memberlist[] = { - {(char *) "gi_running", T_BOOL, offsetof(__pyx_CoroutineObject, is_running), READONLY, NULL}, - {(char*) "gi_yieldfrom", T_OBJECT, offsetof(__pyx_CoroutineObject, yieldfrom), READONLY, - (char*) PyDoc_STR("object being iterated by 'yield from', or None")}, - {(char*) "gi_code", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_code), READONLY, NULL}, + {"gi_yieldfrom", T_OBJECT, offsetof(__pyx_CoroutineObject, yieldfrom), READONLY, + PyDoc_STR("object being iterated by 'yield from', or None")}, + {"gi_code", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_code), READONLY, NULL}, + {"__module__", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_modulename), 0, 0}, + {"__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CoroutineObject, gi_weakreflist), READONLY, 0}, {0, 0, 0, 0, 0} }; static PyGetSetDef __pyx_Generator_getsets[] = { - {(char *) "__name__", (getter)__Pyx_Coroutine_get_name, (setter)__Pyx_Coroutine_set_name, - (char*) PyDoc_STR("name of the generator"), 0}, - {(char *) "__qualname__", (getter)__Pyx_Coroutine_get_qualname, (setter)__Pyx_Coroutine_set_qualname, - (char*) PyDoc_STR("qualified name of the generator"), 0}, + {"__name__", (getter)__Pyx_Coroutine_get_name, (setter)__Pyx_Coroutine_set_name, + PyDoc_STR("name of the generator"), 0}, + {"__qualname__", (getter)__Pyx_Coroutine_get_qualname, (setter)__Pyx_Coroutine_set_qualname, + PyDoc_STR("qualified name of the generator"), 0}, + {"gi_frame", (getter)__Pyx_Coroutine_get_frame, NULL, + PyDoc_STR("Frame of the generator"), 0}, + {"gi_running", __Pyx_Coroutine_get_is_running_getter, NULL, NULL, NULL}, {0, 0, 0, 0, 0} }; -static PyTypeObject __pyx_GeneratorType_type = { - PyVarObject_HEAD_INIT(0, 0) - "generator", - sizeof(__pyx_CoroutineObject), - 0, - (destructor) __Pyx_Coroutine_dealloc, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE, - 0, - (traverseproc) __Pyx_Coroutine_traverse, - 0, - 0, - offsetof(__pyx_CoroutineObject, gi_weakreflist), - 0, - (iternextfunc) __Pyx_Generator_Next, - __pyx_Generator_methods, - __pyx_Generator_memberlist, - __pyx_Generator_getsets, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -#if CYTHON_USE_TP_FINALIZE - 0, -#else - __Pyx_Coroutine_del, -#endif - 0, +static PyType_Slot __pyx_GeneratorType_slots[] = { + {Py_tp_dealloc, (void *)__Pyx_Coroutine_dealloc}, + {Py_tp_traverse, (void *)__Pyx_Coroutine_traverse}, + {Py_tp_iter, (void *)PyObject_SelfIter}, + {Py_tp_iternext, (void *)__Pyx_Generator_Next}, + {Py_tp_methods, (void *)__pyx_Generator_methods}, + {Py_tp_members, (void *)__pyx_Generator_memberlist}, + {Py_tp_getset, (void *)__pyx_Generator_getsets}, + {Py_tp_getattro, (void *) PyObject_GenericGetAttr}, #if CYTHON_USE_TP_FINALIZE - __Pyx_Coroutine_del, -#elif PY_VERSION_HEX >= 0x030400a1 - 0, + {Py_tp_finalize, (void *)__Pyx_Coroutine_del}, #endif -#if PY_VERSION_HEX >= 0x030800b1 - 0, +#if __PYX_HAS_PY_AM_SEND == 1 + {Py_am_send, (void *)__Pyx_Coroutine_AmSend}, #endif -#if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + {0, 0}, +}; +static PyType_Spec __pyx_GeneratorType_spec = { + __PYX_TYPE_MODULE_PREFIX "generator", + sizeof(__pyx_CoroutineObject), 0, +#if PY_VERSION_HEX >= 0x030A0000 + Py_TPFLAGS_IMMUTABLETYPE | #endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE | __Pyx_TPFLAGS_HAVE_AM_SEND, + __pyx_GeneratorType_slots }; -static int __pyx_Generator_init(void) { - __pyx_GeneratorType_type.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; - __pyx_GeneratorType_type.tp_iter = PyObject_SelfIter; - __pyx_GeneratorType = __Pyx_FetchCommonType(&__pyx_GeneratorType_type); - if (unlikely(!__pyx_GeneratorType)) { +#if __PYX_HAS_PY_AM_SEND == 2 +static __Pyx_PyAsyncMethodsStruct __pyx_Generator_as_async; +#endif +static int __pyx_Generator_init(PyObject *module) { + __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module); + mstate->__pyx_GeneratorType = __Pyx_FetchCommonTypeFromSpec( + mstate->__pyx_CommonTypesMetaclassType, module, &__pyx_GeneratorType_spec, NULL); + if (unlikely(!mstate->__pyx_GeneratorType)) { return -1; } +#if __PYX_HAS_PY_AM_SEND == 2 + __Pyx_SetBackportTypeAmSend(mstate->__pyx_GeneratorType, &__pyx_Generator_as_async, &__Pyx_Coroutine_AmSend); +#endif return 0; } +static PyObject *__Pyx_Generator_GetInlinedResult(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; + PyObject *retval = NULL; + if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) { + return __Pyx_Coroutine_AlreadyRunningError(gen); + } + __Pyx_PySendResult result = __Pyx_Coroutine_SendEx(gen, Py_None, &retval, 0); + __Pyx_Coroutine_unset_is_running(gen); + (void) result; + assert (result == PYGEN_RETURN || result == PYGEN_ERROR); + assert ((result == PYGEN_RETURN && retval != NULL) || (result == PYGEN_ERROR && retval == NULL)); + return retval; +} + +/* GetRuntimeVersion */ +static unsigned long __Pyx_get_runtime_version(void) { +#if __PYX_LIMITED_VERSION_HEX >= 0x030b0000 + return Py_Version & ~0xFFUL; +#else + static unsigned long __Pyx_cached_runtime_version = 0; + if (__Pyx_cached_runtime_version == 0) { + const char* rt_version = Py_GetVersion(); + unsigned long version = 0; + unsigned long factor = 0x01000000UL; + unsigned int digit = 0; + int i = 0; + while (factor) { + while ('0' <= rt_version[i] && rt_version[i] <= '9') { + digit = digit * 10 + (unsigned int) (rt_version[i] - '0'); + ++i; + } + version += factor * digit; + if (rt_version[i] != '.') + break; + digit = 0; + factor >>= 8; + ++i; + } + __Pyx_cached_runtime_version = version; + } + return __Pyx_cached_runtime_version; +#endif +} /* CheckBinaryVersion */ -static int __Pyx_check_binary_version(void) { - char ctversion[4], rtversion[4]; - PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); - PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); - if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) { + const unsigned long MAJOR_MINOR = 0xFFFF0000UL; + if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR)) + return 0; + if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR))) + return 1; + { char message[200]; PyOS_snprintf(message, sizeof(message), - "compiletime version %s of module '%.100s' " - "does not match runtime version %s", - ctversion, __Pyx_MODULE_NAME, rtversion); + "compile time Python version %d.%d " + "of module '%.100s' " + "%s " + "runtime version %d.%d", + (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF), + __Pyx_MODULE_NAME, + (allow_newer) ? "was newer than" : "does not match", + (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF) + ); return PyErr_WarnEx(NULL, message, 1); } - return 0; } /* FunctionExport */ @@ -26578,22 +41784,18 @@ static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *s void (*fp)(void); void *p; } tmp; - d = PyObject_GetAttrString(__pyx_m, (char *)"__pyx_capi__"); + d = PyObject_GetAttrString(__pyx_m, "__pyx_capi__"); if (!d) { PyErr_Clear(); d = PyDict_New(); if (!d) goto bad; Py_INCREF(d); - if (PyModule_AddObject(__pyx_m, (char *)"__pyx_capi__", d) < 0) + if (PyModule_AddObject(__pyx_m, "__pyx_capi__", d) < 0) goto bad; } tmp.fp = f; -#if PY_VERSION_HEX >= 0x02070000 cobj = PyCapsule_New(tmp.p, sig, 0); -#else - cobj = PyCObject_FromVoidPtrAndDesc(tmp.p, (void *)sig, 0); -#endif if (!cobj) goto bad; if (PyDict_SetItemString(d, name, cobj) < 0) @@ -26607,71 +41809,261 @@ static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *s return -1; } -/* InitStrings */ -static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { - while (t->p) { - #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); +/* FunctionImport */ +#ifndef __PYX_HAVE_RT_ImportFunction_3_1_3 +#define __PYX_HAVE_RT_ImportFunction_3_1_3 +static int __Pyx_ImportFunction_3_1_3(PyObject *module, const char *funcname, void (**f)(void), const char *sig) { + PyObject *d = 0; + PyObject *cobj = 0; + union { + void (*fp)(void); + void *p; + } tmp; + d = PyObject_GetAttrString(module, "__pyx_capi__"); + if (!d) + goto bad; +#if (defined(Py_LIMITED_API) && Py_LIMITED_API >= 0x030d0000) || (!defined(Py_LIMITED_API) && PY_VERSION_HEX >= 0x030d0000) + PyDict_GetItemStringRef(d, funcname, &cobj); +#else + cobj = PyDict_GetItemString(d, funcname); + Py_XINCREF(cobj); +#endif + if (!cobj) { + PyErr_Format(PyExc_ImportError, + "%.200s does not export expected C function %.200s", + PyModule_GetName(module), funcname); + goto bad; + } + if (!PyCapsule_IsValid(cobj, sig)) { + PyErr_Format(PyExc_TypeError, + "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", + PyModule_GetName(module), funcname, sig, PyCapsule_GetName(cobj)); + goto bad; + } + tmp.p = PyCapsule_GetPointer(cobj, sig); + *f = tmp.fp; + if (!(*f)) + goto bad; + Py_DECREF(d); + Py_DECREF(cobj); + return 0; +bad: + Py_XDECREF(d); + Py_XDECREF(cobj); + return -1; +} +#endif + +/* NewCodeObj */ +#if CYTHON_COMPILING_IN_LIMITED_API + static PyObject* __Pyx__PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyObject *exception_table = NULL; + PyObject *types_module=NULL, *code_type=NULL, *result=NULL; + #if __PYX_LIMITED_VERSION_HEX < 0x030b0000 + PyObject *version_info; + PyObject *py_minor_version = NULL; + #endif + long minor_version = 0; + PyObject *type, *value, *traceback; + PyErr_Fetch(&type, &value, &traceback); + #if __PYX_LIMITED_VERSION_HEX >= 0x030b0000 + minor_version = 11; + #else + if (!(version_info = PySys_GetObject("version_info"))) goto end; + if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; + minor_version = PyLong_AsLong(py_minor_version); + Py_DECREF(py_minor_version); + if (minor_version == -1 && PyErr_Occurred()) goto end; + #endif + if (!(types_module = PyImport_ImportModule("types"))) goto end; + if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; + if (minor_version <= 7) { + (void)p; + result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOOO", a, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else if (minor_version <= 10) { + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOOO", a,p, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); } else { - *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOOOO", a,p, k, l, s, f, code, + c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); } - #else - if (t->is_unicode | t->is_str) { + end: + Py_XDECREF(code_type); + Py_XDECREF(exception_table); + Py_XDECREF(types_module); + if (type) { + PyErr_Restore(type, value, traceback); + } + return result; + } +#elif PY_VERSION_HEX >= 0x030B0000 + static PyCodeObject* __Pyx__PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyCodeObject *result; + result = + #if PY_VERSION_HEX >= 0x030C0000 + PyUnstable_Code_NewWithPosOnlyArgs + #else + PyCode_NewWithPosOnlyArgs + #endif + (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, __pyx_mstate_global->__pyx_empty_bytes); + return result; + } +#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx__PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#else + #define __Pyx__PyCode_New(a, p, 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) +#endif +static PyObject* __Pyx_PyCode_New( + const __Pyx_PyCode_New_function_description descr, + PyObject * const *varnames, + PyObject *filename, + PyObject *funcname, + const char *line_table, + PyObject *tuple_dedup_map +) { + PyObject *code_obj = NULL, *varnames_tuple_dedup = NULL, *code_bytes = NULL, *line_table_bytes = NULL; + Py_ssize_t var_count = (Py_ssize_t) descr.nlocals; + PyObject *varnames_tuple = PyTuple_New(var_count); + if (unlikely(!varnames_tuple)) return NULL; + for (Py_ssize_t i=0; i < var_count; i++) { + Py_INCREF(varnames[i]); + if (__Pyx_PyTuple_SET_ITEM(varnames_tuple, i, varnames[i]) != (0)) goto done; + } + #if CYTHON_COMPILING_IN_LIMITED_API + varnames_tuple_dedup = PyDict_GetItem(tuple_dedup_map, varnames_tuple); + if (!varnames_tuple_dedup) { + if (unlikely(PyDict_SetItem(tuple_dedup_map, varnames_tuple, varnames_tuple) < 0)) goto done; + varnames_tuple_dedup = varnames_tuple; + } + #else + varnames_tuple_dedup = PyDict_SetDefault(tuple_dedup_map, varnames_tuple, varnames_tuple); + if (unlikely(!varnames_tuple_dedup)) goto done; + #endif + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(varnames_tuple_dedup); + #endif + if (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table != NULL + && !CYTHON_COMPILING_IN_GRAAL) { + line_table_bytes = PyBytes_FromStringAndSize(line_table, descr.line_table_length); + if (unlikely(!line_table_bytes)) goto done; + Py_ssize_t code_len = (descr.line_table_length * 2 + 4) & ~3; + code_bytes = PyBytes_FromStringAndSize(NULL, code_len); + if (unlikely(!code_bytes)) goto done; + char* c_code_bytes = PyBytes_AsString(code_bytes); + if (unlikely(!c_code_bytes)) goto done; + memset(c_code_bytes, 0, (size_t) code_len); + } + code_obj = (PyObject*) __Pyx__PyCode_New( + (int) descr.argcount, + (int) descr.num_posonly_args, + (int) descr.num_kwonly_args, + (int) descr.nlocals, + 0, + (int) descr.flags, + code_bytes ? code_bytes : __pyx_mstate_global->__pyx_empty_bytes, + __pyx_mstate_global->__pyx_empty_tuple, + __pyx_mstate_global->__pyx_empty_tuple, + varnames_tuple_dedup, + __pyx_mstate_global->__pyx_empty_tuple, + __pyx_mstate_global->__pyx_empty_tuple, + filename, + funcname, + (int) descr.first_line, + (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table_bytes) ? line_table_bytes : __pyx_mstate_global->__pyx_empty_bytes + ); +done: + Py_XDECREF(code_bytes); + Py_XDECREF(line_table_bytes); + #if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(varnames_tuple_dedup); + #endif + Py_DECREF(varnames_tuple); + return code_obj; +} + +/* InitStrings */ +static int __Pyx_InitStrings(__Pyx_StringTabEntry const *t, PyObject **target, const char* const* encoding_names) { + while (t->s) { + PyObject *str; + if (t->is_unicode) { if (t->intern) { - *t->p = PyUnicode_InternFromString(t->s); + str = PyUnicode_InternFromString(t->s); } else if (t->encoding) { - *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + str = PyUnicode_Decode(t->s, t->n - 1, encoding_names[t->encoding], NULL); } else { - *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + str = PyUnicode_FromStringAndSize(t->s, t->n - 1); } } else { - *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + str = PyBytes_FromStringAndSize(t->s, t->n - 1); } - #endif - if (!*t->p) + if (!str) return -1; - if (PyObject_Hash(*t->p) == -1) + *target = str; + if (PyObject_Hash(str) == -1) return -1; ++t; + ++target; } return 0; } +#include +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) { + size_t len = strlen(s); + if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) { + PyErr_SetString(PyExc_OverflowError, "byte string is too long"); + return -1; + } + return (Py_ssize_t) len; +} static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { - return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return __Pyx_PyUnicode_FromStringAndSize(c_str, len); +} +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) { + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return PyByteArray_FromStringAndSize(c_str, len); } 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 +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 +static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; +#if CYTHON_COMPILING_IN_LIMITED_API { - 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; - } + const char* result; + Py_ssize_t unicode_length; + CYTHON_MAYBE_UNUSED_VAR(unicode_length); // only for __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + #if __PYX_LIMITED_VERSION_HEX < 0x030A0000 + if (unlikely(PyArg_Parse(o, "s#", &result, length) < 0)) return NULL; + #else + result = PyUnicode_AsUTF8AndSize(o, length); + #endif + #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + unicode_length = PyUnicode_GetLength(o); + if (unlikely(unicode_length < 0)) return NULL; + if (unlikely(unicode_length != *length)) { + PyUnicode_AsASCIIString(o); + return NULL; } + #endif + return result; } -#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); @@ -26683,25 +42075,25 @@ static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py #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)) { +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 + if (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)) { +#if (CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS) || (CYTHON_COMPILING_IN_PYPY && (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))) *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); - } else +#else + *length = PyByteArray_Size(o); + if (*length == -1) return NULL; + return PyByteArray_AsString(o); #endif + } else { char* result; int r = PyBytes_AsStringAndSize(o, &result, length); @@ -26724,95 +42116,66 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { Py_DECREF(x); return retval; } -static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { -#if PY_MAJOR_VERSION >= 3 +static PyObject* __Pyx_PyNumber_LongWrongResultType(PyObject* result) { + __Pyx_TypeName result_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(result)); 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)) { + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME "). " + "The ability to return an instance of a strict subclass of int is deprecated, " + "and may be removed in a future version of Python.", + result_type_name)) { + __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } + __Pyx_DECREF_TypeName(result_type_name); return result; } -#endif PyErr_Format(PyExc_TypeError, - "__%.4s__ returned non-%.4s (type %.200s)", - type_name, type_name, Py_TYPE(result)->tp_name); + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ")", + result_type_name); + __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } -static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Long(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); + 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); + res = m->nb_int(x); } - #endif #else if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { - res = PyNumber_Int(x); + res = PyNumber_Long(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); - } + if (unlikely(!PyLong_CheckExact(res))) { + return __Pyx_PyNumber_LongWrongResultType(res); + } } else if (!PyErr_Occurred()) { - PyErr_SetString(PyExc_TypeError, - "an integer is required"); + 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(b); - } -#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; + if (likely(__Pyx_PyLong_IsCompact(b))) { + return __Pyx_PyLong_CompactValue(b); } else { + const digit* digits = __Pyx_PyLong_Digits(b); + const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b); switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { @@ -26851,16 +42214,356 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { } x = PyNumber_Index(b); if (!x) return -1; - ival = PyInt_AsSsize_t(x); + ival = PyLong_AsSsize_t(x); Py_DECREF(x); return ival; } +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { + if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { + return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o); + } else { + Py_ssize_t ival; + PyObject *x; + x = PyNumber_Index(o); + if (!x) return -1; + ival = PyLong_AsLong(x); + Py_DECREF(x); + return ival; + } +} +static CYTHON_INLINE PyObject *__Pyx_Owned_Py_None(int b) { + CYTHON_UNUSED_VAR(b); + return __Pyx_NewRef(Py_None); +} 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); +static CYTHON_INLINE PyObject * __Pyx_PyLong_FromSize_t(size_t ival) { + return PyLong_FromSize_t(ival); +} + + +/* MultiPhaseInitModuleState */ +#if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE +#ifndef CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +#if (CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX >= 0x030C0000) + #define CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE 1 +#else + #define CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE 0 +#endif +#endif +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE && !CYTHON_ATOMICS +#error "Module state with PEP489 requires atomics. Currently that's one of\ + C11, C++11, gcc atomic intrinsics or MSVC atomic intrinsics" +#endif +#if !CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +#define __Pyx_ModuleStateLookup_Lock() +#define __Pyx_ModuleStateLookup_Unlock() +#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d0000 +static PyMutex __Pyx_ModuleStateLookup_mutex = {0}; +#define __Pyx_ModuleStateLookup_Lock() PyMutex_Lock(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() PyMutex_Unlock(&__Pyx_ModuleStateLookup_mutex) +#elif defined(__cplusplus) && __cplusplus >= 201103L +#include +static std::mutex __Pyx_ModuleStateLookup_mutex; +#define __Pyx_ModuleStateLookup_Lock() __Pyx_ModuleStateLookup_mutex.lock() +#define __Pyx_ModuleStateLookup_Unlock() __Pyx_ModuleStateLookup_mutex.unlock() +#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ > 201112L) && !defined(__STDC_NO_THREADS__) +#include +static mtx_t __Pyx_ModuleStateLookup_mutex; +static once_flag __Pyx_ModuleStateLookup_mutex_once_flag = ONCE_FLAG_INIT; +static void __Pyx_ModuleStateLookup_initialize_mutex(void) { + mtx_init(&__Pyx_ModuleStateLookup_mutex, mtx_plain); +} +#define __Pyx_ModuleStateLookup_Lock()\ + call_once(&__Pyx_ModuleStateLookup_mutex_once_flag, __Pyx_ModuleStateLookup_initialize_mutex);\ + mtx_lock(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() mtx_unlock(&__Pyx_ModuleStateLookup_mutex) +#elif defined(HAVE_PTHREAD_H) +#include +static pthread_mutex_t __Pyx_ModuleStateLookup_mutex = PTHREAD_MUTEX_INITIALIZER; +#define __Pyx_ModuleStateLookup_Lock() pthread_mutex_lock(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() pthread_mutex_unlock(&__Pyx_ModuleStateLookup_mutex) +#elif defined(_WIN32) +#include // synchapi.h on its own doesn't work +static SRWLOCK __Pyx_ModuleStateLookup_mutex = SRWLOCK_INIT; +#define __Pyx_ModuleStateLookup_Lock() AcquireSRWLockExclusive(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() ReleaseSRWLockExclusive(&__Pyx_ModuleStateLookup_mutex) +#else +#error "No suitable lock available for CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE.\ + Requires C standard >= C11, or C++ standard >= C++11,\ + or pthreads, or the Windows 32 API, or Python >= 3.13." +#endif +typedef struct { + int64_t id; + PyObject *module; +} __Pyx_InterpreterIdAndModule; +typedef struct { + char interpreter_id_as_index; + Py_ssize_t count; + Py_ssize_t allocated; + __Pyx_InterpreterIdAndModule table[1]; +} __Pyx_ModuleStateLookupData; +#define __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE 32 +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +static __pyx_atomic_int_type __Pyx_ModuleStateLookup_read_counter = 0; +#endif +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +static __pyx_atomic_ptr_type __Pyx_ModuleStateLookup_data = 0; +#else +static __Pyx_ModuleStateLookupData* __Pyx_ModuleStateLookup_data = NULL; +#endif +static __Pyx_InterpreterIdAndModule* __Pyx_State_FindModuleStateLookupTableLowerBound( + __Pyx_InterpreterIdAndModule* table, + Py_ssize_t count, + int64_t interpreterId) { + __Pyx_InterpreterIdAndModule* begin = table; + __Pyx_InterpreterIdAndModule* end = begin + count; + if (begin->id == interpreterId) { + return begin; + } + while ((end - begin) > __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE) { + __Pyx_InterpreterIdAndModule* halfway = begin + (end - begin)/2; + if (halfway->id == interpreterId) { + return halfway; + } + if (halfway->id < interpreterId) { + begin = halfway; + } else { + end = halfway; + } + } + for (; begin < end; ++begin) { + if (begin->id >= interpreterId) return begin; + } + return begin; +} +static PyObject *__Pyx_State_FindModule(CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get()); + if (interpreter_id == -1) return NULL; +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData* data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data); + { + __pyx_atomic_incr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); + if (likely(data)) { + __Pyx_ModuleStateLookupData* new_data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_acquire(&__Pyx_ModuleStateLookup_data); + if (likely(data == new_data)) { + goto read_finished; + } + } + __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); + __Pyx_ModuleStateLookup_Lock(); + __pyx_atomic_incr_relaxed(&__Pyx_ModuleStateLookup_read_counter); + data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data); + __Pyx_ModuleStateLookup_Unlock(); + } + read_finished:; +#else + __Pyx_ModuleStateLookupData* data = __Pyx_ModuleStateLookup_data; +#endif + __Pyx_InterpreterIdAndModule* found = NULL; + if (unlikely(!data)) goto end; + if (data->interpreter_id_as_index) { + if (interpreter_id < data->count) { + found = data->table+interpreter_id; + } + } else { + found = __Pyx_State_FindModuleStateLookupTableLowerBound( + data->table, data->count, interpreter_id); + } + end: + { + PyObject *result=NULL; + if (found && found->id == interpreter_id) { + result = found->module; + } +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); +#endif + return result; + } +} +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +static void __Pyx_ModuleStateLookup_wait_until_no_readers(void) { + while (__pyx_atomic_load(&__Pyx_ModuleStateLookup_read_counter) != 0); +} +#else +#define __Pyx_ModuleStateLookup_wait_until_no_readers() +#endif +static int __Pyx_State_AddModuleInterpIdAsIndex(__Pyx_ModuleStateLookupData **old_data, PyObject* module, int64_t interpreter_id) { + Py_ssize_t to_allocate = (*old_data)->allocated; + while (to_allocate <= interpreter_id) { + if (to_allocate == 0) to_allocate = 1; + else to_allocate *= 2; + } + __Pyx_ModuleStateLookupData *new_data = *old_data; + if (to_allocate != (*old_data)->allocated) { + new_data = (__Pyx_ModuleStateLookupData *)realloc( + *old_data, + sizeof(__Pyx_ModuleStateLookupData)+(to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule)); + if (!new_data) { + PyErr_NoMemory(); + return -1; + } + for (Py_ssize_t i = new_data->allocated; i < to_allocate; ++i) { + new_data->table[i].id = i; + new_data->table[i].module = NULL; + } + new_data->allocated = to_allocate; + } + new_data->table[interpreter_id].module = module; + if (new_data->count < interpreter_id+1) { + new_data->count = interpreter_id+1; + } + *old_data = new_data; + return 0; +} +static void __Pyx_State_ConvertFromInterpIdAsIndex(__Pyx_ModuleStateLookupData *data) { + __Pyx_InterpreterIdAndModule *read = data->table; + __Pyx_InterpreterIdAndModule *write = data->table; + __Pyx_InterpreterIdAndModule *end = read + data->count; + for (; readmodule) { + write->id = read->id; + write->module = read->module; + ++write; + } + } + data->count = write - data->table; + for (; writeid = 0; + write->module = NULL; + } + data->interpreter_id_as_index = 0; +} +static int __Pyx_State_AddModule(PyObject* module, CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get()); + if (interpreter_id == -1) return -1; + int result = 0; + __Pyx_ModuleStateLookup_Lock(); +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData *old_data = (__Pyx_ModuleStateLookupData *) + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0); +#else + __Pyx_ModuleStateLookupData *old_data = __Pyx_ModuleStateLookup_data; +#endif + __Pyx_ModuleStateLookupData *new_data = old_data; + if (!new_data) { + new_data = (__Pyx_ModuleStateLookupData *)calloc(1, sizeof(__Pyx_ModuleStateLookupData)); + if (!new_data) { + result = -1; + PyErr_NoMemory(); + goto end; + } + new_data->allocated = 1; + new_data->interpreter_id_as_index = 1; + } + __Pyx_ModuleStateLookup_wait_until_no_readers(); + if (new_data->interpreter_id_as_index) { + if (interpreter_id < __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE) { + result = __Pyx_State_AddModuleInterpIdAsIndex(&new_data, module, interpreter_id); + goto end; + } + __Pyx_State_ConvertFromInterpIdAsIndex(new_data); + } + { + Py_ssize_t insert_at = 0; + { + __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound( + new_data->table, new_data->count, interpreter_id); + assert(lower_bound); + insert_at = lower_bound - new_data->table; + if (unlikely(insert_at < new_data->count && lower_bound->id == interpreter_id)) { + lower_bound->module = module; + goto end; // already in table, nothing more to do + } + } + if (new_data->count+1 >= new_data->allocated) { + Py_ssize_t to_allocate = (new_data->count+1)*2; + new_data = + (__Pyx_ModuleStateLookupData*)realloc( + new_data, + sizeof(__Pyx_ModuleStateLookupData) + + (to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule)); + if (!new_data) { + result = -1; + new_data = old_data; + PyErr_NoMemory(); + goto end; + } + new_data->allocated = to_allocate; + } + ++new_data->count; + int64_t last_id = interpreter_id; + PyObject *last_module = module; + for (Py_ssize_t i=insert_at; icount; ++i) { + int64_t current_id = new_data->table[i].id; + new_data->table[i].id = last_id; + last_id = current_id; + PyObject *current_module = new_data->table[i].module; + new_data->table[i].module = last_module; + last_module = current_module; + } + } + end: +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, new_data); +#else + __Pyx_ModuleStateLookup_data = new_data; +#endif + __Pyx_ModuleStateLookup_Unlock(); + return result; +} +static int __Pyx_State_RemoveModule(CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get()); + if (interpreter_id == -1) return -1; + __Pyx_ModuleStateLookup_Lock(); +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData *data = (__Pyx_ModuleStateLookupData *) + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0); +#else + __Pyx_ModuleStateLookupData *data = __Pyx_ModuleStateLookup_data; +#endif + if (data->interpreter_id_as_index) { + if (interpreter_id < data->count) { + data->table[interpreter_id].module = NULL; + } + goto done; + } + { + __Pyx_ModuleStateLookup_wait_until_no_readers(); + __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound( + data->table, data->count, interpreter_id); + if (!lower_bound) goto done; + if (lower_bound->id != interpreter_id) goto done; + __Pyx_InterpreterIdAndModule *end = data->table+data->count; + for (;lower_boundid = (lower_bound+1)->id; + lower_bound->module = (lower_bound+1)->module; + } + } + --data->count; + if (data->count == 0) { + free(data); + data = NULL; + } + done: +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, data); +#else + __Pyx_ModuleStateLookup_data = data; +#endif + __Pyx_ModuleStateLookup_Unlock(); + return 0; } +#endif + +/* #### Code section: utility_code_pragmas_end ### */ +#ifdef _MSC_VER +#pragma warning( pop ) +#endif + +/* #### Code section: end ### */ #endif /* Py_PYTHON_H */ diff --git a/src/hunter/_predicates.pxd b/src/hunter/_predicates.pxd index 9799848e..3e365e3a 100644 --- a/src/hunter/_predicates.pxd +++ b/src/hunter/_predicates.pxd @@ -18,27 +18,32 @@ cdef class Query: readonly tuple query_regex readonly tuple query_startswith + @cython.final cdef class And: cdef: readonly tuple predicates + @cython.final cdef class Or: cdef: readonly tuple predicates + @cython.final cdef class Not: cdef: readonly object predicate + @cython.final cdef class When: cdef: readonly object condition readonly tuple actions + @cython.final cdef class From: cdef: @@ -48,10 +53,24 @@ cdef class From: readonly int origin_depth readonly int origin_calls + +@cython.final +cdef class Backlog: + cdef: + readonly object condition + readonly int size + readonly int stack + readonly bint vars + readonly bint strip + readonly object action + readonly object _try_repr + readonly object _filter + readonly object queue + cdef fast_And_call(And self, Event event) cdef fast_From_call(From self, Event event) cdef fast_Not_call(Not self, Event event) cdef fast_Or_call(Or self, Event event) cdef fast_Query_call(Query self, Event event) cdef fast_When_call(When self, Event event) -cdef fast_call(callable, Event event) +cdef fast_call(object callable, Event event) diff --git a/src/hunter/_predicates.pyx b/src/hunter/_predicates.pyx index f3a4197c..cd99c968 100644 --- a/src/hunter/_predicates.pyx +++ b/src/hunter/_predicates.pyx @@ -1,18 +1,19 @@ -# cython: linetrace=True, language_level=3str +# cython: linetrace=True, language_level=3str, c_api_binop_methods=True, freethreading_compatible=True from __future__ import absolute_import -import inspect -import re -from itertools import chain +from collections import deque +from inspect import isclass +from re import compile as re_compile cimport cython -from cpython.object cimport PyObject_RichCompare -from cpython.object cimport Py_EQ -from cpython.object cimport Py_NE from ._event cimport Event +from ._event cimport fast_clone +from ._event cimport fast_detach +from ._tracer cimport * from .actions import Action +from .actions import ColorStreamAction __all__ = ( 'And', @@ -24,8 +25,8 @@ __all__ = ( ) cdef tuple ALLOWED_KEYS = ( - 'function', 'code', 'frame', 'module', 'lineno', 'globals', 'stdlib', 'arg', 'locals', 'kind', 'filename', 'source', - 'fullsource', 'threadname', 'threadid', 'depth', 'calls', + 'function', 'module', 'lineno', 'globals', 'stdlib', 'arg', 'locals', 'kind', 'filename', 'source', + 'fullsource', 'threadname', 'threadid', 'instruction', 'depth', 'calls', 'builtin', ) cdef tuple ALLOWED_OPERATORS = ( 'startswith', 'endswith', 'in', 'contains', 'regex', @@ -33,6 +34,67 @@ cdef tuple ALLOWED_OPERATORS = ( 'gt', 'gte', 'lt', 'lte', ) +ctypedef object (*Event_getter_typedef)(Event) +cdef inline Event_get_function(Event event): return event.function_getter() +cdef inline Event_get_module(Event event): return event.module_getter() +cdef inline Event_get_lineno(Event event): return event.lineno_getter() +cdef inline Event_get_globals(Event event): return event.globals_getter() +cdef inline Event_get_stdlib(Event event): return event.stdlib_getter() +cdef inline Event_get_arg(Event event): return event.arg +cdef inline Event_get_locals(Event event): return event.locals_getter() +cdef inline Event_get_kind(Event event): return event.kind +cdef inline Event_get_filename(Event event): return event.filename_getter() +cdef inline Event_get_source(Event event): return event.source_getter() +cdef inline Event_get_fullsource(Event event): return event.fullsource_getter() +cdef inline Event_get_threadname(Event event): return event.threadname_getter() +cdef inline Event_get_threadid(Event event): return event.threadid_getter() +cdef inline Event_get_instruction(Event event): return event.instruction_getter() +cdef inline Event_get_depth(Event event): return event.depth +cdef inline Event_get_calls(Event event): return event.calls +cdef inline Event_get_builtin(Event event): return event.builtin + +cdef Event_getter_typedef[17] Event_getters = [ + Event_get_function, + Event_get_module, + Event_get_lineno, + Event_get_globals, + Event_get_stdlib, + Event_get_arg, + Event_get_locals, + Event_get_kind, + Event_get_filename, + Event_get_source, + Event_get_fullsource, + Event_get_threadname, + Event_get_threadid, + Event_get_instruction, + Event_get_depth, + Event_get_calls, + Event_get_builtin, +] + + +@cython.final +cdef class QueryEntry: + cdef Event_getter_typedef getter + cdef int getter_index + cdef object value + + def __init__(self, object value, str name): + self.value = value + self.getter_index = ALLOWED_KEYS.index(name) + self.getter = Event_getters[self.getter_index] + + def __repr__(self): + return repr(self.value) + + def __eq__(self, other): + return ( + isinstance(other, QueryEntry) + and self.value == ( other).value + and self.getter_index == ( other).getter_index + ) + @cython.final cdef class Query: @@ -80,21 +142,21 @@ cdef class Query: parts = [p for p in key.split('_') if p] count = len(parts) if count > 2: - raise TypeError('Unexpected argument %r. Must be one of %s with optional operators like: %s' % ( - key, ALLOWED_KEYS, ALLOWED_OPERATORS - )) + raise TypeError( + f'Unexpected argument {key!r}. Must be one of {ALLOWED_KEYS} with optional operators like: {ALLOWED_OPERATORS}' + ) elif count == 2: prefix, operator = parts if operator in ('startswith', 'sw'): if not isinstance(value, basestring): if not isinstance(value, (list, set, tuple)): - raise ValueError('Value %r for %r is invalid. Must be a string, list, tuple or set.' % (value, key)) + raise ValueError(f'Value {value!r} for {key!r} is invalid. Must be a string, list, tuple or set.') value = tuple(value) mapping = query_startswith elif operator in ('endswith', 'ew'): if not isinstance(value, basestring): if not isinstance(value, (list, set, tuple)): - raise ValueError('Value %r for %r is invalid. Must be a string, list, tuple or set.' % (value, key)) + raise ValueError(f'Value {value!r} for {key!r} is invalid. Must be a string, list, tuple or set.') value = tuple(value) mapping = query_endswith elif operator == 'in': @@ -102,7 +164,7 @@ cdef class Query: elif operator in ('contains', 'has'): mapping = query_contains elif operator in ('regex', 'rx'): - value = re.compile(value) + value = re_compile(value) mapping = query_regex elif operator == 'lt': mapping = query_lt @@ -113,15 +175,15 @@ cdef class Query: elif operator == 'gte': mapping = query_gte else: - raise TypeError('Unexpected operator %r. Must be one of %s.' % (operator, ALLOWED_OPERATORS)) + raise TypeError(f'Unexpected operator {operator!r}. Must be one of {ALLOWED_OPERATORS}.') else: mapping = query_eq prefix = key if prefix not in ALLOWED_KEYS: - raise TypeError('Unexpected argument %r. Must be one of %s.' % (key, ALLOWED_KEYS)) + raise TypeError(f'Unexpected argument {key!r}. Must be one of {ALLOWED_KEYS}.') - mapping[prefix] = value + mapping[prefix] = QueryEntry(value, prefix) self.query_eq = tuple(sorted(query_eq.items())) self.query_startswith = tuple(sorted(query_startswith.items())) @@ -136,8 +198,8 @@ cdef class Query: def __str__(self): return 'Query(%s)' % ( - ', '.join( - ', '.join('%s%s=%r' % (key, kind, value) for key, value in mapping) + ', '.join([ + ', '.join(f'{key}{kind}={value!r}' for key, value in mapping) for kind, mapping in [ ('', self.query_eq), ('_in', self.query_in), @@ -149,13 +211,15 @@ cdef class Query: ('_lte', self.query_lte), ('_gt', self.query_gt), ('_gte', self.query_gte), - ] if mapping - ) + ] + if mapping + ]) ) def __repr__(self): - return '' % ' '.join( - fmt % (mapping,) for fmt, mapping in [ + return '' % ' '.join([ + fmt % (mapping,) + for fmt, mapping in [ ('query_eq=%r', self.query_eq), ('query_in=%r', self.query_in), ('query_contains=%r', self.query_contains), @@ -166,9 +230,9 @@ cdef class Query: ('query_lte=%r', self.query_lte), ('query_gt=%r', self.query_gt), ('query_gte=%r', self.query_gte), - - ] if mapping - ) + ] + if mapping + ]) def __eq__(self, other): return ( @@ -179,27 +243,12 @@ cdef class Query: and self.query_in == ( other).query_in and self.query_contains == ( other).query_contains and self.query_regex == ( other).query_regex - and self.query_lt == (other).query_lt - and self.query_lte == (other).query_lte - and self.query_gt == (other).query_gt - and self.query_gte == (other).query_gte + and self.query_lt == ( other).query_lt + and self.query_lte == ( other).query_lte + and self.query_gt == ( other).query_gt + and self.query_gte == ( other).query_gte ) - def __hash__(self): - return hash(( - 'Query', - self.query_eq, - self.query_in, - self.query_contains, - self.query_startswith, - self.query_endswith, - self.query_regex, - self.query_lt, - self.query_lte, - self.query_gt, - self.query_gte, - )) - def __call__(self, Event event): return fast_Query_call(self, event) @@ -212,46 +261,46 @@ cdef class Query: def __invert__(self): return Not(self) -cdef fast_Query_call(Query self, Event event): - for key, value in self.query_eq: - evalue = event[key] - if evalue != value: +cdef inline fast_Query_call(Query self, Event event): + for key, entry in self.query_eq: + value_from_event = ( entry).getter(event) + if value_from_event != ( entry).value: return False - for key, value in self.query_in: - evalue = event[key] - if evalue not in value: + for key, entry in self.query_in: + value_from_event = ( entry).getter(event) + if (value_from_event) not in ( entry).value: return False - for key, value in self.query_contains: - evalue = event[key] - if value not in evalue: + for key, entry in self.query_contains: + value_from_event = ( entry).getter(event) + if ( entry).value not in (value_from_event): return False - for key, value in self.query_startswith: - evalue = event[key] - if not evalue.startswith(value): + for key, entry in self.query_startswith: + value_from_event = ( entry).getter(event) + if not (value_from_event).startswith(( entry).value): return False - for key, value in self.query_endswith: - evalue = event[key] - if not evalue.endswith(value): + for key, entry in self.query_endswith: + value_from_event = ( entry).getter(event) + if not (value_from_event).endswith(( entry).value): return False - for key, value in self.query_regex: - evalue = event[key] - if not value.match(evalue): + for key, entry in self.query_regex: + value_from_event = ( entry).getter(event) + if not ( entry).value.match(value_from_event): return False - for key, value in self.query_gt: - evalue = event[key] - if not evalue > value: + for key, entry in self.query_gt: + value_from_event = ( entry).getter(event) + if not value_from_event > ( entry).value: return False - for key, value in self.query_gte: - evalue = event[key] - if not evalue >= value: + for key, entry in self.query_gte: + value_from_event = ( entry).getter(event) + if not value_from_event >= ( entry).value: return False - for key, value in self.query_lt: - evalue = event[key] - if not evalue < value: + for key, entry in self.query_lt: + value_from_event = ( entry).getter(event) + if not value_from_event < ( entry).value: return False - for key, value in self.query_lte: - evalue = event[key] - if not evalue <= value: + for key, entry in self.query_lte: + value_from_event = ( entry).getter(event) + if not value_from_event <= ( entry).value: return False return True @@ -270,7 +319,7 @@ cdef class When: raise TypeError('Must give at least one action.') self.condition = condition self.actions = tuple( - action() if inspect.isclass(action) and issubclass(action, Action) else action + action() if isclass(action) and issubclass(action, Action) else action for action in actions) def __str__(self): @@ -289,9 +338,6 @@ cdef class When: and self.actions == ( other).actions ) - def __hash__(self): - return hash(('When', self.condition, self.actions)) - def __call__(self, Event event): return fast_When_call(self, event) @@ -346,9 +392,6 @@ cdef class From: and self.predicate == ( other).predicate ) - def __hash__(self): - return hash(('From', self.condition, self.predicate)) - def __call__(self, Event event): return fast_From_call(self, event) @@ -385,11 +428,12 @@ cdef inline fast_From_call(From self, Event event): if self.predicate is None: return True else: - relative_event = event.clone() + relative_event = fast_clone(event) relative_event.depth = delta_depth relative_event.calls = delta_calls return fast_call(self.predicate, relative_event) + @cython.final cdef class And: """ @@ -410,9 +454,6 @@ cdef class And: and self.predicates == ( other).predicates ) - def __hash__(self): - return hash(('And', self.predicates)) - def __call__(self, Event event): return fast_And_call(self, event) @@ -422,7 +463,7 @@ cdef class And: def __and__(self, other): cdef list predicates if type(self) is And: - predicates = list((self).predicates) + predicates = list(( self).predicates) else: predicates = [self] if isinstance(other, And): @@ -463,9 +504,6 @@ cdef class Or: and self.predicates == ( other).predicates ) - def __hash__(self): - return hash(('Or', self.predicates)) - def __call__(self, Event event): return fast_Or_call(self, event) @@ -514,9 +552,6 @@ cdef class Not: and self.predicate == ( other).predicate ) - def __hash__(self): - return hash(('Not', self.predicate)) - def __call__(self, Event event): return fast_Not_call(self, event) @@ -552,5 +587,135 @@ cdef inline fast_call(callable, Event event): return fast_When_call( callable, event) elif type(callable) is From: return fast_From_call( callable, event) + elif type(callable) is Backlog: + return fast_Backlog_call( callable, event) else: return callable(event) + + +@cython.final +cdef class Backlog: + def __init__(self, condition, size=100, stack=10, vars=False, strip=True, action=None, filter=None): + self.action = action() if isclass(action) and issubclass(action, Action) else action + if not isinstance(self.action, ColorStreamAction): + raise TypeError("Action %r must be a ColorStreamAction." % self.action) + self.condition = condition + self.queue = deque(maxlen=size) + self.size = size + self.stack = stack + self.strip = strip + self.vars = vars + self._try_repr = self.action.try_repr if self.vars else None + self._filter = filter + + def __call__(self, event): + return fast_Backlog_call(self, event) + + def __str__(self): + return 'Backlog(%s, size=%s, stack=%s, vars=%s, action=%s, filter=%s)' % ( + self.condition, self.size, self.stack, self.vars, self.action, self._filter + ) + + def __repr__(self): + return '' % ( + self.condition, self.size, self.stack, self.vars, self.action, self._filter + ) + + def __eq__(self, other): + return ( + isinstance(other, Backlog) and + self.condition == ( other).condition and + self.size == ( other).size and + self.stack == ( other).stack and + self.vars == ( other).vars and + self.action == ( other).action + ) + + def __or__(self, other): + return Or(self, other) + + def __and__(self, other): + return And(self, other) + + def __invert__(self): + return Backlog(Not(self.condition), size=self.size, stack=self.stack, vars=self.vars, action=self.action, filter=self._filter) + + def filter(self, *predicates, **kwargs): + from hunter import _merge + + if self._filter is not None: + predicates = (self._filter, *predicates) + + return Backlog( + self.condition, + size=self.size, stack=self.stack, vars=self.vars, action=self.action, + filter=_merge(*predicates, **kwargs) + ) + +cdef inline fast_Backlog_call(Backlog self, Event event): + cdef bint first_is_call + cdef Event detached_event + cdef Event first_event + cdef Event stack_event + cdef FrameType first_frame + cdef FrameType frame + cdef int backlog_call_depth + cdef int depth_delta + cdef int first_depth + cdef int missing_depth + cdef object result + cdef object stack_events + + result = fast_call(self.condition, event) + if result: + if self.queue: + self.action.cleanup() + + first_event = self.queue[0] + first_depth = first_event.depth + backlog_call_depth = event.depth - first_depth + first_is_call = first_event.kind == 'call' # note that True is 1, thus the following math is valid + missing_depth = min(first_depth, max(0, self.stack - backlog_call_depth + first_is_call)) + if missing_depth: + if first_is_call and first_event.frame is not None: + first_frame = first_event.frame.f_back + else: + first_frame = first_event.frame + if first_frame is not None: + stack_events = deque() # a new deque because self.queue is limited, we can't add while it's full + frame = first_frame + depth_delta = 0 + while frame and depth_delta < missing_depth: + stack_event = Event( + frame=frame, kind=0, arg=None, + threading_support=event.threading_support, + depth=first_depth - depth_delta - 1, calls=-1 + ) + if not self.vars: + # noinspection PyPropertyAccess + stack_event._locals = {} + stack_event._globals = {} + stack_event.detached = True + stack_events.appendleft(stack_event) + frame = frame.f_back + depth_delta += 1 + for stack_event in stack_events: + if self._filter is None or self._filter(stack_event): + self.action(stack_event) + for backlog_event in self.queue: + if self._filter is None: + self.action(backlog_event) + elif fast_call(self._filter, backlog_event): + self.action(backlog_event) + self.queue.clear() + else: + if self.strip and event.depth < 1: + # Looks like we're back to depth 0 for some reason. + # Delete everything because we don't want to see what is likely just a long stream of useless returns. + self.queue.clear() + if self._filter is None or self._filter(event): + detached_event = fast_detach(event, self._try_repr) + detached_event.frame = event.frame + self.queue.append(detached_event) + + return result diff --git a/src/hunter/_tracer.c b/src/hunter/_tracer.c index 0d346b03..8a39a5a4 100644 --- a/src/hunter/_tracer.c +++ b/src/hunter/_tracer.c @@ -1,20 +1,49 @@ -/* Generated by Cython 0.29.14 */ +/* Generated by Cython 3.1.3 */ +/* BEGIN: Cython Metadata +{ + "distutils": { + "depends": [ + "src/hunter/vendor/_compat.h" + ], + "extra_compile_args": [ + "-DCYTHON_USE_SYS_MONITORING=0" + ], + "include_dirs": [ + "src/hunter" + ], + "name": "hunter._tracer", + "sources": [ + "src/hunter/_tracer.pyx" + ] + }, + "module_name": "hunter._tracer" +} +END: Cython Metadata */ + +#ifndef PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN +#endif /* PY_SSIZE_T_CLEAN */ +/* InitLimitedAPI */ +#if defined(Py_LIMITED_API) && !defined(CYTHON_LIMITED_API) + #define CYTHON_LIMITED_API 1 +#endif + #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+. +#elif PY_VERSION_HEX < 0x03080000 + #error Cython requires Python 3.8+. #else -#define CYTHON_ABI "0_29_14" -#define CYTHON_HEX_VERSION 0x001D0EF0 +#define __PYX_ABI_VERSION "3_1_3" +#define CYTHON_HEX_VERSION 0x030103F0 #define CYTHON_FUTURE_DIVISION 1 +/* CModulePreamble */ #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif -#if !defined(WIN32) && !defined(MS_WINDOWS) +#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif @@ -33,9 +62,7 @@ #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG - #if PY_VERSION_HEX >= 0x02070000 - #define HAVE_LONG_LONG - #endif + #define HAVE_LONG_LONG #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG @@ -43,20 +70,21 @@ #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 __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX +#if defined(GRAALVM_PYTHON) + /* For very preliminary testing purposes. Most variables are set the same as PyPy. + The existence of this section does not imply that anything works or is even tested */ + #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 1 + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 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 @@ -67,95 +95,219 @@ #define CYTHON_USE_PYLONG_INTERNALS 0 #undef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1 #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 0 #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 -#elif defined(PYSTON_VERSION) - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 1 + #define CYTHON_USE_EXC_INFO_STACK 1 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(PYPY_VERSION) + #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_CPYTHON 0 - #ifndef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 1 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 #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_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_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #ifndef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 1 + #endif + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #if PY_VERSION_HEX < 0x03090000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PYPY_VERSION_NUM >= 0x07030C00) + #endif + #undef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_NUM >= 0x07031100) + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(CYTHON_LIMITED_API) + #ifdef Py_LIMITED_API + #undef __PYX_LIMITED_VERSION_HEX + #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API + #endif + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 1 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + #undef CYTHON_CLINE_IN_TRACEBACK + #define CYTHON_CLINE_IN_TRACEBACK 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 1 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #endif + #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 + #ifndef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0 #endif + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL (__PYX_LIMITED_VERSION_HEX >= 0x030C0000) #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 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif + #undef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #endif + #ifndef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND (__PYX_LIMITED_VERSION_HEX >= 0x030A0000) + #endif #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 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_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #ifdef Py_GIL_DISABLED + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 1 + #else + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + #endif + #if PY_VERSION_HEX < 0x030A0000 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #elif !defined(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 + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 #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 + #ifndef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif - #if PY_VERSION_HEX < 0x02070000 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #ifndef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 1 #endif - #ifndef CYTHON_USE_PYLIST_INTERNALS + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #elif !defined(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 + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING || PY_VERSION_HEX >= 0x030B00A2 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #elif !defined(CYTHON_USE_UNICODE_WRITER) @@ -164,36 +316,82 @@ #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1 + #elif !defined(CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS) + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0 + #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif + #ifndef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 1 + #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #elif !defined(CYTHON_FAST_GIL) + #define CYTHON_FAST_GIL (PY_VERSION_HEX < 0x030C00A6) + #endif + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 1 + #endif #ifndef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 1 #endif + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif + #ifndef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING (PY_VERSION_HEX >= 0x030d00B1) #endif #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) + #define CYTHON_USE_TP_FINALIZE 1 #endif - #ifndef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) + #ifndef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND 1 + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #elif !defined(CYTHON_USE_DICT_VERSIONS) + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5 && !CYTHON_USE_MODULE_STATE) #endif #ifndef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) + #define CYTHON_USE_EXC_INFO_STACK 1 + #endif + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS (!CYTHON_COMPILING_IN_CPYTHON_FREETHREADING) + #endif +#endif +#ifndef CYTHON_FAST_PYCCALL +#define CYTHON_FAST_PYCCALL CYTHON_FAST_PYCALL +#endif +#ifndef CYTHON_VECTORCALL +#if CYTHON_COMPILING_IN_LIMITED_API +#define CYTHON_VECTORCALL (__PYX_LIMITED_VERSION_HEX >= 0x030C0000) +#else +#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) #endif -#if !defined(CYTHON_FAST_PYCCALL) -#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif +#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) #if CYTHON_USE_PYLONG_INTERNALS - #include "longintrepr.h" #undef SHIFT #undef BASE #undef MASK @@ -201,6 +399,9 @@ enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; #endif #endif +#ifndef CYTHON_LOCK_AND_GIL_DEADLOCK_AVOIDANCE_TIME + #define CYTHON_LOCK_AND_GIL_DEADLOCK_AVOIDANCE_TIME 100 +#endif #ifndef __has_attribute #define __has_attribute(x) 0 #endif @@ -218,6 +419,17 @@ #define CYTHON_RESTRICT #endif #endif +#ifndef CYTHON_UNUSED + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(maybe_unused) + #define CYTHON_UNUSED [[maybe_unused]] + #endif + #endif + #endif +#endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) @@ -231,42 +443,76 @@ # define CYTHON_UNUSED # endif #endif -#ifndef CYTHON_MAYBE_UNUSED_VAR +#ifndef CYTHON_UNUSED_VAR # if defined(__cplusplus) - template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } + template void CYTHON_UNUSED_VAR( const T& ) { } # else -# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# define CYTHON_UNUSED_VAR(x) (void)(x) # endif #endif +#ifndef CYTHON_MAYBE_UNUSED_VAR + #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) +#endif #ifndef CYTHON_NCP_UNUSED -# if CYTHON_COMPILING_IN_CPYTHON +# if CYTHON_COMPILING_IN_CPYTHON && !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING # define CYTHON_NCP_UNUSED # else # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif +#ifndef CYTHON_USE_CPP_STD_MOVE + #if defined(__cplusplus) && (\ + __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) + #define CYTHON_USE_CPP_STD_MOVE 1 + #else + #define CYTHON_USE_CPP_STD_MOVE 0 + #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; + typedef unsigned char uint8_t; + typedef unsigned short uint16_t; + typedef unsigned int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; + #endif + #endif + #if _MSC_VER < 1300 + #ifdef _WIN64 + typedef unsigned long long __pyx_uintptr_t; + #else + typedef unsigned int __pyx_uintptr_t; + #endif + #else + #ifdef _WIN64 + typedef unsigned __int64 __pyx_uintptr_t; #else - typedef unsigned __int8 uint8_t; - typedef unsigned __int32 uint32_t; + typedef unsigned __int32 __pyx_uintptr_t; #endif #endif #else - #include + #include + typedef uintptr_t __pyx_uintptr_t; #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]] + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(fallthrough) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif #endif #endif #ifndef CYTHON_FALLTHROUGH @@ -276,14 +522,31 @@ #define CYTHON_FALLTHROUGH #endif #endif - #if defined(__clang__ ) && defined(__apple_build_version__) + #if defined(__clang__) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif +#ifndef Py_UNREACHABLE + #define Py_UNREACHABLE() assert(0); abort() +#endif +#ifdef __cplusplus + template + struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; + #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) +#else + #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) +#endif +#if CYTHON_COMPILING_IN_PYPY == 1 + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000) +#else + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000) +#endif +#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) +/* CInitCode */ #ifndef CYTHON_INLINE #if defined(__clang__) #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) @@ -298,26 +561,72 @@ #endif #endif -#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) - #define Py_OptimizeFlag 0 -#endif +/* PythonCompatibility */ #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" -#if PY_VERSION_HEX >= 0x030800A4 && PY_VERSION_HEX < 0x030800B2 - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_New(a, 0, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) -#else - #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_BUILTIN_MODULE_NAME "builtins" +#define __Pyx_DefaultClassType PyType_Type +#if CYTHON_COMPILING_IN_LIMITED_API + #ifndef CO_OPTIMIZED + static int CO_OPTIMIZED; + #endif + #ifndef CO_NEWLOCALS + static int CO_NEWLOCALS; + #endif + #ifndef CO_VARARGS + static int CO_VARARGS; + #endif + #ifndef CO_VARKEYWORDS + static int CO_VARKEYWORDS; + #endif + #ifndef CO_ASYNC_GENERATOR + static int CO_ASYNC_GENERATOR; + #endif + #ifndef CO_GENERATOR + static int CO_GENERATOR; + #endif + #ifndef CO_COROUTINE + static int CO_COROUTINE; + #endif +#else + #ifndef CO_COROUTINE + #define CO_COROUTINE 0x80 + #endif + #ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x200 + #endif +#endif +static int __Pyx_init_co_variables(void); +#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE) + #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) +#else + #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) + #define __Pyx_Py_Is(x, y) Py_Is(x, y) +#else + #define __Pyx_Py_Is(x, y) ((x) == (y)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) + #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) +#else + #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) + #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) +#else + #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) + #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) +#else + #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) #endif - #define __Pyx_DefaultClassType PyType_Type +#define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) +#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) +#else + #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 @@ -331,10 +640,16 @@ #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif +#ifndef Py_TPFLAGS_SEQUENCE + #define Py_TPFLAGS_SEQUENCE 0 +#endif +#ifndef Py_TPFLAGS_MAPPING + #define Py_TPFLAGS_MAPPING 0 +#endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif -#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) +#ifndef METH_FASTCALL #ifndef METH_FASTCALL #define METH_FASTCALL 0x80 #endif @@ -342,114 +657,208 @@ typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else - #define __Pyx_PyCFunctionFast _PyCFunctionFast - #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #if PY_VERSION_HEX >= 0x030d00A4 + # define __Pyx_PyCFunctionFast PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords + #else + # define __Pyx_PyCFunctionFast _PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #endif +#endif +#if CYTHON_METH_FASTCALL + #define __Pyx_METH_FASTCALL METH_FASTCALL + #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast + #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords +#else + #define __Pyx_METH_FASTCALL METH_VARARGS + #define __Pyx_PyCFunction_FastCall PyCFunction + #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords +#endif +#if CYTHON_VECTORCALL + #define __pyx_vectorcallfunc vectorcallfunc + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET + #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) +#elif CYTHON_BACKPORT_VECTORCALL + typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args, + size_t nargsf, PyObject *kwnames); + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)) +#else + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) +#endif +#if PY_VERSION_HEX >= 0x030900B1 +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) +#else +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) +#endif +#define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) +#elif !CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) +#endif +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) +static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { + return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; +} #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 | METH_STACKLESS))))) +static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void (*cfunc)(void)) { +#if CYTHON_COMPILING_IN_LIMITED_API + return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; #else -#define __Pyx_PyFastCFunction_Check(func) 0 + return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +#endif +} +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) +#if __PYX_LIMITED_VERSION_HEX < 0x03090000 + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) + typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); +#else + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) + #define __Pyx_PyCMethod PyCMethod +#endif +#ifndef METH_METHOD + #define METH_METHOD 0x200 #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_CPYTHON && PY_VERSION_HEX < 0x030400A1 - #define PyMem_RawMalloc(n) PyMem_Malloc(n) - #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) - #define PyMem_RawFree(p) PyMem_Free(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) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) +#elif CYTHON_COMPILING_IN_GRAAL + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #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 +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyThreadState_Current PyThreadState_Get() +#elif !CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() #else - #define __Pyx_PyThreadState_Current _PyThreadState_Current + #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #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; -} -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); +#if CYTHON_USE_MODULE_STATE +static CYTHON_INLINE void *__Pyx__PyModule_GetState(PyObject *op) +{ + void *result; + result = PyModule_GetState(op); + if (!result) + Py_FatalError("Couldn't find the module state"); + return result; } +#define __Pyx_PyModule_GetState(o) (__pyx_mstatetype *)__Pyx__PyModule_GetState(o) +#else +#define __Pyx_PyModule_GetState(op) ((void)op,__pyx_mstate_global) +#endif +#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE((PyObject *) obj), name, func_ctype) +#define __Pyx_PyObject_TryGetSlot(obj, name, func_ctype) __Pyx_PyType_TryGetSlot(Py_TYPE(obj), name, func_ctype) +#define __Pyx_PyObject_GetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_GetSubSlot(Py_TYPE(obj), sub, name, func_ctype) +#define __Pyx_PyObject_TryGetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_TryGetSubSlot(Py_TYPE(obj), sub, name, func_ctype) +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) + #define __Pyx_PyType_TryGetSlot(type, name, func_ctype) __Pyx_PyType_GetSlot(type, name, func_ctype) + #define __Pyx_PyType_GetSubSlot(type, sub, name, func_ctype) (((type)->sub) ? ((type)->sub->name) : NULL) + #define __Pyx_PyType_TryGetSubSlot(type, sub, name, func_ctype) __Pyx_PyType_GetSubSlot(type, sub, name, func_ctype) +#else + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) + #define __Pyx_PyType_TryGetSlot(type, name, func_ctype)\ + ((__PYX_LIMITED_VERSION_HEX >= 0x030A0000 ||\ + (PyType_GetFlags(type) & Py_TPFLAGS_HEAPTYPE) || __Pyx_get_runtime_version() >= 0x030A0000) ?\ + __Pyx_PyType_GetSlot(type, name, func_ctype) : NULL) + #define __Pyx_PyType_GetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_GetSlot(obj, name, func_ctype) + #define __Pyx_PyType_TryGetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_TryGetSlot(obj, name, func_ctype) #endif #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) +#define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) +#define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { + PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); + if (res == NULL) PyErr_Clear(); + return res; +} +#elif !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000 +#define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#else +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { +#if CYTHON_COMPILING_IN_PYPY + return PyDict_GetItem(dict, name); +#else + PyDictEntry *ep; + PyDictObject *mp = (PyDictObject*) dict; + long hash = ((PyStringObject *) name)->ob_shash; + assert(hash != -1); + ep = (mp->ma_lookup)(mp, name, hash); + if (ep == NULL) { + return NULL; + } + return ep->me_value; +#endif +} +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#endif +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) + #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) #else - #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) - #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) + #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) + #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) #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) +#define __Pyx_PyObject_GetIterNextFunc(iterator) __Pyx_PyObject_GetSlot(iterator, tp_iternext, iternextfunc) +#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000 +#define __Pyx_PyHeapTypeObject_GC_Del(obj) {\ + PyTypeObject *type = Py_TYPE((PyObject*)obj);\ + assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\ + PyObject_GC_Del(obj);\ + Py_DECREF(type);\ +} #else -#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) +#define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) #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) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) + #define __Pyx_PyUnicode_DATA(u) ((void*)u) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) +#else + #if PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_READY(op) (0) + #else + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #endif #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_KIND(u) ((int)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)) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, (Py_UCS4) ch) + #if PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #else + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #endif + #endif #endif #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) @@ -459,106 +868,226 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #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) +#if CYTHON_COMPILING_IN_PYPY + #if !defined(PyUnicode_DecodeUnicodeEscape) + #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) + #endif + #if !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) + #endif + #if !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) + #endif + #if !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) + #endif #endif -#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) -#if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#if CYTHON_COMPILING_IN_CPYTHON + #define __Pyx_PySequence_ListKeepNew(obj)\ + (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj)) #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) + #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) #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 +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type) #endif -#if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) - #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#if PY_VERSION_HEX >= 0x030900A4 + #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) +#else + #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) +#endif +#if CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + #define __Pyx_PyList_GetItemRef(o, i) PyList_GetItemRef(o, i) + #elif CYTHON_COMPILING_IN_LIMITED_API || !CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PyList_GetItemRef(o, i) (likely((i) >= 0) ? PySequence_GetItem(o, i) : (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) + #else + #define __Pyx_PyList_GetItemRef(o, i) PySequence_ITEM(o, i) + #endif +#elif CYTHON_COMPILING_IN_LIMITED_API || !CYTHON_ASSUME_SAFE_MACROS + #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + #define __Pyx_PyList_GetItemRef(o, i) PyList_GetItemRef(o, i) + #else + #define __Pyx_PyList_GetItemRef(o, i) __Pyx_XNewRef(PyList_GetItem(o, i)) + #endif +#else + #define __Pyx_PyList_GetItemRef(o, i) __Pyx_NewRef(PyList_GET_ITEM(o, i)) +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 +#define __Pyx_PyDict_GetItemRef(dict, key, result) PyDict_GetItemRef(dict, key, result) +#elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS +static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key, PyObject **result) { + *result = PyObject_GetItem(dict, key); + if (*result == NULL) { + if (PyErr_ExceptionMatches(PyExc_KeyError)) { + PyErr_Clear(); + return 0; + } + return -1; + } + return 1; +} #else - #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) - #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) +static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key, PyObject **result) { + *result = PyDict_GetItemWithError(dict, key); + if (*result == NULL) { + return PyErr_Occurred() ? -1 : 0; + } + Py_INCREF(*result); + return 1; +} #endif -#ifndef PySet_CheckExact - #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#if defined(CYTHON_DEBUG_VISIT_CONST) && CYTHON_DEBUG_VISIT_CONST + #define __Pyx_VISIT_CONST(obj) Py_VISIT(obj) +#else + #define __Pyx_VISIT_CONST(obj) #endif #if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i) #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyTuple_GET_ITEM(o, i) PyTuple_GET_ITEM(o, i) + #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyList_GET_ITEM(o, i) PyList_GET_ITEM(o, i) #else + #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) + #define __Pyx_PyTuple_GET_ITEM(o, i) PyTuple_GetItem(o, i) + #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) + #define __Pyx_PyList_GET_ITEM(o, i) PyList_GetItem(o, i) +#endif +#if CYTHON_ASSUME_SAFE_SIZE + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) + #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GET_LENGTH(o) +#else + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) + #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GetLength(o) +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) +#else + static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { + PyObject *module = PyImport_AddModule(name); + Py_XINCREF(module); + return module; + } #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 +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_InternFromString) + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) +#endif +#define __Pyx_PyLong_FromHash_t PyLong_FromSsize_t +#define __Pyx_PyLong_AsHash_t __Pyx_PyIndex_AsSsize_t +#if __PYX_LIMITED_VERSION_HEX >= 0x030A0000 + #define __Pyx_PySendResult PySendResult +#else + typedef enum { + PYGEN_RETURN = 0, + PYGEN_ERROR = -1, + PYGEN_NEXT = 1, + } __Pyx_PySendResult; +#endif +#if CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX < 0x030A00A3 + typedef __Pyx_PySendResult (*__Pyx_pyiter_sendfunc)(PyObject *iter, PyObject *value, PyObject **result); +#else + #define __Pyx_pyiter_sendfunc sendfunc +#endif +#if !CYTHON_USE_AM_SEND +#define __PYX_HAS_PY_AM_SEND 0 +#elif __PYX_LIMITED_VERSION_HEX >= 0x030A0000 +#define __PYX_HAS_PY_AM_SEND 1 #else - #define __Pyx_PyType_AsAsync(obj) NULL +#define __PYX_HAS_PY_AM_SEND 2 // our own backported implementation #endif -#ifndef __Pyx_PyAsyncMethodsStruct +#if __PYX_HAS_PY_AM_SEND < 2 + #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods +#else typedef struct { unaryfunc am_await; unaryfunc am_aiter; unaryfunc am_anext; + __Pyx_pyiter_sendfunc am_send; } __Pyx_PyAsyncMethodsStruct; + #define __Pyx_SlotTpAsAsync(s) ((PyAsyncMethods*)(s)) +#endif +#if CYTHON_USE_AM_SEND && PY_VERSION_HEX < 0x030A00F0 + #define __Pyx_TPFLAGS_HAVE_AM_SEND (1UL << 21) +#else + #define __Pyx_TPFLAGS_HAVE_AM_SEND (0) +#endif +#if PY_VERSION_HEX >= 0x03090000 +#define __Pyx_PyInterpreterState_Get() PyInterpreterState_Get() +#else +#define __Pyx_PyInterpreterState_Get() PyThreadState_Get()->interp +#endif +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030A0000 +#ifdef __cplusplus +extern "C" +#endif +PyAPI_FUNC(void *) PyMem_Calloc(size_t nelem, size_t elsize); +#endif +#if CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_init_co_variable(PyObject *inspect, const char* name, int *write_to) { + int value; + PyObject *py_value = PyObject_GetAttrString(inspect, name); + if (!py_value) return 0; + value = (int) PyLong_AsLong(py_value); + Py_DECREF(py_value); + *write_to = value; + return value != -1 || !PyErr_Occurred(); +} +static int __Pyx_init_co_variables(void) { + PyObject *inspect; + int result; + inspect = PyImport_ImportModule("inspect"); + result = +#if !defined(CO_OPTIMIZED) + __Pyx_init_co_variable(inspect, "CO_OPTIMIZED", &CO_OPTIMIZED) && +#endif +#if !defined(CO_NEWLOCALS) + __Pyx_init_co_variable(inspect, "CO_NEWLOCALS", &CO_NEWLOCALS) && +#endif +#if !defined(CO_VARARGS) + __Pyx_init_co_variable(inspect, "CO_VARARGS", &CO_VARARGS) && +#endif +#if !defined(CO_VARKEYWORDS) + __Pyx_init_co_variable(inspect, "CO_VARKEYWORDS", &CO_VARKEYWORDS) && +#endif +#if !defined(CO_ASYNC_GENERATOR) + __Pyx_init_co_variable(inspect, "CO_ASYNC_GENERATOR", &CO_ASYNC_GENERATOR) && +#endif +#if !defined(CO_GENERATOR) + __Pyx_init_co_variable(inspect, "CO_GENERATOR", &CO_GENERATOR) && +#endif +#if !defined(CO_COROUTINE) + __Pyx_init_co_variable(inspect, "CO_COROUTINE", &CO_COROUTINE) && +#endif + 1; + Py_DECREF(inspect); + return result ? 0 : -1; +} +#else +static int __Pyx_init_co_variables(void) { + return 0; // It's a limited API-only feature +} #endif -#if defined(WIN32) || defined(MS_WINDOWS) - #define _USE_MATH_DEFINES +/* MathInitCode */ +#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) + #ifndef _USE_MATH_DEFINES + #define _USE_MATH_DEFINES + #endif #endif #include #ifdef NAN @@ -576,13 +1105,30 @@ static CYTHON_INLINE float __PYX_NAN() { #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 +#ifndef CYTHON_CLINE_IN_TRACEBACK_RUNTIME +#define CYTHON_CLINE_IN_TRACEBACK_RUNTIME 0 +#endif +#ifndef CYTHON_CLINE_IN_TRACEBACK +#define CYTHON_CLINE_IN_TRACEBACK CYTHON_CLINE_IN_TRACEBACK_RUNTIME +#endif +#if CYTHON_CLINE_IN_TRACEBACK +#define __PYX_MARK_ERR_POS(f_index, lineno) { __pyx_filename = __pyx_f[f_index]; (void) __pyx_filename; __pyx_lineno = lineno; (void) __pyx_lineno; __pyx_clineno = __LINE__; (void) __pyx_clineno; } +#else +#define __PYX_MARK_ERR_POS(f_index, lineno) { __pyx_filename = __pyx_f[f_index]; (void) __pyx_filename; __pyx_lineno = lineno; (void) __pyx_lineno; (void) __pyx_clineno; } +#endif +#define __PYX_ERR(f_index, lineno, Ln_error) \ + { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } + +#ifdef CYTHON_EXTERN_C + #undef __PYX_EXTERN_C + #define __PYX_EXTERN_C CYTHON_EXTERN_C +#elif defined(__PYX_EXTERN_C) + #ifdef _MSC_VER + #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") + #else + #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. + #endif +#else #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else @@ -595,9 +1141,25 @@ static CYTHON_INLINE float __PYX_NAN() { /* Early includes */ #include #include -#include "frameobject.h" #include "pystate.h" -#include "pythread.h" +#include "vendor/_compat.h" + + static inline PyCodeObject* Hunter_PyFrame_GetCode(PyObject* frame) { + return PyFrame_GetCode((PyFrameObject*) frame); + } + static inline int Hunter_PyFrame_GetLasti(PyObject* frame) { + return PyFrame_GetLasti((PyFrameObject*) frame); + } + static inline int Hunter_PyFrame_GetLineNumber(PyObject* frame) { + return PyFrame_GetLineNumber((PyFrameObject*) frame); + } + static inline PyObject* Hunter_PyFrame_GetGlobals(PyObject* frame) { + return PyFrame_GetGlobals((PyFrameObject*) frame); + } + static inline PyObject* Hunter_PyFrame_GetLocals(PyObject* frame) { + return PyFrame_GetLocals((PyFrameObject*) frame); + } + #ifdef _OPENMP #include #endif /* _OPENMP */ @@ -606,12 +1168,8 @@ static CYTHON_INLINE float __PYX_NAN() { #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_UTF8 0 -#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize @@ -646,139 +1204,129 @@ static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s); 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)) +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*); #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)) +#if CYTHON_ASSUME_SAFE_MACROS + #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_PyByteArray_AsString(s) PyByteArray_AS_STRING(s) +#else + #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AsString(s)) + #define __Pyx_PyByteArray_AsString(s) PyByteArray_AsString(s) +#endif +#define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __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_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) #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_NewRef(PyObject *obj) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030a0000 || defined(Py_NewRef) + return Py_NewRef(obj); +#else + Py_INCREF(obj); + return obj; +#endif +} +static CYTHON_INLINE PyObject *__Pyx_XNewRef(PyObject *obj) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030a0000 || defined(Py_XNewRef) + return Py_XNewRef(obj); +#else + Py_XINCREF(obj); + return obj; +#endif +} +static CYTHON_INLINE PyObject *__Pyx_Owned_Py_None(int b); static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); -static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Long(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); +static CYTHON_INLINE PyObject * __Pyx_PyLong_FromSize_t(size_t); +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); #if CYTHON_ASSUME_SAFE_MACROS -#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#define __Pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#define __Pyx_PyFloat_AS_DOUBLE(x) PyFloat_AS_DOUBLE(x) #else -#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#define __Pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#define __Pyx_PyFloat_AS_DOUBLE(x) PyFloat_AsDouble(x) #endif -#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) -#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyFloat_AsFloat(x) ((float) __Pyx_PyFloat_AsDouble(x)) #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) + 1); - 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; -} +#if CYTHON_USE_PYLONG_INTERNALS + #if PY_VERSION_HEX >= 0x030C00A7 + #ifndef _PyLong_SIGN_MASK + #define _PyLong_SIGN_MASK 3 + #endif + #ifndef _PyLong_NON_SIZE_BITS + #define _PyLong_NON_SIZE_BITS 3 + #endif + #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK) + #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) + #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) + #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) + #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_SignedDigitCount(x)\ + ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) + #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) + #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) + #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) + #else + #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) + #endif + typedef Py_ssize_t __Pyx_compact_pylong; + typedef size_t __Pyx_compact_upylong; + #else + #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) + #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) + #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) + #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) + #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) + #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) + #define __Pyx_PyLong_CompactValue(x)\ + ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) + typedef sdigit __Pyx_compact_pylong; + typedef digit __Pyx_compact_upylong; + #endif + #if PY_VERSION_HEX >= 0x030C00A5 + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) + #else + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) + #endif #endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#elif __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeASCII(c_str, size, NULL) +#else + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #endif @@ -790,31 +1338,261 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #define likely(x) (x) #define unlikely(x) (x) #endif /* __GNUC__ */ +/* PretendToInitialize */ +#ifdef __cplusplus +#if __cplusplus > 201103L +#include +#endif +template +static void __Pyx_pretend_to_initialize(T* ptr) { +#if __cplusplus > 201103L + if ((std::is_trivially_default_constructible::value)) +#endif + *ptr = T(); + (void)ptr; +} +#else static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } +#endif + +#if !CYTHON_USE_MODULE_STATE 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; +#endif static int __pyx_lineno; static int __pyx_clineno = 0; -static const char * __pyx_cfilenm= __FILE__; +static const char * const __pyx_cfilenm = __FILE__; static const char *__pyx_filename; +/* #### Code section: filename_table ### */ -static const char *__pyx_f[] = { +static const char* const __pyx_f[] = { "src/hunter/_tracer.pyx", - "stringsource", + "", "src/hunter/_tracer.pxd", - ".tox/cythonize/lib/python3.8/site-packages/Cython/Includes/cpython/type.pxd", - ".tox/cythonize/lib/python3.8/site-packages/Cython/Includes/cpython/bool.pxd", - ".tox/cythonize/lib/python3.8/site-packages/Cython/Includes/cpython/complex.pxd", + ".tox/cythonize/lib64/python3.13/site-packages/Cython/Includes/cpython/type.pxd", "src/hunter/_event.pxd", "src/hunter/_predicates.pxd", }; +/* #### Code section: utility_code_proto_before_types ### */ +/* Profile_config.proto */ +#ifndef CYTHON_PROFILE +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + #define CYTHON_PROFILE 0 +#else + #define CYTHON_PROFILE 1 +#endif +#endif +#ifndef CYTHON_TRACE_NOGIL + #define CYTHON_TRACE_NOGIL 0 +#else + #if CYTHON_TRACE_NOGIL && !defined(CYTHON_TRACE) + #define CYTHON_TRACE 1 + #endif +#endif +#ifndef CYTHON_TRACE + #define CYTHON_TRACE 0 +#endif +#if CYTHON_PROFILE || CYTHON_TRACE +#if CYTHON_USE_SYS_MONITORING + typedef enum { + __Pyx_Monitoring_PY_START = 0, + __Pyx_Monitoring_PY_RETURN, + __Pyx_Monitoring_PY_UNWIND, + __Pyx_Monitoring_LINE, + __Pyx_Monitoring_RAISE, + __Pyx_Monitoring_RERAISE, + __Pyx_Monitoring_EXCEPTION_HANDLED, + __Pyx_Monitoring_PY_RESUME, + __Pyx_Monitoring_PY_YIELD, + __Pyx_Monitoring_STOP_ITERATION, + } __Pyx_Monitoring_Event_Index; + static const unsigned char __Pyx_MonitoringEventTypes[] = { + PY_MONITORING_EVENT_PY_START, + PY_MONITORING_EVENT_PY_RETURN, + PY_MONITORING_EVENT_PY_UNWIND, + PY_MONITORING_EVENT_LINE, + PY_MONITORING_EVENT_RAISE, + PY_MONITORING_EVENT_RERAISE, + PY_MONITORING_EVENT_EXCEPTION_HANDLED, + PY_MONITORING_EVENT_PY_RESUME, + PY_MONITORING_EVENT_PY_YIELD, + PY_MONITORING_EVENT_STOP_ITERATION, + }; + #define __Pyx_MonitoringEventTypes_CyFunc_count (sizeof(__Pyx_MonitoringEventTypes) - 3) + #define __Pyx_MonitoringEventTypes_CyGen_count (sizeof(__Pyx_MonitoringEventTypes)) +#endif +#endif + +/* NoFastGil.proto */ +#define __Pyx_PyGILState_Ensure PyGILState_Ensure +#define __Pyx_PyGILState_Release PyGILState_Release +#define __Pyx_FastGIL_Remember() +#define __Pyx_FastGIL_Forget() +#define __Pyx_FastGilFuncInit() + +/* Atomics.proto */ +#include +#ifndef CYTHON_ATOMICS + #define CYTHON_ATOMICS 1 +#endif +#define __PYX_CYTHON_ATOMICS_ENABLED() CYTHON_ATOMICS +#define __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING() CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +#define __pyx_atomic_int_type int +#define __pyx_nonatomic_int_type int +#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\ + (__STDC_VERSION__ >= 201112L) &&\ + !defined(__STDC_NO_ATOMICS__)) + #include +#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\ + (__cplusplus >= 201103L) ||\ + (defined(_MSC_VER) && _MSC_VER >= 1700))) + #include +#endif +#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\ + (__STDC_VERSION__ >= 201112L) &&\ + !defined(__STDC_NO_ATOMICS__) &&\ + ATOMIC_INT_LOCK_FREE == 2) + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type atomic_int + #define __pyx_atomic_ptr_type atomic_uintptr_t + #define __pyx_nonatomic_ptr_type uintptr_t + #define __pyx_atomic_incr_relaxed(value) atomic_fetch_add_explicit(value, 1, memory_order_relaxed) + #define __pyx_atomic_incr_acq_rel(value) atomic_fetch_add_explicit(value, 1, memory_order_acq_rel) + #define __pyx_atomic_decr_acq_rel(value) atomic_fetch_sub_explicit(value, 1, memory_order_acq_rel) + #define __pyx_atomic_sub(value, arg) atomic_fetch_sub(value, arg) + #define __pyx_atomic_int_cmp_exchange(value, expected, desired) atomic_compare_exchange_strong(value, expected, desired) + #define __pyx_atomic_load(value) atomic_load(value) + #define __pyx_atomic_store(value, new_value) atomic_store(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) atomic_load_explicit(value, memory_order_relaxed) + #define __pyx_atomic_pointer_load_acquire(value) atomic_load_explicit(value, memory_order_acquire) + #define __pyx_atomic_pointer_exchange(value, new_value) atomic_exchange(value, (__pyx_nonatomic_ptr_type)new_value) + #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) + #pragma message ("Using standard C atomics") + #elif defined(__PYX_DEBUG_ATOMICS) + #warning "Using standard C atomics" + #endif +#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\ + (__cplusplus >= 201103L) ||\ +\ + (defined(_MSC_VER) && _MSC_VER >= 1700)) &&\ + ATOMIC_INT_LOCK_FREE == 2) + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type std::atomic_int + #define __pyx_atomic_ptr_type std::atomic_uintptr_t + #define __pyx_nonatomic_ptr_type uintptr_t + #define __pyx_atomic_incr_relaxed(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_relaxed) + #define __pyx_atomic_incr_acq_rel(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_acq_rel) + #define __pyx_atomic_decr_acq_rel(value) std::atomic_fetch_sub_explicit(value, 1, std::memory_order_acq_rel) + #define __pyx_atomic_sub(value, arg) std::atomic_fetch_sub(value, arg) + #define __pyx_atomic_int_cmp_exchange(value, expected, desired) std::atomic_compare_exchange_strong(value, expected, desired) + #define __pyx_atomic_load(value) std::atomic_load(value) + #define __pyx_atomic_store(value, new_value) std::atomic_store(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) std::atomic_load_explicit(value, std::memory_order_relaxed) + #define __pyx_atomic_pointer_load_acquire(value) std::atomic_load_explicit(value, std::memory_order_acquire) + #define __pyx_atomic_pointer_exchange(value, new_value) std::atomic_exchange(value, (__pyx_nonatomic_ptr_type)new_value) + #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) + #pragma message ("Using standard C++ atomics") + #elif defined(__PYX_DEBUG_ATOMICS) + #warning "Using standard C++ atomics" + #endif +#elif CYTHON_ATOMICS && (__GNUC__ >= 5 || (__GNUC__ == 4 &&\ + (__GNUC_MINOR__ > 1 ||\ + (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ >= 2)))) + #define __pyx_atomic_ptr_type void* + #define __pyx_atomic_incr_relaxed(value) __sync_fetch_and_add(value, 1) + #define __pyx_atomic_incr_acq_rel(value) __sync_fetch_and_add(value, 1) + #define __pyx_atomic_decr_acq_rel(value) __sync_fetch_and_sub(value, 1) + #define __pyx_atomic_sub(value, arg) __sync_fetch_and_sub(value, arg) + static CYTHON_INLINE int __pyx_atomic_int_cmp_exchange(__pyx_atomic_int_type* value, __pyx_nonatomic_int_type* expected, __pyx_nonatomic_int_type desired) { + __pyx_nonatomic_int_type old = __sync_val_compare_and_swap(value, *expected, desired); + int result = old == *expected; + *expected = old; + return result; + } + #define __pyx_atomic_load(value) __sync_fetch_and_add(value, 0) + #define __pyx_atomic_store(value, new_value) __sync_lock_test_and_set(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) __sync_fetch_and_add(value, 0) + #define __pyx_atomic_pointer_load_acquire(value) __sync_fetch_and_add(value, 0) + #define __pyx_atomic_pointer_exchange(value, new_value) __sync_lock_test_and_set(value, (__pyx_atomic_ptr_type)new_value) + #ifdef __PYX_DEBUG_ATOMICS + #warning "Using GNU atomics" + #endif +#elif CYTHON_ATOMICS && defined(_MSC_VER) + #include + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type long + #define __pyx_atomic_ptr_type void* + #undef __pyx_nonatomic_int_type + #define __pyx_nonatomic_int_type long + #pragma intrinsic (_InterlockedExchangeAdd, _InterlockedExchange, _InterlockedCompareExchange, _InterlockedCompareExchangePointer, _InterlockedExchangePointer) + #define __pyx_atomic_incr_relaxed(value) _InterlockedExchangeAdd(value, 1) + #define __pyx_atomic_incr_acq_rel(value) _InterlockedExchangeAdd(value, 1) + #define __pyx_atomic_decr_acq_rel(value) _InterlockedExchangeAdd(value, -1) + #define __pyx_atomic_sub(value, arg) _InterlockedExchangeAdd(value, -arg) + static CYTHON_INLINE int __pyx_atomic_int_cmp_exchange(__pyx_atomic_int_type* value, __pyx_nonatomic_int_type* expected, __pyx_nonatomic_int_type desired) { + __pyx_nonatomic_int_type old = _InterlockedCompareExchange(value, desired, *expected); + int result = old == *expected; + *expected = old; + return result; + } + #define __pyx_atomic_load(value) _InterlockedExchangeAdd(value, 0) + #define __pyx_atomic_store(value, new_value) _InterlockedExchange(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) *(void * volatile *)value + #define __pyx_atomic_pointer_load_acquire(value) _InterlockedCompareExchangePointer(value, 0, 0) + #define __pyx_atomic_pointer_exchange(value, new_value) _InterlockedExchangePointer(value, (__pyx_atomic_ptr_type)new_value) + #ifdef __PYX_DEBUG_ATOMICS + #pragma message ("Using MSVC atomics") + #endif +#else + #undef CYTHON_ATOMICS + #define CYTHON_ATOMICS 0 + #ifdef __PYX_DEBUG_ATOMICS + #warning "Not using atomics" + #endif +#endif +#if CYTHON_ATOMICS + #define __pyx_add_acquisition_count(memview)\ + __pyx_atomic_incr_relaxed(__pyx_get_slice_count_pointer(memview)) + #define __pyx_sub_acquisition_count(memview)\ + __pyx_atomic_decr_acq_rel(__pyx_get_slice_count_pointer(memview)) +#else + #define __pyx_add_acquisition_count(memview)\ + __pyx_add_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) + #define __pyx_sub_acquisition_count(memview)\ + __pyx_sub_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) +#endif + +/* IncludeStructmemberH.proto */ +#include + +/* CriticalSections.proto */ +#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +#define __Pyx_PyCriticalSection void* +#define __Pyx_PyCriticalSection2 void* +#define __Pyx_PyCriticalSection_Begin1(cs, arg) (void)cs +#define __Pyx_PyCriticalSection_Begin2(cs, arg1, arg2) (void)cs +#define __Pyx_PyCriticalSection_End1(cs) +#define __Pyx_PyCriticalSection_End2(cs) +#else +#define __Pyx_PyCriticalSection PyCriticalSection +#define __Pyx_PyCriticalSection2 PyCriticalSection2 +#define __Pyx_PyCriticalSection_Begin1 PyCriticalSection_Begin +#define __Pyx_PyCriticalSection_Begin2 PyCriticalSection2_Begin +#define __Pyx_PyCriticalSection_End1 PyCriticalSection_End +#define __Pyx_PyCriticalSection_End2 PyCriticalSection2_End +#endif +#if PY_VERSION_HEX < 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_BEGIN_CRITICAL_SECTION(o) { +#define __Pyx_END_CRITICAL_SECTION() } +#else +#define __Pyx_BEGIN_CRITICAL_SECTION Py_BEGIN_CRITICAL_SECTION +#define __Pyx_END_CRITICAL_SECTION Py_END_CRITICAL_SECTION +#endif + +/* #### Code section: numeric_typedefs ### */ +/* #### Code section: complex_type_declarations ### */ +/* #### Code section: type_declarations ### */ /*--- Type declarations ---*/ struct __pyx_obj_6hunter_6_event_Event; @@ -824,25 +1602,45 @@ struct __pyx_obj_6hunter_11_predicates_Or; struct __pyx_obj_6hunter_11_predicates_Not; struct __pyx_obj_6hunter_11_predicates_When; struct __pyx_obj_6hunter_11_predicates_From; +struct __pyx_obj_6hunter_11_predicates_Backlog; struct __pyx_obj_6hunter_7_tracer_Tracer; -/* "_event.pxd":11 +/* "_event.pxd":4 + * + * + * ctypedef extern FrameType # <<<<<<<<<<<<<< + * + * cdef extern from *: +*/ +typedef PyObject *FrameType; + +/* "hunter/_tracer.pxd":6 + * + * + * ctypedef extern FrameType # <<<<<<<<<<<<<< + * + * cdef extern from *: +*/ +typedef PyObject *FrameType; + +/* "_event.pxd":39 + * * - * @cython.final - * cdef class Event: # <<<<<<<<<<<<<< + * @cython.final # <<<<<<<<<<<<<< + * cdef class Event: * cdef: - * readonly FrameType frame - */ +*/ struct __pyx_obj_6hunter_6_event_Event { PyObject_HEAD struct __pyx_vtabstruct_6hunter_6_event_Event *__pyx_vtab; - PyFrameObject *frame; + FrameType frame; PyObject *kind; PyObject *arg; int depth; int calls; int threading_support; int detached; + PyObject *builtin; PyObject *_code; PyObject *_filename; PyObject *_fullsource; @@ -857,16 +1655,17 @@ struct __pyx_obj_6hunter_6_event_Event { PyObject *_thread; PyObject *_threadidn; PyObject *_threadname; + PyObject *_instruction; }; -/* "_predicates.pxd":8 +/* "_predicates.pxd":7 + * * - * @cython.final - * cdef class Query: # <<<<<<<<<<<<<< + * @cython.final # <<<<<<<<<<<<<< + * cdef class Query: * cdef: - * readonly tuple query_contains - */ +*/ struct __pyx_obj_6hunter_11_predicates_Query { PyObject_HEAD PyObject *query_contains; @@ -884,50 +1683,50 @@ struct __pyx_obj_6hunter_11_predicates_Query { /* "_predicates.pxd":22 * - * @cython.final - * cdef class And: # <<<<<<<<<<<<<< + * + * @cython.final # <<<<<<<<<<<<<< + * cdef class And: * cdef: - * readonly tuple predicates - */ +*/ struct __pyx_obj_6hunter_11_predicates_And { PyObject_HEAD PyObject *predicates; }; -/* "_predicates.pxd":27 +/* "_predicates.pxd":28 + * * - * @cython.final - * cdef class Or: # <<<<<<<<<<<<<< + * @cython.final # <<<<<<<<<<<<<< + * cdef class Or: * cdef: - * readonly tuple predicates - */ +*/ struct __pyx_obj_6hunter_11_predicates_Or { PyObject_HEAD PyObject *predicates; }; -/* "_predicates.pxd":32 +/* "_predicates.pxd":34 + * * - * @cython.final - * cdef class Not: # <<<<<<<<<<<<<< + * @cython.final # <<<<<<<<<<<<<< + * cdef class Not: * cdef: - * readonly object predicate - */ +*/ struct __pyx_obj_6hunter_11_predicates_Not { PyObject_HEAD PyObject *predicate; }; -/* "_predicates.pxd":37 +/* "_predicates.pxd":40 + * * - * @cython.final - * cdef class When: # <<<<<<<<<<<<<< + * @cython.final # <<<<<<<<<<<<<< + * cdef class When: * cdef: - * readonly object condition - */ +*/ struct __pyx_obj_6hunter_11_predicates_When { PyObject_HEAD PyObject *condition; @@ -935,13 +1734,13 @@ struct __pyx_obj_6hunter_11_predicates_When { }; -/* "_predicates.pxd":43 +/* "_predicates.pxd":47 + * * - * @cython.final - * cdef class From: # <<<<<<<<<<<<<< + * @cython.final # <<<<<<<<<<<<<< + * cdef class From: * cdef: - * readonly object condition - */ +*/ struct __pyx_obj_6hunter_11_predicates_From { PyObject_HEAD PyObject *condition; @@ -952,18 +1751,40 @@ struct __pyx_obj_6hunter_11_predicates_From { }; -/* "hunter/_tracer.pxd":28 +/* "_predicates.pxd":57 * - * @cython.final - * cdef class Tracer: # <<<<<<<<<<<<<< + * + * @cython.final # <<<<<<<<<<<<<< + * cdef class Backlog: * cdef: - * readonly object handler - */ +*/ +struct __pyx_obj_6hunter_11_predicates_Backlog { + PyObject_HEAD + PyObject *condition; + int size; + int stack; + int vars; + int strip; + PyObject *action; + PyObject *_try_repr; + PyObject *_filter; + PyObject *queue; +}; + + +/* "hunter/_tracer.pxd":25 + * + * + * @cython.final # <<<<<<<<<<<<<< + * cdef class Tracer: + * cdef: +*/ struct __pyx_obj_6hunter_7_tracer_Tracer { PyObject_HEAD PyObject *handler; PyObject *previous; PyObject *threading_support; + int profiling_mode; int depth; int calls; PyObject *__weakref__; @@ -973,18 +1794,31 @@ struct __pyx_obj_6hunter_7_tracer_Tracer { -/* "_event.pxd":11 +/* "_event.pxd":39 * - * @cython.final - * cdef class Event: # <<<<<<<<<<<<<< + * + * @cython.final # <<<<<<<<<<<<<< + * cdef class Event: * cdef: - * readonly FrameType frame - */ +*/ struct __pyx_vtabstruct_6hunter_6_event_Event { - struct __pyx_obj_6hunter_6_event_Event *(*clone)(struct __pyx_obj_6hunter_6_event_Event *); + PyCodeObject *(*code_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*filename_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*fullsource_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*function_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*globals_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*lineno_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*locals_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*module_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*source_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*stdlib_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*threadid_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*threadname_getter)(struct __pyx_obj_6hunter_6_event_Event *); + PyObject *(*instruction_getter)(struct __pyx_obj_6hunter_6_event_Event *); }; static struct __pyx_vtabstruct_6hunter_6_event_Event *__pyx_vtabptr_6hunter_6_event_Event; +/* #### Code section: utility_code_proto ### */ /* --- Runtime support code (head) --- */ /* Refnanny.proto */ @@ -993,42 +1827,48 @@ static struct __pyx_vtabstruct_6hunter_6_event_Event *__pyx_vtabptr_6hunter_6_ev #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 (*INCREF)(void*, PyObject*, Py_ssize_t); + void (*DECREF)(void*, PyObject*, Py_ssize_t); + void (*GOTREF)(void*, PyObject*, Py_ssize_t); + void (*GIVEREF)(void*, PyObject*, Py_ssize_t); + void* (*SetupContext)(const char*, Py_ssize_t, 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__);\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ + } + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ + } + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ } -#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) + #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); else {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContextNogil() #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) @@ -1039,6 +1879,10 @@ static struct __pyx_vtabstruct_6hunter_6_event_Event *__pyx_vtabptr_6hunter_6_ev #define __Pyx_XGOTREF(r) #define __Pyx_XGIVEREF(r) #endif +#define __Pyx_Py_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; Py_XDECREF(tmp);\ + } while (0) #define __Pyx_XDECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_XDECREF(tmp);\ @@ -1050,25 +1894,30 @@ static struct __pyx_vtabstruct_6hunter_6_event_Event *__pyx_vtabptr_6hunter_6_ev #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); +/* PyErrExceptionMatches.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); #else -#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) #endif -/* GetBuiltinName.proto */ -static PyObject *__Pyx_GetBuiltinName(PyObject *name); - /* 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 +#if PY_VERSION_HEX >= 0x030C00A6 +#define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL) +#else +#define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type) +#endif #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign -#define __Pyx_PyErr_Occurred() PyErr_Occurred() +#define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) +#define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() #endif /* PyErrFetchRestore.proto */ @@ -1080,7 +1929,7 @@ static PyObject *__Pyx_GetBuiltinName(PyObject *name); #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 +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6 #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) #else #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) @@ -1096,34 +1945,210 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif -/* Profile.proto */ -#ifndef CYTHON_PROFILE -#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_PYSTON - #define CYTHON_PROFILE 0 -#else - #define CYTHON_PROFILE 1 -#endif -#endif -#ifndef CYTHON_TRACE_NOGIL - #define CYTHON_TRACE_NOGIL 0 +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); #else - #if CYTHON_TRACE_NOGIL && !defined(CYTHON_TRACE) - #define CYTHON_TRACE 1 - #endif -#endif -#ifndef CYTHON_TRACE - #define CYTHON_TRACE 0 +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif + +/* PyObjectGetAttrStrNoError.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* Profile.proto */ #if CYTHON_TRACE #undef CYTHON_PROFILE_REUSE_FRAME #endif +#if CYTHON_USE_MODULE_STATE + #undef CYTHON_PROFILE_REUSE_CODEOBJ + #define CYTHON_PROFILE_REUSE_CODEOBJ 0 + #undef CYTHON_PROFILE_REUSE_FRAME +#endif +#ifndef CYTHON_PROFILE_REUSE_CODEOBJ + #define CYTHON_PROFILE_REUSE_CODEOBJ 1 +#endif #ifndef CYTHON_PROFILE_REUSE_FRAME #define CYTHON_PROFILE_REUSE_FRAME 0 #endif +#if CYTHON_USE_SYS_MONITORING && (CYTHON_PROFILE || CYTHON_TRACE) + #define __PYX_MONITORING_ABI_SUFFIX "_mon" +#else + #define __PYX_MONITORING_ABI_SUFFIX +#endif #if CYTHON_PROFILE || CYTHON_TRACE +#if CYTHON_USE_SYS_MONITORING + typedef uint64_t __pyx_monitoring_version_type; + #define __Pyx_TraceDeclarationsFunc\ + PyObject *__pyx_frame_code = NULL;\ + PyMonitoringState __pyx_pymonitoring_state[__Pyx_MonitoringEventTypes_CyFunc_count];\ + int __pyx_exception_already_reported = 0;\ + const int __pyx_sys_monitoring_disabled_in_parallel = 0; CYTHON_UNUSED_VAR(__pyx_sys_monitoring_disabled_in_parallel); + #define __Pyx_TraceDeclarationsGen\ + PyObject *__pyx_frame_code = Py_NewRef(__pyx_generator->gi_code);\ + PyMonitoringState* __pyx_pymonitoring_state = __pyx_generator->__pyx_pymonitoring_state;\ + __pyx_monitoring_version_type __pyx_pymonitoring_version = __pyx_generator->__pyx_pymonitoring_version;\ + int __pyx_exception_already_reported = 0;\ + const int __pyx_sys_monitoring_disabled_in_parallel = 0; CYTHON_UNUSED_VAR(__pyx_sys_monitoring_disabled_in_parallel); + #define __Pyx_IsTracing(event_id) ((!__pyx_sys_monitoring_disabled_in_parallel) && (__pyx_pymonitoring_state[event_id]).active) + #define __Pyx_TraceFrameInit(codeobj)\ + if (codeobj) __pyx_frame_code = codeobj; + #define __Pyx_TurnOffSysMonitoringInParallel\ + const int __pyx_sys_monitoring_disabled_in_parallel = 1;\ + CYTHON_UNUSED_VAR(__pyx_sys_monitoring_disabled_in_parallel); + CYTHON_UNUSED static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno); + CYTHON_UNUSED static int __Pyx__TraceStartFunc(PyMonitoringState *state_array, PyObject *code_obj, int offset, int skip_event); + CYTHON_UNUSED static int __Pyx__TraceStartGen(PyMonitoringState *state_array, __pyx_monitoring_version_type *version, PyObject *code_obj, int offset); + CYTHON_UNUSED static int __Pyx__TraceResumeGen(PyMonitoringState *state_array, __pyx_monitoring_version_type *version, PyObject *code_obj, int offset); + CYTHON_UNUSED static void __Pyx__TraceException(PyMonitoringState *monitoring_state, PyObject *code_obj, int offset, int reraised); + #define __Pyx_PyMonitoring_ExitScope(nogil)\ + if (nogil) {\ + (void) __pyx_exception_already_reported;\ + if (CYTHON_TRACE_NOGIL) {\ + PyGILState_STATE state = PyGILState_Ensure();\ + PyMonitoring_ExitScope();\ + Py_XDECREF(__pyx_frame_code);\ + PyGILState_Release(state);\ + }\ + } else {\ + PyMonitoring_ExitScope();\ + Py_XDECREF(__pyx_frame_code);\ + } + #define __Pyx_TraceStartFunc(funcname, srcfile, firstlineno, offset, nogil, skip_event, goto_error)\ + if ((0) ); else {\ + int ret = 0;\ + memset(__pyx_pymonitoring_state, 0, sizeof(__pyx_pymonitoring_state));\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + PyGILState_STATE state = PyGILState_Ensure();\ + if (!__Pyx_PyThreadState_Current->tracing) {\ + if (likely(__pyx_frame_code)) Py_INCREF(__pyx_frame_code);\ + else __pyx_frame_code = (PyObject*) __Pyx_createFrameCodeObject(funcname, srcfile, firstlineno);\ + if (unlikely(!__pyx_frame_code)) goto_error;\ + ret = __Pyx__TraceStartFunc(__pyx_pymonitoring_state, __pyx_frame_code, offset, skip_event);\ + }\ + PyGILState_Release(state);\ + }\ + } else {\ + if (!__Pyx_PyThreadState_Current->tracing) {\ + if (likely(__pyx_frame_code)) Py_INCREF(__pyx_frame_code);\ + else __pyx_frame_code = (PyObject*) __Pyx_createFrameCodeObject(funcname, srcfile, firstlineno);\ + if (unlikely(!__pyx_frame_code)) goto_error;\ + ret = __Pyx__TraceStartFunc(__pyx_pymonitoring_state, __pyx_frame_code, offset, skip_event);\ + }\ + }\ + if (unlikely(ret == -1)) goto_error;\ + } + #define __Pyx_TraceStartGen(funcname, srcfile, firstlineno, offset, nogil, skip_event, goto_error)\ + if ((0) ); else {\ + int ret = __Pyx__TraceStartGen(__pyx_pymonitoring_state, &__pyx_pymonitoring_version, __pyx_frame_code, offset);\ + if (unlikely(ret == -1)) goto_error;\ + } + #define __Pyx_TraceResumeGen(funcname, srcfile, firstlineno, offset, goto_error)\ + if ((0) ); else {\ + int ret = __Pyx__TraceResumeGen(__pyx_pymonitoring_state, &__pyx_pymonitoring_version, __pyx_frame_code, offset);\ + if (unlikely(ret == -1)) goto_error;\ + } + #define __Pyx_TraceYield(result, offset, goto_error)\ + if (!__Pyx_IsTracing(__Pyx_Monitoring_PY_YIELD)); else {\ + int ret = PyMonitoring_FirePyYieldEvent(&__pyx_pymonitoring_state[__Pyx_Monitoring_PY_RETURN], __pyx_frame_code, offset, result);\ + PyMonitoring_ExitScope();\ + if (unlikely(ret == -1)) goto_error;\ + } + #define __Pyx_TraceException(offset, reraised, fresh)\ + if (!__Pyx_IsTracing((reraised) ? __Pyx_Monitoring_RERAISE : __Pyx_Monitoring_RAISE)); else {\ + if (fresh || reraised || !__pyx_exception_already_reported) {\ + __Pyx__TraceException(&__pyx_pymonitoring_state[(reraised) ? __Pyx_Monitoring_RERAISE : __Pyx_Monitoring_RAISE], __pyx_frame_code, offset, reraised);\ + }\ + __pyx_exception_already_reported = 1;\ + } + #define __Pyx_TraceExceptionDone() __pyx_exception_already_reported = 0 + #define __Pyx_TraceExceptionHandled(offset)\ + if (!__Pyx_IsTracing(__Pyx_Monitoring_EXCEPTION_HANDLED)); else {\ + (void) PyMonitoring_FireExceptionHandledEvent(&__pyx_pymonitoring_state[__Pyx_Monitoring_EXCEPTION_HANDLED], __pyx_frame_code, offset);\ + __pyx_exception_already_reported = 0;\ + } + #define __Pyx_TraceReturnValue(result, offset, nogil, goto_error)\ + if (!__Pyx_IsTracing(__Pyx_Monitoring_PY_RETURN)); else {\ + int ret = 0;\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + PyGILState_STATE state = PyGILState_Ensure();\ + ret = PyMonitoring_FirePyReturnEvent(&__pyx_pymonitoring_state[__Pyx_Monitoring_PY_RETURN], __pyx_frame_code, offset, result);\ + PyGILState_Release(state);\ + }\ + } else {\ + ret = PyMonitoring_FirePyReturnEvent(&__pyx_pymonitoring_state[__Pyx_Monitoring_PY_RETURN], __pyx_frame_code, offset, result);\ + }\ + if (unlikely(ret == -1)) goto_error;\ + } + #define __Pyx_TraceReturnCValue(cresult, convert_function, offset, nogil, goto_error)\ + if (!__Pyx_IsTracing(__Pyx_Monitoring_PY_RETURN)); else {\ + int ret = 0;\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + PyGILState_STATE state = PyGILState_Ensure();\ + PyObject *pyvalue = convert_function(cresult);\ + if (unlikely(!pyvalue)) {\ + PyErr_Clear();\ + pyvalue = Py_None; Py_INCREF(Py_None);\ + }\ + ret = PyMonitoring_FirePyReturnEvent(&__pyx_pymonitoring_state[__Pyx_Monitoring_PY_RETURN], __pyx_frame_code, offset, pyvalue);\ + Py_DECREF(pyvalue);\ + PyGILState_Release(state);\ + }\ + } else {\ + PyObject *pyvalue = convert_function(cresult);\ + if (unlikely(!pyvalue)) {\ + PyErr_Clear();\ + pyvalue = Py_None; Py_INCREF(Py_None);\ + }\ + ret = PyMonitoring_FirePyReturnEvent(&__pyx_pymonitoring_state[__Pyx_Monitoring_PY_RETURN], __pyx_frame_code, offset, pyvalue);\ + Py_DECREF(pyvalue);\ + }\ + if (unlikely(ret == -1)) goto_error;\ + } + #define __Pyx_TraceExceptionUnwind(offset, nogil)\ + if (!__Pyx_IsTracing(__Pyx_Monitoring_PY_UNWIND)); else {\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + PyGILState_STATE state = PyGILState_Ensure();\ + (void) PyMonitoring_FirePyUnwindEvent(&__pyx_pymonitoring_state[__Pyx_Monitoring_PY_UNWIND], __pyx_frame_code, offset);\ + PyGILState_Release(state);\ + }\ + } else {\ + (void) PyMonitoring_FirePyUnwindEvent(&__pyx_pymonitoring_state[__Pyx_Monitoring_PY_UNWIND], __pyx_frame_code, offset);\ + }\ + } + #if CYTHON_TRACE + CYTHON_UNUSED static int __Pyx__TraceLine(PyMonitoringState *monitoring_state, PyObject *code_obj, int line, int offset); + #define __Pyx_TraceLine(line, offset, nogil, goto_error)\ + if (!__Pyx_IsTracing(__Pyx_Monitoring_LINE)); else {\ + int ret = 0;\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + PyGILState_STATE state = PyGILState_Ensure();\ + ret = __Pyx__TraceLine(&__pyx_pymonitoring_state[__Pyx_Monitoring_LINE], __pyx_frame_code, line, offset);\ + PyGILState_Release(state);\ + }\ + } else {\ + ret = __Pyx__TraceLine(&__pyx_pymonitoring_state[__Pyx_Monitoring_LINE], __pyx_frame_code, line, offset);\ + }\ + if (unlikely(ret == -1)) goto_error;\ + } + #endif +#else #include "compile.h" #include "frameobject.h" #include "traceback.h" +#if PY_VERSION_HEX >= 0x030b00a6 && !defined(PYPY_VERSION) + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif #if CYTHON_PROFILE_REUSE_FRAME #define CYTHON_FRAME_MODIFIER static #define CYTHON_FRAME_DEL(frame) @@ -1131,194 +2156,267 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #define CYTHON_FRAME_MODIFIER #define CYTHON_FRAME_DEL(frame) Py_CLEAR(frame) #endif - #define __Pyx_TraceDeclarations\ - static PyCodeObject *__pyx_frame_code = NULL;\ - CYTHON_FRAME_MODIFIER PyFrameObject *__pyx_frame = NULL;\ - int __Pyx_use_tracing = 0; + #if CYTHON_PROFILE_REUSE_CODEOBJ + #define CYTHON_CODEOBJ_MODIFIER static + #else + #define CYTHON_CODEOBJ_MODIFIER + #endif + #define __Pyx_TraceDeclarationsFunc\ + CYTHON_CODEOBJ_MODIFIER PyCodeObject *__pyx_frame_code = NULL;\ + CYTHON_FRAME_MODIFIER PyFrameObject *__pyx_frame = NULL;\ + int __Pyx_use_tracing = 0; + #define __Pyx_TraceDeclarationsGen\ + PyObject *__pyx_frame_code = __pyx_generator->gi_code;\ + CYTHON_FRAME_MODIFIER PyFrameObject *__pyx_frame = NULL;\ + int __Pyx_use_tracing = 0; #define __Pyx_TraceFrameInit(codeobj)\ - if (codeobj) __pyx_frame_code = (PyCodeObject*) codeobj; - #ifdef WITH_THREAD - #define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error)\ + if (codeobj) __pyx_frame_code = (PyCodeObject*) codeobj; + #define __Pyx_PyMonitoring_ExitScope(nogil) {} + #define __Pyx_TraceException(offset, reraised, fresh) {} + #define __Pyx_TraceExceptionHandled(offset) {} + #define __Pyx_TraceExceptionDone() {} + #define __Pyx_TurnOffSysMonitoringInParallel {} // Only needed for freethreading +#if PY_VERSION_HEX >= 0x030b00a2 + #if PY_VERSION_HEX >= 0x030C00b1 + #define __Pyx_IsTracing(tstate, check_tracing, check_funcs)\ + ((!(check_tracing) || !(tstate)->tracing) &&\ + (!(check_funcs) || (tstate)->c_profilefunc || (CYTHON_TRACE && (tstate)->c_tracefunc))) + #else + #define __Pyx_IsTracing(tstate, check_tracing, check_funcs)\ + (unlikely((tstate)->cframe->use_tracing) &&\ + (!(check_tracing) || !(tstate)->tracing) &&\ + (!(check_funcs) || (tstate)->c_profilefunc || (CYTHON_TRACE && (tstate)->c_tracefunc))) + #endif + #define __Pyx_EnterTracing(tstate) PyThreadState_EnterTracing(tstate) + #define __Pyx_LeaveTracing(tstate) PyThreadState_LeaveTracing(tstate) +#elif PY_VERSION_HEX >= 0x030a00b1 + #define __Pyx_IsTracing(tstate, check_tracing, check_funcs)\ + (unlikely((tstate)->cframe->use_tracing) &&\ + (!(check_tracing) || !(tstate)->tracing) &&\ + (!(check_funcs) || (tstate)->c_profilefunc || (CYTHON_TRACE && (tstate)->c_tracefunc))) + #define __Pyx_EnterTracing(tstate)\ + do { tstate->tracing++; tstate->cframe->use_tracing = 0; } while (0) + #define __Pyx_LeaveTracing(tstate)\ + do {\ + tstate->tracing--;\ + tstate->cframe->use_tracing = ((CYTHON_TRACE && tstate->c_tracefunc != NULL)\ + || tstate->c_profilefunc != NULL);\ + } while (0) +#else + #define __Pyx_IsTracing(tstate, check_tracing, check_funcs)\ + (unlikely((tstate)->use_tracing) &&\ + (!(check_tracing) || !(tstate)->tracing) &&\ + (!(check_funcs) || (tstate)->c_profilefunc || (CYTHON_TRACE && (tstate)->c_tracefunc))) + #define __Pyx_EnterTracing(tstate)\ + do { tstate->tracing++; tstate->use_tracing = 0; } while (0) + #define __Pyx_LeaveTracing(tstate)\ + do {\ + tstate->tracing--;\ + tstate->use_tracing = ((CYTHON_TRACE && tstate->c_tracefunc != NULL)\ + || tstate->c_profilefunc != NULL);\ + } while (0) +#endif + #define __Pyx_TraceStartFunc(funcname, srcfile, firstlineno, offset, nogil, skip_event, goto_error)\ if (nogil) {\ if (CYTHON_TRACE_NOGIL) {\ PyThreadState *tstate;\ PyGILState_STATE state = PyGILState_Ensure();\ tstate = __Pyx_PyThreadState_Current;\ - if (unlikely(tstate->use_tracing) && !tstate->tracing &&\ - (tstate->c_profilefunc || (CYTHON_TRACE && tstate->c_tracefunc))) {\ - __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ + if (__Pyx_IsTracing(tstate, 1, 1)) {\ + __Pyx_use_tracing = __Pyx_TraceSetupAndCall((PyCodeObject**)&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno, skip_event);\ }\ PyGILState_Release(state);\ if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ }\ } else {\ PyThreadState* tstate = PyThreadState_GET();\ - if (unlikely(tstate->use_tracing) && !tstate->tracing &&\ - (tstate->c_profilefunc || (CYTHON_TRACE && tstate->c_tracefunc))) {\ - __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ - if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ - }\ - } - #else - #define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error)\ - { PyThreadState* tstate = PyThreadState_GET();\ - if (unlikely(tstate->use_tracing) && !tstate->tracing &&\ - (tstate->c_profilefunc || (CYTHON_TRACE && tstate->c_tracefunc))) {\ - __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ + if (__Pyx_IsTracing(tstate, 1, 1)) {\ + __Pyx_use_tracing = __Pyx_TraceSetupAndCall((PyCodeObject**)&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno, skip_event);\ if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ }\ } - #endif - #define __Pyx_TraceException()\ + #define __Pyx_TraceStartGen __Pyx_TraceStartFunc + #define __Pyx_TraceYield(result, offset, goto_error)\ if (likely(!__Pyx_use_tracing)); else {\ PyThreadState* tstate = __Pyx_PyThreadState_Current;\ - if (tstate->use_tracing &&\ - (tstate->c_profilefunc || (CYTHON_TRACE && tstate->c_tracefunc))) {\ - tstate->tracing++;\ - tstate->use_tracing = 0;\ - PyObject *exc_info = __Pyx_GetExceptionTuple(tstate);\ - if (exc_info) {\ - if (CYTHON_TRACE && tstate->c_tracefunc)\ - tstate->c_tracefunc(\ - tstate->c_traceobj, __pyx_frame, PyTrace_EXCEPTION, exc_info);\ - tstate->c_profilefunc(\ - tstate->c_profileobj, __pyx_frame, PyTrace_EXCEPTION, exc_info);\ - Py_DECREF(exc_info);\ - }\ - tstate->use_tracing = 1;\ - tstate->tracing--;\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result, 0);\ }\ + if ((1)); else goto_error;\ } - static void __Pyx_call_return_trace_func(PyThreadState *tstate, PyFrameObject *frame, PyObject *result) { + #define __Pyx_TraceResumeGen(funcname, srcfile, firstlineno, offset, goto_error)\ + __Pyx_TraceStartFunc(funcname, srcfile, firstlineno, offset, 0, 0, goto_error) + CYTHON_UNUSED static void __Pyx_call_return_trace_func(PyThreadState *tstate, PyFrameObject *frame, PyObject *result, int delete_frame) { PyObject *type, *value, *traceback; __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); - tstate->tracing++; - tstate->use_tracing = 0; + __Pyx_EnterTracing(tstate); if (CYTHON_TRACE && tstate->c_tracefunc) tstate->c_tracefunc(tstate->c_traceobj, frame, PyTrace_RETURN, result); if (tstate->c_profilefunc) tstate->c_profilefunc(tstate->c_profileobj, frame, PyTrace_RETURN, result); - CYTHON_FRAME_DEL(frame); - tstate->use_tracing = 1; - tstate->tracing--; + if (delete_frame) { + CYTHON_FRAME_DEL(frame); + } + __Pyx_LeaveTracing(tstate); __Pyx_ErrRestoreInState(tstate, type, value, traceback); } - #ifdef WITH_THREAD - #define __Pyx_TraceReturn(result, nogil)\ + #define __Pyx_TraceReturnValue(result, offset, nogil, goto_error)\ if (likely(!__Pyx_use_tracing)); else {\ if (nogil) {\ if (CYTHON_TRACE_NOGIL) {\ PyThreadState *tstate;\ PyGILState_STATE state = PyGILState_Ensure();\ tstate = __Pyx_PyThreadState_Current;\ - if (tstate->use_tracing) {\ - __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result, 1);\ }\ PyGILState_Release(state);\ }\ } else {\ PyThreadState* tstate = __Pyx_PyThreadState_Current;\ - if (tstate->use_tracing) {\ - __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result, 1);\ }\ }\ + if ((1)); else goto_error;\ } - #else - #define __Pyx_TraceReturn(result, nogil)\ + #define __Pyx_TraceReturnCValue(cresult, convert_function, offset, nogil, goto_error)\ if (likely(!__Pyx_use_tracing)); else {\ - PyThreadState* tstate = __Pyx_PyThreadState_Current;\ - if (tstate->use_tracing) {\ - __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + PyThreadState *tstate;\ + PyGILState_STATE state = PyGILState_Ensure();\ + tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ + PyObject *pyvalue = convert_function(cresult);\ + if (unlikely(!pyvalue)) goto_error;\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, pyvalue, 1);\ + Py_DECREF(pyvalue);\ + }\ + PyGILState_Release(state);\ + }\ + } else {\ + PyThreadState* tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ + PyObject *pyvalue = convert_function(cresult);\ + if (unlikely(!pyvalue)) goto_error;\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, pyvalue, 1);\ + Py_DECREF(pyvalue);\ + }\ }\ } - #endif - static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno); - static int __Pyx_TraceSetupAndCall(PyCodeObject** code, PyFrameObject** frame, PyThreadState* tstate, const char *funcname, const char *srcfile, int firstlineno); -#else - #define __Pyx_TraceDeclarations - #define __Pyx_TraceFrameInit(codeobj) - #define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error) if ((1)); else goto_error; - #define __Pyx_TraceException() - #define __Pyx_TraceReturn(result, nogil) -#endif -#if CYTHON_TRACE - static int __Pyx_call_line_trace_func(PyThreadState *tstate, PyFrameObject *frame, int lineno) { - int ret; - PyObject *type, *value, *traceback; - __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); - __Pyx_PyFrame_SetLineNumber(frame, lineno); - tstate->tracing++; - tstate->use_tracing = 0; - ret = tstate->c_tracefunc(tstate->c_traceobj, frame, PyTrace_LINE, NULL); - tstate->use_tracing = 1; - tstate->tracing--; - if (likely(!ret)) { - __Pyx_ErrRestoreInState(tstate, type, value, traceback); - } else { - Py_XDECREF(type); - Py_XDECREF(value); - Py_XDECREF(traceback); - } - return ret; - } - #ifdef WITH_THREAD - #define __Pyx_TraceLine(lineno, nogil, goto_error)\ + #define __Pyx_TraceExceptionUnwind(offset, nogil)\ if (likely(!__Pyx_use_tracing)); else {\ if (nogil) {\ if (CYTHON_TRACE_NOGIL) {\ - int ret = 0;\ PyThreadState *tstate;\ PyGILState_STATE state = PyGILState_Ensure();\ tstate = __Pyx_PyThreadState_Current;\ - if (unlikely(tstate->use_tracing && tstate->c_tracefunc && __pyx_frame->f_trace)) {\ - ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, Py_None, 1);\ }\ PyGILState_Release(state);\ - if (unlikely(ret)) goto_error;\ }\ } else {\ PyThreadState* tstate = __Pyx_PyThreadState_Current;\ - if (unlikely(tstate->use_tracing && tstate->c_tracefunc && __pyx_frame->f_trace)) {\ - int ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ - if (unlikely(ret)) goto_error;\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, Py_None, 1);\ }\ }\ } - #else - #define __Pyx_TraceLine(lineno, nogil, goto_error)\ + static int __Pyx_TraceSetupAndCall(PyCodeObject** code, PyFrameObject** frame, PyThreadState* tstate, const char *funcname, const char *srcfile, int firstlineno, int skip_event); +#if CYTHON_TRACE + CYTHON_UNUSED static int __Pyx_call_line_trace_func(PyThreadState *tstate, PyFrameObject *frame, int line); + #define __Pyx_TraceLine(line, offset, nogil, goto_error)\ if (likely(!__Pyx_use_tracing)); else {\ - PyThreadState* tstate = __Pyx_PyThreadState_Current;\ - if (unlikely(tstate->use_tracing && tstate->c_tracefunc && __pyx_frame->f_trace)) {\ - int ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ - if (unlikely(ret)) goto_error;\ + int ret = 0;\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + PyThreadState *tstate;\ + PyGILState_STATE state = __Pyx_PyGILState_Ensure();\ + tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && __pyx_frame->f_trace) {\ + ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, line);\ + }\ + __Pyx_PyGILState_Release(state);\ + }\ + } else {\ + PyThreadState* tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && __pyx_frame->f_trace) {\ + ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, line);\ + }\ }\ + if (unlikely(ret)) goto_error;\ } - #endif +#endif +#endif +#else + #define __Pyx_TraceDeclarationsFunc + #define __Pyx_TraceDeclarationsGen + #define __Pyx_TraceExceptionDone() {} + #define __Pyx_TraceFrameInit(codeobj) {} + #define __Pyx_TurnOffSysMonitoringInParallel {} + #define __Pyx_PyMonitoring_ExitScope(nogil) {} + #define __Pyx_TraceException(offset, reraised, fresh) {} + #define __Pyx_TraceExceptionUnwind(offset, nogil) {} + #define __Pyx_TraceExceptionHandled(offset) {} + #define __Pyx_TraceStartFunc(funcname, srcfile, firstlineno, offset, nogil, skip_event, goto_error) if ((1)); else goto_error; + #define __Pyx_TraceStartGen __Pyx_TraceStartFunc + #define __Pyx_TraceResumeGen(funcname, srcfile, firstlineno, offset, goto_error) if ((1)); else goto_error; + #define __Pyx_TraceYield(result, offset, goto_error) if ((1)); else goto_error; + #define __Pyx_TraceReturnValue(result, offset, nogil, goto_error)\ + if ((1)); else goto_error; + #define __Pyx_TraceReturnCValue(cresult, convert_function, offset, nogil, goto_error)\ + if ((1)); else { (void) convert_function; goto_error } +#endif +#if !CYTHON_TRACE + #define __Pyx_TraceLine(line, offset, nogil, goto_error) if ((1)); else goto_error; +#endif + +/* PyObjectDelAttr.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 +#define __Pyx_PyObject_DelAttr(o, n) PyObject_SetAttr(o, n, NULL) +#else +#define __Pyx_PyObject_DelAttr(o, n) PyObject_DelAttr(o, n) +#endif + +/* PyObjectSetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +#define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o, n, NULL) +static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value); +#else +#define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_DelAttr(o,n) +#define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v) +#endif + +/* PyFunctionFastCall.proto */ +#if CYTHON_FAST_PYCALL +#if !CYTHON_VECTORCALL +#define __Pyx_PyFunction_FastCall(func, args, nargs)\ + __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject *const *args, Py_ssize_t nargs, PyObject *kwargs); +#endif +#define __Pyx_BUILD_ASSERT_EXPR(cond)\ + (sizeof(char [1 - 2*!(cond)]) - 1) +#ifndef Py_MEMBER_SIZE +#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) +#endif +#if !CYTHON_VECTORCALL +#if PY_VERSION_HEX >= 0x03080000 + #include "frameobject.h" + #define __Pxy_PyFrame_Initialize_Offsets() + #define __Pyx_PyFrame_GetLocalsplus(frame) ((frame)->f_localsplus) #else - #define __Pyx_TraceLine(lineno, nogil, goto_error) if ((1)); else goto_error; -#endif - -/* 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); + static size_t __pyx_pyframe_localsplus_offset = 0; + #include "frameobject.h" + #define __Pxy_PyFrame_Initialize_Offsets()\ + ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ + (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) + #define __Pyx_PyFrame_GetLocalsplus(frame)\ + (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) +#endif +#endif +#endif /* PyObjectCall.proto */ #if CYTHON_COMPILING_IN_CPYTHON @@ -1327,8 +2425,17 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg #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 + +/* PyObjectFastCall.proto */ +#define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject * const*args, size_t nargs, PyObject *kwargs); + /* GetTopmostException.proto */ -#if CYTHON_USE_EXC_INFO_STACK +#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); #endif @@ -1343,14 +2450,6 @@ static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject #define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) #endif -/* PyErrExceptionMatches.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) -static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); -#else -#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) -#endif - /* GetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) @@ -1387,18 +2486,18 @@ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UIN /* GetModuleGlobalName.proto */ #if CYTHON_USE_DICT_VERSIONS -#define __Pyx_GetModuleGlobalName(var, name) {\ +#define __Pyx_GetModuleGlobalName(var, name) do {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ - (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ + (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_mstate_global->__pyx_d))) ?\ (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ -} -#define __Pyx_GetModuleGlobalNameUncached(var, name) {\ +} while(0) +#define __Pyx_GetModuleGlobalNameUncached(var, name) do {\ PY_UINT64_T __pyx_dict_version;\ PyObject *__pyx_dict_cached_value;\ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ -} +} while(0) static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); #else #define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) @@ -1406,52 +2505,40 @@ static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_ve static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); #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, Py_ssize_t nargs, PyObject *kwargs); +/* PyObjectVectorCallKwBuilder.proto */ +CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n); +#if CYTHON_VECTORCALL +#if PY_VERSION_HEX >= 0x03090000 +#define __Pyx_Object_Vectorcall_CallFromBuilder PyObject_Vectorcall #else -#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) -#endif -#define __Pyx_BUILD_ASSERT_EXPR(cond)\ - (sizeof(char [1 - 2*!(cond)]) - 1) -#ifndef Py_MEMBER_SIZE -#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) -#endif - static size_t __pyx_pyframe_localsplus_offset = 0; - #include "frameobject.h" - #define __Pxy_PyFrame_Initialize_Offsets()\ - ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ - (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) - #define __Pyx_PyFrame_GetLocalsplus(frame)\ - (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) +#define __Pyx_Object_Vectorcall_CallFromBuilder _PyObject_Vectorcall #endif - -/* PyCFunctionFastCall.proto */ -#if CYTHON_FAST_PYCCALL -static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); +#define __Pyx_MakeVectorcallBuilderKwds(n) PyTuple_New(n) +static int __Pyx_VectorcallBuilder_AddArg(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n); +static int __Pyx_VectorcallBuilder_AddArgStr(const char *key, PyObject *value, PyObject *builder, PyObject **args, int n); #else -#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) +#define __Pyx_Object_Vectorcall_CallFromBuilder __Pyx_PyObject_FastCallDict +#define __Pyx_MakeVectorcallBuilderKwds(n) __Pyx_PyDict_NewPresized(n) +#define __Pyx_VectorcallBuilder_AddArg(key, value, builder, args, n) PyDict_SetItem(builder, key, value) +#define __Pyx_VectorcallBuilder_AddArgStr(key, value, builder, args, n) PyDict_SetItemString(builder, key, value) #endif -/* PyObjectCall2Args.proto */ -static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); +/* PyObjectFormatAndDecref.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f); +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f); -/* PyObjectCallMethO.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); -#endif +/* IncludeStringH.proto */ +#include -/* PyObjectCallOneArg.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); +/* JoinPyUnicode.proto */ +static PyObject* __Pyx_PyUnicode_Join(PyObject** values, Py_ssize_t value_count, Py_ssize_t result_ulength, + Py_UCS4 max_char); -/* PyObjectCallNoArg.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); +/* PyObjectFastCallMethod.proto */ +#if CYTHON_VECTORCALL && PY_VERSION_HEX >= 0x03090000 +#define __Pyx_PyObject_FastCallMethod(name, args, nargsf) PyObject_VectorcallMethod(name, args, nargsf, NULL) #else -#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) +static PyObject *__Pyx_PyObject_FastCallMethod(PyObject *name, PyObject *const *args, size_t nargsf); #endif /* SwapException.proto */ @@ -1462,367 +2549,660 @@ static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject * static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); #endif -/* 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); - -/* 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); - /* WriteUnraisableException.proto */ static void __Pyx_WriteUnraisable(const char *name, int clineno, int lineno, const char *filename, int full_traceback, int nogil); -/* ExtTypeTest.proto */ -static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); +/* TupleAndListFromArray.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); +#endif +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); +#endif + +/* BytesEquals.proto */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); + +/* UnicodeEquals.proto */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); + +/* fastcall.proto */ +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_PySequence_ITEM(args, i) +#elif CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_NewRef(__Pyx_PyTuple_GET_ITEM(args, i)) +#else + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_XNewRef(PyTuple_GetItem(args, i)) +#endif +#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) +#define __Pyx_KwValues_VARARGS(args, nargs) NULL +#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) +#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) +#if CYTHON_METH_FASTCALL + #define __Pyx_ArgRef_FASTCALL(args, i) __Pyx_NewRef(args[i]) + #define __Pyx_NumKwargs_FASTCALL(kwds) __Pyx_PyTuple_GET_SIZE(kwds) + #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) + static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API + CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); + #else + #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) + #endif +#else + #define __Pyx_ArgRef_FASTCALL __Pyx_ArgRef_VARARGS + #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS + #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS + #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS + #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS +#endif +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) +#if CYTHON_METH_FASTCALL || (CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(args + start, stop - start) +#else +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) +#endif + +/* RaiseDoubleKeywords.proto */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +/* ParseKeywords.proto */ +static CYTHON_INLINE int __Pyx_ParseKeywords( + PyObject *kwds, PyObject *const *kwvalues, PyObject ** const argnames[], + PyObject *kwds2, PyObject *values[], + Py_ssize_t num_pos_args, Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs +); + +/* CallCFunction.proto */ +#define __Pyx_CallCFunction(cfunc, self, args)\ + ((PyCFunction)(void(*)(void))(cfunc)->func)(self, args) +#define __Pyx_CallCFunctionWithKeywords(cfunc, self, args, kwargs)\ + ((PyCFunctionWithKeywords)(void(*)(void))(cfunc)->func)(self, args, kwargs) +#define __Pyx_CallCFunctionFast(cfunc, self, args, nargs)\ + ((__Pyx_PyCFunctionFast)(void(*)(void))(PyCFunction)(cfunc)->func)(self, args, nargs) +#define __Pyx_CallCFunctionFastWithKeywords(cfunc, self, args, nargs, kwnames)\ + ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))(PyCFunction)(cfunc)->func)(self, args, nargs, kwnames) /* UnpackUnboundCMethod.proto */ typedef struct { PyObject *type; PyObject **method_name; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && CYTHON_ATOMICS + __pyx_atomic_int_type initialized; +#endif PyCFunction func; PyObject *method; int flag; } __Pyx_CachedCFunction; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +static CYTHON_INLINE int __Pyx_CachedCFunction_GetAndSetInitializing(__Pyx_CachedCFunction *cfunc) { +#if !CYTHON_ATOMICS + return 1; +#else + __pyx_nonatomic_int_type expected = 0; + if (__pyx_atomic_int_cmp_exchange(&cfunc->initialized, &expected, 1)) { + return 0; + } + return expected; +#endif +} +static CYTHON_INLINE void __Pyx_CachedCFunction_SetFinishedInitializing(__Pyx_CachedCFunction *cfunc) { +#if CYTHON_ATOMICS + __pyx_atomic_store(&cfunc->initialized, 2); +#endif +} +#else +#define __Pyx_CachedCFunction_GetAndSetInitializing(cfunc) 2 +#define __Pyx_CachedCFunction_SetFinishedInitializing(cfunc) +#endif -/* CallUnboundCMethod1.proto */ -static PyObject* __Pyx__CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg); +/* CallUnboundCMethod2.proto */ +CYTHON_UNUSED +static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2); #if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg); +static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2); #else -#define __Pyx_CallUnboundCMethod1(cfunc, self, arg) __Pyx__CallUnboundCMethod1(cfunc, self, arg) +#define __Pyx_CallUnboundCMethod2(cfunc, self, arg1, arg2) __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2) #endif -/* IncludeStringH.proto */ -#include - -/* BytesEquals.proto */ -static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); +/* 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); -/* UnicodeEquals.proto */ -static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); -/* StrEquals.proto */ -#if PY_MAJOR_VERSION >= 3 -#define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals +/* PyObjectFormat.proto */ +#if CYTHON_USE_UNICODE_WRITER +static PyObject* __Pyx_PyObject_Format(PyObject* s, PyObject* f); #else -#define __Pyx_PyString_Equals __Pyx_PyBytes_Equals +#define __Pyx_PyObject_Format(s, f) PyObject_Format(s, f) #endif -/* GetAttr.proto */ -static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); +/* PyUnicode_Unicode.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_Unicode(PyObject *obj); + +/* ArgTypeTest.proto */ +#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ + ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\ + __Pyx__ArgTypeTest(obj, type, name, exact)) +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); + +/* DictGetItem.proto */ +#if !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 /* GetAttr3.proto */ static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); +/* RejectKeywords.proto */ +static void __Pyx_RejectKeywords(const char* function_name, PyObject *kwds); + /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); +/* CallTypeTraverse.proto */ +#if !CYTHON_USE_TYPE_SPECS || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x03090000) +#define __Pyx_call_type_traverse(o, always_call, visit, arg) 0 +#else +static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg); +#endif + /* TypeImport.proto */ -#ifndef __PYX_HAVE_RT_ImportType_proto -#define __PYX_HAVE_RT_ImportType_proto -enum __Pyx_ImportType_CheckSize { - __Pyx_ImportType_CheckSize_Error = 0, - __Pyx_ImportType_CheckSize_Warn = 1, - __Pyx_ImportType_CheckSize_Ignore = 2 +#ifndef __PYX_HAVE_RT_ImportType_proto_3_1_3 +#define __PYX_HAVE_RT_ImportType_proto_3_1_3 +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L +#include +#endif +#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L +#define __PYX_GET_STRUCT_ALIGNMENT_3_1_3(s) alignof(s) +#else +#define __PYX_GET_STRUCT_ALIGNMENT_3_1_3(s) sizeof(void*) +#endif +enum __Pyx_ImportType_CheckSize_3_1_3 { + __Pyx_ImportType_CheckSize_Error_3_1_3 = 0, + __Pyx_ImportType_CheckSize_Warn_3_1_3 = 1, + __Pyx_ImportType_CheckSize_Ignore_3_1_3 = 2 }; -static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size); +static PyTypeObject *__Pyx_ImportType_3_1_3(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_1_3 check_size); #endif -/* PyObject_GenericGetAttrNoDict.proto */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name); -#else -#define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr +/* LimitedApiGetTypeDict.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_GetTypeDict(PyTypeObject *tp); +#endif + +/* SetItemOnTypeDict.proto */ +static int __Pyx__SetItemOnTypeDict(PyTypeObject *tp, PyObject *k, PyObject *v); +#define __Pyx_SetItemOnTypeDict(tp, k, v) __Pyx__SetItemOnTypeDict((PyTypeObject*)tp, k, v) + +/* FixUpExtensionType.proto */ +static CYTHON_INLINE int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); + +/* PyObjectCallNoArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); + +/* PyObjectGetMethod.proto */ +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); + +/* PyObjectCallMethod0.proto */ +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); + +/* ValidateBasesTuple.proto */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases); #endif +/* PyType_Ready.proto */ +CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t); + +/* DelItemOnTypeDict.proto */ +static int __Pyx__DelItemOnTypeDict(PyTypeObject *tp, PyObject *k); +#define __Pyx_DelItemOnTypeDict(tp, k) __Pyx__DelItemOnTypeDict((PyTypeObject*)tp, k) + /* SetupReduce.proto */ static int __Pyx_setup_reduce(PyObject* type_obj); /* GetVTable.proto */ -static void* __Pyx_GetVtable(PyObject *dict); +static void* __Pyx_GetVtable(PyTypeObject *type); /* Import.proto */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); -/* CLineInTraceback.proto */ -#ifdef CYTHON_CLINE_IN_TRACEBACK -#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) +/* ImportDottedModule.proto */ +static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple); +static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple); + +/* FetchSharedCythonModule.proto */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void); + +/* dict_setdefault.proto */ +static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value, int is_safe_type); + +/* FetchCommonType.proto */ +static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases); + +/* CommonTypesMetaclass.proto */ +static int __pyx_CommonTypesMetaclass_init(PyObject *module); +#define __Pyx_CommonTypesMetaclass_USED + +/* PyMethodNew.proto */ +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ); + +/* PyVectorcallFastCallDict.proto */ +#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL) +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw); +#endif + +/* CythonFunctionShared.proto */ +#define __Pyx_CyFunction_USED +#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 +#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 +#define __Pyx_CYFUNCTION_CCLASS 0x04 +#define __Pyx_CYFUNCTION_COROUTINE 0x08 +#define __Pyx_CyFunction_GetClosure(f)\ + (((__pyx_CyFunctionObject *) (f))->func_closure) +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_CyFunction_GetClassObj(f)\ + (((__pyx_CyFunctionObject *) (f))->func_classobj) +#else + #define __Pyx_CyFunction_GetClassObj(f)\ + ((PyObject*) ((PyCMethodObject *) (f))->mm_class) +#endif +#define __Pyx_CyFunction_SetClassObj(f, classobj)\ + __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (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 { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject_HEAD + PyObject *func; +#elif PY_VERSION_HEX < 0x030900B1 + PyCFunctionObject func; #else + PyCMethodObject func; +#endif +#if CYTHON_BACKPORT_VECTORCALL ||\ + (CYTHON_COMPILING_IN_LIMITED_API && CYTHON_METH_FASTCALL) + __pyx_vectorcallfunc func_vectorcall; +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + 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; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_classobj; +#endif + PyObject *defaults; + int flags; + PyObject *defaults_tuple; + PyObject *defaults_kwdict; + PyObject *(*defaults_getter)(PyObject *); + PyObject *func_annotations; + PyObject *func_is_coroutine; +} __pyx_CyFunctionObject; +#undef __Pyx_CyOrPyCFunction_Check +#define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_mstate_global->__pyx_CyFunctionType) +#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_mstate_global->__pyx_CyFunctionType, &PyCFunction_Type) +#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_mstate_global->__pyx_CyFunctionType) +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)); +#undef __Pyx_IsSameCFunction +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCyOrCFunction(func, cfunc) +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); +static CYTHON_INLINE PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func, + PyTypeObject *defaults_type); +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(PyObject *module); +#if CYTHON_METH_FASTCALL +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +#if CYTHON_BACKPORT_VECTORCALL || CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall) +#else +#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall) +#endif +#endif + +/* CythonFunction.proto */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); + +/* CLineInTraceback.proto */ +#if CYTHON_CLINE_IN_TRACEBACK && CYTHON_CLINE_IN_TRACEBACK_RUNTIME static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); +#else +#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) #endif /* CodeObjectCache.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject __Pyx_CachedCodeObjectType; +#else +typedef PyCodeObject __Pyx_CachedCodeObjectType; +#endif typedef struct { - PyCodeObject* code_object; + __Pyx_CachedCodeObjectType* code_object; int code_line; } __Pyx_CodeObjectCacheEntry; struct __Pyx_CodeObjectCache { int count; int max_count; __Pyx_CodeObjectCacheEntry* entries; + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_atomic_int_type accessor_count; + #endif }; -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); +static __Pyx_CachedCodeObjectType *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, __Pyx_CachedCodeObjectType* code_object); /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); +/* GCCDiagnostics.proto */ +#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#define __Pyx_HAS_GCC_DIAGNOSTIC +#endif + /* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_int(int value); /* CIntFromPy.proto */ -static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); +static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *); + +/* FormatTypeName.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%U" +#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 +#define __Pyx_PyType_GetFullyQualifiedName PyType_GetFullyQualifiedName +#else +static __Pyx_TypeName __Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp); +#endif +#else // !LIMITED_API +typedef const char *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%.200s" +#define __Pyx_PyType_GetFullyQualifiedName(tp) ((tp)->tp_name) +#define __Pyx_DECREF_TypeName(obj) +#endif /* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value); /* CIntFromPy.proto */ -static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); +static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *); /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, 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_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) #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)) +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2) { + return PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2); +} #endif +#define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) +#ifdef PyExceptionInstance_Check + #define __Pyx_PyBaseException_Check(obj) PyExceptionInstance_Check(obj) +#else + #define __Pyx_PyBaseException_Check(obj) __Pyx_TypeCheck(obj, PyExc_BaseException) +#endif + +/* GetRuntimeVersion.proto */ +static unsigned long __Pyx_get_runtime_version(void); /* CheckBinaryVersion.proto */ -static int __Pyx_check_binary_version(void); +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); /* FunctionImport.proto */ -static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig); - -/* InitStrings.proto */ -static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); - - -/* Module declarations from 'cython' */ - -/* Module declarations from 'libc.string' */ - -/* Module declarations from 'libc.stdio' */ - -/* Module declarations from '__builtin__' */ - -/* Module declarations from 'cpython.type' */ -static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; - -/* Module declarations from 'cpython.version' */ - -/* Module declarations from 'cpython.ref' */ - -/* Module declarations from 'cpython.exc' */ - -/* Module declarations from 'cpython.module' */ - -/* Module declarations from 'cpython.mem' */ - -/* Module declarations from 'cpython.tuple' */ - -/* Module declarations from 'cpython.list' */ - -/* Module declarations from 'cpython.sequence' */ - -/* Module declarations from 'cpython.mapping' */ - -/* Module declarations from 'cpython.iterator' */ - -/* Module declarations from 'cpython.number' */ - -/* Module declarations from 'cpython.int' */ - -/* Module declarations from '__builtin__' */ +static int __Pyx_ImportFunction_3_1_3(PyObject *module, const char *funcname, void (**f)(void), const char *sig); + +/* MultiPhaseInitModuleState.proto */ +#if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE +static PyObject *__Pyx_State_FindModule(void*); +static int __Pyx_State_AddModule(PyObject* module, void*); +static int __Pyx_State_RemoveModule(void*); +#elif CYTHON_USE_MODULE_STATE +#define __Pyx_State_FindModule PyState_FindModule +#define __Pyx_State_AddModule PyState_AddModule +#define __Pyx_State_RemoveModule PyState_RemoveModule +#endif + +/* #### Code section: module_declarations ### */ +/* CythonABIVersion.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API + #if CYTHON_METH_FASTCALL + #define __PYX_FASTCALL_ABI_SUFFIX "_fastcall" + #else + #define __PYX_FASTCALL_ABI_SUFFIX + #endif + #define __PYX_LIMITED_ABI_SUFFIX "limited" __PYX_FASTCALL_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX +#else + #define __PYX_LIMITED_ABI_SUFFIX +#endif +#if __PYX_HAS_PY_AM_SEND == 1 + #define __PYX_AM_SEND_ABI_SUFFIX +#elif __PYX_HAS_PY_AM_SEND == 2 + #define __PYX_AM_SEND_ABI_SUFFIX "amsendbackport" +#else + #define __PYX_AM_SEND_ABI_SUFFIX "noamsend" +#endif +#ifndef __PYX_MONITORING_ABI_SUFFIX + #define __PYX_MONITORING_ABI_SUFFIX +#endif +#if CYTHON_USE_TP_FINALIZE + #define __PYX_TP_FINALIZE_ABI_SUFFIX +#else + #define __PYX_TP_FINALIZE_ABI_SUFFIX "nofinalize" +#endif +#if CYTHON_USE_FREELISTS || !defined(__Pyx_AsyncGen_USED) + #define __PYX_FREELISTS_ABI_SUFFIX +#else + #define __PYX_FREELISTS_ABI_SUFFIX "nofreelists" +#endif +#define CYTHON_ABI __PYX_ABI_VERSION __PYX_LIMITED_ABI_SUFFIX __PYX_MONITORING_ABI_SUFFIX __PYX_TP_FINALIZE_ABI_SUFFIX __PYX_FREELISTS_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX +#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI +#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." -/* Module declarations from 'cpython.bool' */ -static PyTypeObject *__pyx_ptype_7cpython_4bool_bool = 0; -/* Module declarations from 'cpython.long' */ +/* Module declarations from "cython" */ -/* Module declarations from 'cpython.float' */ +/* Module declarations from "libc.string" */ -/* Module declarations from '__builtin__' */ +/* Module declarations from "libc.stdio" */ -/* Module declarations from 'cpython.complex' */ -static PyTypeObject *__pyx_ptype_7cpython_7complex_complex = 0; +/* Module declarations from "__builtin__" */ -/* Module declarations from 'cpython.string' */ +/* Module declarations from "cpython.type" */ -/* Module declarations from 'cpython.unicode' */ +/* Module declarations from "cpython" */ -/* Module declarations from 'cpython.dict' */ +/* Module declarations from "cpython.object" */ -/* Module declarations from 'cpython.instance' */ +/* Module declarations from "cpython.pystate" */ -/* Module declarations from 'cpython.function' */ +/* Module declarations from "cpython.ref" */ -/* Module declarations from 'cpython.method' */ +/* Module declarations from "types" */ -/* Module declarations from 'cpython.weakref' */ +/* Module declarations from "types" */ -/* Module declarations from 'cpython.getargs' */ +/* Module declarations from "hunter._event" */ -/* Module declarations from 'cpython.pythread' */ +/* Module declarations from "hunter._predicates" */ +static PyObject *(*__pyx_f_6hunter_11_predicates_fast_call)(PyObject *, struct __pyx_obj_6hunter_6_event_Event *); /*proto*/ -/* Module declarations from 'cpython.cobject' */ +/* Module declarations from "hunter._tracer" */ +static PyObject *__pyx_v_6hunter_7_tracer_KIND_INTS = 0; +static int __pyx_f_6hunter_7_tracer_trace_func(PyObject *, PyFrameObject *, int, PyObject *); /*proto*/ +/* #### Code section: typeinfo ### */ +/* #### Code section: before_global_var ### */ +#define __Pyx_MODULE_NAME "hunter._tracer" +extern int __pyx_module_is_main_hunter___tracer; +int __pyx_module_is_main_hunter___tracer = 0; -/* Module declarations from 'cpython.oldbuffer' */ - -/* Module declarations from 'cpython.set' */ - -/* Module declarations from 'cpython.buffer' */ - -/* Module declarations from 'cpython.bytes' */ - -/* Module declarations from 'cpython.pycapsule' */ - -/* Module declarations from 'cpython' */ - -/* Module declarations from 'cpython.object' */ - -/* Module declarations from 'cpython.pystate' */ - -/* Module declarations from 'types' */ - -/* Module declarations from 'hunter._event' */ -static PyTypeObject *__pyx_ptype_6hunter_6_event_Event = 0; - -/* Module declarations from 'hunter._predicates' */ -static PyTypeObject *__pyx_ptype_6hunter_11_predicates_Query = 0; -static PyTypeObject *__pyx_ptype_6hunter_11_predicates_And = 0; -static PyTypeObject *__pyx_ptype_6hunter_11_predicates_Or = 0; -static PyTypeObject *__pyx_ptype_6hunter_11_predicates_Not = 0; -static PyTypeObject *__pyx_ptype_6hunter_11_predicates_When = 0; -static PyTypeObject *__pyx_ptype_6hunter_11_predicates_From = 0; -static PyObject *(*__pyx_f_6hunter_11_predicates_fast_call)(PyObject *, struct __pyx_obj_6hunter_6_event_Event *); /*proto*/ - -/* Module declarations from 'hunter._tracer' */ -static PyTypeObject *__pyx_ptype_6hunter_7_tracer_CodeType = 0; -static PyTypeObject *__pyx_ptype_6hunter_7_tracer_FrameType = 0; -static PyTypeObject *__pyx_ptype_6hunter_7_tracer_Tracer = 0; -static PyObject *__pyx_v_6hunter_7_tracer_KIND_NAMES = 0; -static int __pyx_f_6hunter_7_tracer_trace_func(struct __pyx_obj_6hunter_7_tracer_Tracer *, PyFrameObject *, int, PyObject *); /*proto*/ -#define __Pyx_MODULE_NAME "hunter._tracer" -extern int __pyx_module_is_main_hunter___tracer; -int __pyx_module_is_main_hunter___tracer = 0; - -/* Implementation of 'hunter._tracer' */ +/* Implementation of "hunter._tracer" */ +/* #### Code section: global_var ### */ static PyObject *__pyx_builtin_id; static PyObject *__pyx_builtin_TypeError; -static const char __pyx_k_[] = ""; +/* #### Code section: string_decls ### */ +static const char __pyx_k_[] = ".\n\n"; +static const char __pyx_k_Q[] = "\220Q"; +static const char __pyx_k_a[] = "\220a"; +static const char __pyx_k_x[] = "x"; +static const char __pyx_k__2[] = ", "; +static const char __pyx_k__3[] = ""; +static const char __pyx_k__4[] = ">"; +static const char __pyx_k__5[] = "?"; +static const char __pyx_k__6[] = "\230\001"; +static const char __pyx_k_at[] = ") at "; +static const char __pyx_k_gc[] = "gc"; static const char __pyx_k_id[] = "id"; +static const char __pyx_k_A_E[] = "\200A\330\010\014\210E\220\021"; +static const char __pyx_k_A_q[] = "\200A\330\010\017\210q"; +static const char __pyx_k_Q_2[] = "\200\001\330\004\n\210+\220Q"; static const char __pyx_k_all[] = "__all__"; static const char __pyx_k_arg[] = "arg"; +static const char __pyx_k_get[] = "__get__"; +static const char __pyx_k_pop[] = "pop"; +static const char __pyx_k_None[] = "None"; static const char __pyx_k_call[] = "call"; +static const char __pyx_k_exit[] = "__exit__"; static const char __pyx_k_file[] = "file"; +static const char __pyx_k_func[] = "__func__"; static const char __pyx_k_kind[] = "kind"; static const char __pyx_k_line[] = "line"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_name[] = "__name__"; +static const char __pyx_k_repr[] = "__repr__"; +static const char __pyx_k_self[] = "self"; +static const char __pyx_k_spec[] = "__spec__"; static const char __pyx_k_stop[] = "stop"; static const char __pyx_k_test[] = "__test__"; +static const char __pyx_k_cinit[] = "__cinit__"; +static const char __pyx_k_enter[] = "__enter__"; static const char __pyx_k_frame[] = "frame"; -static const char __pyx_k_index[] = "index"; +static const char __pyx_k_state[] = "state"; +static const char __pyx_k_trace[] = "trace"; static const char __pyx_k_write[] = "write"; static const char __pyx_k_Tracer[] = "Tracer"; static const char __pyx_k_c_call[] = "c_call"; +static const char __pyx_k_call_2[] = "__call__"; +static const char __pyx_k_enable[] = "enable"; static const char __pyx_k_exc_tb[] = "exc_tb"; -static const char __pyx_k_format[] = "format"; +static const char __pyx_k_failed[] = " failed ("; static const char __pyx_k_hunter[] = "hunter"; -static const char __pyx_k_import[] = "__import__"; +static const char __pyx_k_module[] = "__module__"; static const char __pyx_k_reduce[] = "__reduce__"; static const char __pyx_k_return[] = "return"; +static const char __pyx_k_tracer[] = "tracer"; +static const char __pyx_k_dealloc[] = "__dealloc__"; +static const char __pyx_k_disable[] = "disable"; static const char __pyx_k_exc_val[] = "exc_val"; +static const char __pyx_k_f_trace[] = "f_trace"; static const char __pyx_k_handler[] = "handler="; static const char __pyx_k_stopped[] = ""; +static const char __pyx_k_add_note[] = "add_note"; static const char __pyx_k_c_return[] = "c_return"; static const char __pyx_k_exc_type[] = "exc_type"; static const char __pyx_k_getstate[] = "__getstate__"; static const char __pyx_k_previous[] = ", previous="; +static const char __pyx_k_qualname[] = "__qualname__"; +static const char __pyx_k_set_name[] = "__set_name__"; static const char __pyx_k_setstate[] = "__setstate__"; static const char __pyx_k_settrace[] = "settrace"; +static const char __pyx_k_KIND_INTS[] = "KIND_INTS"; static const char __pyx_k_TypeError[] = "TypeError"; static const char __pyx_k_exception[] = "exception"; +static const char __pyx_k_isenabled[] = "isenabled"; +static const char __pyx_k_predicate[] = "predicate"; static const char __pyx_k_print_exc[] = "print_exc"; +static const char __pyx_k_pyx_state[] = "__pyx_state"; static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; static const char __pyx_k_threading[] = "threading"; static const char __pyx_k_traceback[] = "traceback"; static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; +static const char __pyx_k_setprofile[] = "setprofile"; +static const char __pyx_k_trace_func[] = "trace_func"; static const char __pyx_k_trace_hook[] = "_trace_hook"; +static const char __pyx_k_Tracer_stop[] = "Tracer.stop"; static const char __pyx_k_c_exception[] = "c_exception"; +static const char __pyx_k_A_5Q_5_C_1_Q[] = "\200A\330\010$\320$5\260Q\330\010\013\2105\220\014\230C\230|\2501\330\014\020\220\005\220Q"; +static const char __pyx_k_Tracer_trace[] = "Tracer.trace"; +static const char __pyx_k_initializing[] = "_initializing"; +static const char __pyx_k_is_coroutine[] = "_is_coroutine"; +static const char __pyx_k_profile_hook[] = "_profile_hook"; +static const char __pyx_k_stringsource[] = ""; +static const char __pyx_k_Tracer___exit[] = "Tracer.__exit__"; static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; +static const char __pyx_k_Tracer___enter[] = "Tracer.__enter__"; static const char __pyx_k_default_stream[] = "_default_stream"; +static const char __pyx_k_hunter__tracer[] = "hunter._tracer"; +static const char __pyx_k_profiling_mode[] = "profiling_mode"; static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; static const char __pyx_k_threading_support[] = "threading_support"; +static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; -static const char __pyx_k_hunter__tracer_Tracer_at_0x_x_t[] = ""; -static const char __pyx_k_Disabling_tracer_because_handler[] = "Disabling tracer because handler {} failed ({!r}).\n\n"; +static const char __pyx_k_q_Kq_L_Q_1_a_IQ_IQ[] = "\320\004*\320*?\270q\330\010\014\210K\220q\330\010\014\210L\230\001\330\010\014\320\014\035\230Q\330\010\014\320\014#\2401\330\010\014\320\014!\240\021\330\010\014\320\014\036\230a\330\010\014\210I\220Q\330\010\014\210I\220Q"; +static const char __pyx_k_threading_support_2[] = ": threading_support="; +static const char __pyx_k_A_v_6gYawlZ_5_1_1L_A_q[] = "\200A\330\010\022\220!\220<\230v\320%6\260g\270Y\300a\300w\310l\320Z[\330\010\013\2105\220\003\2201\330\014\033\2301\230L\250\014\260A\330\010\017\210q"; +static const char __pyx_k_Tracer___reduce_cython[] = "Tracer.__reduce_cython__"; +static const char __pyx_k_src_hunter__tracer_pxd[] = "src/hunter/_tracer.pxd"; +static const char __pyx_k_src_hunter__tracer_pyx[] = "src/hunter/_tracer.pyx"; +static const char __pyx_k_Tracer___setstate_cython[] = "Tracer.__setstate_cython__"; +static const char __pyx_k_hunter__tracer_Tracer_at_0x[] = " 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) + #define CYTHON_SMALL_CODE __attribute__((cold)) +#else + #define CYTHON_SMALL_CODE +#endif +#endif + +typedef struct { + PyObject *__pyx_d; + PyObject *__pyx_b; + PyObject *__pyx_cython_runtime; + PyObject *__pyx_empty_tuple; + PyObject *__pyx_empty_bytes; + PyObject *__pyx_empty_unicode; + #ifdef __Pyx_CyFunction_USED + PyTypeObject *__pyx_CyFunctionType; + #endif + #ifdef __Pyx_FusedFunction_USED + PyTypeObject *__pyx_FusedFunctionType; + #endif + #ifdef __Pyx_Generator_USED + PyTypeObject *__pyx_GeneratorType; + #endif + #ifdef __Pyx_IterableCoroutine_USED + PyTypeObject *__pyx_IterableCoroutineType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineAwaitType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineType; + #endif + PyTypeObject *__pyx_ptype_7cpython_4type_type; + PyTypeObject *__pyx_ptype_6hunter_6_event_CodeType; + PyTypeObject *__pyx_ptype_6hunter_6_event_Event; + PyTypeObject *__pyx_ptype_6hunter_11_predicates_Query; + PyTypeObject *__pyx_ptype_6hunter_11_predicates_And; + PyTypeObject *__pyx_ptype_6hunter_11_predicates_Or; + PyTypeObject *__pyx_ptype_6hunter_11_predicates_Not; + PyTypeObject *__pyx_ptype_6hunter_11_predicates_When; + PyTypeObject *__pyx_ptype_6hunter_11_predicates_From; + PyTypeObject *__pyx_ptype_6hunter_11_predicates_Backlog; + PyObject *__pyx_type_6hunter_7_tracer_Tracer; + PyTypeObject *__pyx_ptype_6hunter_7_tracer_CodeType; + PyTypeObject *__pyx_ptype_6hunter_7_tracer_Tracer; + __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_pop; + PyObject *__pyx_tuple[1]; + PyObject *__pyx_codeobj_tab[18]; + PyObject *__pyx_string_tab[99]; + PyObject *__pyx_int_0; + PyObject *__pyx_int_1; + PyObject *__pyx_int_2; + PyObject *__pyx_int_3; + PyObject *__pyx_int_4; + PyObject *__pyx_int_5; + PyObject *__pyx_int_6; +/* #### Code section: module_state_contents ### */ +/* CommonTypesMetaclass.module_state_decls */ +PyTypeObject *__pyx_CommonTypesMetaclassType; + +/* CachedMethodType.module_state_decls */ +#if CYTHON_COMPILING_IN_LIMITED_API +PyObject *__Pyx_CachedMethodType; +#endif + +/* CodeObjectCache.module_state_decls */ +struct __Pyx_CodeObjectCache __pyx_code_cache; + +/* #### Code section: module_state_end ### */ +} __pyx_mstatetype; + +#if CYTHON_USE_MODULE_STATE +#ifdef __cplusplus +namespace { +extern struct PyModuleDef __pyx_moduledef; +} /* anonymous namespace */ +#else +static struct PyModuleDef __pyx_moduledef; +#endif + +#define __pyx_mstate_global (__Pyx_PyModule_GetState(__Pyx_State_FindModule(&__pyx_moduledef))) + +#define __pyx_m (__Pyx_State_FindModule(&__pyx_moduledef)) +#else +static __pyx_mstatetype __pyx_mstate_global_static = +#ifdef __cplusplus + {}; +#else + {0}; +#endif +static __pyx_mstatetype * const __pyx_mstate_global = &__pyx_mstate_global_static; +#endif +/* #### Code section: constant_name_defines ### */ +#define __pyx_kp_u_ __pyx_string_tab[0] +#define __pyx_kp_u_Disabling_tracer_because_handler __pyx_string_tab[1] +#define __pyx_n_u_KIND_INTS __pyx_string_tab[2] +#define __pyx_kp_u_None __pyx_string_tab[3] +#define __pyx_kp_u_Note_that_Cython_is_deliberately __pyx_string_tab[4] +#define __pyx_n_u_Tracer __pyx_string_tab[5] +#define __pyx_n_u_Tracer___enter __pyx_string_tab[6] +#define __pyx_n_u_Tracer___exit __pyx_string_tab[7] +#define __pyx_n_u_Tracer___reduce_cython __pyx_string_tab[8] +#define __pyx_n_u_Tracer___setstate_cython __pyx_string_tab[9] +#define __pyx_n_u_Tracer_stop __pyx_string_tab[10] +#define __pyx_n_u_Tracer_trace __pyx_string_tab[11] +#define __pyx_n_u_TypeError __pyx_string_tab[12] +#define __pyx_kp_u__2 __pyx_string_tab[13] +#define __pyx_kp_u__3 __pyx_string_tab[14] +#define __pyx_kp_u__4 __pyx_string_tab[15] +#define __pyx_kp_u__5 __pyx_string_tab[16] +#define __pyx_kp_u_add_note __pyx_string_tab[17] +#define __pyx_n_u_all __pyx_string_tab[18] +#define __pyx_n_u_arg __pyx_string_tab[19] +#define __pyx_n_u_asyncio_coroutines __pyx_string_tab[20] +#define __pyx_kp_u_at __pyx_string_tab[21] +#define __pyx_n_u_c_call __pyx_string_tab[22] +#define __pyx_n_u_c_exception __pyx_string_tab[23] +#define __pyx_n_u_c_return __pyx_string_tab[24] +#define __pyx_n_u_call __pyx_string_tab[25] +#define __pyx_n_u_call_2 __pyx_string_tab[26] +#define __pyx_n_u_cinit __pyx_string_tab[27] +#define __pyx_n_u_cline_in_traceback __pyx_string_tab[28] +#define __pyx_n_u_dealloc __pyx_string_tab[29] +#define __pyx_n_u_default_stream __pyx_string_tab[30] +#define __pyx_kp_u_disable __pyx_string_tab[31] +#define __pyx_kp_u_enable __pyx_string_tab[32] +#define __pyx_n_u_enter __pyx_string_tab[33] +#define __pyx_n_u_exc_tb __pyx_string_tab[34] +#define __pyx_n_u_exc_type __pyx_string_tab[35] +#define __pyx_n_u_exc_val __pyx_string_tab[36] +#define __pyx_n_u_exception __pyx_string_tab[37] +#define __pyx_n_u_exit __pyx_string_tab[38] +#define __pyx_n_u_f_trace __pyx_string_tab[39] +#define __pyx_kp_u_failed __pyx_string_tab[40] +#define __pyx_n_u_file __pyx_string_tab[41] +#define __pyx_n_u_frame __pyx_string_tab[42] +#define __pyx_n_u_func __pyx_string_tab[43] +#define __pyx_kp_u_gc __pyx_string_tab[44] +#define __pyx_n_u_get __pyx_string_tab[45] +#define __pyx_n_u_getstate __pyx_string_tab[46] +#define __pyx_kp_u_handler __pyx_string_tab[47] +#define __pyx_n_u_hunter __pyx_string_tab[48] +#define __pyx_n_u_hunter__tracer __pyx_string_tab[49] +#define __pyx_kp_u_hunter__tracer_Tracer_at_0x __pyx_string_tab[50] +#define __pyx_n_u_id __pyx_string_tab[51] +#define __pyx_n_u_initializing __pyx_string_tab[52] +#define __pyx_n_u_is_coroutine __pyx_string_tab[53] +#define __pyx_kp_u_isenabled __pyx_string_tab[54] +#define __pyx_n_u_kind __pyx_string_tab[55] +#define __pyx_n_u_line __pyx_string_tab[56] +#define __pyx_n_u_main __pyx_string_tab[57] +#define __pyx_n_u_module __pyx_string_tab[58] +#define __pyx_n_u_name __pyx_string_tab[59] +#define __pyx_kp_u_no_default___reduce___due_to_non __pyx_string_tab[60] +#define __pyx_n_u_pop __pyx_string_tab[61] +#define __pyx_n_u_predicate __pyx_string_tab[62] +#define __pyx_kp_u_previous __pyx_string_tab[63] +#define __pyx_n_u_print_exc __pyx_string_tab[64] +#define __pyx_n_u_profile_hook __pyx_string_tab[65] +#define __pyx_n_u_profiling_mode __pyx_string_tab[66] +#define __pyx_n_u_pyx_state __pyx_string_tab[67] +#define __pyx_n_u_pyx_vtable __pyx_string_tab[68] +#define __pyx_n_u_qualname __pyx_string_tab[69] +#define __pyx_n_u_reduce __pyx_string_tab[70] +#define __pyx_n_u_reduce_cython __pyx_string_tab[71] +#define __pyx_n_u_reduce_ex __pyx_string_tab[72] +#define __pyx_n_u_repr __pyx_string_tab[73] +#define __pyx_n_u_return __pyx_string_tab[74] +#define __pyx_n_u_self __pyx_string_tab[75] +#define __pyx_n_u_set_name __pyx_string_tab[76] +#define __pyx_n_u_setprofile __pyx_string_tab[77] +#define __pyx_n_u_setstate __pyx_string_tab[78] +#define __pyx_n_u_setstate_cython __pyx_string_tab[79] +#define __pyx_n_u_settrace __pyx_string_tab[80] +#define __pyx_n_u_spec __pyx_string_tab[81] +#define __pyx_kp_u_src_hunter__tracer_pxd __pyx_string_tab[82] +#define __pyx_kp_u_src_hunter__tracer_pyx __pyx_string_tab[83] +#define __pyx_n_u_state __pyx_string_tab[84] +#define __pyx_n_u_stop __pyx_string_tab[85] +#define __pyx_kp_u_stopped __pyx_string_tab[86] +#define __pyx_kp_u_stringsource __pyx_string_tab[87] +#define __pyx_n_u_test __pyx_string_tab[88] +#define __pyx_n_u_threading __pyx_string_tab[89] +#define __pyx_n_u_threading_support __pyx_string_tab[90] +#define __pyx_kp_u_threading_support_2 __pyx_string_tab[91] +#define __pyx_n_u_trace __pyx_string_tab[92] +#define __pyx_n_u_trace_func __pyx_string_tab[93] +#define __pyx_n_u_trace_hook __pyx_string_tab[94] +#define __pyx_n_u_traceback __pyx_string_tab[95] +#define __pyx_n_u_tracer __pyx_string_tab[96] +#define __pyx_n_u_write __pyx_string_tab[97] +#define __pyx_n_u_x __pyx_string_tab[98] +/* #### Code section: module_state_clear ### */ +#if CYTHON_USE_MODULE_STATE +static CYTHON_SMALL_CODE int __pyx_m_clear(PyObject *m) { + __pyx_mstatetype *clear_module_state = __Pyx_PyModule_GetState(m); + if (!clear_module_state) return 0; + Py_CLEAR(clear_module_state->__pyx_d); + Py_CLEAR(clear_module_state->__pyx_b); + Py_CLEAR(clear_module_state->__pyx_cython_runtime); + Py_CLEAR(clear_module_state->__pyx_empty_tuple); + Py_CLEAR(clear_module_state->__pyx_empty_bytes); + Py_CLEAR(clear_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_CLEAR(clear_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_CLEAR(clear_module_state->__pyx_FusedFunctionType); + #endif + #if CYTHON_PEP489_MULTI_PHASE_INIT + __Pyx_State_RemoveModule(NULL); + #endif + Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_4type_type); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_6_event_CodeType); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_6_event_Event); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_11_predicates_Query); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_11_predicates_And); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_11_predicates_Or); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_11_predicates_Not); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_11_predicates_When); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_11_predicates_From); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_11_predicates_Backlog); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_7_tracer_CodeType); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_7_tracer_Tracer); + Py_CLEAR(clear_module_state->__pyx_type_6hunter_7_tracer_Tracer); + for (int i=0; i<1; ++i) { Py_CLEAR(clear_module_state->__pyx_tuple[i]); } + for (int i=0; i<18; ++i) { Py_CLEAR(clear_module_state->__pyx_codeobj_tab[i]); } + for (int i=0; i<99; ++i) { Py_CLEAR(clear_module_state->__pyx_string_tab[i]); } + Py_CLEAR(clear_module_state->__pyx_int_0); + Py_CLEAR(clear_module_state->__pyx_int_1); + Py_CLEAR(clear_module_state->__pyx_int_2); + Py_CLEAR(clear_module_state->__pyx_int_3); + Py_CLEAR(clear_module_state->__pyx_int_4); + Py_CLEAR(clear_module_state->__pyx_int_5); + Py_CLEAR(clear_module_state->__pyx_int_6); + return 0; +} +#endif +/* #### Code section: module_state_traverse ### */ +#if CYTHON_USE_MODULE_STATE +static CYTHON_SMALL_CODE int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { + __pyx_mstatetype *traverse_module_state = __Pyx_PyModule_GetState(m); + if (!traverse_module_state) return 0; + Py_VISIT(traverse_module_state->__pyx_d); + Py_VISIT(traverse_module_state->__pyx_b); + Py_VISIT(traverse_module_state->__pyx_cython_runtime); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_tuple); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_bytes); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_VISIT(traverse_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_VISIT(traverse_module_state->__pyx_FusedFunctionType); + #endif + Py_VISIT(traverse_module_state->__pyx_ptype_7cpython_4type_type); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_6_event_CodeType); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_6_event_Event); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_11_predicates_Query); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_11_predicates_And); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_11_predicates_Or); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_11_predicates_Not); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_11_predicates_When); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_11_predicates_From); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_11_predicates_Backlog); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_7_tracer_CodeType); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_7_tracer_Tracer); + Py_VISIT(traverse_module_state->__pyx_type_6hunter_7_tracer_Tracer); + for (int i=0; i<1; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_tuple[i]); } + for (int i=0; i<18; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_codeobj_tab[i]); } + for (int i=0; i<99; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_string_tab[i]); } + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_0); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_1); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_2); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_3); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_4); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_5); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_6); + return 0; +} +#endif +/* #### Code section: module_code ### */ /* "hunter/_tracer.pyx":24 + * } * - * - * cdef int trace_func(Tracer self, FrameType frame, int kind, PyObject *arg) except -1: # <<<<<<<<<<<<<< - * if frame.f_trace is not self: - * Py_CLEAR(frame.f_trace) - */ - -static int __pyx_f_6hunter_7_tracer_trace_func(struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self, PyFrameObject *__pyx_v_frame, int __pyx_v_kind, PyObject *__pyx_v_arg) { + * cdef int trace_func(PyObject* tracer, PyFrameObject* frame, int kind, PyObject* arg) noexcept: # <<<<<<<<<<<<<< + * cdef Tracer self = tracer + * cdef FrameType frame_object = frame +*/ + +static int __pyx_f_6hunter_7_tracer_trace_func(PyObject *__pyx_v_tracer, PyFrameObject *__pyx_v_frame, int __pyx_v_kind, PyObject *__pyx_v_arg) { + struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self = 0; + FrameType __pyx_v_frame_object = 0; PyObject *__pyx_v_handler = NULL; struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event = 0; PyObject *__pyx_v_exc = NULL; int __pyx_r; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; - int __pyx_t_9; - PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_9 = NULL; + size_t __pyx_t_10; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; - PyObject *__pyx_t_14 = NULL; + int __pyx_t_14; PyObject *__pyx_t_15 = NULL; - int __pyx_t_16; - char const *__pyx_t_17; + PyObject *__pyx_t_16 = NULL; + PyObject *__pyx_t_17[7]; PyObject *__pyx_t_18 = NULL; - PyObject *__pyx_t_19 = NULL; - PyObject *__pyx_t_20 = NULL; + int __pyx_t_19; + char const *__pyx_t_20; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; PyObject *__pyx_t_23 = NULL; + PyObject *__pyx_t_24 = NULL; + PyObject *__pyx_t_25 = NULL; + PyObject *__pyx_t_26 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[0])) __Pyx_RefNannySetupContext("trace_func", 0); - __Pyx_TraceCall("trace_func", __pyx_f[0], 24, 0, __PYX_ERR(0, 24, __pyx_L1_error)); + __Pyx_TraceStartFunc("trace_func", __pyx_f[0], 24, 0, 0, 0, __PYX_ERR(0, 24, __pyx_L1_error)); /* "hunter/_tracer.pyx":25 * - * cdef int trace_func(Tracer self, FrameType frame, int kind, PyObject *arg) except -1: - * if frame.f_trace is not self: # <<<<<<<<<<<<<< - * Py_CLEAR(frame.f_trace) - * Py_INCREF(self) - */ - __Pyx_TraceLine(25,0,__PYX_ERR(0, 25, __pyx_L1_error)) - __pyx_t_1 = ((__pyx_v_frame->f_trace != ((PyObject *)__pyx_v_self)) != 0); - if (__pyx_t_1) { + * cdef int trace_func(PyObject* tracer, PyFrameObject* frame, int kind, PyObject* arg) noexcept: + * cdef Tracer self = tracer # <<<<<<<<<<<<<< + * cdef FrameType frame_object = frame + * +*/ + __Pyx_TraceLine(25,2,0,__PYX_ERR(0, 25, __pyx_L1_error)) + __pyx_t_1 = ((PyObject *)__pyx_v_tracer); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_self = ((struct __pyx_obj_6hunter_7_tracer_Tracer *)__pyx_t_1); + __pyx_t_1 = 0; - /* "hunter/_tracer.pyx":26 - * cdef int trace_func(Tracer self, FrameType frame, int kind, PyObject *arg) except -1: - * if frame.f_trace is not self: - * Py_CLEAR(frame.f_trace) # <<<<<<<<<<<<<< - * Py_INCREF(self) - * frame.f_trace = self - */ - __Pyx_TraceLine(26,0,__PYX_ERR(0, 26, __pyx_L1_error)) - Py_CLEAR(__pyx_v_frame->f_trace); - - /* "hunter/_tracer.pyx":27 - * if frame.f_trace is not self: - * Py_CLEAR(frame.f_trace) - * Py_INCREF(self) # <<<<<<<<<<<<<< - * frame.f_trace = self + /* "hunter/_tracer.pyx":26 + * cdef int trace_func(PyObject* tracer, PyFrameObject* frame, int kind, PyObject* arg) noexcept: + * cdef Tracer self = tracer + * cdef FrameType frame_object = frame # <<<<<<<<<<<<<< * - */ - __Pyx_TraceLine(27,0,__PYX_ERR(0, 27, __pyx_L1_error)) - Py_INCREF(((PyObject *)__pyx_v_self)); + * frame_object.f_trace = self +*/ + __Pyx_TraceLine(26,5,0,__PYX_ERR(0, 26, __pyx_L1_error)) + __pyx_t_1 = ((PyObject *)__pyx_v_frame); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_frame_object = ((FrameType)__pyx_t_1); + __pyx_t_1 = 0; - /* "hunter/_tracer.pyx":28 - * Py_CLEAR(frame.f_trace) - * Py_INCREF(self) - * frame.f_trace = self # <<<<<<<<<<<<<< + /* "hunter/_tracer.pyx":28 + * cdef FrameType frame_object = frame * + * frame_object.f_trace = self # <<<<<<<<<<<<<< * handler = self.handler - */ - __Pyx_TraceLine(28,0,__PYX_ERR(0, 28, __pyx_L1_error)) - __pyx_v_frame->f_trace = ((PyObject *)__pyx_v_self); - - /* "hunter/_tracer.pyx":25 * - * cdef int trace_func(Tracer self, FrameType frame, int kind, PyObject *arg) except -1: - * if frame.f_trace is not self: # <<<<<<<<<<<<<< - * Py_CLEAR(frame.f_trace) - * Py_INCREF(self) - */ - } +*/ + __Pyx_TraceLine(28,7,0,__PYX_ERR(0, 28, __pyx_L1_error)) + if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_frame_object), __pyx_mstate_global->__pyx_n_u_f_trace, ((PyObject *)__pyx_v_self)) < 0) __PYX_ERR(0, 28, __pyx_L1_error) - /* "hunter/_tracer.pyx":30 - * frame.f_trace = self + /* "hunter/_tracer.pyx":29 * + * frame_object.f_trace = self * handler = self.handler # <<<<<<<<<<<<<< * + * if handler is None: # the tracer was stopped +*/ + __Pyx_TraceLine(29,12,0,__PYX_ERR(0, 29, __pyx_L1_error)) + __pyx_t_1 = __pyx_v_self->handler; + __Pyx_INCREF(__pyx_t_1); + __pyx_v_handler = __pyx_t_1; + __pyx_t_1 = 0; + + /* "hunter/_tracer.pyx":31 + * handler = self.handler + * + * if handler is None: # the tracer was stopped # <<<<<<<<<<<<<< + * # make sure it's uninstalled even for running threads + * if self.profiling_mode: +*/ + __Pyx_TraceLine(31,16,0,__PYX_ERR(0, 31, __pyx_L1_error)) + __pyx_t_2 = (__pyx_v_handler == Py_None); + if (__pyx_t_2) { + + /* "hunter/_tracer.pyx":33 + * if handler is None: # the tracer was stopped + * # make sure it's uninstalled even for running threads + * if self.profiling_mode: # <<<<<<<<<<<<<< + * PyEval_SetProfile(NULL, NULL) + * else: +*/ + __Pyx_TraceLine(33,18,0,__PYX_ERR(0, 33, __pyx_L1_error)) + if (__pyx_v_self->profiling_mode) { + + /* "hunter/_tracer.pyx":34 + * # make sure it's uninstalled even for running threads + * if self.profiling_mode: + * PyEval_SetProfile(NULL, NULL) # <<<<<<<<<<<<<< + * else: + * PyEval_SetTrace(NULL, NULL) +*/ + __Pyx_TraceLine(34,21,0,__PYX_ERR(0, 34, __pyx_L1_error)) + PyEval_SetProfile(NULL, NULL); + + /* "hunter/_tracer.pyx":33 + * if handler is None: # the tracer was stopped + * # make sure it's uninstalled even for running threads + * if self.profiling_mode: # <<<<<<<<<<<<<< + * PyEval_SetProfile(NULL, NULL) + * else: +*/ + goto __pyx_L4; + } + + /* "hunter/_tracer.pyx":36 + * PyEval_SetProfile(NULL, NULL) + * else: + * PyEval_SetTrace(NULL, NULL) # <<<<<<<<<<<<<< + * return 0 + * +*/ + __Pyx_TraceLine(36,25,0,__PYX_ERR(0, 36, __pyx_L1_error)) + /*else*/ { + PyEval_SetTrace(NULL, NULL); + } + __pyx_L4:; + + /* "hunter/_tracer.pyx":37 + * else: + * PyEval_SetTrace(NULL, NULL) + * return 0 # <<<<<<<<<<<<<< + * * if kind == 3 and self.depth > 0: - */ - __Pyx_TraceLine(30,0,__PYX_ERR(0, 30, __pyx_L1_error)) - __pyx_t_2 = __pyx_v_self->handler; - __Pyx_INCREF(__pyx_t_2); - __pyx_v_handler = __pyx_t_2; - __pyx_t_2 = 0; +*/ + __Pyx_TraceLine(37,28,0,__PYX_ERR(0, 37, __pyx_L1_error)) + __pyx_r = 0; + __Pyx_TraceReturnCValue(__pyx_r, __Pyx_PyLong_From_int, 28, 0, __PYX_ERR(0, 37, __pyx_L1_error)); + goto __pyx_L0; - /* "hunter/_tracer.pyx":32 + /* "hunter/_tracer.pyx":31 * handler = self.handler * + * if handler is None: # the tracer was stopped # <<<<<<<<<<<<<< + * # make sure it's uninstalled even for running threads + * if self.profiling_mode: +*/ + } + + /* "hunter/_tracer.pyx":39 + * return 0 + * * if kind == 3 and self.depth > 0: # <<<<<<<<<<<<<< * self.depth -= 1 * - */ - __Pyx_TraceLine(32,0,__PYX_ERR(0, 32, __pyx_L1_error)) - __pyx_t_3 = ((__pyx_v_kind == 3) != 0); +*/ + __Pyx_TraceLine(39,32,0,__PYX_ERR(0, 39, __pyx_L1_error)) + __pyx_t_3 = (__pyx_v_kind == 3); if (__pyx_t_3) { } else { - __pyx_t_1 = __pyx_t_3; - goto __pyx_L5_bool_binop_done; + __pyx_t_2 = __pyx_t_3; + goto __pyx_L6_bool_binop_done; } - __pyx_t_3 = ((__pyx_v_self->depth > 0) != 0); - __pyx_t_1 = __pyx_t_3; - __pyx_L5_bool_binop_done:; - if (__pyx_t_1) { + __pyx_t_3 = (__pyx_v_self->depth > 0); + __pyx_t_2 = __pyx_t_3; + __pyx_L6_bool_binop_done:; + if (__pyx_t_2) { - /* "hunter/_tracer.pyx":33 + /* "hunter/_tracer.pyx":40 * * if kind == 3 and self.depth > 0: * self.depth -= 1 # <<<<<<<<<<<<<< * - * cdef Event event = Event(frame, KIND_NAMES[kind], None if arg is NULL else arg, self) - */ - __Pyx_TraceLine(33,0,__PYX_ERR(0, 33, __pyx_L1_error)) + * cdef Event event = Event( frame, kind, None if arg is NULL else arg, self.depth, self.calls, self.threading_support) +*/ + __Pyx_TraceLine(40,39,0,__PYX_ERR(0, 40, __pyx_L1_error)) __pyx_v_self->depth = (__pyx_v_self->depth - 1); - /* "hunter/_tracer.pyx":32 - * handler = self.handler + /* "hunter/_tracer.pyx":39 + * return 0 * * if kind == 3 and self.depth > 0: # <<<<<<<<<<<<<< * self.depth -= 1 * - */ +*/ } - /* "hunter/_tracer.pyx":35 + /* "hunter/_tracer.pyx":42 * self.depth -= 1 * - * cdef Event event = Event(frame, KIND_NAMES[kind], None if arg is NULL else arg, self) # <<<<<<<<<<<<<< - * + * cdef Event event = Event( frame, kind, None if arg is NULL else arg, self.depth, self.calls, self.threading_support) # <<<<<<<<<<<<<< * try: - */ - __Pyx_TraceLine(35,0,__PYX_ERR(0, 35, __pyx_L1_error)) - if (unlikely(__pyx_v_6hunter_7_tracer_KIND_NAMES == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(0, 35, __pyx_L1_error) - } - __pyx_t_2 = __Pyx_GetItemInt_Tuple(__pyx_v_6hunter_7_tracer_KIND_NAMES, __pyx_v_kind, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 35, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (((__pyx_v_arg == NULL) != 0)) { + * fast_call(handler, event) +*/ + __Pyx_TraceLine(42,44,0,__PYX_ERR(0, 42, __pyx_L1_error)) + __pyx_t_4 = NULL; + __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_6_event_Event); + __pyx_t_5 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_6hunter_6_event_Event); + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_kind); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = (__pyx_v_arg == NULL); + if (__pyx_t_2) { __Pyx_INCREF(Py_None); - __pyx_t_4 = Py_None; + __pyx_t_7 = Py_None; } else { __Pyx_INCREF(((PyObject *)__pyx_v_arg)); - __pyx_t_4 = ((PyObject *)__pyx_v_arg); + __pyx_t_7 = ((PyObject *)__pyx_v_arg); } - __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 35, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_INCREF(((PyObject *)__pyx_v_frame)); - __Pyx_GIVEREF(((PyObject *)__pyx_v_frame)); - PyTuple_SET_ITEM(__pyx_t_5, 0, ((PyObject *)__pyx_v_frame)); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_4); - __Pyx_INCREF(((PyObject *)__pyx_v_self)); - __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); - PyTuple_SET_ITEM(__pyx_t_5, 3, ((PyObject *)__pyx_v_self)); - __pyx_t_2 = 0; - __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_6_event_Event), __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 35, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_event = ((struct __pyx_obj_6hunter_6_event_Event *)__pyx_t_4); - __pyx_t_4 = 0; + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_self->depth); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyLong_From_int(__pyx_v_self->calls); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = 1; + { + PyObject *__pyx_callargs[7] = {__pyx_t_4, ((PyObject *)__pyx_v_frame), __pyx_t_6, __pyx_t_7, __pyx_t_8, __pyx_t_9, __pyx_v_self->threading_support}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_10, (7-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_1); + } + __pyx_v_event = ((struct __pyx_obj_6hunter_6_event_Event *)__pyx_t_1); + __pyx_t_1 = 0; - /* "hunter/_tracer.pyx":37 - * cdef Event event = Event(frame, KIND_NAMES[kind], None if arg is NULL else arg, self) + /* "hunter/_tracer.pyx":43 * + * cdef Event event = Event( frame, kind, None if arg is NULL else arg, self.depth, self.calls, self.threading_support) * try: # <<<<<<<<<<<<<< * fast_call(handler, event) * except Exception as exc: - */ - __Pyx_TraceLine(37,0,__PYX_ERR(0, 37, __pyx_L1_error)) +*/ + __Pyx_TraceLine(43,60,0,__PYX_ERR(0, 43, __pyx_L1_error)) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8); - __Pyx_XGOTREF(__pyx_t_6); - __Pyx_XGOTREF(__pyx_t_7); - __Pyx_XGOTREF(__pyx_t_8); + __Pyx_ExceptionSave(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13); + __Pyx_XGOTREF(__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_12); + __Pyx_XGOTREF(__pyx_t_13); /*try:*/ { - /* "hunter/_tracer.pyx":38 - * + /* "hunter/_tracer.pyx":44 + * cdef Event event = Event( frame, kind, None if arg is NULL else arg, self.depth, self.calls, self.threading_support) * try: * fast_call(handler, event) # <<<<<<<<<<<<<< * except Exception as exc: * traceback.print_exc(file=hunter._default_stream) - */ - __Pyx_TraceLine(38,0,__PYX_ERR(0, 38, __pyx_L7_error)) - __pyx_t_4 = __pyx_f_6hunter_11_predicates_fast_call(__pyx_v_handler, __pyx_v_event); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 38, __pyx_L7_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; +*/ + __Pyx_TraceLine(44,62,0,__PYX_ERR(0, 44, __pyx_L8_error)) + __pyx_t_1 = __pyx_f_6hunter_11_predicates_fast_call(__pyx_v_handler, __pyx_v_event); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 44, __pyx_L8_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "hunter/_tracer.pyx":37 - * cdef Event event = Event(frame, KIND_NAMES[kind], None if arg is NULL else arg, self) + /* "hunter/_tracer.pyx":43 * + * cdef Event event = Event( frame, kind, None if arg is NULL else arg, self.depth, self.calls, self.threading_support) * try: # <<<<<<<<<<<<<< * fast_call(handler, event) * except Exception as exc: - */ - } +*/ + } + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + goto __pyx_L13_try_end; + __pyx_L8_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - goto __pyx_L12_try_end; - __pyx_L7_error:; - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_TraceException(__pyx_lineno, 0, 0); - /* "hunter/_tracer.pyx":39 + /* "hunter/_tracer.pyx":45 * try: * fast_call(handler, event) * except Exception as exc: # <<<<<<<<<<<<<< * traceback.print_exc(file=hunter._default_stream) - * hunter._default_stream.write('Disabling tracer because handler {} failed ({!r}).\n\n'.format( - */ - __Pyx_TraceLine(39,0,__PYX_ERR(0, 39, __pyx_L9_except_error)) - __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); - if (__pyx_t_9) { + * hunter._default_stream.write('Disabling tracer because handler %r failed (%r) at %r.\n\n' % ( +*/ + __Pyx_TraceLine(45,66,0,__PYX_ERR(0, 45, __pyx_L10_except_error)) + __pyx_t_14 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception)))); + if (__pyx_t_14) { __Pyx_AddTraceback("hunter._tracer.trace_func", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_5, &__pyx_t_2) < 0) __PYX_ERR(0, 39, __pyx_L9_except_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GOTREF(__pyx_t_2); + __Pyx_TraceExceptionHandled(65); + if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_5, &__pyx_t_9) < 0) __PYX_ERR(0, 45, __pyx_L10_except_error) + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_9); + __Pyx_TraceExceptionDone(); __Pyx_INCREF(__pyx_t_5); __pyx_v_exc = __pyx_t_5; /*try:*/ { - /* "hunter/_tracer.pyx":40 + /* "hunter/_tracer.pyx":46 * fast_call(handler, event) * except Exception as exc: * traceback.print_exc(file=hunter._default_stream) # <<<<<<<<<<<<<< - * hunter._default_stream.write('Disabling tracer because handler {} failed ({!r}).\n\n'.format( - * handler, exc)) - */ - __Pyx_TraceLine(40,0,__PYX_ERR(0, 40, __pyx_L18_error)) - __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_traceback); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 40, __pyx_L18_error) - __Pyx_GOTREF(__pyx_t_10); - __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_print_exc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 40, __pyx_L18_error) - __Pyx_GOTREF(__pyx_t_11); - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_t_10 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 40, __pyx_L18_error) - __Pyx_GOTREF(__pyx_t_10); - __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_n_s_hunter); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 40, __pyx_L18_error) - __Pyx_GOTREF(__pyx_t_12); - __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_n_s_default_stream); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 40, __pyx_L18_error) - __Pyx_GOTREF(__pyx_t_13); - __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_file, __pyx_t_13) < 0) __PYX_ERR(0, 40, __pyx_L18_error) - __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; - __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_empty_tuple, __pyx_t_10); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 40, __pyx_L18_error) - __Pyx_GOTREF(__pyx_t_13); - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; - - /* "hunter/_tracer.pyx":41 + * hunter._default_stream.write('Disabling tracer because handler %r failed (%r) at %r.\n\n' % ( + * handler, exc, event)) +*/ + __Pyx_TraceLine(46,70,0,__PYX_ERR(0, 46, __pyx_L19_error)) + __pyx_t_7 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_traceback); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 46, __pyx_L19_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_print_exc); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 46, __pyx_L19_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_hunter); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 46, __pyx_L19_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_default_stream); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 46, __pyx_L19_error) + __Pyx_GOTREF(__pyx_t_15); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_10 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_7); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_10 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_7, NULL}; + __pyx_t_6 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 46, __pyx_L19_error) + __Pyx_GOTREF(__pyx_t_6); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_file, __pyx_t_15, __pyx_t_6, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 46, __pyx_L19_error) + __pyx_t_8 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_4, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 46, __pyx_L19_error) + __Pyx_GOTREF(__pyx_t_8); + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "hunter/_tracer.pyx":47 * except Exception as exc: * traceback.print_exc(file=hunter._default_stream) - * hunter._default_stream.write('Disabling tracer because handler {} failed ({!r}).\n\n'.format( # <<<<<<<<<<<<<< - * handler, exc)) + * hunter._default_stream.write('Disabling tracer because handler %r failed (%r) at %r.\n\n' % ( # <<<<<<<<<<<<<< + * handler, exc, event)) * self.stop() - */ - __Pyx_TraceLine(41,0,__PYX_ERR(0, 41, __pyx_L18_error)) - __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_hunter); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 41, __pyx_L18_error) - __Pyx_GOTREF(__pyx_t_10); - __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_default_stream); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 41, __pyx_L18_error) - __Pyx_GOTREF(__pyx_t_11); - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_write); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 41, __pyx_L18_error) - __Pyx_GOTREF(__pyx_t_10); - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Disabling_tracer_because_handler, __pyx_n_s_format); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 41, __pyx_L18_error) - __Pyx_GOTREF(__pyx_t_12); - - /* "hunter/_tracer.pyx":42 +*/ + __Pyx_TraceLine(47,74,0,__PYX_ERR(0, 47, __pyx_L19_error)) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_hunter); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 47, __pyx_L19_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_default_stream); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 47, __pyx_L19_error) + __Pyx_GOTREF(__pyx_t_15); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_4 = __pyx_t_15; + __Pyx_INCREF(__pyx_t_4); + + /* "hunter/_tracer.pyx":48 * traceback.print_exc(file=hunter._default_stream) - * hunter._default_stream.write('Disabling tracer because handler {} failed ({!r}).\n\n'.format( - * handler, exc)) # <<<<<<<<<<<<<< + * hunter._default_stream.write('Disabling tracer because handler %r failed (%r) at %r.\n\n' % ( + * handler, exc, event)) # <<<<<<<<<<<<<< * self.stop() * return 0 - */ - __Pyx_TraceLine(42,0,__PYX_ERR(0, 42, __pyx_L18_error)) - __pyx_t_14 = NULL; - __pyx_t_9 = 0; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_12))) { - __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_12); - if (likely(__pyx_t_14)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12); - __Pyx_INCREF(__pyx_t_14); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_12, function); - __pyx_t_9 = 1; - } - } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_12)) { - PyObject *__pyx_temp[3] = {__pyx_t_14, __pyx_v_handler, __pyx_v_exc}; - __pyx_t_11 = __Pyx_PyFunction_FastCall(__pyx_t_12, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 41, __pyx_L18_error) - __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; - __Pyx_GOTREF(__pyx_t_11); - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_12)) { - PyObject *__pyx_temp[3] = {__pyx_t_14, __pyx_v_handler, __pyx_v_exc}; - __pyx_t_11 = __Pyx_PyCFunction_FastCall(__pyx_t_12, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 41, __pyx_L18_error) - __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; - __Pyx_GOTREF(__pyx_t_11); - } else - #endif +*/ + __Pyx_TraceLine(48,79,0,__PYX_ERR(0, 48, __pyx_L19_error)) + __pyx_t_6 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_handler), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 48, __pyx_L19_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_exc), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 48, __pyx_L19_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_16 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(((PyObject *)__pyx_v_event)), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 48, __pyx_L19_error) + __Pyx_GOTREF(__pyx_t_16); + __pyx_t_17[0] = __pyx_mstate_global->__pyx_kp_u_Disabling_tracer_because_handler; + __pyx_t_17[1] = __pyx_t_6; + __pyx_t_17[2] = __pyx_mstate_global->__pyx_kp_u_failed; + __pyx_t_17[3] = __pyx_t_7; + __pyx_t_17[4] = __pyx_mstate_global->__pyx_kp_u_at; + __pyx_t_17[5] = __pyx_t_16; + __pyx_t_17[6] = __pyx_mstate_global->__pyx_kp_u_; + + /* "hunter/_tracer.pyx":47 + * except Exception as exc: + * traceback.print_exc(file=hunter._default_stream) + * hunter._default_stream.write('Disabling tracer because handler %r failed (%r) at %r.\n\n' % ( # <<<<<<<<<<<<<< + * handler, exc, event)) + * self.stop() +*/ + __Pyx_TraceLine(47,78,0,__PYX_ERR(0, 47, __pyx_L19_error)) + __pyx_t_18 = __Pyx_PyUnicode_Join(__pyx_t_17, 7, 33 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6) + 9 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7) + 5 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_16) + 3, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_16)); + if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 47, __pyx_L19_error) + __Pyx_GOTREF(__pyx_t_18); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_10 = 0; { - __pyx_t_15 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 41, __pyx_L18_error) - __Pyx_GOTREF(__pyx_t_15); - if (__pyx_t_14) { - __Pyx_GIVEREF(__pyx_t_14); PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_14); __pyx_t_14 = NULL; - } - __Pyx_INCREF(__pyx_v_handler); - __Pyx_GIVEREF(__pyx_v_handler); - PyTuple_SET_ITEM(__pyx_t_15, 0+__pyx_t_9, __pyx_v_handler); - __Pyx_INCREF(__pyx_v_exc); - __Pyx_GIVEREF(__pyx_v_exc); - PyTuple_SET_ITEM(__pyx_t_15, 1+__pyx_t_9, __pyx_v_exc); - __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_15, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 41, __pyx_L18_error) - __Pyx_GOTREF(__pyx_t_11); + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_18}; + __pyx_t_8 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_write, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 47, __pyx_L19_error) + __Pyx_GOTREF(__pyx_t_8); } - __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; - __pyx_t_12 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_10))) { - __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_10); - if (likely(__pyx_t_12)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10); - __Pyx_INCREF(__pyx_t_12); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_10, function); - } - } - __pyx_t_13 = (__pyx_t_12) ? __Pyx_PyObject_Call2Args(__pyx_t_10, __pyx_t_12, __pyx_t_11) : __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_11); - __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 41, __pyx_L18_error) - __Pyx_GOTREF(__pyx_t_13); - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; - - /* "hunter/_tracer.pyx":43 - * hunter._default_stream.write('Disabling tracer because handler {} failed ({!r}).\n\n'.format( - * handler, exc)) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "hunter/_tracer.pyx":49 + * hunter._default_stream.write('Disabling tracer because handler %r failed (%r) at %r.\n\n' % ( + * handler, exc, event)) * self.stop() # <<<<<<<<<<<<<< * return 0 * - */ - __Pyx_TraceLine(43,0,__PYX_ERR(0, 43, __pyx_L18_error)) - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_stop); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 43, __pyx_L18_error) - __Pyx_GOTREF(__pyx_t_10); - __pyx_t_11 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_10))) { - __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_10); - if (likely(__pyx_t_11)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10); - __Pyx_INCREF(__pyx_t_11); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_10, function); - } +*/ + __Pyx_TraceLine(49,82,0,__PYX_ERR(0, 49, __pyx_L19_error)) + __pyx_t_15 = ((PyObject *)__pyx_v_self); + __Pyx_INCREF(__pyx_t_15); + __pyx_t_10 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_15, NULL}; + __pyx_t_8 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_stop, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 49, __pyx_L19_error) + __Pyx_GOTREF(__pyx_t_8); } - __pyx_t_13 = (__pyx_t_11) ? __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_11) : __Pyx_PyObject_CallNoArg(__pyx_t_10); - __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; - if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 43, __pyx_L18_error) - __Pyx_GOTREF(__pyx_t_13); - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "hunter/_tracer.pyx":44 - * handler, exc)) + /* "hunter/_tracer.pyx":50 + * handler, exc, event)) * self.stop() * return 0 # <<<<<<<<<<<<<< * * if kind == 0: - */ - __Pyx_TraceLine(44,0,__PYX_ERR(0, 44, __pyx_L18_error)) +*/ + __Pyx_TraceLine(50,85,0,__PYX_ERR(0, 50, __pyx_L19_error)) __pyx_r = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_TraceReturnCValue(__pyx_r, __Pyx_PyLong_From_int, 85, 0, __PYX_ERR(0, 50, __pyx_L19_error)); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - goto __pyx_L17_return; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L18_return; } - /* "hunter/_tracer.pyx":39 + /* "hunter/_tracer.pyx":45 * try: * fast_call(handler, event) * except Exception as exc: # <<<<<<<<<<<<<< * traceback.print_exc(file=hunter._default_stream) - * hunter._default_stream.write('Disabling tracer because handler {} failed ({!r}).\n\n'.format( - */ - __Pyx_TraceLine(39,0,__PYX_ERR(0, 39, __pyx_L18_error)) + * hunter._default_stream.write('Disabling tracer because handler %r failed (%r) at %r.\n\n' % ( +*/ + __Pyx_TraceLine(45,65,0,__PYX_ERR(0, 45, __pyx_L19_error)) /*finally:*/ { - __pyx_L18_error:; + __pyx_L19_error:; /*exception exit:*/{ __Pyx_PyThreadState_declare + __Pyx_TraceException(__pyx_lineno, 0, 0); + __Pyx_TraceExceptionHandled(65); __Pyx_PyThreadState_assign - __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0; - __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; - __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; - __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; - __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; - __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0; __pyx_t_24 = 0; __pyx_t_25 = 0; __pyx_t_26 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_21, &__pyx_t_22, &__pyx_t_23); - if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20) < 0)) __Pyx_ErrFetch(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20); - __Pyx_XGOTREF(__pyx_t_18); - __Pyx_XGOTREF(__pyx_t_19); - __Pyx_XGOTREF(__pyx_t_20); + __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_ExceptionSwap(&__pyx_t_24, &__pyx_t_25, &__pyx_t_26); + if ( unlikely(__Pyx_GetException(&__pyx_t_21, &__pyx_t_22, &__pyx_t_23) < 0)) __Pyx_ErrFetch(&__pyx_t_21, &__pyx_t_22, &__pyx_t_23); __Pyx_XGOTREF(__pyx_t_21); __Pyx_XGOTREF(__pyx_t_22); __Pyx_XGOTREF(__pyx_t_23); - __pyx_t_9 = __pyx_lineno; __pyx_t_16 = __pyx_clineno; __pyx_t_17 = __pyx_filename; + __Pyx_XGOTREF(__pyx_t_24); + __Pyx_XGOTREF(__pyx_t_25); + __Pyx_XGOTREF(__pyx_t_26); + __pyx_t_14 = __pyx_lineno; __pyx_t_19 = __pyx_clineno; __pyx_t_20 = __pyx_filename; { - __Pyx_DECREF(__pyx_v_exc); - __pyx_v_exc = NULL; - } - if (PY_MAJOR_VERSION >= 3) { - __Pyx_XGIVEREF(__pyx_t_21); - __Pyx_XGIVEREF(__pyx_t_22); - __Pyx_XGIVEREF(__pyx_t_23); - __Pyx_ExceptionReset(__pyx_t_21, __pyx_t_22, __pyx_t_23); + __Pyx_DECREF(__pyx_v_exc); __pyx_v_exc = 0; } - __Pyx_XGIVEREF(__pyx_t_18); - __Pyx_XGIVEREF(__pyx_t_19); - __Pyx_XGIVEREF(__pyx_t_20); - __Pyx_ErrRestore(__pyx_t_18, __pyx_t_19, __pyx_t_20); - __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0; - __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_16; __pyx_filename = __pyx_t_17; - goto __pyx_L9_except_error; - } - __pyx_L17_return: { - __pyx_t_16 = __pyx_r; - __Pyx_DECREF(__pyx_v_exc); - __pyx_v_exc = NULL; - __pyx_r = __pyx_t_16; - goto __pyx_L10_except_return; + __Pyx_XGIVEREF(__pyx_t_24); + __Pyx_XGIVEREF(__pyx_t_25); + __Pyx_XGIVEREF(__pyx_t_26); + __Pyx_ExceptionReset(__pyx_t_24, __pyx_t_25, __pyx_t_26); + __Pyx_XGIVEREF(__pyx_t_21); + __Pyx_XGIVEREF(__pyx_t_22); + __Pyx_XGIVEREF(__pyx_t_23); + __Pyx_ErrRestore(__pyx_t_21, __pyx_t_22, __pyx_t_23); + __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0; __pyx_t_24 = 0; __pyx_t_25 = 0; __pyx_t_26 = 0; + __pyx_lineno = __pyx_t_14; __pyx_clineno = __pyx_t_19; __pyx_filename = __pyx_t_20; + __Pyx_TraceException(65, 1, 0); + goto __pyx_L10_except_error; + } + __pyx_L18_return: { + __pyx_t_19 = __pyx_r; + __Pyx_DECREF(__pyx_v_exc); __pyx_v_exc = 0; + __pyx_r = __pyx_t_19; + goto __pyx_L11_except_return; } } } - goto __pyx_L9_except_error; - __pyx_L9_except_error:; + goto __pyx_L10_except_error; - /* "hunter/_tracer.pyx":37 - * cdef Event event = Event(frame, KIND_NAMES[kind], None if arg is NULL else arg, self) + /* "hunter/_tracer.pyx":43 * + * cdef Event event = Event( frame, kind, None if arg is NULL else arg, self.depth, self.calls, self.threading_support) * try: # <<<<<<<<<<<<<< * fast_call(handler, event) * except Exception as exc: - */ - __Pyx_XGIVEREF(__pyx_t_6); - __Pyx_XGIVEREF(__pyx_t_7); - __Pyx_XGIVEREF(__pyx_t_8); - __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8); +*/ + __pyx_L10_except_error:; + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13); goto __pyx_L1_error; - __pyx_L10_except_return:; - __Pyx_XGIVEREF(__pyx_t_6); - __Pyx_XGIVEREF(__pyx_t_7); - __Pyx_XGIVEREF(__pyx_t_8); - __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8); + __pyx_L11_except_return:; + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13); goto __pyx_L0; - __pyx_L12_try_end:; + __pyx_L13_try_end:; } - /* "hunter/_tracer.pyx":46 + /* "hunter/_tracer.pyx":52 * return 0 * * if kind == 0: # <<<<<<<<<<<<<< * self.depth += 1 * self.calls += 1 - */ - __Pyx_TraceLine(46,0,__PYX_ERR(0, 46, __pyx_L1_error)) - __pyx_t_1 = ((__pyx_v_kind == 0) != 0); - if (__pyx_t_1) { +*/ + __Pyx_TraceLine(52,89,0,__PYX_ERR(0, 52, __pyx_L1_error)) + __pyx_t_2 = (__pyx_v_kind == 0); + if (__pyx_t_2) { - /* "hunter/_tracer.pyx":47 + /* "hunter/_tracer.pyx":53 * * if kind == 0: * self.depth += 1 # <<<<<<<<<<<<<< * self.calls += 1 - * - */ - __Pyx_TraceLine(47,0,__PYX_ERR(0, 47, __pyx_L1_error)) + * return 0 +*/ + __Pyx_TraceLine(53,91,0,__PYX_ERR(0, 53, __pyx_L1_error)) __pyx_v_self->depth = (__pyx_v_self->depth + 1); - /* "hunter/_tracer.pyx":48 + /* "hunter/_tracer.pyx":54 * if kind == 0: * self.depth += 1 * self.calls += 1 # <<<<<<<<<<<<<< + * return 0 * - * - */ - __Pyx_TraceLine(48,0,__PYX_ERR(0, 48, __pyx_L1_error)) +*/ + __Pyx_TraceLine(54,94,0,__PYX_ERR(0, 54, __pyx_L1_error)) __pyx_v_self->calls = (__pyx_v_self->calls + 1); - /* "hunter/_tracer.pyx":46 + /* "hunter/_tracer.pyx":52 * return 0 * * if kind == 0: # <<<<<<<<<<<<<< * self.depth += 1 * self.calls += 1 - */ +*/ } - /* "hunter/_tracer.pyx":24 + /* "hunter/_tracer.pyx":55 + * self.depth += 1 + * self.calls += 1 + * return 0 # <<<<<<<<<<<<<< * * - * cdef int trace_func(Tracer self, FrameType frame, int kind, PyObject *arg) except -1: # <<<<<<<<<<<<<< - * if frame.f_trace is not self: - * Py_CLEAR(frame.f_trace) - */ - - /* function exit code */ +*/ + __Pyx_TraceLine(55,97,0,__PYX_ERR(0, 55, __pyx_L1_error)) __pyx_r = 0; + __Pyx_TraceReturnCValue(__pyx_r, __Pyx_PyLong_From_int, 97, 0, __PYX_ERR(0, 55, __pyx_L1_error)); goto __pyx_L0; + + /* "hunter/_tracer.pyx":24 + * } + * + * cdef int trace_func(PyObject* tracer, PyFrameObject* frame, int kind, PyObject* arg) noexcept: # <<<<<<<<<<<<<< + * cdef Tracer self = tracer + * cdef FrameType frame_object = frame +*/ + + /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_10); - __Pyx_XDECREF(__pyx_t_11); - __Pyx_XDECREF(__pyx_t_12); - __Pyx_XDECREF(__pyx_t_13); - __Pyx_XDECREF(__pyx_t_14); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_15); - __Pyx_AddTraceback("hunter._tracer.trace_func", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; + __Pyx_XDECREF(__pyx_t_16); + __Pyx_XDECREF(__pyx_t_18); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 24, __pyx_L1_error)); + #endif + __Pyx_WriteUnraisable("hunter._tracer.trace_func", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_self); + __Pyx_XDECREF(__pyx_v_frame_object); __Pyx_XDECREF(__pyx_v_handler); __Pyx_XDECREF((PyObject *)__pyx_v_event); __Pyx_XDECREF(__pyx_v_exc); - __Pyx_TraceReturn(Py_None, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_tracer.pyx":52 +/* "hunter/_tracer.pyx":59 * * cdef class Tracer: - * def __cinit__(self, threading_support=None): # <<<<<<<<<<<<<< + * def __cinit__(self, threading_support=None, profiling_mode=False): # <<<<<<<<<<<<<< * self.handler = None * self.previous = None - */ +*/ /* Python wrapper */ static int __pyx_pw_6hunter_7_tracer_6Tracer_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_6hunter_7_tracer_6Tracer_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_threading_support = 0; + PyObject *__pyx_v_profiling_mode = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_threading_support,0}; - PyObject* values[1] = {0}; - values[0] = ((PyObject *)Py_None); - if (unlikely(__pyx_kwds)) { - Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_threading_support,&__pyx_mstate_global->__pyx_n_u_profiling_mode,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 59, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 2: + values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 59, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 59, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { - case 0: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_threading_support); - if (value) { values[0] = value; kw_args--; } - } - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(0, 52, __pyx_L3_error) - } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__cinit__", 0) < 0) __PYX_ERR(0, 59, __pyx_L3_error) + if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_False)); } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + switch (__pyx_nargs) { + case 2: + values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 59, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 59, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } + if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_False)); } __pyx_v_threading_support = values[0]; + __pyx_v_profiling_mode = values[1]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 52, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 0, 2, __pyx_nargs); __PYX_ERR(0, 59, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } __Pyx_AddTraceback("hunter._tracer.Tracer.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6hunter_7_tracer_6Tracer___cinit__(((struct __pyx_obj_6hunter_7_tracer_Tracer *)__pyx_v_self), __pyx_v_threading_support); + __pyx_r = __pyx_pf_6hunter_7_tracer_6Tracer___cinit__(((struct __pyx_obj_6hunter_7_tracer_Tracer *)__pyx_v_self), __pyx_v_threading_support, __pyx_v_profiling_mode); /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } __Pyx_RefNannyFinishContext(); return __pyx_r; } -static int __pyx_pf_6hunter_7_tracer_6Tracer___cinit__(struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self, PyObject *__pyx_v_threading_support) { +static int __pyx_pf_6hunter_7_tracer_6Tracer___cinit__(struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self, PyObject *__pyx_v_threading_support, PyObject *__pyx_v_profiling_mode) { int __pyx_r; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[1])) __Pyx_RefNannySetupContext("__cinit__", 0); - __Pyx_TraceCall("__cinit__", __pyx_f[0], 52, 0, __PYX_ERR(0, 52, __pyx_L1_error)); + __Pyx_TraceStartFunc("__cinit__", __pyx_f[0], 59, 0, 0, 0, __PYX_ERR(0, 59, __pyx_L1_error)); - /* "hunter/_tracer.pyx":53 + /* "hunter/_tracer.pyx":60 * cdef class Tracer: - * def __cinit__(self, threading_support=None): + * def __cinit__(self, threading_support=None, profiling_mode=False): * self.handler = None # <<<<<<<<<<<<<< * self.previous = None * self._previousfunc = NULL - */ - __Pyx_TraceLine(53,0,__PYX_ERR(0, 53, __pyx_L1_error)) +*/ + __Pyx_TraceLine(60,3,0,__PYX_ERR(0, 60, __pyx_L1_error)) __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->handler); __Pyx_DECREF(__pyx_v_self->handler); __pyx_v_self->handler = Py_None; - /* "hunter/_tracer.pyx":54 - * def __cinit__(self, threading_support=None): + /* "hunter/_tracer.pyx":61 + * def __cinit__(self, threading_support=None, profiling_mode=False): * self.handler = None * self.previous = None # <<<<<<<<<<<<<< * self._previousfunc = NULL * self._threading_previous = None - */ - __Pyx_TraceLine(54,0,__PYX_ERR(0, 54, __pyx_L1_error)) +*/ + __Pyx_TraceLine(61,6,0,__PYX_ERR(0, 61, __pyx_L1_error)) __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->previous); __Pyx_DECREF(__pyx_v_self->previous); __pyx_v_self->previous = Py_None; - /* "hunter/_tracer.pyx":55 + /* "hunter/_tracer.pyx":62 * self.handler = None * self.previous = None * self._previousfunc = NULL # <<<<<<<<<<<<<< * self._threading_previous = None * self.threading_support = threading_support - */ - __Pyx_TraceLine(55,0,__PYX_ERR(0, 55, __pyx_L1_error)) +*/ + __Pyx_TraceLine(62,9,0,__PYX_ERR(0, 62, __pyx_L1_error)) __pyx_v_self->_previousfunc = NULL; - /* "hunter/_tracer.pyx":56 + /* "hunter/_tracer.pyx":63 * self.previous = None * self._previousfunc = NULL * self._threading_previous = None # <<<<<<<<<<<<<< * self.threading_support = threading_support - * self.depth = 0 - */ - __Pyx_TraceLine(56,0,__PYX_ERR(0, 56, __pyx_L1_error)) + * self.profiling_mode = profiling_mode +*/ + __Pyx_TraceLine(63,12,0,__PYX_ERR(0, 63, __pyx_L1_error)) __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->_threading_previous); __Pyx_DECREF(__pyx_v_self->_threading_previous); __pyx_v_self->_threading_previous = Py_None; - /* "hunter/_tracer.pyx":57 + /* "hunter/_tracer.pyx":64 * self._previousfunc = NULL * self._threading_previous = None * self.threading_support = threading_support # <<<<<<<<<<<<<< + * self.profiling_mode = profiling_mode * self.depth = 0 - * self.calls = 0 - */ - __Pyx_TraceLine(57,0,__PYX_ERR(0, 57, __pyx_L1_error)) +*/ + __Pyx_TraceLine(64,15,0,__PYX_ERR(0, 64, __pyx_L1_error)) __Pyx_INCREF(__pyx_v_threading_support); __Pyx_GIVEREF(__pyx_v_threading_support); __Pyx_GOTREF(__pyx_v_self->threading_support); __Pyx_DECREF(__pyx_v_self->threading_support); __pyx_v_self->threading_support = __pyx_v_threading_support; - /* "hunter/_tracer.pyx":58 + /* "hunter/_tracer.pyx":65 * self._threading_previous = None * self.threading_support = threading_support + * self.profiling_mode = profiling_mode # <<<<<<<<<<<<<< + * self.depth = 0 + * self.calls = 0 +*/ + __Pyx_TraceLine(65,20,0,__PYX_ERR(0, 65, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_profiling_mode); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 65, __pyx_L1_error) + __pyx_v_self->profiling_mode = __pyx_t_1; + + /* "hunter/_tracer.pyx":66 + * self.threading_support = threading_support + * self.profiling_mode = profiling_mode * self.depth = 0 # <<<<<<<<<<<<<< * self.calls = 0 * - */ - __Pyx_TraceLine(58,0,__PYX_ERR(0, 58, __pyx_L1_error)) +*/ + __Pyx_TraceLine(66,21,0,__PYX_ERR(0, 66, __pyx_L1_error)) __pyx_v_self->depth = 0; - /* "hunter/_tracer.pyx":59 - * self.threading_support = threading_support + /* "hunter/_tracer.pyx":67 + * self.profiling_mode = profiling_mode * self.depth = 0 * self.calls = 0 # <<<<<<<<<<<<<< * * def __dealloc__(self): - */ - __Pyx_TraceLine(59,0,__PYX_ERR(0, 59, __pyx_L1_error)) +*/ + __Pyx_TraceLine(67,24,0,__PYX_ERR(0, 67, __pyx_L1_error)) __pyx_v_self->calls = 0; - /* "hunter/_tracer.pyx":52 + /* "hunter/_tracer.pyx":59 * * cdef class Tracer: - * def __cinit__(self, threading_support=None): # <<<<<<<<<<<<<< + * def __cinit__(self, threading_support=None, profiling_mode=False): # <<<<<<<<<<<<<< * self.handler = None * self.previous = None - */ +*/ /* function exit code */ __pyx_r = 0; + __Pyx_TraceReturnCValue(__pyx_r, __Pyx_Owned_Py_None, 0, 0, __PYX_ERR(0, 59, __pyx_L1_error)); goto __pyx_L0; __pyx_L1_error:; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 59, __pyx_L1_error)); + #endif __Pyx_AddTraceback("hunter._tracer.Tracer.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; - __Pyx_TraceReturn(Py_None, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_tracer.pyx":61 +/* "hunter/_tracer.pyx":69 * self.calls = 0 * * def __dealloc__(self): # <<<<<<<<<<<<<< * cdef PyThreadState *state = PyThreadState_Get() - * if state.c_traceobj is self: - */ + * if state.c_traceobj is self: +*/ /* Python wrapper */ static void __pyx_pw_6hunter_7_tracer_6Tracer_3__dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_pw_6hunter_7_tracer_6Tracer_3__dealloc__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_pf_6hunter_7_tracer_6Tracer_2__dealloc__(((struct __pyx_obj_6hunter_7_tracer_Tracer *)__pyx_v_self)); /* function exit code */ @@ -2604,106 +4401,111 @@ static void __pyx_pw_6hunter_7_tracer_6Tracer_3__dealloc__(PyObject *__pyx_v_sel static void __pyx_pf_6hunter_7_tracer_6Tracer_2__dealloc__(struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self) { PyThreadState *__pyx_v_state; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; + size_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[2])) __Pyx_RefNannySetupContext("__dealloc__", 0); - __Pyx_TraceCall("__dealloc__", __pyx_f[0], 61, 0, __PYX_ERR(0, 61, __pyx_L1_error)); + __Pyx_TraceStartFunc("__dealloc__", __pyx_f[0], 69, 0, 0, 0, __PYX_ERR(0, 69, __pyx_L1_error)); - /* "hunter/_tracer.pyx":62 + /* "hunter/_tracer.pyx":70 * * def __dealloc__(self): * cdef PyThreadState *state = PyThreadState_Get() # <<<<<<<<<<<<<< - * if state.c_traceobj is self: + * if state.c_traceobj is self: * self.stop() - */ - __Pyx_TraceLine(62,0,__PYX_ERR(0, 62, __pyx_L1_error)) +*/ + __Pyx_TraceLine(70,3,0,__PYX_ERR(0, 70, __pyx_L1_error)) __pyx_v_state = PyThreadState_Get(); - /* "hunter/_tracer.pyx":63 + /* "hunter/_tracer.pyx":71 * def __dealloc__(self): * cdef PyThreadState *state = PyThreadState_Get() - * if state.c_traceobj is self: # <<<<<<<<<<<<<< + * if state.c_traceobj is self: # <<<<<<<<<<<<<< * self.stop() * - */ - __Pyx_TraceLine(63,0,__PYX_ERR(0, 63, __pyx_L1_error)) - __pyx_t_1 = ((__pyx_v_state->c_traceobj == ((PyObject *)__pyx_v_self)) != 0); +*/ + __Pyx_TraceLine(71,7,0,__PYX_ERR(0, 71, __pyx_L1_error)) + __pyx_t_1 = (__pyx_v_state->c_traceobj == ((PyObject *)__pyx_v_self)); if (__pyx_t_1) { - /* "hunter/_tracer.pyx":64 + /* "hunter/_tracer.pyx":72 * cdef PyThreadState *state = PyThreadState_Get() - * if state.c_traceobj is self: + * if state.c_traceobj is self: * self.stop() # <<<<<<<<<<<<<< * * def __repr__(self): - */ - __Pyx_TraceLine(64,0,__PYX_ERR(0, 64, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_stop); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 64, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - } +*/ + __Pyx_TraceLine(72,10,0,__PYX_ERR(0, 72, __pyx_L1_error)) + __pyx_t_3 = ((PyObject *)__pyx_v_self); + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_stop, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 72, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); } - __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 64, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "hunter/_tracer.pyx":63 + /* "hunter/_tracer.pyx":71 * def __dealloc__(self): * cdef PyThreadState *state = PyThreadState_Get() - * if state.c_traceobj is self: # <<<<<<<<<<<<<< + * if state.c_traceobj is self: # <<<<<<<<<<<<<< * self.stop() * - */ +*/ } - /* "hunter/_tracer.pyx":61 + /* "hunter/_tracer.pyx":69 * self.calls = 0 * * def __dealloc__(self): # <<<<<<<<<<<<<< * cdef PyThreadState *state = PyThreadState_Get() - * if state.c_traceobj is self: - */ + * if state.c_traceobj is self: +*/ /* function exit code */ + __Pyx_TraceReturnValue(Py_None, 0, 0, __PYX_ERR(0, 69, __pyx_L1_error)); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 69, __pyx_L1_error)); + #endif __Pyx_WriteUnraisable("hunter._tracer.Tracer.__dealloc__", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; - __Pyx_TraceReturn(Py_None, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); } -/* "hunter/_tracer.pyx":66 +/* "hunter/_tracer.pyx":74 * self.stop() * * def __repr__(self): # <<<<<<<<<<<<<< * return '' % ( * id(self), - */ +*/ /* Python wrapper */ static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_5__repr__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_5__repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_6hunter_7_tracer_6Tracer_4__repr__(((struct __pyx_obj_6hunter_7_tracer_Tracer *)__pyx_v_self)); /* function exit code */ @@ -2713,195 +4515,222 @@ static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_5__repr__(PyObject *__pyx_v_s static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_4__repr__(struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; - int __pyx_t_3; - PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10[10]; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[3])) __Pyx_RefNannySetupContext("__repr__", 0); - __Pyx_TraceCall("__repr__", __pyx_f[0], 66, 0, __PYX_ERR(0, 66, __pyx_L1_error)); + __Pyx_TraceStartFunc("__repr__", __pyx_f[0], 74, 0, 0, 0, __PYX_ERR(0, 74, __pyx_L1_error)); - /* "hunter/_tracer.pyx":67 + /* "hunter/_tracer.pyx":75 * * def __repr__(self): * return '' % ( # <<<<<<<<<<<<<< * id(self), * self.threading_support, - */ - __Pyx_TraceLine(67,0,__PYX_ERR(0, 67, __pyx_L1_error)) +*/ + __Pyx_TraceLine(75,1,0,__PYX_ERR(0, 75, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - /* "hunter/_tracer.pyx":68 + /* "hunter/_tracer.pyx":76 * def __repr__(self): * return '' % ( * id(self), # <<<<<<<<<<<<<< * self.threading_support, * '' if self.handler is None else 'handler=', - */ - __Pyx_TraceLine(68,0,__PYX_ERR(0, 68, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 68, __pyx_L1_error) +*/ + __Pyx_TraceLine(76,4,0,__PYX_ERR(0, 76, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 76, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Format(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_x); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "hunter/_tracer.pyx":70 + /* "hunter/_tracer.pyx":77 + * return '' % ( + * id(self), + * self.threading_support, # <<<<<<<<<<<<<< + * '' if self.handler is None else 'handler=', + * '' if self.handler is None else repr(self.handler), +*/ + __Pyx_TraceLine(77,7,0,__PYX_ERR(0, 77, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_self->threading_support), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "hunter/_tracer.pyx":78 * id(self), * self.threading_support, * '' if self.handler is None else 'handler=', # <<<<<<<<<<<<<< * '' if self.handler is None else repr(self.handler), * '' if self.previous is None else ', previous=', - */ - __Pyx_TraceLine(70,0,__PYX_ERR(0, 70, __pyx_L1_error)) - __pyx_t_3 = (__pyx_v_self->handler == Py_None); - if ((__pyx_t_3 != 0)) { - __Pyx_INCREF(__pyx_kp_s_stopped); - __pyx_t_2 = __pyx_kp_s_stopped; +*/ + __Pyx_TraceLine(78,12,0,__PYX_ERR(0, 78, __pyx_L1_error)) + __pyx_t_4 = (__pyx_v_self->handler == Py_None); + if (__pyx_t_4) { + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_stopped); + __pyx_t_3 = __pyx_mstate_global->__pyx_kp_u_stopped; } else { - __Pyx_INCREF(__pyx_kp_s_handler); - __pyx_t_2 = __pyx_kp_s_handler; + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_handler); + __pyx_t_3 = __pyx_mstate_global->__pyx_kp_u_handler; } + __pyx_t_5 = __Pyx_PyUnicode_Unicode(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 78, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "hunter/_tracer.pyx":71 + /* "hunter/_tracer.pyx":79 * self.threading_support, * '' if self.handler is None else 'handler=', * '' if self.handler is None else repr(self.handler), # <<<<<<<<<<<<<< * '' if self.previous is None else ', previous=', * '' if self.previous is None else repr(self.previous), - */ - __Pyx_TraceLine(71,0,__PYX_ERR(0, 71, __pyx_L1_error)) - __pyx_t_3 = (__pyx_v_self->handler == Py_None); - if ((__pyx_t_3 != 0)) { - __Pyx_INCREF(__pyx_kp_s_); - __pyx_t_4 = __pyx_kp_s_; +*/ + __Pyx_TraceLine(79,18,0,__PYX_ERR(0, 79, __pyx_L1_error)) + __pyx_t_4 = (__pyx_v_self->handler == Py_None); + if (__pyx_t_4) { + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u__3); + __pyx_t_3 = __pyx_mstate_global->__pyx_kp_u__3; } else { - __pyx_t_5 = __pyx_v_self->handler; - __Pyx_INCREF(__pyx_t_5); - __pyx_t_6 = PyObject_Repr(__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 71, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_4 = __pyx_t_6; - __pyx_t_6 = 0; + __pyx_t_6 = __pyx_v_self->handler; + __Pyx_INCREF(__pyx_t_6); + __pyx_t_7 = PyObject_Repr(__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_3 = __pyx_t_7; + __pyx_t_7 = 0; } + __pyx_t_7 = __Pyx_PyUnicode_Unicode(__pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "hunter/_tracer.pyx":72 + /* "hunter/_tracer.pyx":80 * '' if self.handler is None else 'handler=', * '' if self.handler is None else repr(self.handler), * '' if self.previous is None else ', previous=', # <<<<<<<<<<<<<< * '' if self.previous is None else repr(self.previous), * ) - */ - __Pyx_TraceLine(72,0,__PYX_ERR(0, 72, __pyx_L1_error)) - __pyx_t_3 = (__pyx_v_self->previous == Py_None); - if ((__pyx_t_3 != 0)) { - __Pyx_INCREF(__pyx_kp_s_); - __pyx_t_6 = __pyx_kp_s_; +*/ + __Pyx_TraceLine(80,27,0,__PYX_ERR(0, 80, __pyx_L1_error)) + __pyx_t_4 = (__pyx_v_self->previous == Py_None); + if (__pyx_t_4) { + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u__3); + __pyx_t_3 = __pyx_mstate_global->__pyx_kp_u__3; } else { - __Pyx_INCREF(__pyx_kp_s_previous); - __pyx_t_6 = __pyx_kp_s_previous; + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_previous); + __pyx_t_3 = __pyx_mstate_global->__pyx_kp_u_previous; } + __pyx_t_6 = __Pyx_PyUnicode_Unicode(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "hunter/_tracer.pyx":73 + /* "hunter/_tracer.pyx":81 * '' if self.handler is None else repr(self.handler), * '' if self.previous is None else ', previous=', * '' if self.previous is None else repr(self.previous), # <<<<<<<<<<<<<< * ) * - */ - __Pyx_TraceLine(73,0,__PYX_ERR(0, 73, __pyx_L1_error)) - __pyx_t_3 = (__pyx_v_self->previous == Py_None); - if ((__pyx_t_3 != 0)) { - __Pyx_INCREF(__pyx_kp_s_); - __pyx_t_5 = __pyx_kp_s_; +*/ + __Pyx_TraceLine(81,33,0,__PYX_ERR(0, 81, __pyx_L1_error)) + __pyx_t_4 = (__pyx_v_self->previous == Py_None); + if (__pyx_t_4) { + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u__3); + __pyx_t_3 = __pyx_mstate_global->__pyx_kp_u__3; } else { - __pyx_t_7 = __pyx_v_self->previous; - __Pyx_INCREF(__pyx_t_7); - __pyx_t_8 = PyObject_Repr(__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 73, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_5 = __pyx_t_8; - __pyx_t_8 = 0; + __pyx_t_8 = __pyx_v_self->previous; + __Pyx_INCREF(__pyx_t_8); + __pyx_t_9 = PyObject_Repr(__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_3 = __pyx_t_9; + __pyx_t_9 = 0; } - - /* "hunter/_tracer.pyx":68 - * def __repr__(self): - * return '' % ( - * id(self), # <<<<<<<<<<<<<< - * self.threading_support, - * '' if self.handler is None else 'handler=', - */ - __Pyx_TraceLine(68,0,__PYX_ERR(0, 68, __pyx_L1_error)) - __pyx_t_8 = PyTuple_New(6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 68, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_1); - __Pyx_INCREF(__pyx_v_self->threading_support); - __Pyx_GIVEREF(__pyx_v_self->threading_support); - PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_v_self->threading_support); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_2); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_8, 3, __pyx_t_4); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_8, 4, __pyx_t_6); - __Pyx_GIVEREF(__pyx_t_5); - PyTuple_SET_ITEM(__pyx_t_8, 5, __pyx_t_5); - __pyx_t_1 = 0; - __pyx_t_2 = 0; - __pyx_t_4 = 0; - __pyx_t_6 = 0; - __pyx_t_5 = 0; - - /* "hunter/_tracer.pyx":67 + __pyx_t_9 = __Pyx_PyUnicode_Unicode(__pyx_t_3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_10[0] = __pyx_mstate_global->__pyx_kp_u_hunter__tracer_Tracer_at_0x; + __pyx_t_10[1] = __pyx_t_2; + __pyx_t_10[2] = __pyx_mstate_global->__pyx_kp_u_threading_support_2; + __pyx_t_10[3] = __pyx_t_1; + __pyx_t_10[4] = __pyx_mstate_global->__pyx_kp_u__2; + __pyx_t_10[5] = __pyx_t_5; + __pyx_t_10[6] = __pyx_t_7; + __pyx_t_10[7] = __pyx_t_6; + __pyx_t_10[8] = __pyx_t_9; + __pyx_t_10[9] = __pyx_mstate_global->__pyx_kp_u__4; + + /* "hunter/_tracer.pyx":75 * * def __repr__(self): * return '' % ( # <<<<<<<<<<<<<< * id(self), * self.threading_support, - */ - __Pyx_TraceLine(67,0,__PYX_ERR(0, 67, __pyx_L1_error)) - __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_hunter__tracer_Tracer_at_0x_x_t, __pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 67, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; +*/ + __Pyx_TraceLine(75,2,0,__PYX_ERR(0, 75, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_10, 10, 28 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2) + 20 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1) + 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9)); + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 75, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 75, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_tracer.pyx":66 + /* "hunter/_tracer.pyx":74 * self.stop() * * def __repr__(self): # <<<<<<<<<<<<<< * return '' % ( * id(self), - */ +*/ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 74, __pyx_L1_error)); + #endif __Pyx_AddTraceback("hunter._tracer.Tracer.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_tracer.pyx":76 +/* "hunter/_tracer.pyx":84 * ) * - * def __call__(self, frame, kind, arg): # <<<<<<<<<<<<<< - * trace_func(self, frame, KIND_NAMES.index(kind), arg) - * if kind == 'call': - */ + * def __call__(self, frame, str kind, arg): # <<<<<<<<<<<<<< + * trace_func( self, frame, KIND_INTS[kind], arg) + * if kind == 0: +*/ /* Python wrapper */ static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_7__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ @@ -2909,178 +4738,285 @@ static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_7__call__(PyObject *__pyx_v_s PyObject *__pyx_v_frame = 0; PyObject *__pyx_v_kind = 0; PyObject *__pyx_v_arg = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__call__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_frame,&__pyx_n_s_kind,&__pyx_n_s_arg,0}; - PyObject* values[3] = {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 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_frame,&__pyx_mstate_global->__pyx_n_u_kind,&__pyx_mstate_global->__pyx_n_u_arg,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 84, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 84, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 84, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 84, __pyx_L3_error) 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_frame)) != 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_kind)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("__call__", 1, 3, 3, 1); __PYX_ERR(0, 76, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_arg)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("__call__", 1, 3, 3, 2); __PYX_ERR(0, 76, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__call__") < 0)) __PYX_ERR(0, 76, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__call__", 0) < 0) __PYX_ERR(0, 84, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__call__", 1, 3, 3, i); __PYX_ERR(0, 84, __pyx_L3_error) } } - } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { + } else if (unlikely(__pyx_nargs != 3)) { 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[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 84, __pyx_L3_error) + values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 84, __pyx_L3_error) + values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 84, __pyx_L3_error) } __pyx_v_frame = values[0]; - __pyx_v_kind = values[1]; + __pyx_v_kind = ((PyObject*)values[1]); __pyx_v_arg = values[2]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__call__", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 76, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__call__", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 84, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } __Pyx_AddTraceback("hunter._tracer.Tracer.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_kind), (&PyUnicode_Type), 1, "kind", 1))) __PYX_ERR(0, 84, __pyx_L1_error) __pyx_r = __pyx_pf_6hunter_7_tracer_6Tracer_6__call__(((struct __pyx_obj_6hunter_7_tracer_Tracer *)__pyx_v_self), __pyx_v_frame, __pyx_v_kind, __pyx_v_arg); /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_6__call__(struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self, PyObject *__pyx_v_frame, PyObject *__pyx_v_kind, PyObject *__pyx_v_arg) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; - int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[4])) __Pyx_RefNannySetupContext("__call__", 0); - __Pyx_TraceCall("__call__", __pyx_f[0], 76, 0, __PYX_ERR(0, 76, __pyx_L1_error)); + __Pyx_TraceStartFunc("__call__", __pyx_f[0], 84, 0, 0, 0, __PYX_ERR(0, 84, __pyx_L1_error)); - /* "hunter/_tracer.pyx":77 + /* "hunter/_tracer.pyx":85 * - * def __call__(self, frame, kind, arg): - * trace_func(self, frame, KIND_NAMES.index(kind), arg) # <<<<<<<<<<<<<< - * if kind == 'call': - * PyEval_SetTrace( trace_func, self) - */ - __Pyx_TraceLine(77,0,__PYX_ERR(0, 77, __pyx_L1_error)) - if (!(likely(((__pyx_v_frame) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_frame, __pyx_ptype_6hunter_7_tracer_FrameType))))) __PYX_ERR(0, 77, __pyx_L1_error) - __pyx_t_1 = __Pyx_CallUnboundCMethod1(&__pyx_umethod_PyTuple_Type_index, __pyx_v_6hunter_7_tracer_KIND_NAMES, __pyx_v_kind); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error) + * def __call__(self, frame, str kind, arg): + * trace_func( self, frame, KIND_INTS[kind], arg) # <<<<<<<<<<<<<< + * if kind == 0: + * PyEval_SetTrace(trace_func, self) +*/ + __Pyx_TraceLine(85,7,0,__PYX_ERR(0, 85, __pyx_L1_error)) + if (unlikely(__pyx_v_6hunter_7_tracer_KIND_INTS == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 85, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_6hunter_7_tracer_KIND_INTS, __pyx_v_kind); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 85, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 77, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 85, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_6hunter_7_tracer_trace_func(__pyx_v_self, ((PyFrameObject *)__pyx_v_frame), __pyx_t_2, ((PyObject *)__pyx_v_arg)); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 77, __pyx_L1_error) + (void)(__pyx_f_6hunter_7_tracer_trace_func(((PyObject *)__pyx_v_self), ((PyFrameObject *)__pyx_v_frame), __pyx_t_2, ((PyObject *)__pyx_v_arg))); - /* "hunter/_tracer.pyx":78 - * def __call__(self, frame, kind, arg): - * trace_func(self, frame, KIND_NAMES.index(kind), arg) - * if kind == 'call': # <<<<<<<<<<<<<< - * PyEval_SetTrace( trace_func, self) + /* "hunter/_tracer.pyx":86 + * def __call__(self, frame, str kind, arg): + * trace_func( self, frame, KIND_INTS[kind], arg) + * if kind == 0: # <<<<<<<<<<<<<< + * PyEval_SetTrace(trace_func, self) * return self - */ - __Pyx_TraceLine(78,0,__PYX_ERR(0, 78, __pyx_L1_error)) - __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_v_kind, __pyx_n_s_call, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 78, __pyx_L1_error) - if (__pyx_t_4) { +*/ + __Pyx_TraceLine(86,13,0,__PYX_ERR(0, 86, __pyx_L1_error)) + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_v_kind, __pyx_mstate_global->__pyx_int_0, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 86, __pyx_L1_error) + if (__pyx_t_3) { - /* "hunter/_tracer.pyx":79 - * trace_func(self, frame, KIND_NAMES.index(kind), arg) - * if kind == 'call': - * PyEval_SetTrace( trace_func, self) # <<<<<<<<<<<<<< + /* "hunter/_tracer.pyx":87 + * trace_func( self, frame, KIND_INTS[kind], arg) + * if kind == 0: + * PyEval_SetTrace(trace_func, self) # <<<<<<<<<<<<<< * return self * - */ - __Pyx_TraceLine(79,0,__PYX_ERR(0, 79, __pyx_L1_error)) - PyEval_SetTrace(((Py_tracefunc)__pyx_f_6hunter_7_tracer_trace_func), ((PyObject *)__pyx_v_self)); - - /* "hunter/_tracer.pyx":78 - * def __call__(self, frame, kind, arg): - * trace_func(self, frame, KIND_NAMES.index(kind), arg) - * if kind == 'call': # <<<<<<<<<<<<<< - * PyEval_SetTrace( trace_func, self) +*/ + __Pyx_TraceLine(87,17,0,__PYX_ERR(0, 87, __pyx_L1_error)) + PyEval_SetTrace(__pyx_f_6hunter_7_tracer_trace_func, ((PyObject *)__pyx_v_self)); + + /* "hunter/_tracer.pyx":86 + * def __call__(self, frame, str kind, arg): + * trace_func( self, frame, KIND_INTS[kind], arg) + * if kind == 0: # <<<<<<<<<<<<<< + * PyEval_SetTrace(trace_func, self) * return self - */ +*/ } - /* "hunter/_tracer.pyx":80 - * if kind == 'call': - * PyEval_SetTrace( trace_func, self) + /* "hunter/_tracer.pyx":88 + * if kind == 0: + * PyEval_SetTrace(trace_func, self) * return self # <<<<<<<<<<<<<< * * def trace(self, predicate): - */ - __Pyx_TraceLine(80,0,__PYX_ERR(0, 80, __pyx_L1_error)) +*/ + __Pyx_TraceLine(88,21,0,__PYX_ERR(0, 88, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_INCREF((PyObject *)__pyx_v_self); __pyx_r = ((PyObject *)__pyx_v_self); + __Pyx_TraceReturnValue(__pyx_r, 21, 0, __PYX_ERR(0, 88, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_tracer.pyx":76 + /* "hunter/_tracer.pyx":84 * ) * - * def __call__(self, frame, kind, arg): # <<<<<<<<<<<<<< - * trace_func(self, frame, KIND_NAMES.index(kind), arg) - * if kind == 'call': - */ + * def __call__(self, frame, str kind, arg): # <<<<<<<<<<<<<< + * trace_func( self, frame, KIND_INTS[kind], arg) + * if kind == 0: +*/ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 84, __pyx_L1_error)); + #endif __Pyx_AddTraceback("hunter._tracer.Tracer.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_tracer.pyx":82 +/* "hunter/_tracer.pyx":90 * return self * * def trace(self, predicate): # <<<<<<<<<<<<<< - * cdef PyThreadState *state = PyThreadState_Get() * self.handler = predicate - */ + * cdef PyThreadState *state = PyThreadState_Get() +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_9trace(PyObject *__pyx_v_self, PyObject *__pyx_v_predicate); /*proto*/ -static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_9trace(PyObject *__pyx_v_self, PyObject *__pyx_v_predicate) { +static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_9trace(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_7_tracer_6Tracer_9trace = {"trace", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_7_tracer_6Tracer_9trace, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_9trace(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_predicate = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("trace (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_7_tracer_6Tracer_8trace(((struct __pyx_obj_6hunter_7_tracer_Tracer *)__pyx_v_self), ((PyObject *)__pyx_v_predicate)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_predicate,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 90, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 90, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "trace", 0) < 0) __PYX_ERR(0, 90, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("trace", 1, 1, 1, i); __PYX_ERR(0, 90, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 90, __pyx_L3_error) + } + __pyx_v_predicate = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("trace", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 90, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("hunter._tracer.Tracer.trace", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6hunter_7_tracer_6Tracer_8trace(((struct __pyx_obj_6hunter_7_tracer_Tracer *)__pyx_v_self), __pyx_v_predicate); /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3088,254 +5024,492 @@ static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_9trace(PyObject *__pyx_v_self static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_8trace(struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self, PyObject *__pyx_v_predicate) { PyThreadState *__pyx_v_state; PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; - int __pyx_t_3; + PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; - Py_tracefunc __pyx_t_7; + size_t __pyx_t_7; + Py_tracefunc __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[5])) __Pyx_RefNannySetupContext("trace", 0); - __Pyx_TraceCall("trace", __pyx_f[0], 82, 0, __PYX_ERR(0, 82, __pyx_L1_error)); + __Pyx_TraceStartFunc("trace", __pyx_f[0], 90, 0, 0, 0, __PYX_ERR(0, 90, __pyx_L1_error)); - /* "hunter/_tracer.pyx":83 + /* "hunter/_tracer.pyx":91 * * def trace(self, predicate): - * cdef PyThreadState *state = PyThreadState_Get() # <<<<<<<<<<<<<< - * self.handler = predicate - * if self.threading_support is None or self.threading_support: - */ - __Pyx_TraceLine(83,0,__PYX_ERR(0, 83, __pyx_L1_error)) - __pyx_v_state = PyThreadState_Get(); - - /* "hunter/_tracer.pyx":84 - * def trace(self, predicate): - * cdef PyThreadState *state = PyThreadState_Get() * self.handler = predicate # <<<<<<<<<<<<<< - * if self.threading_support is None or self.threading_support: - * self._threading_previous = getattr(threading, '_trace_hook', None) - */ - __Pyx_TraceLine(84,0,__PYX_ERR(0, 84, __pyx_L1_error)) + * cdef PyThreadState *state = PyThreadState_Get() + * +*/ + __Pyx_TraceLine(91,1,0,__PYX_ERR(0, 91, __pyx_L1_error)) __Pyx_INCREF(__pyx_v_predicate); __Pyx_GIVEREF(__pyx_v_predicate); __Pyx_GOTREF(__pyx_v_self->handler); __Pyx_DECREF(__pyx_v_self->handler); __pyx_v_self->handler = __pyx_v_predicate; - /* "hunter/_tracer.pyx":85 - * cdef PyThreadState *state = PyThreadState_Get() + /* "hunter/_tracer.pyx":92 + * def trace(self, predicate): * self.handler = predicate - * if self.threading_support is None or self.threading_support: # <<<<<<<<<<<<<< - * self._threading_previous = getattr(threading, '_trace_hook', None) - * threading.settrace(self) - */ - __Pyx_TraceLine(85,0,__PYX_ERR(0, 85, __pyx_L1_error)) - __pyx_t_2 = (__pyx_v_self->threading_support == Py_None); - __pyx_t_3 = (__pyx_t_2 != 0); - if (!__pyx_t_3) { - } else { - __pyx_t_1 = __pyx_t_3; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_self->threading_support); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 85, __pyx_L1_error) - __pyx_t_1 = __pyx_t_3; - __pyx_L4_bool_binop_done:; - if (__pyx_t_1) { + * cdef PyThreadState *state = PyThreadState_Get() # <<<<<<<<<<<<<< + * + * if self.profiling_mode: +*/ + __Pyx_TraceLine(92,6,0,__PYX_ERR(0, 92, __pyx_L1_error)) + __pyx_v_state = PyThreadState_Get(); - /* "hunter/_tracer.pyx":86 - * self.handler = predicate - * if self.threading_support is None or self.threading_support: - * self._threading_previous = getattr(threading, '_trace_hook', None) # <<<<<<<<<<<<<< - * threading.settrace(self) - * if state.c_traceobj is NULL: - */ - __Pyx_TraceLine(86,0,__PYX_ERR(0, 86, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_threading); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 86, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_GetAttr3(__pyx_t_4, __pyx_n_s_trace_hook, Py_None); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 86, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_GIVEREF(__pyx_t_5); - __Pyx_GOTREF(__pyx_v_self->_threading_previous); - __Pyx_DECREF(__pyx_v_self->_threading_previous); - __pyx_v_self->_threading_previous = __pyx_t_5; - __pyx_t_5 = 0; + /* "hunter/_tracer.pyx":94 + * cdef PyThreadState *state = PyThreadState_Get() + * + * if self.profiling_mode: # <<<<<<<<<<<<<< + * if self.threading_support is None or self.threading_support: + * self._threading_previous = getattr(threading, '_profile_hook', None) +*/ + __Pyx_TraceLine(94,8,0,__PYX_ERR(0, 94, __pyx_L1_error)) + if (__pyx_v_self->profiling_mode) { - /* "hunter/_tracer.pyx":87 - * if self.threading_support is None or self.threading_support: - * self._threading_previous = getattr(threading, '_trace_hook', None) - * threading.settrace(self) # <<<<<<<<<<<<<< - * if state.c_traceobj is NULL: - * self.previous = None - */ - __Pyx_TraceLine(87,0,__PYX_ERR(0, 87, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_threading); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_settrace); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_6, function); + /* "hunter/_tracer.pyx":95 + * + * if self.profiling_mode: + * if self.threading_support is None or self.threading_support: # <<<<<<<<<<<<<< + * self._threading_previous = getattr(threading, '_profile_hook', None) + * threading.setprofile(self) +*/ + __Pyx_TraceLine(95,14,0,__PYX_ERR(0, 95, __pyx_L1_error)) + __pyx_t_2 = (__pyx_v_self->threading_support == Py_None); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L5_bool_binop_done; + } + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_self->threading_support); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 95, __pyx_L1_error) + __pyx_t_1 = __pyx_t_2; + __pyx_L5_bool_binop_done:; + if (__pyx_t_1) { + + /* "hunter/_tracer.pyx":96 + * if self.profiling_mode: + * if self.threading_support is None or self.threading_support: + * self._threading_previous = getattr(threading, '_profile_hook', None) # <<<<<<<<<<<<<< + * threading.setprofile(self) + * if state.c_profileobj is NULL: +*/ + __Pyx_TraceLine(96,22,0,__PYX_ERR(0, 96, __pyx_L1_error)) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_threading); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 96, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_GetAttr3(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_profile_hook, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 96, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GIVEREF(__pyx_t_4); + __Pyx_GOTREF(__pyx_v_self->_threading_previous); + __Pyx_DECREF(__pyx_v_self->_threading_previous); + __pyx_v_self->_threading_previous = __pyx_t_4; + __pyx_t_4 = 0; + + /* "hunter/_tracer.pyx":97 + * if self.threading_support is None or self.threading_support: + * self._threading_previous = getattr(threading, '_profile_hook', None) + * threading.setprofile(self) # <<<<<<<<<<<<<< + * if state.c_profileobj is NULL: + * self.previous = None +*/ + __Pyx_TraceLine(97,27,0,__PYX_ERR(0, 97, __pyx_L1_error)) + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_threading); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_setprofile); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_7 = 0; } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, ((PyObject *)__pyx_v_self)}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "hunter/_tracer.pyx":95 + * + * if self.profiling_mode: + * if self.threading_support is None or self.threading_support: # <<<<<<<<<<<<<< + * self._threading_previous = getattr(threading, '_profile_hook', None) + * threading.setprofile(self) +*/ } - __pyx_t_5 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_4, ((PyObject *)__pyx_v_self)) : __Pyx_PyObject_CallOneArg(__pyx_t_6, ((PyObject *)__pyx_v_self)); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "hunter/_tracer.pyx":85 - * cdef PyThreadState *state = PyThreadState_Get() - * self.handler = predicate - * if self.threading_support is None or self.threading_support: # <<<<<<<<<<<<<< - * self._threading_previous = getattr(threading, '_trace_hook', None) - * threading.settrace(self) - */ - } + /* "hunter/_tracer.pyx":98 + * self._threading_previous = getattr(threading, '_profile_hook', None) + * threading.setprofile(self) + * if state.c_profileobj is NULL: # <<<<<<<<<<<<<< + * self.previous = None + * self._previousfunc = NULL +*/ + __Pyx_TraceLine(98,32,0,__PYX_ERR(0, 98, __pyx_L1_error)) + __pyx_t_1 = (__pyx_v_state->c_profileobj == NULL); + if (__pyx_t_1) { - /* "hunter/_tracer.pyx":88 - * self._threading_previous = getattr(threading, '_trace_hook', None) - * threading.settrace(self) - * if state.c_traceobj is NULL: # <<<<<<<<<<<<<< - * self.previous = None - * self._previousfunc = NULL - */ - __Pyx_TraceLine(88,0,__PYX_ERR(0, 88, __pyx_L1_error)) - __pyx_t_1 = ((__pyx_v_state->c_traceobj == NULL) != 0); - if (__pyx_t_1) { + /* "hunter/_tracer.pyx":99 + * threading.setprofile(self) + * if state.c_profileobj is NULL: + * self.previous = None # <<<<<<<<<<<<<< + * self._previousfunc = NULL + * else: +*/ + __Pyx_TraceLine(99,34,0,__PYX_ERR(0, 99, __pyx_L1_error)) + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->previous); + __Pyx_DECREF(__pyx_v_self->previous); + __pyx_v_self->previous = Py_None; + + /* "hunter/_tracer.pyx":100 + * if state.c_profileobj is NULL: + * self.previous = None + * self._previousfunc = NULL # <<<<<<<<<<<<<< + * else: + * self.previous = (state.c_profileobj) +*/ + __Pyx_TraceLine(100,37,0,__PYX_ERR(0, 100, __pyx_L1_error)) + __pyx_v_self->_previousfunc = NULL; + + /* "hunter/_tracer.pyx":98 + * self._threading_previous = getattr(threading, '_profile_hook', None) + * threading.setprofile(self) + * if state.c_profileobj is NULL: # <<<<<<<<<<<<<< + * self.previous = None + * self._previousfunc = NULL +*/ + goto __pyx_L7; + } - /* "hunter/_tracer.pyx":89 - * threading.settrace(self) - * if state.c_traceobj is NULL: - * self.previous = None # <<<<<<<<<<<<<< - * self._previousfunc = NULL + /* "hunter/_tracer.pyx":102 + * self._previousfunc = NULL + * else: + * self.previous = (state.c_profileobj) # <<<<<<<<<<<<<< + * self._previousfunc = state.c_profilefunc + * PyEval_SetProfile(trace_func, self) +*/ + __Pyx_TraceLine(102,40,0,__PYX_ERR(0, 102, __pyx_L1_error)) + /*else*/ { + __pyx_t_4 = ((PyObject *)__pyx_v_state->c_profileobj); + __Pyx_INCREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + __Pyx_GOTREF(__pyx_v_self->previous); + __Pyx_DECREF(__pyx_v_self->previous); + __pyx_v_self->previous = __pyx_t_4; + __pyx_t_4 = 0; + + /* "hunter/_tracer.pyx":103 + * else: + * self.previous = (state.c_profileobj) + * self._previousfunc = state.c_profilefunc # <<<<<<<<<<<<<< + * PyEval_SetProfile(trace_func, self) * else: - */ - __Pyx_TraceLine(89,0,__PYX_ERR(0, 89, __pyx_L1_error)) - __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(Py_None); - __Pyx_GOTREF(__pyx_v_self->previous); - __Pyx_DECREF(__pyx_v_self->previous); - __pyx_v_self->previous = Py_None; - - /* "hunter/_tracer.pyx":90 - * if state.c_traceobj is NULL: - * self.previous = None - * self._previousfunc = NULL # <<<<<<<<<<<<<< +*/ + __Pyx_TraceLine(103,48,0,__PYX_ERR(0, 103, __pyx_L1_error)) + __pyx_t_8 = __pyx_v_state->c_profilefunc; + __pyx_v_self->_previousfunc = __pyx_t_8; + } + __pyx_L7:; + + /* "hunter/_tracer.pyx":104 + * self.previous = (state.c_profileobj) + * self._previousfunc = state.c_profilefunc + * PyEval_SetProfile(trace_func, self) # <<<<<<<<<<<<<< * else: - * self.previous = (state.c_traceobj) - */ - __Pyx_TraceLine(90,0,__PYX_ERR(0, 90, __pyx_L1_error)) - __pyx_v_self->_previousfunc = NULL; - - /* "hunter/_tracer.pyx":88 - * self._threading_previous = getattr(threading, '_trace_hook', None) - * threading.settrace(self) - * if state.c_traceobj is NULL: # <<<<<<<<<<<<<< - * self.previous = None - * self._previousfunc = NULL - */ - goto __pyx_L6; + * if self.threading_support is None or self.threading_support: +*/ + __Pyx_TraceLine(104,50,0,__PYX_ERR(0, 104, __pyx_L1_error)) + PyEval_SetProfile(__pyx_f_6hunter_7_tracer_trace_func, ((PyObject *)__pyx_v_self)); + + /* "hunter/_tracer.pyx":94 + * cdef PyThreadState *state = PyThreadState_Get() + * + * if self.profiling_mode: # <<<<<<<<<<<<<< + * if self.threading_support is None or self.threading_support: + * self._threading_previous = getattr(threading, '_profile_hook', None) +*/ + goto __pyx_L3; } - /* "hunter/_tracer.pyx":92 - * self._previousfunc = NULL + /* "hunter/_tracer.pyx":106 + * PyEval_SetProfile(trace_func, self) * else: - * self.previous = (state.c_traceobj) # <<<<<<<<<<<<<< - * self._previousfunc = state.c_tracefunc - * PyEval_SetTrace( trace_func, self) - */ - __Pyx_TraceLine(92,0,__PYX_ERR(0, 92, __pyx_L1_error)) + * if self.threading_support is None or self.threading_support: # <<<<<<<<<<<<<< + * self._threading_previous = getattr(threading, '_trace_hook', None) + * threading.settrace(self) +*/ + __Pyx_TraceLine(106,54,0,__PYX_ERR(0, 106, __pyx_L1_error)) /*else*/ { - __pyx_t_5 = ((PyObject *)__pyx_v_state->c_traceobj); - __Pyx_INCREF(__pyx_t_5); - __Pyx_GIVEREF(__pyx_t_5); - __Pyx_GOTREF(__pyx_v_self->previous); - __Pyx_DECREF(__pyx_v_self->previous); - __pyx_v_self->previous = __pyx_t_5; - __pyx_t_5 = 0; - - /* "hunter/_tracer.pyx":93 - * else: - * self.previous = (state.c_traceobj) - * self._previousfunc = state.c_tracefunc # <<<<<<<<<<<<<< - * PyEval_SetTrace( trace_func, self) + __pyx_t_2 = (__pyx_v_self->threading_support == Py_None); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_self->threading_support); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 106, __pyx_L1_error) + __pyx_t_1 = __pyx_t_2; + __pyx_L9_bool_binop_done:; + if (__pyx_t_1) { + + /* "hunter/_tracer.pyx":107 + * else: + * if self.threading_support is None or self.threading_support: + * self._threading_previous = getattr(threading, '_trace_hook', None) # <<<<<<<<<<<<<< + * threading.settrace(self) + * if state.c_traceobj is NULL: +*/ + __Pyx_TraceLine(107,66,0,__PYX_ERR(0, 107, __pyx_L1_error)) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_threading); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_GetAttr3(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_trace_hook, Py_None); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GIVEREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_v_self->_threading_previous); + __Pyx_DECREF(__pyx_v_self->_threading_previous); + __pyx_v_self->_threading_previous = __pyx_t_6; + __pyx_t_6 = 0; + + /* "hunter/_tracer.pyx":108 + * if self.threading_support is None or self.threading_support: + * self._threading_previous = getattr(threading, '_trace_hook', None) + * threading.settrace(self) # <<<<<<<<<<<<<< + * if state.c_traceobj is NULL: + * self.previous = None +*/ + __Pyx_TraceLine(108,71,0,__PYX_ERR(0, 108, __pyx_L1_error)) + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_threading); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_settrace); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, ((PyObject *)__pyx_v_self)}; + __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "hunter/_tracer.pyx":106 + * PyEval_SetProfile(trace_func, self) + * else: + * if self.threading_support is None or self.threading_support: # <<<<<<<<<<<<<< + * self._threading_previous = getattr(threading, '_trace_hook', None) + * threading.settrace(self) +*/ + } + + /* "hunter/_tracer.pyx":109 + * self._threading_previous = getattr(threading, '_trace_hook', None) + * threading.settrace(self) + * if state.c_traceobj is NULL: # <<<<<<<<<<<<<< + * self.previous = None + * self._previousfunc = NULL +*/ + __Pyx_TraceLine(109,76,0,__PYX_ERR(0, 109, __pyx_L1_error)) + __pyx_t_1 = (__pyx_v_state->c_traceobj == NULL); + if (__pyx_t_1) { + + /* "hunter/_tracer.pyx":110 + * threading.settrace(self) + * if state.c_traceobj is NULL: + * self.previous = None # <<<<<<<<<<<<<< + * self._previousfunc = NULL + * else: +*/ + __Pyx_TraceLine(110,78,0,__PYX_ERR(0, 110, __pyx_L1_error)) + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->previous); + __Pyx_DECREF(__pyx_v_self->previous); + __pyx_v_self->previous = Py_None; + + /* "hunter/_tracer.pyx":111 + * if state.c_traceobj is NULL: + * self.previous = None + * self._previousfunc = NULL # <<<<<<<<<<<<<< + * else: + * self.previous = (state.c_traceobj) +*/ + __Pyx_TraceLine(111,81,0,__PYX_ERR(0, 111, __pyx_L1_error)) + __pyx_v_self->_previousfunc = NULL; + + /* "hunter/_tracer.pyx":109 + * self._threading_previous = getattr(threading, '_trace_hook', None) + * threading.settrace(self) + * if state.c_traceobj is NULL: # <<<<<<<<<<<<<< + * self.previous = None + * self._previousfunc = NULL +*/ + goto __pyx_L11; + } + + /* "hunter/_tracer.pyx":113 + * self._previousfunc = NULL + * else: + * self.previous = (state.c_traceobj) # <<<<<<<<<<<<<< + * self._previousfunc = state.c_tracefunc + * PyEval_SetTrace(trace_func, self) +*/ + __Pyx_TraceLine(113,84,0,__PYX_ERR(0, 113, __pyx_L1_error)) + /*else*/ { + __pyx_t_6 = ((PyObject *)__pyx_v_state->c_traceobj); + __Pyx_INCREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_v_self->previous); + __Pyx_DECREF(__pyx_v_self->previous); + __pyx_v_self->previous = __pyx_t_6; + __pyx_t_6 = 0; + + /* "hunter/_tracer.pyx":114 + * else: + * self.previous = (state.c_traceobj) + * self._previousfunc = state.c_tracefunc # <<<<<<<<<<<<<< + * PyEval_SetTrace(trace_func, self) * return self - */ - __Pyx_TraceLine(93,0,__PYX_ERR(0, 93, __pyx_L1_error)) - __pyx_t_7 = __pyx_v_state->c_tracefunc; - __pyx_v_self->_previousfunc = __pyx_t_7; - } - __pyx_L6:; +*/ + __Pyx_TraceLine(114,92,0,__PYX_ERR(0, 114, __pyx_L1_error)) + __pyx_t_8 = __pyx_v_state->c_tracefunc; + __pyx_v_self->_previousfunc = __pyx_t_8; + } + __pyx_L11:; - /* "hunter/_tracer.pyx":94 - * self.previous = (state.c_traceobj) - * self._previousfunc = state.c_tracefunc - * PyEval_SetTrace( trace_func, self) # <<<<<<<<<<<<<< + /* "hunter/_tracer.pyx":115 + * self.previous = (state.c_traceobj) + * self._previousfunc = state.c_tracefunc + * PyEval_SetTrace(trace_func, self) # <<<<<<<<<<<<<< * return self * - */ - __Pyx_TraceLine(94,0,__PYX_ERR(0, 94, __pyx_L1_error)) - PyEval_SetTrace(((Py_tracefunc)__pyx_f_6hunter_7_tracer_trace_func), ((PyObject *)__pyx_v_self)); +*/ + __Pyx_TraceLine(115,94,0,__PYX_ERR(0, 115, __pyx_L1_error)) + PyEval_SetTrace(__pyx_f_6hunter_7_tracer_trace_func, ((PyObject *)__pyx_v_self)); + } + __pyx_L3:; - /* "hunter/_tracer.pyx":95 - * self._previousfunc = state.c_tracefunc - * PyEval_SetTrace( trace_func, self) + /* "hunter/_tracer.pyx":116 + * self._previousfunc = state.c_tracefunc + * PyEval_SetTrace(trace_func, self) * return self # <<<<<<<<<<<<<< * * def stop(self): - */ - __Pyx_TraceLine(95,0,__PYX_ERR(0, 95, __pyx_L1_error)) +*/ + __Pyx_TraceLine(116,98,0,__PYX_ERR(0, 116, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_INCREF((PyObject *)__pyx_v_self); __pyx_r = ((PyObject *)__pyx_v_self); + __Pyx_TraceReturnValue(__pyx_r, 98, 0, __PYX_ERR(0, 116, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_tracer.pyx":82 + /* "hunter/_tracer.pyx":90 * return self * * def trace(self, predicate): # <<<<<<<<<<<<<< - * cdef PyThreadState *state = PyThreadState_Get() * self.handler = predicate - */ + * cdef PyThreadState *state = PyThreadState_Get() +*/ /* function exit code */ __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 90, __pyx_L1_error)); + #endif __Pyx_AddTraceback("hunter._tracer.Tracer.trace", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_tracer.pyx":97 +/* "hunter/_tracer.pyx":118 * return self * * def stop(self): # <<<<<<<<<<<<<< * if self.handler is not None: - * if self.previous is None: - */ + * if self.profiling_mode: +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_11stop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_11stop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_11stop(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_7_tracer_6Tracer_11stop = {"stop", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_7_tracer_6Tracer_11stop, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_11stop(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stop (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("stop", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("stop", __pyx_kwds); return NULL;} __pyx_r = __pyx_pf_6hunter_7_tracer_6Tracer_10stop(((struct __pyx_obj_6hunter_7_tracer_Tracer *)__pyx_v_self)); /* function exit code */ @@ -3345,223 +5519,442 @@ static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_11stop(PyObject *__pyx_v_self static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_10stop(struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; - int __pyx_t_3; + PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; + size_t __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[6])) __Pyx_RefNannySetupContext("stop", 0); - __Pyx_TraceCall("stop", __pyx_f[0], 97, 0, __PYX_ERR(0, 97, __pyx_L1_error)); + __Pyx_TraceStartFunc("stop", __pyx_f[0], 118, 0, 0, 0, __PYX_ERR(0, 118, __pyx_L1_error)); - /* "hunter/_tracer.pyx":98 + /* "hunter/_tracer.pyx":119 * * def stop(self): * if self.handler is not None: # <<<<<<<<<<<<<< - * if self.previous is None: - * PyEval_SetTrace(NULL, NULL) - */ - __Pyx_TraceLine(98,0,__PYX_ERR(0, 98, __pyx_L1_error)) + * if self.profiling_mode: + * if self.previous is None: +*/ + __Pyx_TraceLine(119,5,0,__PYX_ERR(0, 119, __pyx_L1_error)) __pyx_t_1 = (__pyx_v_self->handler != Py_None); - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { + if (__pyx_t_1) { - /* "hunter/_tracer.pyx":99 + /* "hunter/_tracer.pyx":120 * def stop(self): * if self.handler is not None: - * if self.previous is None: # <<<<<<<<<<<<<< - * PyEval_SetTrace(NULL, NULL) + * if self.profiling_mode: # <<<<<<<<<<<<<< + * if self.previous is None: + * PyEval_SetProfile(NULL, NULL) +*/ + __Pyx_TraceLine(120,7,0,__PYX_ERR(0, 120, __pyx_L1_error)) + if (__pyx_v_self->profiling_mode) { + + /* "hunter/_tracer.pyx":121 + * if self.handler is not None: + * if self.profiling_mode: + * if self.previous is None: # <<<<<<<<<<<<<< + * PyEval_SetProfile(NULL, NULL) + * else: +*/ + __Pyx_TraceLine(121,13,0,__PYX_ERR(0, 121, __pyx_L1_error)) + __pyx_t_1 = (__pyx_v_self->previous == Py_None); + if (__pyx_t_1) { + + /* "hunter/_tracer.pyx":122 + * if self.profiling_mode: + * if self.previous is None: + * PyEval_SetProfile(NULL, NULL) # <<<<<<<<<<<<<< + * else: + * PyEval_SetProfile(self._previousfunc, self.previous) +*/ + __Pyx_TraceLine(122,15,0,__PYX_ERR(0, 122, __pyx_L1_error)) + PyEval_SetProfile(NULL, NULL); + + /* "hunter/_tracer.pyx":121 + * if self.handler is not None: + * if self.profiling_mode: + * if self.previous is None: # <<<<<<<<<<<<<< + * PyEval_SetProfile(NULL, NULL) + * else: +*/ + goto __pyx_L5; + } + + /* "hunter/_tracer.pyx":124 + * PyEval_SetProfile(NULL, NULL) + * else: + * PyEval_SetProfile(self._previousfunc, self.previous) # <<<<<<<<<<<<<< + * self.handler = self.previous = None + * self._previousfunc = NULL +*/ + __Pyx_TraceLine(124,19,0,__PYX_ERR(0, 124, __pyx_L1_error)) + /*else*/ { + PyEval_SetProfile(__pyx_v_self->_previousfunc, ((PyObject *)__pyx_v_self->previous)); + } + __pyx_L5:; + + /* "hunter/_tracer.pyx":125 + * else: + * PyEval_SetProfile(self._previousfunc, self.previous) + * self.handler = self.previous = None # <<<<<<<<<<<<<< + * self._previousfunc = NULL + * if self.threading_support is None or self.threading_support: +*/ + __Pyx_TraceLine(125,25,0,__PYX_ERR(0, 125, __pyx_L1_error)) + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->handler); + __Pyx_DECREF(__pyx_v_self->handler); + __pyx_v_self->handler = Py_None; + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->previous); + __Pyx_DECREF(__pyx_v_self->previous); + __pyx_v_self->previous = Py_None; + + /* "hunter/_tracer.pyx":126 + * PyEval_SetProfile(self._previousfunc, self.previous) + * self.handler = self.previous = None + * self._previousfunc = NULL # <<<<<<<<<<<<<< + * if self.threading_support is None or self.threading_support: + * threading.setprofile(self._threading_previous) +*/ + __Pyx_TraceLine(126,30,0,__PYX_ERR(0, 126, __pyx_L1_error)) + __pyx_v_self->_previousfunc = NULL; + + /* "hunter/_tracer.pyx":127 + * self.handler = self.previous = None + * self._previousfunc = NULL + * if self.threading_support is None or self.threading_support: # <<<<<<<<<<<<<< + * threading.setprofile(self._threading_previous) + * self._threading_previous = None +*/ + __Pyx_TraceLine(127,37,0,__PYX_ERR(0, 127, __pyx_L1_error)) + __pyx_t_2 = (__pyx_v_self->threading_support == Py_None); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_self->threading_support); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 127, __pyx_L1_error) + __pyx_t_1 = __pyx_t_2; + __pyx_L7_bool_binop_done:; + if (__pyx_t_1) { + + /* "hunter/_tracer.pyx":128 + * self._previousfunc = NULL + * if self.threading_support is None or self.threading_support: + * threading.setprofile(self._threading_previous) # <<<<<<<<<<<<<< + * self._threading_previous = None * else: - */ - __Pyx_TraceLine(99,0,__PYX_ERR(0, 99, __pyx_L1_error)) - __pyx_t_2 = (__pyx_v_self->previous == Py_None); - __pyx_t_1 = (__pyx_t_2 != 0); - if (__pyx_t_1) { +*/ + __Pyx_TraceLine(128,43,0,__PYX_ERR(0, 128, __pyx_L1_error)) + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_threading); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_setprofile); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_self->_threading_previous}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "hunter/_tracer.pyx":100 - * if self.handler is not None: - * if self.previous is None: - * PyEval_SetTrace(NULL, NULL) # <<<<<<<<<<<<<< + /* "hunter/_tracer.pyx":129 + * if self.threading_support is None or self.threading_support: + * threading.setprofile(self._threading_previous) + * self._threading_previous = None # <<<<<<<<<<<<<< * else: - * PyEval_SetTrace(self._previousfunc, self.previous) - */ - __Pyx_TraceLine(100,0,__PYX_ERR(0, 100, __pyx_L1_error)) - PyEval_SetTrace(NULL, NULL); + * if self.previous is None: +*/ + __Pyx_TraceLine(129,46,0,__PYX_ERR(0, 129, __pyx_L1_error)) + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_threading_previous); + __Pyx_DECREF(__pyx_v_self->_threading_previous); + __pyx_v_self->_threading_previous = Py_None; + + /* "hunter/_tracer.pyx":127 + * self.handler = self.previous = None + * self._previousfunc = NULL + * if self.threading_support is None or self.threading_support: # <<<<<<<<<<<<<< + * threading.setprofile(self._threading_previous) + * self._threading_previous = None +*/ + } - /* "hunter/_tracer.pyx":99 + /* "hunter/_tracer.pyx":120 * def stop(self): * if self.handler is not None: - * if self.previous is None: # <<<<<<<<<<<<<< - * PyEval_SetTrace(NULL, NULL) - * else: - */ + * if self.profiling_mode: # <<<<<<<<<<<<<< + * if self.previous is None: + * PyEval_SetProfile(NULL, NULL) +*/ goto __pyx_L4; } - /* "hunter/_tracer.pyx":102 - * PyEval_SetTrace(NULL, NULL) + /* "hunter/_tracer.pyx":131 + * self._threading_previous = None * else: - * PyEval_SetTrace(self._previousfunc, self.previous) # <<<<<<<<<<<<<< - * self.handler = self.previous = None - * self._previousfunc = NULL - */ - __Pyx_TraceLine(102,0,__PYX_ERR(0, 102, __pyx_L1_error)) + * if self.previous is None: # <<<<<<<<<<<<<< + * PyEval_SetTrace(NULL, NULL) + * else: +*/ + __Pyx_TraceLine(131,49,0,__PYX_ERR(0, 131, __pyx_L1_error)) /*else*/ { - PyEval_SetTrace(__pyx_v_self->_previousfunc, ((PyObject *)__pyx_v_self->previous)); - } - __pyx_L4:; + __pyx_t_1 = (__pyx_v_self->previous == Py_None); + if (__pyx_t_1) { - /* "hunter/_tracer.pyx":103 + /* "hunter/_tracer.pyx":132 * else: - * PyEval_SetTrace(self._previousfunc, self.previous) - * self.handler = self.previous = None # <<<<<<<<<<<<<< - * self._previousfunc = NULL - * if self.threading_support is None or self.threading_support: - */ - __Pyx_TraceLine(103,0,__PYX_ERR(0, 103, __pyx_L1_error)) - __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(Py_None); - __Pyx_GOTREF(__pyx_v_self->handler); - __Pyx_DECREF(__pyx_v_self->handler); - __pyx_v_self->handler = Py_None; - __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(Py_None); - __Pyx_GOTREF(__pyx_v_self->previous); - __Pyx_DECREF(__pyx_v_self->previous); - __pyx_v_self->previous = Py_None; - - /* "hunter/_tracer.pyx":104 - * PyEval_SetTrace(self._previousfunc, self.previous) - * self.handler = self.previous = None - * self._previousfunc = NULL # <<<<<<<<<<<<<< - * if self.threading_support is None or self.threading_support: - * threading.settrace(self._threading_previous) - */ - __Pyx_TraceLine(104,0,__PYX_ERR(0, 104, __pyx_L1_error)) - __pyx_v_self->_previousfunc = NULL; - - /* "hunter/_tracer.pyx":105 - * self.handler = self.previous = None - * self._previousfunc = NULL - * if self.threading_support is None or self.threading_support: # <<<<<<<<<<<<<< - * threading.settrace(self._threading_previous) - * self._threading_previous = None - */ - __Pyx_TraceLine(105,0,__PYX_ERR(0, 105, __pyx_L1_error)) - __pyx_t_2 = (__pyx_v_self->threading_support == Py_None); - __pyx_t_3 = (__pyx_t_2 != 0); - if (!__pyx_t_3) { - } else { - __pyx_t_1 = __pyx_t_3; - goto __pyx_L6_bool_binop_done; - } - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_self->threading_support); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 105, __pyx_L1_error) - __pyx_t_1 = __pyx_t_3; - __pyx_L6_bool_binop_done:; - if (__pyx_t_1) { + * if self.previous is None: + * PyEval_SetTrace(NULL, NULL) # <<<<<<<<<<<<<< + * else: + * PyEval_SetTrace(self._previousfunc, self.previous) +*/ + __Pyx_TraceLine(132,55,0,__PYX_ERR(0, 132, __pyx_L1_error)) + PyEval_SetTrace(NULL, NULL); + + /* "hunter/_tracer.pyx":131 + * self._threading_previous = None + * else: + * if self.previous is None: # <<<<<<<<<<<<<< + * PyEval_SetTrace(NULL, NULL) + * else: +*/ + goto __pyx_L9; + } - /* "hunter/_tracer.pyx":106 - * self._previousfunc = NULL - * if self.threading_support is None or self.threading_support: - * threading.settrace(self._threading_previous) # <<<<<<<<<<<<<< - * self._threading_previous = None + /* "hunter/_tracer.pyx":134 + * PyEval_SetTrace(NULL, NULL) + * else: + * PyEval_SetTrace(self._previousfunc, self.previous) # <<<<<<<<<<<<<< + * self.handler = self.previous = None + * self._previousfunc = NULL +*/ + __Pyx_TraceLine(134,59,0,__PYX_ERR(0, 134, __pyx_L1_error)) + /*else*/ { + PyEval_SetTrace(__pyx_v_self->_previousfunc, ((PyObject *)__pyx_v_self->previous)); + } + __pyx_L9:; + + /* "hunter/_tracer.pyx":135 + * else: + * PyEval_SetTrace(self._previousfunc, self.previous) + * self.handler = self.previous = None # <<<<<<<<<<<<<< + * self._previousfunc = NULL + * if self.threading_support is None or self.threading_support: +*/ + __Pyx_TraceLine(135,65,0,__PYX_ERR(0, 135, __pyx_L1_error)) + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->handler); + __Pyx_DECREF(__pyx_v_self->handler); + __pyx_v_self->handler = Py_None; + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->previous); + __Pyx_DECREF(__pyx_v_self->previous); + __pyx_v_self->previous = Py_None; + + /* "hunter/_tracer.pyx":136 + * PyEval_SetTrace(self._previousfunc, self.previous) + * self.handler = self.previous = None + * self._previousfunc = NULL # <<<<<<<<<<<<<< + * if self.threading_support is None or self.threading_support: + * threading.settrace(self._threading_previous) +*/ + __Pyx_TraceLine(136,70,0,__PYX_ERR(0, 136, __pyx_L1_error)) + __pyx_v_self->_previousfunc = NULL; + + /* "hunter/_tracer.pyx":137 + * self.handler = self.previous = None + * self._previousfunc = NULL + * if self.threading_support is None or self.threading_support: # <<<<<<<<<<<<<< + * threading.settrace(self._threading_previous) + * self._threading_previous = None +*/ + __Pyx_TraceLine(137,77,0,__PYX_ERR(0, 137, __pyx_L1_error)) + __pyx_t_2 = (__pyx_v_self->threading_support == Py_None); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L11_bool_binop_done; + } + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_self->threading_support); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 137, __pyx_L1_error) + __pyx_t_1 = __pyx_t_2; + __pyx_L11_bool_binop_done:; + if (__pyx_t_1) { + + /* "hunter/_tracer.pyx":138 + * self._previousfunc = NULL + * if self.threading_support is None or self.threading_support: + * threading.settrace(self._threading_previous) # <<<<<<<<<<<<<< + * self._threading_previous = None * - */ - __Pyx_TraceLine(106,0,__PYX_ERR(0, 106, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_threading); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 106, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_settrace); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 106, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_6, function); +*/ + __Pyx_TraceLine(138,83,0,__PYX_ERR(0, 138, __pyx_L1_error)) + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_threading); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_settrace); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_7 = 0; } - } - __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_5, __pyx_v_self->_threading_previous) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_self->_threading_previous); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 106, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_v_self->_threading_previous}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "hunter/_tracer.pyx":107 - * if self.threading_support is None or self.threading_support: - * threading.settrace(self._threading_previous) - * self._threading_previous = None # <<<<<<<<<<<<<< + /* "hunter/_tracer.pyx":139 + * if self.threading_support is None or self.threading_support: + * threading.settrace(self._threading_previous) + * self._threading_previous = None # <<<<<<<<<<<<<< * * def __enter__(self): - */ - __Pyx_TraceLine(107,0,__PYX_ERR(0, 107, __pyx_L1_error)) - __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(Py_None); - __Pyx_GOTREF(__pyx_v_self->_threading_previous); - __Pyx_DECREF(__pyx_v_self->_threading_previous); - __pyx_v_self->_threading_previous = Py_None; - - /* "hunter/_tracer.pyx":105 - * self.handler = self.previous = None - * self._previousfunc = NULL - * if self.threading_support is None or self.threading_support: # <<<<<<<<<<<<<< - * threading.settrace(self._threading_previous) - * self._threading_previous = None - */ +*/ + __Pyx_TraceLine(139,86,0,__PYX_ERR(0, 139, __pyx_L1_error)) + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_threading_previous); + __Pyx_DECREF(__pyx_v_self->_threading_previous); + __pyx_v_self->_threading_previous = Py_None; + + /* "hunter/_tracer.pyx":137 + * self.handler = self.previous = None + * self._previousfunc = NULL + * if self.threading_support is None or self.threading_support: # <<<<<<<<<<<<<< + * threading.settrace(self._threading_previous) + * self._threading_previous = None +*/ + } } + __pyx_L4:; - /* "hunter/_tracer.pyx":98 + /* "hunter/_tracer.pyx":119 * * def stop(self): * if self.handler is not None: # <<<<<<<<<<<<<< - * if self.previous is None: - * PyEval_SetTrace(NULL, NULL) - */ + * if self.profiling_mode: + * if self.previous is None: +*/ } - /* "hunter/_tracer.pyx":97 + /* "hunter/_tracer.pyx":118 * return self * * def stop(self): # <<<<<<<<<<<<<< * if self.handler is not None: - * if self.previous is None: - */ + * if self.profiling_mode: +*/ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(0, 118, __pyx_L1_error)); goto __pyx_L0; __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 118, __pyx_L1_error)); + #endif __Pyx_AddTraceback("hunter._tracer.Tracer.stop", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_tracer.pyx":109 - * self._threading_previous = None +/* "hunter/_tracer.pyx":141 + * self._threading_previous = None * * def __enter__(self): # <<<<<<<<<<<<<< * return self * - */ +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_13__enter__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_13__enter__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_13__enter__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_7_tracer_6Tracer_13__enter__ = {"__enter__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_7_tracer_6Tracer_13__enter__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_13__enter__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__enter__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__enter__", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__enter__", __pyx_kwds); return NULL;} __pyx_r = __pyx_pf_6hunter_7_tracer_6Tracer_12__enter__(((struct __pyx_obj_6hunter_7_tracer_Tracer *)__pyx_v_self)); /* function exit code */ @@ -3571,111 +5964,148 @@ static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_13__enter__(PyObject *__pyx_v static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_12__enter__(struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[7])) __Pyx_RefNannySetupContext("__enter__", 0); - __Pyx_TraceCall("__enter__", __pyx_f[0], 109, 0, __PYX_ERR(0, 109, __pyx_L1_error)); + __Pyx_TraceStartFunc("__enter__", __pyx_f[0], 141, 0, 0, 0, __PYX_ERR(0, 141, __pyx_L1_error)); - /* "hunter/_tracer.pyx":110 + /* "hunter/_tracer.pyx":142 * * def __enter__(self): * return self # <<<<<<<<<<<<<< * * def __exit__(self, exc_type, exc_val, exc_tb): - */ - __Pyx_TraceLine(110,0,__PYX_ERR(0, 110, __pyx_L1_error)) +*/ + __Pyx_TraceLine(142,1,0,__PYX_ERR(0, 142, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_INCREF((PyObject *)__pyx_v_self); __pyx_r = ((PyObject *)__pyx_v_self); + __Pyx_TraceReturnValue(__pyx_r, 1, 0, __PYX_ERR(0, 142, __pyx_L1_error)); goto __pyx_L0; - /* "hunter/_tracer.pyx":109 - * self._threading_previous = None + /* "hunter/_tracer.pyx":141 + * self._threading_previous = None * * def __enter__(self): # <<<<<<<<<<<<<< * return self * - */ +*/ /* function exit code */ __pyx_L1_error:; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 141, __pyx_L1_error)); + #endif __Pyx_AddTraceback("hunter._tracer.Tracer.__enter__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_tracer.pyx":112 +/* "hunter/_tracer.pyx":144 * return self * * def __exit__(self, exc_type, exc_val, exc_tb): # <<<<<<<<<<<<<< * self.stop() - */ +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_15__exit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_15__exit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_15__exit__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_7_tracer_6Tracer_15__exit__ = {"__exit__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_7_tracer_6Tracer_15__exit__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_15__exit__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { CYTHON_UNUSED PyObject *__pyx_v_exc_type = 0; CYTHON_UNUSED PyObject *__pyx_v_exc_val = 0; CYTHON_UNUSED PyObject *__pyx_v_exc_tb = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__exit__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_exc_type,&__pyx_n_s_exc_val,&__pyx_n_s_exc_tb,0}; - PyObject* values[3] = {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 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_exc_type,&__pyx_mstate_global->__pyx_n_u_exc_val,&__pyx_mstate_global->__pyx_n_u_exc_tb,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 144, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 144, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 144, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 144, __pyx_L3_error) 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_exc_type)) != 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_exc_val)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("__exit__", 1, 3, 3, 1); __PYX_ERR(0, 112, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_exc_tb)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("__exit__", 1, 3, 3, 2); __PYX_ERR(0, 112, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__exit__") < 0)) __PYX_ERR(0, 112, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__exit__", 0) < 0) __PYX_ERR(0, 144, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__exit__", 1, 3, 3, i); __PYX_ERR(0, 144, __pyx_L3_error) } } - } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { + } else if (unlikely(__pyx_nargs != 3)) { 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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 144, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 144, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 144, __pyx_L3_error) } __pyx_v_exc_type = values[0]; __pyx_v_exc_val = values[1]; __pyx_v_exc_tb = values[2]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__exit__", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 112, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__exit__", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 144, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } __Pyx_AddTraceback("hunter._tracer.Tracer.__exit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -3683,82 +6113,90 @@ static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_15__exit__(PyObject *__pyx_v_ __pyx_r = __pyx_pf_6hunter_7_tracer_6Tracer_14__exit__(((struct __pyx_obj_6hunter_7_tracer_Tracer *)__pyx_v_self), __pyx_v_exc_type, __pyx_v_exc_val, __pyx_v_exc_tb); /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_14__exit__(struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_exc_type, CYTHON_UNUSED PyObject *__pyx_v_exc_val, CYTHON_UNUSED PyObject *__pyx_v_exc_tb) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[8])) __Pyx_RefNannySetupContext("__exit__", 0); - __Pyx_TraceCall("__exit__", __pyx_f[0], 112, 0, __PYX_ERR(0, 112, __pyx_L1_error)); + __Pyx_TraceStartFunc("__exit__", __pyx_f[0], 144, 0, 0, 0, __PYX_ERR(0, 144, __pyx_L1_error)); - /* "hunter/_tracer.pyx":113 + /* "hunter/_tracer.pyx":145 * * def __exit__(self, exc_type, exc_val, exc_tb): * self.stop() # <<<<<<<<<<<<<< - */ - __Pyx_TraceLine(113,0,__PYX_ERR(0, 113, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_stop); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 113, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - } +*/ + __Pyx_TraceLine(145,1,0,__PYX_ERR(0, 145, __pyx_L1_error)) + __pyx_t_2 = ((PyObject *)__pyx_v_self); + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_stop, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 145, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); } - __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 113, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "hunter/_tracer.pyx":112 + /* "hunter/_tracer.pyx":144 * return self * * def __exit__(self, exc_type, exc_val, exc_tb): # <<<<<<<<<<<<<< * self.stop() - */ +*/ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(0, 144, __pyx_L1_error)); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(0, 144, __pyx_L1_error)); + #endif __Pyx_AddTraceback("hunter._tracer.Tracer.__exit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_tracer.pxd":30 +/* "hunter/_tracer.pxd":28 * cdef class Tracer: * cdef: * readonly object handler # <<<<<<<<<<<<<< * readonly object previous * readonly object threading_support - */ +*/ /* Python wrapper */ static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_7handler_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_7handler_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_6hunter_7_tracer_6Tracer_7handler___get__(((struct __pyx_obj_6hunter_7_tracer_Tracer *)__pyx_v_self)); /* function exit code */ @@ -3768,40 +6206,53 @@ static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_7handler_1__get__(PyObject *_ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_7handler___get__(struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[9])) __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[2], 30, 0, __PYX_ERR(2, 30, __pyx_L1_error)); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 28, 0, 0, 0, __PYX_ERR(2, 28, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->handler); __pyx_r = __pyx_v_self->handler; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 28, __pyx_L1_error)); goto __pyx_L0; /* function exit code */ __pyx_L1_error:; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 28, __pyx_L1_error)); + #endif __Pyx_AddTraceback("hunter._tracer.Tracer.handler.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_tracer.pxd":31 +/* "hunter/_tracer.pxd":29 * cdef: * readonly object handler * readonly object previous # <<<<<<<<<<<<<< * readonly object threading_support - * readonly int depth - */ + * readonly bint profiling_mode +*/ /* Python wrapper */ static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_8previous_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_8previous_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_6hunter_7_tracer_6Tracer_8previous___get__(((struct __pyx_obj_6hunter_7_tracer_Tracer *)__pyx_v_self)); /* function exit code */ @@ -3811,40 +6262,53 @@ static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_8previous_1__get__(PyObject * static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_8previous___get__(struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[10])) __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[2], 31, 0, __PYX_ERR(2, 31, __pyx_L1_error)); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 29, 0, 0, 0, __PYX_ERR(2, 29, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->previous); __pyx_r = __pyx_v_self->previous; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 29, __pyx_L1_error)); goto __pyx_L0; /* function exit code */ __pyx_L1_error:; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 29, __pyx_L1_error)); + #endif __Pyx_AddTraceback("hunter._tracer.Tracer.previous.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_tracer.pxd":32 +/* "hunter/_tracer.pxd":30 * readonly object handler * readonly object previous * readonly object threading_support # <<<<<<<<<<<<<< + * readonly bint profiling_mode * readonly int depth - * readonly int calls - */ +*/ /* Python wrapper */ static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_17threading_support_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_17threading_support_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_6hunter_7_tracer_6Tracer_17threading_support___get__(((struct __pyx_obj_6hunter_7_tracer_Tracer *)__pyx_v_self)); /* function exit code */ @@ -3854,134 +6318,233 @@ static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_17threading_support_1__get__( static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_17threading_support___get__(struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[11])) __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[2], 32, 0, __PYX_ERR(2, 32, __pyx_L1_error)); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 30, 0, 0, 0, __PYX_ERR(2, 30, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->threading_support); __pyx_r = __pyx_v_self->threading_support; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 30, __pyx_L1_error)); goto __pyx_L0; /* function exit code */ __pyx_L1_error:; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 30, __pyx_L1_error)); + #endif __Pyx_AddTraceback("hunter._tracer.Tracer.threading_support.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_tracer.pxd":33 +/* "hunter/_tracer.pxd":31 * readonly object previous * readonly object threading_support - * readonly int depth # <<<<<<<<<<<<<< + * readonly bint profiling_mode # <<<<<<<<<<<<<< + * readonly int depth * readonly int calls - * - */ +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_5depth_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_5depth_1__get__(PyObject *__pyx_v_self) { +static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_14profiling_mode_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_14profiling_mode_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_7_tracer_6Tracer_5depth___get__(((struct __pyx_obj_6hunter_7_tracer_Tracer *)__pyx_v_self)); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_7_tracer_6Tracer_14profiling_mode___get__(((struct __pyx_obj_6hunter_7_tracer_Tracer *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_5depth___get__(struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self) { +static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_14profiling_mode___get__(struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[12])) __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[2], 33, 0, __PYX_ERR(2, 33, __pyx_L1_error)); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 31, 0, 0, 0, __PYX_ERR(2, 31, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->depth); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 33, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->profiling_mode); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 31, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 31, __pyx_L1_error)); goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._tracer.Tracer.depth.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 31, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._tracer.Tracer.profiling_mode.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_tracer.pxd":34 +/* "hunter/_tracer.pxd":32 * readonly object threading_support - * readonly int depth - * readonly int calls # <<<<<<<<<<<<<< + * readonly bint profiling_mode + * readonly int depth # <<<<<<<<<<<<<< + * readonly int calls * - * object __weakref__ - */ +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_5calls_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_5calls_1__get__(PyObject *__pyx_v_self) { +static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_5depth_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_5depth_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_7_tracer_6Tracer_5calls___get__(((struct __pyx_obj_6hunter_7_tracer_Tracer *)__pyx_v_self)); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_7_tracer_6Tracer_5depth___get__(((struct __pyx_obj_6hunter_7_tracer_Tracer *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_5calls___get__(struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self) { +static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_5depth___get__(struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[13])) __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[2], 34, 0, __PYX_ERR(2, 34, __pyx_L1_error)); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 32, 0, 0, 0, __PYX_ERR(2, 32, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->calls); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 34, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->depth); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 32, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 32, __pyx_L1_error)); goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._tracer.Tracer.calls.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 32, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._tracer.Tracer.depth.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_tracer.pxd":38 - * object __weakref__ +/* "hunter/_tracer.pxd":33 + * readonly bint profiling_mode + * readonly int depth + * readonly int calls # <<<<<<<<<<<<<< * - * readonly object _threading_previous # <<<<<<<<<<<<<< - * Py_tracefunc _previousfunc - */ + * object __weakref__ +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_19_threading_previous_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_19_threading_previous_1__get__(PyObject *__pyx_v_self) { +static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_5calls_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_5calls_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_7_tracer_6Tracer_19_threading_previous___get__(((struct __pyx_obj_6hunter_7_tracer_Tracer *)__pyx_v_self)); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_7_tracer_6Tracer_5calls___get__(((struct __pyx_obj_6hunter_7_tracer_Tracer *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_5calls___get__(struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarationsFunc + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[14])) + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 33, 0, 0, 0, __PYX_ERR(2, 33, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->calls); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 33, __pyx_L1_error)); + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 33, __pyx_L1_error)); + #endif + __Pyx_AddTraceback("hunter._tracer.Tracer.calls.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_PyMonitoring_ExitScope(0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/_tracer.pxd":37 + * object __weakref__ + * + * readonly object _threading_previous # <<<<<<<<<<<<<< + * Py_tracefunc _previousfunc +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_19_threading_previous_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_19_threading_previous_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_6hunter_7_tracer_6Tracer_19_threading_previous___get__(((struct __pyx_obj_6hunter_7_tracer_Tracer *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); @@ -3990,38 +6553,78 @@ static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_19_threading_previous_1__get_ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_19_threading_previous___get__(struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[15])) __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[2], 38, 0, __PYX_ERR(2, 38, __pyx_L1_error)); + __Pyx_TraceStartFunc("__get__", __pyx_f[2], 37, 0, 0, 0, __PYX_ERR(2, 37, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->_threading_previous); __pyx_r = __pyx_v_self->_threading_previous; + __Pyx_TraceReturnValue(__pyx_r, 0, 0, __PYX_ERR(2, 37, __pyx_L1_error)); goto __pyx_L0; /* function exit code */ __pyx_L1_error:; + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(2, 37, __pyx_L1_error)); + #endif __Pyx_AddTraceback("hunter._tracer.Tracer._threading_previous.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - */ +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_17__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_17__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_17__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_7_tracer_6Tracer_17__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_7_tracer_6Tracer_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_17__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;} __pyx_r = __pyx_pf_6hunter_7_tracer_6Tracer_16__reduce_cython__(((struct __pyx_obj_6hunter_7_tracer_Tracer *)__pyx_v_self)); /* function exit code */ @@ -4031,105 +6634,193 @@ static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_17__reduce_cython__(PyObject static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_16__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[16])) __Pyx_RefNannySetupContext("__reduce_cython__", 0); - __Pyx_TraceCall("__reduce_cython__", __pyx_f[1], 1, 0, __PYX_ERR(1, 1, __pyx_L1_error)); + __Pyx_TraceStartFunc("__reduce_cython__", __pyx_f[1], 1, 0, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - */ - __Pyx_TraceLine(2,0,__PYX_ERR(1, 2, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" +*/ + __Pyx_TraceLine(2,2,0,__PYX_ERR(1, 2, __pyx_L1_error)) + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(1, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - */ +*/ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 1, __pyx_L1_error)); + #endif __Pyx_AddTraceback("hunter._tracer.Tracer.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - */ + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" +*/ /* Python wrapper */ -static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_19__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_19__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_19__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_7_tracer_6Tracer_19__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_7_tracer_6Tracer_19__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6hunter_7_tracer_6Tracer_19__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_7_tracer_6Tracer_18__setstate_cython__(((struct __pyx_obj_6hunter_7_tracer_Tracer *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 3, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 3, __pyx_L3_error) + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("hunter._tracer.Tracer.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6hunter_7_tracer_6Tracer_18__setstate_cython__(((struct __pyx_obj_6hunter_7_tracer_Tracer *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_18__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations + __Pyx_TraceDeclarationsFunc __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[17])) __Pyx_RefNannySetupContext("__setstate_cython__", 0); - __Pyx_TraceCall("__setstate_cython__", __pyx_f[1], 3, 0, __PYX_ERR(1, 3, __pyx_L1_error)); + __Pyx_TraceStartFunc("__setstate_cython__", __pyx_f[1], 3, 0, 0, 0, __PYX_ERR(1, 3, __pyx_L1_error)); /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< - */ - __Pyx_TraceLine(4,0,__PYX_ERR(1, 4, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< +*/ + __Pyx_TraceLine(4,2,0,__PYX_ERR(1, 4, __pyx_L1_error)) + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(1, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - */ + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" +*/ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); + __Pyx_TraceException(__pyx_lineno, 0, 0); + #if CYTHON_USE_SYS_MONITORING + __Pyx_TraceExceptionUnwind(0, 0); + #else + __Pyx_TraceReturnValue(NULL, 0, 0, __PYX_ERR(1, 3, __pyx_L1_error)); + #endif __Pyx_AddTraceback("hunter._tracer.Tracer.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_PyMonitoring_ExitScope(0); __Pyx_RefNannyFinishContext(); return __pyx_r; } +/* #### Code section: module_exttypes ### */ static PyObject *__pyx_tp_new_6hunter_7_tracer_Tracer(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_obj_6hunter_7_tracer_Tracer *p; PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; + #endif p = ((struct __pyx_obj_6hunter_7_tracer_Tracer *)o); p->handler = Py_None; Py_INCREF(Py_None); p->previous = Py_None; Py_INCREF(Py_None); @@ -4145,25 +6836,36 @@ static PyObject *__pyx_tp_new_6hunter_7_tracer_Tracer(PyTypeObject *t, PyObject static void __pyx_tp_dealloc_6hunter_7_tracer_Tracer(PyObject *o) { struct __pyx_obj_6hunter_7_tracer_Tracer *p = (struct __pyx_obj_6hunter_7_tracer_Tracer *)o; PyObject_GC_UnTrack(o); + if (p->__weakref__) PyObject_ClearWeakRefs(o); { PyObject *etype, *eval, *etb; PyErr_Fetch(&etype, &eval, &etb); - ++Py_REFCNT(o); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); __pyx_pw_6hunter_7_tracer_6Tracer_3__dealloc__(o); - --Py_REFCNT(o); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); PyErr_Restore(etype, eval, etb); } - if (p->__weakref__) PyObject_ClearWeakRefs(o); Py_CLEAR(p->handler); Py_CLEAR(p->previous); Py_CLEAR(p->threading_support); Py_CLEAR(p->_threading_previous); + #if CYTHON_USE_TYPE_SLOTS (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif } static int __pyx_tp_traverse_6hunter_7_tracer_Tracer(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_6hunter_7_tracer_Tracer *p = (struct __pyx_obj_6hunter_7_tracer_Tracer *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } if (p->handler) { e = (*v)(p->handler, a); if (e) return e; } @@ -4209,6 +6911,10 @@ static PyObject *__pyx_getprop_6hunter_7_tracer_6Tracer_threading_support(PyObje return __pyx_pw_6hunter_7_tracer_6Tracer_17threading_support_1__get__(o); } +static PyObject *__pyx_getprop_6hunter_7_tracer_6Tracer_profiling_mode(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_7_tracer_6Tracer_14profiling_mode_1__get__(o); +} + static PyObject *__pyx_getprop_6hunter_7_tracer_6Tracer_depth(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_6hunter_7_tracer_6Tracer_5depth_1__get__(o); } @@ -4222,28 +6928,63 @@ static PyObject *__pyx_getprop_6hunter_7_tracer_6Tracer__threading_previous(PyOb } static PyMethodDef __pyx_methods_6hunter_7_tracer_Tracer[] = { - {"trace", (PyCFunction)__pyx_pw_6hunter_7_tracer_6Tracer_9trace, METH_O, 0}, - {"stop", (PyCFunction)__pyx_pw_6hunter_7_tracer_6Tracer_11stop, METH_NOARGS, 0}, - {"__enter__", (PyCFunction)__pyx_pw_6hunter_7_tracer_6Tracer_13__enter__, METH_NOARGS, 0}, - {"__exit__", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6hunter_7_tracer_6Tracer_15__exit__, METH_VARARGS|METH_KEYWORDS, 0}, - {"__reduce_cython__", (PyCFunction)__pyx_pw_6hunter_7_tracer_6Tracer_17__reduce_cython__, METH_NOARGS, 0}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_6hunter_7_tracer_6Tracer_19__setstate_cython__, METH_O, 0}, + {"trace", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_7_tracer_6Tracer_9trace, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"stop", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_7_tracer_6Tracer_11stop, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__enter__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_7_tracer_6Tracer_13__enter__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__exit__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_7_tracer_6Tracer_15__exit__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_7_tracer_6Tracer_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_7_tracer_6Tracer_19__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_6hunter_7_tracer_Tracer[] = { - {(char *)"handler", __pyx_getprop_6hunter_7_tracer_6Tracer_handler, 0, (char *)0, 0}, - {(char *)"previous", __pyx_getprop_6hunter_7_tracer_6Tracer_previous, 0, (char *)0, 0}, - {(char *)"threading_support", __pyx_getprop_6hunter_7_tracer_6Tracer_threading_support, 0, (char *)0, 0}, - {(char *)"depth", __pyx_getprop_6hunter_7_tracer_6Tracer_depth, 0, (char *)0, 0}, - {(char *)"calls", __pyx_getprop_6hunter_7_tracer_6Tracer_calls, 0, (char *)0, 0}, - {(char *)"_threading_previous", __pyx_getprop_6hunter_7_tracer_6Tracer__threading_previous, 0, (char *)0, 0}, + {"handler", __pyx_getprop_6hunter_7_tracer_6Tracer_handler, 0, 0, 0}, + {"previous", __pyx_getprop_6hunter_7_tracer_6Tracer_previous, 0, 0, 0}, + {"threading_support", __pyx_getprop_6hunter_7_tracer_6Tracer_threading_support, 0, 0, 0}, + {"profiling_mode", __pyx_getprop_6hunter_7_tracer_6Tracer_profiling_mode, 0, 0, 0}, + {"depth", __pyx_getprop_6hunter_7_tracer_6Tracer_depth, 0, 0, 0}, + {"calls", __pyx_getprop_6hunter_7_tracer_6Tracer_calls, 0, 0, 0}, + {"_threading_previous", __pyx_getprop_6hunter_7_tracer_6Tracer__threading_previous, 0, 0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyMemberDef __pyx_type_6hunter_7_tracer_Tracer_members[] = { + #if !CYTHON_USE_TYPE_SLOTS + {"__weaklistoffset__", T_PYSSIZET, offsetof(struct __pyx_obj_6hunter_7_tracer_Tracer, __weakref__), READONLY, 0}, + #endif {0, 0, 0, 0, 0} }; +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x03090000 +#if defined(__GNUC__) || defined(__clang__) +#warning "src/hunter/_tracer.pxd:35:15: : __weakref__ is unsupported in the Limited API when running on Python <3.9." +#elif defined(_MSC_VER) +#pragma message("src/hunter/_tracer.pxd:35:15: : __weakref__ is unsupported in the Limited API when running on Python <3.9.") +#endif +#endif +static PyType_Slot __pyx_type_6hunter_7_tracer_Tracer_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_6hunter_7_tracer_Tracer}, + {Py_tp_repr, (void *)__pyx_pw_6hunter_7_tracer_6Tracer_5__repr__}, + {Py_tp_call, (void *)__pyx_pw_6hunter_7_tracer_6Tracer_7__call__}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_6hunter_7_tracer_Tracer}, + {Py_tp_clear, (void *)__pyx_tp_clear_6hunter_7_tracer_Tracer}, + {Py_tp_methods, (void *)__pyx_methods_6hunter_7_tracer_Tracer}, + {Py_tp_getset, (void *)__pyx_getsets_6hunter_7_tracer_Tracer}, + {Py_tp_new, (void *)__pyx_tp_new_6hunter_7_tracer_Tracer}, + {Py_tp_members, (void*)__pyx_type_6hunter_7_tracer_Tracer_members}, + {0, 0}, +}; +static PyType_Spec __pyx_type_6hunter_7_tracer_Tracer_spec = { + "hunter._tracer.Tracer", + sizeof(struct __pyx_obj_6hunter_7_tracer_Tracer), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, + __pyx_type_6hunter_7_tracer_Tracer_slots, +}; +#else static PyTypeObject __pyx_type_6hunter_7_tracer_Tracer = { PyVarObject_HEAD_INIT(0, 0) - "hunter._tracer.Tracer", /*tp_name*/ + "hunter._tracer.""Tracer", /*tp_name*/ sizeof(struct __pyx_obj_6hunter_7_tracer_Tracer), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_6hunter_7_tracer_Tracer, /*tp_dealloc*/ @@ -4255,12 +6996,7 @@ static PyTypeObject __pyx_type_6hunter_7_tracer_Tracer = { #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ - #endif __pyx_pw_6hunter_7_tracer_6Tracer_5__repr__, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ @@ -4286,7 +7022,9 @@ static PyTypeObject __pyx_type_6hunter_7_tracer_Tracer = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_6hunter_7_tracer_Tracer, /*tp_new*/ @@ -4299,236 +7037,116 @@ static PyTypeObject __pyx_type_6hunter_7_tracer_Tracer = { 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ #endif - #if PY_VERSION_HEX >= 0x030800b1 + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif -}; - -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__tracer(PyObject* module); /*proto*/ -static PyModuleDef_Slot __pyx_moduledef_slots[] = { - {Py_mod_create, (void*)__pyx_pymod_create}, - {Py_mod_exec, (void*)__pyx_pymod_exec__tracer}, - {0, NULL} -}; -#endif - -static struct PyModuleDef __pyx_moduledef = { - PyModuleDef_HEAD_INIT, - "_tracer", - 0, /* m_doc */ - #if CYTHON_PEP489_MULTI_PHASE_INIT - 0, /* m_size */ - #else - -1, /* m_size */ + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ #endif - __pyx_methods /* m_methods */, - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_moduledef_slots, /* m_slots */ - #else - NULL, /* m_reload */ + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ #endif - NULL, /* m_traverse */ - NULL, /* m_clear */ - NULL /* m_free */ }; #endif -#ifndef CYTHON_SMALL_CODE -#if defined(__clang__) - #define CYTHON_SMALL_CODE -#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) - #define CYTHON_SMALL_CODE __attribute__((cold)) -#else - #define CYTHON_SMALL_CODE -#endif -#endif -static __Pyx_StringTabEntry __pyx_string_tab[] = { - {&__pyx_kp_s_, __pyx_k_, sizeof(__pyx_k_), 0, 0, 1, 0}, - {&__pyx_kp_s_Disabling_tracer_because_handler, __pyx_k_Disabling_tracer_because_handler, sizeof(__pyx_k_Disabling_tracer_because_handler), 0, 0, 1, 0}, - {&__pyx_n_s_Tracer, __pyx_k_Tracer, sizeof(__pyx_k_Tracer), 0, 0, 1, 1}, - {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, - {&__pyx_n_s_all, __pyx_k_all, sizeof(__pyx_k_all), 0, 0, 1, 1}, - {&__pyx_n_s_arg, __pyx_k_arg, sizeof(__pyx_k_arg), 0, 0, 1, 1}, - {&__pyx_n_s_c_call, __pyx_k_c_call, sizeof(__pyx_k_c_call), 0, 0, 1, 1}, - {&__pyx_n_s_c_exception, __pyx_k_c_exception, sizeof(__pyx_k_c_exception), 0, 0, 1, 1}, - {&__pyx_n_s_c_return, __pyx_k_c_return, sizeof(__pyx_k_c_return), 0, 0, 1, 1}, - {&__pyx_n_s_call, __pyx_k_call, sizeof(__pyx_k_call), 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_default_stream, __pyx_k_default_stream, sizeof(__pyx_k_default_stream), 0, 0, 1, 1}, - {&__pyx_n_s_exc_tb, __pyx_k_exc_tb, sizeof(__pyx_k_exc_tb), 0, 0, 1, 1}, - {&__pyx_n_s_exc_type, __pyx_k_exc_type, sizeof(__pyx_k_exc_type), 0, 0, 1, 1}, - {&__pyx_n_s_exc_val, __pyx_k_exc_val, sizeof(__pyx_k_exc_val), 0, 0, 1, 1}, - {&__pyx_n_s_exception, __pyx_k_exception, sizeof(__pyx_k_exception), 0, 0, 1, 1}, - {&__pyx_n_s_file, __pyx_k_file, sizeof(__pyx_k_file), 0, 0, 1, 1}, - {&__pyx_n_s_format, __pyx_k_format, sizeof(__pyx_k_format), 0, 0, 1, 1}, - {&__pyx_n_s_frame, __pyx_k_frame, sizeof(__pyx_k_frame), 0, 0, 1, 1}, - {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, - {&__pyx_kp_s_handler, __pyx_k_handler, sizeof(__pyx_k_handler), 0, 0, 1, 0}, - {&__pyx_n_s_hunter, __pyx_k_hunter, sizeof(__pyx_k_hunter), 0, 0, 1, 1}, - {&__pyx_kp_s_hunter__tracer_Tracer_at_0x_x_t, __pyx_k_hunter__tracer_Tracer_at_0x_x_t, sizeof(__pyx_k_hunter__tracer_Tracer_at_0x_x_t), 0, 0, 1, 0}, - {&__pyx_n_s_id, __pyx_k_id, sizeof(__pyx_k_id), 0, 0, 1, 1}, - {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, - {&__pyx_n_s_index, __pyx_k_index, sizeof(__pyx_k_index), 0, 0, 1, 1}, - {&__pyx_n_s_kind, __pyx_k_kind, sizeof(__pyx_k_kind), 0, 0, 1, 1}, - {&__pyx_n_s_line, __pyx_k_line, sizeof(__pyx_k_line), 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_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0}, - {&__pyx_kp_s_previous, __pyx_k_previous, sizeof(__pyx_k_previous), 0, 0, 1, 0}, - {&__pyx_n_s_print_exc, __pyx_k_print_exc, sizeof(__pyx_k_print_exc), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, - {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, - {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, - {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, - {&__pyx_n_s_return, __pyx_k_return, sizeof(__pyx_k_return), 0, 0, 1, 1}, - {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, - {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, - {&__pyx_n_s_settrace, __pyx_k_settrace, sizeof(__pyx_k_settrace), 0, 0, 1, 1}, - {&__pyx_n_s_stop, __pyx_k_stop, sizeof(__pyx_k_stop), 0, 0, 1, 1}, - {&__pyx_kp_s_stopped, __pyx_k_stopped, sizeof(__pyx_k_stopped), 0, 0, 1, 0}, - {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, - {&__pyx_n_s_threading, __pyx_k_threading, sizeof(__pyx_k_threading), 0, 0, 1, 1}, - {&__pyx_n_s_threading_support, __pyx_k_threading_support, sizeof(__pyx_k_threading_support), 0, 0, 1, 1}, - {&__pyx_n_s_trace_hook, __pyx_k_trace_hook, sizeof(__pyx_k_trace_hook), 0, 0, 1, 1}, - {&__pyx_n_s_traceback, __pyx_k_traceback, sizeof(__pyx_k_traceback), 0, 0, 1, 1}, - {&__pyx_n_s_write, __pyx_k_write, sizeof(__pyx_k_write), 0, 0, 1, 1}, - {0, 0, 0, 0, 0, 0, 0} +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} }; -static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { - __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_n_s_id); if (!__pyx_builtin_id) __PYX_ERR(0, 68, __pyx_L1_error) - __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 2, __pyx_L1_error) - return 0; - __pyx_L1_error:; - return -1; -} - -static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - - /* "(tree fragment)":2 - * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - */ - __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__2); - __Pyx_GIVEREF(__pyx_tuple__2); - - /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< - */ - __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__3); - __Pyx_GIVEREF(__pyx_tuple__3); - - /* "hunter/_tracer.pyx":19 - * import hunter - * - * __all__ = 'Tracer', # <<<<<<<<<<<<<< - * - * cdef tuple KIND_NAMES = ('call', 'exception', 'line', 'return', 'c_call', 'c_exception', 'c_return') - */ - __pyx_tuple__4 = PyTuple_Pack(1, __pyx_n_s_Tracer); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 19, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__4); - __Pyx_GIVEREF(__pyx_tuple__4); - - /* "hunter/_tracer.pyx":21 - * __all__ = 'Tracer', - * - * cdef tuple KIND_NAMES = ('call', 'exception', 'line', 'return', 'c_call', 'c_exception', 'c_return') # <<<<<<<<<<<<<< - * - * - */ - __pyx_tuple__5 = PyTuple_Pack(7, __pyx_n_s_call, __pyx_n_s_exception, __pyx_n_s_line, __pyx_n_s_return, __pyx_n_s_c_call, __pyx_n_s_c_exception, __pyx_n_s_c_return); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 21, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__5); - __Pyx_GIVEREF(__pyx_tuple__5); - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_RefNannyFinishContext(); - return -1; -} - -static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { - __pyx_umethod_PyTuple_Type_index.type = (PyObject*)&PyTuple_Type; - if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); - return 0; - __pyx_L1_error:; - return -1; -} - -static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ - -static int __Pyx_modinit_global_init_code(void) { +/* #### Code section: initfunc_declarations ### */ +static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate); /*proto*/ +/* #### Code section: init_module ### */ + +static int __Pyx_modinit_global_init_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); /*--- Global init code ---*/ - __pyx_v_6hunter_7_tracer_KIND_NAMES = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_6hunter_7_tracer_KIND_INTS = ((PyObject*)Py_None); Py_INCREF(Py_None); __Pyx_RefNannyFinishContext(); return 0; } -static int __Pyx_modinit_variable_export_code(void) { +static int __Pyx_modinit_variable_export_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); /*--- Variable export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } -static int __Pyx_modinit_function_export_code(void) { +static int __Pyx_modinit_function_export_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); /*--- Function export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } -static int __Pyx_modinit_type_init_code(void) { +static int __Pyx_modinit_type_init_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); /*--- Type init code ---*/ - __pyx_t_1 = PyImport_ImportModule("types"); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 9, __pyx_L1_error) + __pyx_t_1 = PyImport_ImportModule("types"); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_6hunter_7_tracer_CodeType = __Pyx_ImportType(__pyx_t_1, "types", "CodeType", sizeof(PyCodeObject), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_6hunter_7_tracer_CodeType) __PYX_ERR(2, 9, __pyx_L1_error) - __pyx_ptype_6hunter_7_tracer_FrameType = __Pyx_ImportType(__pyx_t_1, "types", "FrameType", sizeof(PyFrameObject), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_6hunter_7_tracer_FrameType) __PYX_ERR(2, 13, __pyx_L1_error) - if (PyType_Ready(&__pyx_type_6hunter_7_tracer_Tracer) < 0) __PYX_ERR(0, 51, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_6hunter_7_tracer_Tracer.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6hunter_7_tracer_Tracer.tp_dictoffset && __pyx_type_6hunter_7_tracer_Tracer.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_6hunter_7_tracer_Tracer.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + __pyx_mstate->__pyx_ptype_6hunter_7_tracer_CodeType = __Pyx_ImportType_3_1_3(__pyx_t_1, "types", "CodeType", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyCodeObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(PyCodeObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyCodeObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(PyCodeObject), + #else + sizeof(PyCodeObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(PyCodeObject), + #endif + __Pyx_ImportType_CheckSize_Ignore_3_1_3); if (!__pyx_mstate->__pyx_ptype_6hunter_7_tracer_CodeType) __PYX_ERR(2, 12, __pyx_L1_error) + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_6hunter_7_tracer_Tracer = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6hunter_7_tracer_Tracer_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_6hunter_7_tracer_Tracer)) __PYX_ERR(0, 58, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_7_tracer_Tracer_spec, __pyx_mstate->__pyx_ptype_6hunter_7_tracer_Tracer) < 0) __PYX_ERR(0, 58, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_6hunter_7_tracer_Tracer = &__pyx_type_6hunter_7_tracer_Tracer; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_6hunter_7_tracer_Tracer) < 0) __PYX_ERR(0, 58, __pyx_L1_error) + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_6hunter_7_tracer_Tracer->tp_dictoffset && __pyx_mstate->__pyx_ptype_6hunter_7_tracer_Tracer->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_6hunter_7_tracer_Tracer->tp_getattro = PyObject_GenericGetAttr; } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Tracer, (PyObject *)&__pyx_type_6hunter_7_tracer_Tracer) < 0) __PYX_ERR(0, 51, __pyx_L1_error) - if (__pyx_type_6hunter_7_tracer_Tracer.tp_weaklistoffset == 0) __pyx_type_6hunter_7_tracer_Tracer.tp_weaklistoffset = offsetof(struct __pyx_obj_6hunter_7_tracer_Tracer, __weakref__); - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6hunter_7_tracer_Tracer) < 0) __PYX_ERR(0, 51, __pyx_L1_error) - __pyx_ptype_6hunter_7_tracer_Tracer = &__pyx_type_6hunter_7_tracer_Tracer; + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_Tracer, (PyObject *) __pyx_mstate->__pyx_ptype_6hunter_7_tracer_Tracer) < 0) __PYX_ERR(0, 58, __pyx_L1_error) + #if CYTHON_USE_TYPE_SLOTS + if (__pyx_mstate->__pyx_ptype_6hunter_7_tracer_Tracer->tp_weaklistoffset == 0) __pyx_mstate->__pyx_ptype_6hunter_7_tracer_Tracer->tp_weaklistoffset = offsetof(struct __pyx_obj_6hunter_7_tracer_Tracer, __weakref__); + #endif + if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_6hunter_7_tracer_Tracer) < 0) __PYX_ERR(0, 58, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; @@ -4538,77 +7156,150 @@ static int __Pyx_modinit_type_init_code(void) { return -1; } -static int __Pyx_modinit_type_import_code(void) { +static int __Pyx_modinit_type_import_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); /*--- Type import code ---*/ __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", + __pyx_mstate->__pyx_ptype_7cpython_4type_type = __Pyx_ImportType_3_1_3(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 - sizeof(PyTypeObject), + sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(PyTypeObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + 0, 0, #else - sizeof(PyHeapTypeObject), + sizeof(PyHeapTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(PyHeapTypeObject), #endif - __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(3, 9, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_7cpython_4bool_bool = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "bool", sizeof(PyBoolObject), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_7cpython_4bool_bool) __PYX_ERR(4, 8, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_7cpython_7complex_complex = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "complex", sizeof(PyComplexObject), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_7cpython_7complex_complex) __PYX_ERR(5, 15, __pyx_L1_error) + __Pyx_ImportType_CheckSize_Warn_3_1_3); if (!__pyx_mstate->__pyx_ptype_7cpython_4type_type) __PYX_ERR(3, 9, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyImport_ImportModule("hunter._event"); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 11, __pyx_L1_error) + __pyx_t_1 = PyImport_ImportModule("types"); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_6hunter_6_event_Event = __Pyx_ImportType(__pyx_t_1, "hunter._event", "Event", sizeof(struct __pyx_obj_6hunter_6_event_Event), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_6hunter_6_event_Event) __PYX_ERR(6, 11, __pyx_L1_error) - __pyx_vtabptr_6hunter_6_event_Event = (struct __pyx_vtabstruct_6hunter_6_event_Event*)__Pyx_GetVtable(__pyx_ptype_6hunter_6_event_Event->tp_dict); if (unlikely(!__pyx_vtabptr_6hunter_6_event_Event)) __PYX_ERR(6, 11, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyImport_ImportModule("hunter._predicates"); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_6hunter_11_predicates_Query = __Pyx_ImportType(__pyx_t_1, "hunter._predicates", "Query", sizeof(struct __pyx_obj_6hunter_11_predicates_Query), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_6hunter_11_predicates_Query) __PYX_ERR(7, 8, __pyx_L1_error) - __pyx_ptype_6hunter_11_predicates_And = __Pyx_ImportType(__pyx_t_1, "hunter._predicates", "And", sizeof(struct __pyx_obj_6hunter_11_predicates_And), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_6hunter_11_predicates_And) __PYX_ERR(7, 22, __pyx_L1_error) - __pyx_ptype_6hunter_11_predicates_Or = __Pyx_ImportType(__pyx_t_1, "hunter._predicates", "Or", sizeof(struct __pyx_obj_6hunter_11_predicates_Or), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_6hunter_11_predicates_Or) __PYX_ERR(7, 27, __pyx_L1_error) - __pyx_ptype_6hunter_11_predicates_Not = __Pyx_ImportType(__pyx_t_1, "hunter._predicates", "Not", sizeof(struct __pyx_obj_6hunter_11_predicates_Not), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_6hunter_11_predicates_Not) __PYX_ERR(7, 32, __pyx_L1_error) - __pyx_ptype_6hunter_11_predicates_When = __Pyx_ImportType(__pyx_t_1, "hunter._predicates", "When", sizeof(struct __pyx_obj_6hunter_11_predicates_When), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_6hunter_11_predicates_When) __PYX_ERR(7, 37, __pyx_L1_error) - __pyx_ptype_6hunter_11_predicates_From = __Pyx_ImportType(__pyx_t_1, "hunter._predicates", "From", sizeof(struct __pyx_obj_6hunter_11_predicates_From), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_6hunter_11_predicates_From) __PYX_ERR(7, 43, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_6hunter_6_event_CodeType = __Pyx_ImportType_3_1_3(__pyx_t_1, "types", "CodeType", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyCodeObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(PyCodeObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyCodeObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(PyCodeObject), + #else + sizeof(PyCodeObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(PyCodeObject), + #endif + __Pyx_ImportType_CheckSize_Ignore_3_1_3); if (!__pyx_mstate->__pyx_ptype_6hunter_6_event_CodeType) __PYX_ERR(4, 7, __pyx_L1_error) + __pyx_t_2 = PyImport_ImportModule("hunter._event"); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_mstate->__pyx_ptype_6hunter_6_event_Event = __Pyx_ImportType_3_1_3(__pyx_t_2, "hunter._event", "Event", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(struct __pyx_obj_6hunter_6_event_Event), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(struct __pyx_obj_6hunter_6_event_Event), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(struct __pyx_obj_6hunter_6_event_Event), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(struct __pyx_obj_6hunter_6_event_Event), + #else + sizeof(struct __pyx_obj_6hunter_6_event_Event), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(struct __pyx_obj_6hunter_6_event_Event), + #endif + __Pyx_ImportType_CheckSize_Warn_3_1_3); if (!__pyx_mstate->__pyx_ptype_6hunter_6_event_Event) __PYX_ERR(4, 39, __pyx_L1_error) + __pyx_vtabptr_6hunter_6_event_Event = (struct __pyx_vtabstruct_6hunter_6_event_Event*)__Pyx_GetVtable(__pyx_mstate->__pyx_ptype_6hunter_6_event_Event); if (unlikely(!__pyx_vtabptr_6hunter_6_event_Event)) __PYX_ERR(4, 39, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyImport_ImportModule("hunter._predicates"); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Query = __Pyx_ImportType_3_1_3(__pyx_t_2, "hunter._predicates", "Query", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(struct __pyx_obj_6hunter_11_predicates_Query), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(struct __pyx_obj_6hunter_11_predicates_Query), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(struct __pyx_obj_6hunter_11_predicates_Query), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(struct __pyx_obj_6hunter_11_predicates_Query), + #else + sizeof(struct __pyx_obj_6hunter_11_predicates_Query), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(struct __pyx_obj_6hunter_11_predicates_Query), + #endif + __Pyx_ImportType_CheckSize_Warn_3_1_3); if (!__pyx_mstate->__pyx_ptype_6hunter_11_predicates_Query) __PYX_ERR(5, 7, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_6hunter_11_predicates_And = __Pyx_ImportType_3_1_3(__pyx_t_2, "hunter._predicates", "And", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(struct __pyx_obj_6hunter_11_predicates_And), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(struct __pyx_obj_6hunter_11_predicates_And), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(struct __pyx_obj_6hunter_11_predicates_And), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(struct __pyx_obj_6hunter_11_predicates_And), + #else + sizeof(struct __pyx_obj_6hunter_11_predicates_And), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(struct __pyx_obj_6hunter_11_predicates_And), + #endif + __Pyx_ImportType_CheckSize_Warn_3_1_3); if (!__pyx_mstate->__pyx_ptype_6hunter_11_predicates_And) __PYX_ERR(5, 22, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Or = __Pyx_ImportType_3_1_3(__pyx_t_2, "hunter._predicates", "Or", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(struct __pyx_obj_6hunter_11_predicates_Or), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(struct __pyx_obj_6hunter_11_predicates_Or), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(struct __pyx_obj_6hunter_11_predicates_Or), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(struct __pyx_obj_6hunter_11_predicates_Or), + #else + sizeof(struct __pyx_obj_6hunter_11_predicates_Or), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(struct __pyx_obj_6hunter_11_predicates_Or), + #endif + __Pyx_ImportType_CheckSize_Warn_3_1_3); if (!__pyx_mstate->__pyx_ptype_6hunter_11_predicates_Or) __PYX_ERR(5, 28, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Not = __Pyx_ImportType_3_1_3(__pyx_t_2, "hunter._predicates", "Not", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(struct __pyx_obj_6hunter_11_predicates_Not), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(struct __pyx_obj_6hunter_11_predicates_Not), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(struct __pyx_obj_6hunter_11_predicates_Not), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(struct __pyx_obj_6hunter_11_predicates_Not), + #else + sizeof(struct __pyx_obj_6hunter_11_predicates_Not), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(struct __pyx_obj_6hunter_11_predicates_Not), + #endif + __Pyx_ImportType_CheckSize_Warn_3_1_3); if (!__pyx_mstate->__pyx_ptype_6hunter_11_predicates_Not) __PYX_ERR(5, 34, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_6hunter_11_predicates_When = __Pyx_ImportType_3_1_3(__pyx_t_2, "hunter._predicates", "When", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(struct __pyx_obj_6hunter_11_predicates_When), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(struct __pyx_obj_6hunter_11_predicates_When), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(struct __pyx_obj_6hunter_11_predicates_When), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(struct __pyx_obj_6hunter_11_predicates_When), + #else + sizeof(struct __pyx_obj_6hunter_11_predicates_When), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(struct __pyx_obj_6hunter_11_predicates_When), + #endif + __Pyx_ImportType_CheckSize_Warn_3_1_3); if (!__pyx_mstate->__pyx_ptype_6hunter_11_predicates_When) __PYX_ERR(5, 40, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_6hunter_11_predicates_From = __Pyx_ImportType_3_1_3(__pyx_t_2, "hunter._predicates", "From", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(struct __pyx_obj_6hunter_11_predicates_From), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(struct __pyx_obj_6hunter_11_predicates_From), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(struct __pyx_obj_6hunter_11_predicates_From), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(struct __pyx_obj_6hunter_11_predicates_From), + #else + sizeof(struct __pyx_obj_6hunter_11_predicates_From), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(struct __pyx_obj_6hunter_11_predicates_From), + #endif + __Pyx_ImportType_CheckSize_Warn_3_1_3); if (!__pyx_mstate->__pyx_ptype_6hunter_11_predicates_From) __PYX_ERR(5, 47, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_6hunter_11_predicates_Backlog = __Pyx_ImportType_3_1_3(__pyx_t_2, "hunter._predicates", "Backlog", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(struct __pyx_obj_6hunter_11_predicates_Backlog), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(struct __pyx_obj_6hunter_11_predicates_Backlog), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(struct __pyx_obj_6hunter_11_predicates_Backlog), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(struct __pyx_obj_6hunter_11_predicates_Backlog), + #else + sizeof(struct __pyx_obj_6hunter_11_predicates_Backlog), __PYX_GET_STRUCT_ALIGNMENT_3_1_3(struct __pyx_obj_6hunter_11_predicates_Backlog), + #endif + __Pyx_ImportType_CheckSize_Warn_3_1_3); if (!__pyx_mstate->__pyx_ptype_6hunter_11_predicates_Backlog) __PYX_ERR(5, 57, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); __Pyx_RefNannyFinishContext(); return -1; } -static int __Pyx_modinit_variable_import_code(void) { +static int __Pyx_modinit_variable_import_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); /*--- Variable import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } -static int __Pyx_modinit_function_import_code(void) { +static int __Pyx_modinit_function_import_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); /*--- Function import code ---*/ __pyx_t_1 = PyImport_ImportModule("hunter._predicates"); if (!__pyx_t_1) __PYX_ERR(0, 1, __pyx_L1_error) - if (__Pyx_ImportFunction(__pyx_t_1, "fast_call", (void (**)(void))&__pyx_f_6hunter_11_predicates_fast_call, "PyObject *(PyObject *, struct __pyx_obj_6hunter_6_event_Event *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) - Py_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_ImportFunction_3_1_3(__pyx_t_1, "fast_call", (void (**)(void))&__pyx_f_6hunter_11_predicates_fast_call, "PyObject *(PyObject *, struct __pyx_obj_6hunter_6_event_Event *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; @@ -4617,48 +7308,121 @@ static int __Pyx_modinit_function_import_code(void) { return -1; } - -#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 - - -#if PY_MAJOR_VERSION < 3 -__Pyx_PyMODINIT_FUNC init_tracer(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC init_tracer(void) -#else -__Pyx_PyMODINIT_FUNC PyInit__tracer(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC PyInit__tracer(void) +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec__tracer(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec__tracer}, + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + {Py_mod_gil, Py_MOD_GIL_NOT_USED}, + #endif + #if PY_VERSION_HEX >= 0x030C0000 && CYTHON_USE_MODULE_STATE + {Py_mod_multiple_interpreters, Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED}, + #endif + {0, NULL} +}; +#endif + +#ifdef __cplusplus +namespace { + struct PyModuleDef __pyx_moduledef = + #else + static struct PyModuleDef __pyx_moduledef = + #endif + { + PyModuleDef_HEAD_INIT, + "_tracer", + 0, /* m_doc */ + #if CYTHON_USE_MODULE_STATE + sizeof(__pyx_mstatetype), /* m_size */ + #else + (CYTHON_PEP489_MULTI_PHASE_INIT) ? 0 : -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + #if CYTHON_USE_MODULE_STATE + __pyx_m_traverse, /* m_traverse */ + __pyx_m_clear, /* m_clear */ + NULL /* m_free */ + #else + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ + #endif + }; + #ifdef __cplusplus +} /* anonymous namespace */ +#endif + +/* PyModInitFuncType */ +#ifndef CYTHON_NO_PYINIT_EXPORT + #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#else + #ifdef __cplusplus + #define __Pyx_PyMODINIT_FUNC extern "C" PyObject * + #else + #define __Pyx_PyMODINIT_FUNC PyObject * + #endif +#endif + +__Pyx_PyMODINIT_FUNC PyInit__tracer(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit__tracer(void) #if CYTHON_PEP489_MULTI_PHASE_INIT { return PyModuleDef_Init(&__pyx_moduledef); } +/* ModuleCreationPEP489 */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x03090000 +static PY_INT64_T __Pyx_GetCurrentInterpreterId(void) { + { + PyObject *module = PyImport_ImportModule("_interpreters"); // 3.13+ I think + if (!module) { + PyErr_Clear(); // just try the 3.8-3.12 version + module = PyImport_ImportModule("_xxsubinterpreters"); + if (!module) goto bad; + } + PyObject *current = PyObject_CallMethod(module, "get_current", NULL); + Py_DECREF(module); + if (!current) goto bad; + if (PyTuple_Check(current)) { + PyObject *new_current = PySequence_GetItem(current, 0); + Py_DECREF(current); + current = new_current; + if (!new_current) goto bad; + } + long long as_c_int = PyLong_AsLongLong(current); + Py_DECREF(current); + return as_c_int; + } + bad: + PySys_WriteStderr("__Pyx_GetCurrentInterpreterId failed. Try setting the C define CYTHON_PEP489_MULTI_PHASE_INIT=0\n"); + return -1; +} +#endif +#if !CYTHON_USE_MODULE_STATE static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { - #if PY_VERSION_HEX >= 0x030700A1 static PY_INT64_T main_interpreter_id = -1; +#if CYTHON_COMPILING_IN_GRAAL + PY_INT64_T current_id = PyInterpreterState_GetIDFromThreadState(PyThreadState_Get()); +#elif CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX >= 0x03090000 + PY_INT64_T current_id = PyInterpreterState_GetID(PyInterpreterState_Get()); +#elif CYTHON_COMPILING_IN_LIMITED_API + PY_INT64_T current_id = __Pyx_GetCurrentInterpreterId(); +#else PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); +#endif + if (unlikely(current_id == -1)) { + return -1; + } if (main_interpreter_id == -1) { main_interpreter_id = current_id; - return (unlikely(current_id == -1)) ? -1 : 0; - } else if (unlikely(main_interpreter_id != current_id)) - #else - static PyInterpreterState *main_interpreter = NULL; - PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; - if (!main_interpreter) { - main_interpreter = current_interpreter; - } else if (unlikely(main_interpreter != current_interpreter)) - #endif - { + return 0; + } else if (unlikely(main_interpreter_id != current_id)) { PyErr_SetString( PyExc_ImportError, "Interpreter change detected - this module can only be loaded into one interpreter per process."); @@ -4666,7 +7430,9 @@ static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { } return 0; } -static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { +#endif +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) +{ PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { @@ -4681,10 +7447,13 @@ static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject } return result; } -static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; + CYTHON_UNUSED_VAR(def); + #if !CYTHON_USE_MODULE_STATE if (__Pyx_check_single_interpreter()) return NULL; + #endif if (__pyx_m) return __Pyx_NewRef(__pyx_m); modname = PyObject_GetAttrString(spec, "name"); @@ -4707,10 +7476,18 @@ static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNU static CYTHON_SMALL_CODE int __pyx_pymod_exec__tracer(PyObject *__pyx_pyinit_module) #endif -#endif { - __Pyx_TraceDeclarations + int stringtab_initialized = 0; + #if CYTHON_USE_MODULE_STATE + int pystate_addmodule_run = 0; + #endif + __pyx_mstatetype *__pyx_mstate = NULL; + __Pyx_TraceDeclarationsFunc PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannyDeclarations #if CYTHON_PEP489_MULTI_PHASE_INIT if (__pyx_m) { @@ -4718,9 +7495,37 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec__tracer(PyObject *__pyx_pyinit_mod PyErr_SetString(PyExc_RuntimeError, "Module '_tracer' has already been imported. Re-initialisation is not supported."); return -1; } - #elif PY_MAJOR_VERSION >= 3 + #else if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_t_1 = __pyx_pyinit_module; + Py_INCREF(__pyx_t_1); + #else + __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #if CYTHON_USE_MODULE_STATE + { + int add_module_result = __Pyx_State_AddModule(__pyx_t_1, &__pyx_moduledef); + __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "_tracer" pseudovariable */ + if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + pystate_addmodule_run = 1; + } + #else + __pyx_m = __pyx_t_1; + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + PyUnstable_Module_SetGIL(__pyx_m, Py_MOD_GIL_NOT_USED); + #endif + __pyx_mstate = __pyx_mstate_global; + CYTHON_UNUSED_VAR(__pyx_t_1); + __pyx_mstate->__pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_mstate->__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_mstate->__pyx_d); + __pyx_mstate->__pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_mstate->__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_cython_runtime = __Pyx_PyImport_AddModuleRef("cython_runtime"); if (unlikely(!__pyx_mstate->__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_mstate->__pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /* ImportRefnannyAPI */ #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { @@ -4730,185 +7535,252 @@ if (!__Pyx_RefNanny) { Py_FatalError("failed to import 'refnanny' module"); } #endif - __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit__tracer(void)", 0); - if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + +__Pyx_RefNannySetupContext("PyInit__tracer", 0); + if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pxy_PyFrame_Initialize_Offsets __Pxy_PyFrame_Initialize_Offsets(); #endif - __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) + __pyx_mstate->__pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_mstate->__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_mstate->__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_mstate->__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitConstants(__pyx_mstate) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + stringtab_initialized = 1; + if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #if 0 || defined(__Pyx_CyFunction_USED) || defined(__Pyx_FusedFunction_USED) || defined(__Pyx_Coroutine_USED) || defined(__Pyx_Generator_USED) || defined(__Pyx_AsyncGen_USED) + if (__pyx_CommonTypesMetaclass_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif #ifdef __Pyx_CyFunction_USED - if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_CyFunction_init(__pyx_m) < 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) + if (__pyx_FusedFunction_init(__pyx_m) < 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) + if (__pyx_Coroutine_init(__pyx_m) < 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) + if (__pyx_Generator_init(__pyx_m) < 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) + if (__pyx_AsyncGen_init(__pyx_m) < 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("_tracer", __pyx_methods, 0, 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) - Py_INCREF(__pyx_b); - __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_cython_runtime); - 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_hunter___tracer) { - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_name, __pyx_mstate_global->__pyx_n_u_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, "hunter._tracer")) { - if (unlikely(PyDict_SetItemString(modules, "hunter._tracer", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + if (unlikely((PyDict_SetItemString(modules, "hunter._tracer", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) } } - #endif /*--- Builtin init code ---*/ - if (__Pyx_InitCachedBuiltins() < 0) goto __pyx_L1_error; + if (__Pyx_InitCachedBuiltins(__pyx_mstate) < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Constants init code ---*/ - if (__Pyx_InitCachedConstants() < 0) goto __pyx_L1_error; + if (__Pyx_InitCachedConstants(__pyx_mstate) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_CreateCodeObjects(__pyx_mstate) < 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(); - if (unlikely(__Pyx_modinit_type_init_code() != 0)) goto __pyx_L1_error; - if (unlikely(__Pyx_modinit_type_import_code() != 0)) goto __pyx_L1_error; - (void)__Pyx_modinit_variable_import_code(); - if (unlikely(__Pyx_modinit_function_import_code() != 0)) goto __pyx_L1_error; + (void)__Pyx_modinit_global_init_code(__pyx_mstate); + (void)__Pyx_modinit_variable_export_code(__pyx_mstate); + (void)__Pyx_modinit_function_export_code(__pyx_mstate); + if (unlikely((__Pyx_modinit_type_init_code(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_type_import_code(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + (void)__Pyx_modinit_variable_import_code(__pyx_mstate); + if (unlikely((__Pyx_modinit_function_import_code(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Execution code ---*/ - #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) - if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - __Pyx_TraceCall("__Pyx_PyMODINIT_FUNC PyInit__tracer(void)", __pyx_f[0], 1, 0, __PYX_ERR(0, 1, __pyx_L1_error)); + __Pyx_TraceStartFunc("PyInit__tracer", __pyx_f[0], 1, 0, 0, 0, __PYX_ERR(0, 1, __pyx_L1_error)); /* "hunter/_tracer.pyx":2 - * # cython: linetrace=True, language_level=3str + * # cython: linetrace=True, language_level=3str, freethreading_compatible=True * import threading # <<<<<<<<<<<<<< * import traceback * - */ - __Pyx_TraceLine(2,0,__PYX_ERR(0, 2, __pyx_L1_error)) - __pyx_t_1 = __Pyx_Import(__pyx_n_s_threading, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_threading, __pyx_t_1) < 0) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; +*/ + __Pyx_TraceLine(2,2,0,__PYX_ERR(0, 2, __pyx_L1_error)) + __pyx_t_2 = __Pyx_ImportDottedModule(__pyx_mstate_global->__pyx_n_u_threading, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_threading, __pyx_t_2) < 0) __PYX_ERR(0, 2, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "hunter/_tracer.pyx":3 - * # cython: linetrace=True, language_level=3str + * # cython: linetrace=True, language_level=3str, freethreading_compatible=True * import threading * import traceback # <<<<<<<<<<<<<< * - * from cpython cimport pystate - */ - __Pyx_TraceLine(3,0,__PYX_ERR(0, 3, __pyx_L1_error)) - __pyx_t_1 = __Pyx_Import(__pyx_n_s_traceback, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_traceback, __pyx_t_1) < 0) __PYX_ERR(0, 3, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + * from cpython.pystate cimport PyThreadState_Get +*/ + __Pyx_TraceLine(3,4,0,__PYX_ERR(0, 3, __pyx_L1_error)) + __pyx_t_2 = __Pyx_ImportDottedModule(__pyx_mstate_global->__pyx_n_u_traceback, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_traceback, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "hunter/_tracer.pyx":17 - * from ._predicates cimport When + /* "hunter/_tracer.pyx":10 + * from ._predicates cimport fast_call * * import hunter # <<<<<<<<<<<<<< * * __all__ = 'Tracer', - */ - __Pyx_TraceLine(17,0,__PYX_ERR(0, 17, __pyx_L1_error)) - __pyx_t_1 = __Pyx_Import(__pyx_n_s_hunter, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_hunter, __pyx_t_1) < 0) __PYX_ERR(0, 17, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; +*/ + __Pyx_TraceLine(10,9,0,__PYX_ERR(0, 10, __pyx_L1_error)) + __pyx_t_2 = __Pyx_ImportDottedModule(__pyx_mstate_global->__pyx_n_u_hunter, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_hunter, __pyx_t_2) < 0) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "hunter/_tracer.pyx":19 + /* "hunter/_tracer.pyx":12 * import hunter * * __all__ = 'Tracer', # <<<<<<<<<<<<<< * - * cdef tuple KIND_NAMES = ('call', 'exception', 'line', 'return', 'c_call', 'c_exception', 'c_return') - */ - __Pyx_TraceLine(19,0,__PYX_ERR(0, 19, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_d, __pyx_n_s_all, __pyx_tuple__4) < 0) __PYX_ERR(0, 19, __pyx_L1_error) + * cdef dict KIND_INTS = { +*/ + __Pyx_TraceLine(12,11,0,__PYX_ERR(0, 12, __pyx_L1_error)) + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_all, __pyx_mstate_global->__pyx_tuple[0]) < 0) __PYX_ERR(0, 12, __pyx_L1_error) - /* "hunter/_tracer.pyx":21 - * __all__ = 'Tracer', + /* "hunter/_tracer.pyx":15 * - * cdef tuple KIND_NAMES = ('call', 'exception', 'line', 'return', 'c_call', 'c_exception', 'c_return') # <<<<<<<<<<<<<< + * cdef dict KIND_INTS = { + * 'call': 0, # <<<<<<<<<<<<<< + * 'exception': 1, + * 'line': 2, +*/ + __Pyx_TraceLine(15,13,0,__PYX_ERR(0, 15, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_call, __pyx_mstate_global->__pyx_int_0) < 0) __PYX_ERR(0, 15, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_exception, __pyx_mstate_global->__pyx_int_1) < 0) __PYX_ERR(0, 15, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_line, __pyx_mstate_global->__pyx_int_2) < 0) __PYX_ERR(0, 15, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_int_3) < 0) __PYX_ERR(0, 15, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_c_call, __pyx_mstate_global->__pyx_int_4) < 0) __PYX_ERR(0, 15, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_c_exception, __pyx_mstate_global->__pyx_int_5) < 0) __PYX_ERR(0, 15, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_c_return, __pyx_mstate_global->__pyx_int_6) < 0) __PYX_ERR(0, 15, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_v_6hunter_7_tracer_KIND_INTS); + __Pyx_DECREF_SET(__pyx_v_6hunter_7_tracer_KIND_INTS, ((PyObject*)__pyx_t_2)); + __Pyx_GIVEREF(__pyx_t_2); + __pyx_t_2 = 0; + + /* "hunter/_tracer.pyx":24 + * } * + * cdef int trace_func(PyObject* tracer, PyFrameObject* frame, int kind, PyObject* arg) noexcept: # <<<<<<<<<<<<<< + * cdef Tracer self = tracer + * cdef FrameType frame_object = frame +*/ + __Pyx_TraceLine(24,27,0,__PYX_ERR(0, 24, __pyx_L1_error)) + + + /* "hunter/_tracer.pyx":90 + * return self * - */ - __Pyx_TraceLine(21,0,__PYX_ERR(0, 21, __pyx_L1_error)) - __Pyx_INCREF(__pyx_tuple__5); - __Pyx_XGOTREF(__pyx_v_6hunter_7_tracer_KIND_NAMES); - __Pyx_DECREF_SET(__pyx_v_6hunter_7_tracer_KIND_NAMES, __pyx_tuple__5); - __Pyx_GIVEREF(__pyx_tuple__5); + * def trace(self, predicate): # <<<<<<<<<<<<<< + * self.handler = predicate + * cdef PyThreadState *state = PyThreadState_Get() +*/ + __Pyx_TraceLine(90,40,0,__PYX_ERR(0, 90, __pyx_L1_error)) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_7_tracer_6Tracer_9trace, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Tracer_trace, NULL, __pyx_mstate_global->__pyx_n_u_hunter__tracer, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[5])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6hunter_7_tracer_Tracer, __pyx_mstate_global->__pyx_n_u_trace, __pyx_t_2) < 0) __PYX_ERR(0, 90, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "hunter/_tracer.pyx":24 + /* "hunter/_tracer.pyx":118 + * return self + * + * def stop(self): # <<<<<<<<<<<<<< + * if self.handler is not None: + * if self.profiling_mode: +*/ + __Pyx_TraceLine(118,41,0,__PYX_ERR(0, 118, __pyx_L1_error)) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_7_tracer_6Tracer_11stop, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Tracer_stop, NULL, __pyx_mstate_global->__pyx_n_u_hunter__tracer, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[6])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 118, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6hunter_7_tracer_Tracer, __pyx_mstate_global->__pyx_n_u_stop, __pyx_t_2) < 0) __PYX_ERR(0, 118, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "hunter/_tracer.pyx":141 + * self._threading_previous = None * + * def __enter__(self): # <<<<<<<<<<<<<< + * return self * - * cdef int trace_func(Tracer self, FrameType frame, int kind, PyObject *arg) except -1: # <<<<<<<<<<<<<< - * if frame.f_trace is not self: - * Py_CLEAR(frame.f_trace) - */ - __Pyx_TraceLine(24,0,__PYX_ERR(0, 24, __pyx_L1_error)) +*/ + __Pyx_TraceLine(141,42,0,__PYX_ERR(0, 141, __pyx_L1_error)) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_7_tracer_6Tracer_13__enter__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Tracer___enter, NULL, __pyx_mstate_global->__pyx_n_u_hunter__tracer, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[7])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6hunter_7_tracer_Tracer, __pyx_mstate_global->__pyx_n_u_enter, __pyx_t_2) < 0) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "hunter/_tracer.pyx":144 + * return self + * + * def __exit__(self, exc_type, exc_val, exc_tb): # <<<<<<<<<<<<<< + * self.stop() +*/ + __Pyx_TraceLine(144,43,0,__PYX_ERR(0, 144, __pyx_L1_error)) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_7_tracer_6Tracer_15__exit__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Tracer___exit, NULL, __pyx_mstate_global->__pyx_n_u_hunter__tracer, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[8])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6hunter_7_tracer_Tracer, __pyx_mstate_global->__pyx_n_u_exit, __pyx_t_2) < 0) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): +*/ + __Pyx_TraceLine(1,1,0,__PYX_ERR(1, 1, __pyx_L1_error)) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_7_tracer_6Tracer_17__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Tracer___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_hunter__tracer, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[16])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" +*/ + __Pyx_TraceLine(3,3,0,__PYX_ERR(1, 3, __pyx_L1_error)) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_7_tracer_6Tracer_19__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Tracer___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_hunter__tracer, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[17])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "hunter/_tracer.pyx":1 - * # cython: linetrace=True, language_level=3str # <<<<<<<<<<<<<< + * # cython: linetrace=True, language_level=3str, freethreading_compatible=True # <<<<<<<<<<<<<< * import threading * import traceback - */ - __Pyx_TraceLine(1,0,__PYX_ERR(0, 1, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_TraceReturn(Py_None, 0); +*/ + __Pyx_TraceLine(1,0,0,__PYX_ERR(0, 1, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_TraceReturnValue(Py_None, 0, 0, __PYX_ERR(0, 1, __pyx_L1_error)); + __Pyx_PyMonitoring_ExitScope(0); /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_TraceException(__pyx_lineno, 0, 0); + __Pyx_TraceExceptionUnwind(0, 0); if (__pyx_m) { - if (__pyx_d) { + if (__pyx_mstate->__pyx_d && stringtab_initialized) { __Pyx_AddTraceback("init hunter._tracer", __pyx_clineno, __pyx_lineno, __pyx_filename); } + #if !CYTHON_USE_MODULE_STATE Py_CLEAR(__pyx_m); + #else + Py_DECREF(__pyx_m); + if (pystate_addmodule_run) { + PyObject *tp, *value, *tb; + PyErr_Fetch(&tp, &value, &tb); + PyState_RemoveModule(&__pyx_moduledef); + PyErr_Restore(tp, value, tb); + } + #endif } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init hunter._tracer"); } @@ -4916,12 +7788,355 @@ if (!__Pyx_RefNanny) { __Pyx_RefNannyFinishContext(); #if CYTHON_PEP489_MULTI_PHASE_INIT return (__pyx_m != NULL) ? 0 : -1; - #elif PY_MAJOR_VERSION >= 3 - return __pyx_m; #else - return; + return __pyx_m; #endif } +/* #### Code section: pystring_table ### */ + +typedef struct { + const char *s; +#if 179 <= 65535 + const unsigned short n; +#elif 179 / 2 < INT_MAX + const unsigned int n; +#elif 179 / 2 < LONG_MAX + const unsigned long n; +#else + const Py_ssize_t n; +#endif +#if 1 <= 31 + const unsigned int encoding : 5; +#elif 1 <= 255 + const unsigned char encoding; +#elif 1 <= 65535 + const unsigned short encoding; +#else + const Py_ssize_t encoding; +#endif + const unsigned int is_unicode : 1; + const unsigned int intern : 1; +} __Pyx_StringTabEntry; +static const char * const __pyx_string_tab_encodings[] = { 0 }; +static const __Pyx_StringTabEntry __pyx_string_tab[] = { + {__pyx_k_, sizeof(__pyx_k_), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_ */ + {__pyx_k_Disabling_tracer_because_handler, sizeof(__pyx_k_Disabling_tracer_because_handler), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Disabling_tracer_because_handler */ + {__pyx_k_KIND_INTS, sizeof(__pyx_k_KIND_INTS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_KIND_INTS */ + {__pyx_k_None, sizeof(__pyx_k_None), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_None */ + {__pyx_k_Note_that_Cython_is_deliberately, sizeof(__pyx_k_Note_that_Cython_is_deliberately), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Note_that_Cython_is_deliberately */ + {__pyx_k_Tracer, sizeof(__pyx_k_Tracer), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Tracer */ + {__pyx_k_Tracer___enter, sizeof(__pyx_k_Tracer___enter), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Tracer___enter */ + {__pyx_k_Tracer___exit, sizeof(__pyx_k_Tracer___exit), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Tracer___exit */ + {__pyx_k_Tracer___reduce_cython, sizeof(__pyx_k_Tracer___reduce_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Tracer___reduce_cython */ + {__pyx_k_Tracer___setstate_cython, sizeof(__pyx_k_Tracer___setstate_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Tracer___setstate_cython */ + {__pyx_k_Tracer_stop, sizeof(__pyx_k_Tracer_stop), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Tracer_stop */ + {__pyx_k_Tracer_trace, sizeof(__pyx_k_Tracer_trace), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Tracer_trace */ + {__pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TypeError */ + {__pyx_k__2, sizeof(__pyx_k__2), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__2 */ + {__pyx_k__3, sizeof(__pyx_k__3), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__3 */ + {__pyx_k__4, sizeof(__pyx_k__4), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__4 */ + {__pyx_k__5, sizeof(__pyx_k__5), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__5 */ + {__pyx_k_add_note, sizeof(__pyx_k_add_note), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_add_note */ + {__pyx_k_all, sizeof(__pyx_k_all), 0, 1, 1}, /* PyObject cname: __pyx_n_u_all */ + {__pyx_k_arg, sizeof(__pyx_k_arg), 0, 1, 1}, /* PyObject cname: __pyx_n_u_arg */ + {__pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 1, 1}, /* PyObject cname: __pyx_n_u_asyncio_coroutines */ + {__pyx_k_at, sizeof(__pyx_k_at), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_at */ + {__pyx_k_c_call, sizeof(__pyx_k_c_call), 0, 1, 1}, /* PyObject cname: __pyx_n_u_c_call */ + {__pyx_k_c_exception, sizeof(__pyx_k_c_exception), 0, 1, 1}, /* PyObject cname: __pyx_n_u_c_exception */ + {__pyx_k_c_return, sizeof(__pyx_k_c_return), 0, 1, 1}, /* PyObject cname: __pyx_n_u_c_return */ + {__pyx_k_call, sizeof(__pyx_k_call), 0, 1, 1}, /* PyObject cname: __pyx_n_u_call */ + {__pyx_k_call_2, sizeof(__pyx_k_call_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_call_2 */ + {__pyx_k_cinit, sizeof(__pyx_k_cinit), 0, 1, 1}, /* PyObject cname: __pyx_n_u_cinit */ + {__pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 1, 1}, /* PyObject cname: __pyx_n_u_cline_in_traceback */ + {__pyx_k_dealloc, sizeof(__pyx_k_dealloc), 0, 1, 1}, /* PyObject cname: __pyx_n_u_dealloc */ + {__pyx_k_default_stream, sizeof(__pyx_k_default_stream), 0, 1, 1}, /* PyObject cname: __pyx_n_u_default_stream */ + {__pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_disable */ + {__pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_enable */ + {__pyx_k_enter, sizeof(__pyx_k_enter), 0, 1, 1}, /* PyObject cname: __pyx_n_u_enter */ + {__pyx_k_exc_tb, sizeof(__pyx_k_exc_tb), 0, 1, 1}, /* PyObject cname: __pyx_n_u_exc_tb */ + {__pyx_k_exc_type, sizeof(__pyx_k_exc_type), 0, 1, 1}, /* PyObject cname: __pyx_n_u_exc_type */ + {__pyx_k_exc_val, sizeof(__pyx_k_exc_val), 0, 1, 1}, /* PyObject cname: __pyx_n_u_exc_val */ + {__pyx_k_exception, sizeof(__pyx_k_exception), 0, 1, 1}, /* PyObject cname: __pyx_n_u_exception */ + {__pyx_k_exit, sizeof(__pyx_k_exit), 0, 1, 1}, /* PyObject cname: __pyx_n_u_exit */ + {__pyx_k_f_trace, sizeof(__pyx_k_f_trace), 0, 1, 1}, /* PyObject cname: __pyx_n_u_f_trace */ + {__pyx_k_failed, sizeof(__pyx_k_failed), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_failed */ + {__pyx_k_file, sizeof(__pyx_k_file), 0, 1, 1}, /* PyObject cname: __pyx_n_u_file */ + {__pyx_k_frame, sizeof(__pyx_k_frame), 0, 1, 1}, /* PyObject cname: __pyx_n_u_frame */ + {__pyx_k_func, sizeof(__pyx_k_func), 0, 1, 1}, /* PyObject cname: __pyx_n_u_func */ + {__pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_gc */ + {__pyx_k_get, sizeof(__pyx_k_get), 0, 1, 1}, /* PyObject cname: __pyx_n_u_get */ + {__pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 1, 1}, /* PyObject cname: __pyx_n_u_getstate */ + {__pyx_k_handler, sizeof(__pyx_k_handler), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_handler */ + {__pyx_k_hunter, sizeof(__pyx_k_hunter), 0, 1, 1}, /* PyObject cname: __pyx_n_u_hunter */ + {__pyx_k_hunter__tracer, sizeof(__pyx_k_hunter__tracer), 0, 1, 1}, /* PyObject cname: __pyx_n_u_hunter__tracer */ + {__pyx_k_hunter__tracer_Tracer_at_0x, sizeof(__pyx_k_hunter__tracer_Tracer_at_0x), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_hunter__tracer_Tracer_at_0x */ + {__pyx_k_id, sizeof(__pyx_k_id), 0, 1, 1}, /* PyObject cname: __pyx_n_u_id */ + {__pyx_k_initializing, sizeof(__pyx_k_initializing), 0, 1, 1}, /* PyObject cname: __pyx_n_u_initializing */ + {__pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 1, 1}, /* PyObject cname: __pyx_n_u_is_coroutine */ + {__pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_isenabled */ + {__pyx_k_kind, sizeof(__pyx_k_kind), 0, 1, 1}, /* PyObject cname: __pyx_n_u_kind */ + {__pyx_k_line, sizeof(__pyx_k_line), 0, 1, 1}, /* PyObject cname: __pyx_n_u_line */ + {__pyx_k_main, sizeof(__pyx_k_main), 0, 1, 1}, /* PyObject cname: __pyx_n_u_main */ + {__pyx_k_module, sizeof(__pyx_k_module), 0, 1, 1}, /* PyObject cname: __pyx_n_u_module */ + {__pyx_k_name, sizeof(__pyx_k_name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_name */ + {__pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_no_default___reduce___due_to_non */ + {__pyx_k_pop, sizeof(__pyx_k_pop), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pop */ + {__pyx_k_predicate, sizeof(__pyx_k_predicate), 0, 1, 1}, /* PyObject cname: __pyx_n_u_predicate */ + {__pyx_k_previous, sizeof(__pyx_k_previous), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_previous */ + {__pyx_k_print_exc, sizeof(__pyx_k_print_exc), 0, 1, 1}, /* PyObject cname: __pyx_n_u_print_exc */ + {__pyx_k_profile_hook, sizeof(__pyx_k_profile_hook), 0, 1, 1}, /* PyObject cname: __pyx_n_u_profile_hook */ + {__pyx_k_profiling_mode, sizeof(__pyx_k_profiling_mode), 0, 1, 1}, /* PyObject cname: __pyx_n_u_profiling_mode */ + {__pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pyx_state */ + {__pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pyx_vtable */ + {__pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 1, 1}, /* PyObject cname: __pyx_n_u_qualname */ + {__pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 1, 1}, /* PyObject cname: __pyx_n_u_reduce */ + {__pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_reduce_cython */ + {__pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 1, 1}, /* PyObject cname: __pyx_n_u_reduce_ex */ + {__pyx_k_repr, sizeof(__pyx_k_repr), 0, 1, 1}, /* PyObject cname: __pyx_n_u_repr */ + {__pyx_k_return, sizeof(__pyx_k_return), 0, 1, 1}, /* PyObject cname: __pyx_n_u_return */ + {__pyx_k_self, sizeof(__pyx_k_self), 0, 1, 1}, /* PyObject cname: __pyx_n_u_self */ + {__pyx_k_set_name, sizeof(__pyx_k_set_name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_set_name */ + {__pyx_k_setprofile, sizeof(__pyx_k_setprofile), 0, 1, 1}, /* PyObject cname: __pyx_n_u_setprofile */ + {__pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 1, 1}, /* PyObject cname: __pyx_n_u_setstate */ + {__pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_setstate_cython */ + {__pyx_k_settrace, sizeof(__pyx_k_settrace), 0, 1, 1}, /* PyObject cname: __pyx_n_u_settrace */ + {__pyx_k_spec, sizeof(__pyx_k_spec), 0, 1, 1}, /* PyObject cname: __pyx_n_u_spec */ + {__pyx_k_src_hunter__tracer_pxd, sizeof(__pyx_k_src_hunter__tracer_pxd), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_src_hunter__tracer_pxd */ + {__pyx_k_src_hunter__tracer_pyx, sizeof(__pyx_k_src_hunter__tracer_pyx), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_src_hunter__tracer_pyx */ + {__pyx_k_state, sizeof(__pyx_k_state), 0, 1, 1}, /* PyObject cname: __pyx_n_u_state */ + {__pyx_k_stop, sizeof(__pyx_k_stop), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stop */ + {__pyx_k_stopped, sizeof(__pyx_k_stopped), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_stopped */ + {__pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_stringsource */ + {__pyx_k_test, sizeof(__pyx_k_test), 0, 1, 1}, /* PyObject cname: __pyx_n_u_test */ + {__pyx_k_threading, sizeof(__pyx_k_threading), 0, 1, 1}, /* PyObject cname: __pyx_n_u_threading */ + {__pyx_k_threading_support, sizeof(__pyx_k_threading_support), 0, 1, 1}, /* PyObject cname: __pyx_n_u_threading_support */ + {__pyx_k_threading_support_2, sizeof(__pyx_k_threading_support_2), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_threading_support_2 */ + {__pyx_k_trace, sizeof(__pyx_k_trace), 0, 1, 1}, /* PyObject cname: __pyx_n_u_trace */ + {__pyx_k_trace_func, sizeof(__pyx_k_trace_func), 0, 1, 1}, /* PyObject cname: __pyx_n_u_trace_func */ + {__pyx_k_trace_hook, sizeof(__pyx_k_trace_hook), 0, 1, 1}, /* PyObject cname: __pyx_n_u_trace_hook */ + {__pyx_k_traceback, sizeof(__pyx_k_traceback), 0, 1, 1}, /* PyObject cname: __pyx_n_u_traceback */ + {__pyx_k_tracer, sizeof(__pyx_k_tracer), 0, 1, 1}, /* PyObject cname: __pyx_n_u_tracer */ + {__pyx_k_write, sizeof(__pyx_k_write), 0, 1, 1}, /* PyObject cname: __pyx_n_u_write */ + {__pyx_k_x, sizeof(__pyx_k_x), 0, 1, 1}, /* PyObject cname: __pyx_n_u_x */ + {0, 0, 0, 0, 0} +}; +/* InitStrings.proto */ +static int __Pyx_InitStrings(__Pyx_StringTabEntry const *t, PyObject **target, const char* const* encoding_names); + +/* #### Code section: cached_builtins ### */ + +static int __Pyx_InitCachedBuiltins(__pyx_mstatetype *__pyx_mstate) { + CYTHON_UNUSED_VAR(__pyx_mstate); + __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_id); if (!__pyx_builtin_id) __PYX_ERR(0, 76, __pyx_L1_error) + __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 2, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: cached_constants ### */ + +static int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "hunter/_tracer.pyx":12 + * import hunter + * + * __all__ = 'Tracer', # <<<<<<<<<<<<<< + * + * cdef dict KIND_INTS = { +*/ + __pyx_mstate_global->__pyx_tuple[0] = PyTuple_Pack(1, __pyx_mstate_global->__pyx_n_u_Tracer); if (unlikely(!__pyx_mstate_global->__pyx_tuple[0])) __PYX_ERR(0, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[0]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[0]); + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} +/* #### Code section: init_constants ### */ + +static int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate) { + CYTHON_UNUSED_VAR(__pyx_mstate); + __pyx_mstate->__pyx_umethod_PyDict_Type_pop.type = (PyObject*)&PyDict_Type; + __pyx_mstate->__pyx_umethod_PyDict_Type_pop.method_name = &__pyx_mstate->__pyx_n_u_pop; + if (__Pyx_InitStrings(__pyx_string_tab, __pyx_mstate->__pyx_string_tab, __pyx_string_tab_encodings) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + __pyx_mstate->__pyx_int_0 = PyLong_FromLong(0); if (unlikely(!__pyx_mstate->__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_1 = PyLong_FromLong(1); if (unlikely(!__pyx_mstate->__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_2 = PyLong_FromLong(2); if (unlikely(!__pyx_mstate->__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_3 = PyLong_FromLong(3); if (unlikely(!__pyx_mstate->__pyx_int_3)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_4 = PyLong_FromLong(4); if (unlikely(!__pyx_mstate->__pyx_int_4)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_5 = PyLong_FromLong(5); if (unlikely(!__pyx_mstate->__pyx_int_5)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_6 = PyLong_FromLong(6); if (unlikely(!__pyx_mstate->__pyx_int_6)) __PYX_ERR(0, 1, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: init_codeobjects ### */ +\ + typedef struct { + unsigned int argcount : 3; + unsigned int num_posonly_args : 1; + unsigned int num_kwonly_args : 1; + unsigned int nlocals : 3; + unsigned int flags : 10; + unsigned int first_line : 8; + unsigned int line_table_length : 13; + } __Pyx_PyCode_New_function_description; +/* NewCodeObj.proto */ +static PyObject* __Pyx_PyCode_New( + const __Pyx_PyCode_New_function_description descr, + PyObject * const *varnames, + PyObject *filename, + PyObject *funcname, + const char *line_table, + PyObject *tuple_dedup_map +); + + +static int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate) { + PyObject* tuple_dedup_map = PyDict_New(); + if (unlikely(!tuple_dedup_map)) return -1; + { + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 24, 230}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_tracer, __pyx_mstate->__pyx_n_u_frame, __pyx_mstate->__pyx_n_u_kind, __pyx_mstate->__pyx_n_u_arg, __pyx_mstate->__pyx_n_u_KIND_INTS}; + __pyx_mstate_global->__pyx_codeobj_tab[0] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__tracer_pyx, __pyx_mstate->__pyx_n_u_trace_func, __pyx_k_z_a_1_d_xs_4q_QfA_1F_q_uCr_T_Ja, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[0])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 59, 68}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_threading_support, __pyx_mstate->__pyx_n_u_profiling_mode}; + __pyx_mstate_global->__pyx_codeobj_tab[1] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__tracer_pyx, __pyx_mstate->__pyx_n_u_cinit, __pyx_k_q_Kq_L_Q_1_a_IQ_IQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[1])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 69, 30}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_state}; + __pyx_mstate_global->__pyx_codeobj_tab[2] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__tracer_pyx, __pyx_mstate->__pyx_n_u_dealloc, __pyx_k_A_5Q_5_C_1_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[2])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 74, 83}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[3] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__tracer_pyx, __pyx_mstate->__pyx_n_u_repr, __pyx_k_A_q_aq_4y_Q_is_D_Q_j_Q_j_T_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[3])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 84, 52}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_frame, __pyx_mstate->__pyx_n_u_kind, __pyx_mstate->__pyx_n_u_arg}; + __pyx_mstate_global->__pyx_codeobj_tab[4] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__tracer_pyx, __pyx_mstate->__pyx_n_u_call_2, __pyx_k_A_v_6gYawlZ_5_1_1L_A_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[4])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 90, 232}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_predicate, __pyx_mstate->__pyx_n_u_state}; + __pyx_mstate_global->__pyx_codeobj_tab[5] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__tracer_pyx, __pyx_mstate->__pyx_n_u_trace, __pyx_k_A_Kq_5Q_4q_t_c_c_Q_7_Oq_AQ_uN_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[5])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 118, 204}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[6] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__tracer_pyx, __pyx_mstate->__pyx_n_u_stop, __pyx_k_A_4y_q_t1_4z_A_QfA_Qd_d_Kt_q_Q_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[6])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 141, 7}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[7] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__tracer_pyx, __pyx_mstate->__pyx_n_u_enter, __pyx_k_A_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[7])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 144, 9}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_exc_type, __pyx_mstate->__pyx_n_u_exc_val, __pyx_mstate->__pyx_n_u_exc_tb}; + __pyx_mstate_global->__pyx_codeobj_tab[8] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__tracer_pyx, __pyx_mstate->__pyx_n_u_exit, __pyx_k_A_E, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[8])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 28, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[9] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__tracer_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k__6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[9])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 29, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[10] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__tracer_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k__6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[10])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 30, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[11] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__tracer_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k__6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[11])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 31, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[12] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__tracer_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[12])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 32, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[13] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__tracer_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[13])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 33, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[14] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__tracer_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[14])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 37, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[15] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_hunter__tracer_pxd, __pyx_mstate->__pyx_n_u_get, __pyx_k__6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[15])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[16] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[16])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state}; + __pyx_mstate_global->__pyx_codeobj_tab[17] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[17])) goto bad; + } + Py_DECREF(tuple_dedup_map); + return 0; + bad: + Py_DECREF(tuple_dedup_map); + return -1; +} +/* #### Code section: init_globals ### */ + +static int __Pyx_InitGlobals(void) { + /* PythonCompatibility.init */ + if (likely(__Pyx_init_co_variables() == 0)); else + +if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + /* CachedMethodType.init */ + #if CYTHON_COMPILING_IN_LIMITED_API +{ + PyObject *typesModule=NULL; + typesModule = PyImport_ImportModule("types"); + if (typesModule) { + __pyx_mstate_global->__Pyx_CachedMethodType = PyObject_GetAttrString(typesModule, "MethodType"); + Py_DECREF(typesModule); + } +} // error handling follows +#endif + +if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: cleanup_globals ### */ +/* #### Code section: cleanup_module ### */ +/* #### Code section: main_method ### */ +/* #### Code section: utility_code_pragmas ### */ +#ifdef _MSC_VER +#pragma warning( push ) +/* Warning 4127: conditional expression is constant + * Cython uses constant conditional expressions to allow in inline functions to be optimized at + * compile-time, so this warning is not useful + */ +#pragma warning( disable : 4127 ) +#endif + + + +/* #### Code section: utility_code_def ### */ /* --- Runtime support code --- */ /* Refnanny */ @@ -4941,37 +8156,65 @@ static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { } #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); +/* PyErrExceptionMatches */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); + for (i=0; i= 0x030C00A6 + PyObject *current_exception = tstate->current_exception; + if (unlikely(!current_exception)) return 0; + exc_type = (PyObject*) Py_TYPE(current_exception); + if (exc_type == err) return 1; #else - "name '%.200s' is not defined", PyString_AS_STRING(name)); + exc_type = tstate->curexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; #endif + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(exc_type); + #endif + if (unlikely(PyTuple_Check(err))) { + result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + } else { + result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err); } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(exc_type); + #endif return result; } +#endif /* PyErrFetchRestore */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject *tmp_value; + assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value))); + if (value) { + #if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb)) + #endif + PyException_SetTraceback(value, tb); + } + tmp_value = tstate->current_exception; + tstate->current_exception = value; + Py_XDECREF(tmp_value); + Py_XDECREF(type); + Py_XDECREF(tb); +#else PyObject *tmp_type, *tmp_value, *tmp_tb; tmp_type = tstate->curexc_type; tmp_value = tstate->curexc_value; @@ -4982,205 +8225,326 @@ static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObjec Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); +#endif } static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject* exc_value; + exc_value = tstate->current_exception; + tstate->current_exception = 0; + *value = exc_value; + *type = NULL; + *tb = NULL; + if (exc_value) { + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + #if CYTHON_COMPILING_IN_CPYTHON + *tb = ((PyBaseExceptionObject*) exc_value)->traceback; + Py_XINCREF(*tb); + #else + *tb = PyException_GetTraceback(exc_value); + #endif + } +#else *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 +} +#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); + return PyObject_GetAttr(obj, attr_name); +} +#endif + +/* PyObjectGetAttrStrNoError */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d0000 +static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + __Pyx_PyErr_Clear(); } #endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { + PyObject *result; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + (void) PyObject_GetOptionalAttr(obj, attr_name, &result); + return result; +#else +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { + return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); + } +#endif + result = __Pyx_PyObject_GetAttrStr(obj, attr_name); + if (unlikely(!result)) { + __Pyx_PyObject_GetAttrStr_ClearAttributeError(); + } + return result; +#endif +} + +/* GetBuiltinName */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_mstate_global->__pyx_b, name); + if (unlikely(!result) && !PyErr_Occurred()) { + PyErr_Format(PyExc_NameError, + "name '%U' is not defined", name); + } + return result; +} /* Profile */ -#if CYTHON_PROFILE +#if CYTHON_PROFILE || CYTHON_TRACE +#if CYTHON_TRACE && !CYTHON_USE_SYS_MONITORING +static int __Pyx_call_line_trace_func(PyThreadState *tstate, PyFrameObject *frame, int line) { + int ret; + PyObject *type, *value, *traceback; + __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); + __Pyx_PyFrame_SetLineNumber(frame, line); + __Pyx_EnterTracing(tstate); + ret = tstate->c_tracefunc(tstate->c_traceobj, frame, PyTrace_LINE, NULL); + __Pyx_LeaveTracing(tstate); + if (likely(!ret)) { + __Pyx_ErrRestoreInState(tstate, type, value, traceback); + } else { + Py_XDECREF(type); + Py_XDECREF(value); + Py_XDECREF(traceback); + } + return ret; +} +#endif +CYTHON_UNUSED static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno) { + PyCodeObject *py_code = PyCode_NewEmpty(srcfile, funcname, firstlineno); + if (likely(py_code)) { + py_code->co_flags |= CO_OPTIMIZED | CO_NEWLOCALS; + } + return py_code; +} +#if CYTHON_USE_SYS_MONITORING +CYTHON_UNUSED static int __Pyx__TraceStartFunc(PyMonitoringState *state_array, PyObject *code_obj, int offset, int skip_event) { + int ret; + __pyx_monitoring_version_type version = 0; + ret = PyMonitoring_EnterScope(state_array, &version, __Pyx_MonitoringEventTypes, __Pyx_MonitoringEventTypes_CyFunc_count); + if (unlikely(ret == -1)) return -1; + return skip_event ? 0 : PyMonitoring_FirePyStartEvent(&state_array[__Pyx_Monitoring_PY_START], code_obj, offset); +} +CYTHON_UNUSED static int __Pyx__TraceStartGen(PyMonitoringState *state_array, __pyx_monitoring_version_type *version, PyObject *code_obj, int offset) { + int ret; + ret = PyMonitoring_EnterScope(state_array, version, __Pyx_MonitoringEventTypes, __Pyx_MonitoringEventTypes_CyGen_count); + if (unlikely(ret == -1)) return -1; + return PyMonitoring_FirePyStartEvent(&state_array[__Pyx_Monitoring_PY_START], code_obj, offset); +} +CYTHON_UNUSED static int __Pyx__TraceResumeGen(PyMonitoringState *state_array, __pyx_monitoring_version_type *version, PyObject *code_obj, int offset) { + int ret; + ret = PyMonitoring_EnterScope(state_array, version, __Pyx_MonitoringEventTypes, __Pyx_MonitoringEventTypes_CyGen_count); + if (unlikely(ret == -1)) return -1; + return PyMonitoring_FirePyResumeEvent(&state_array[__Pyx_Monitoring_PY_RESUME], code_obj, offset); +} +CYTHON_UNUSED static void __Pyx__TraceException(PyMonitoringState *monitoring_state, PyObject *code_obj, int offset, int reraised) { + if (reraised) { + (void) PyMonitoring_FireReraiseEvent(monitoring_state, code_obj, offset); + } else { + (void) PyMonitoring_FireRaiseEvent(monitoring_state, code_obj, offset); + } +} +#if CYTHON_TRACE +CYTHON_UNUSED static int __Pyx__TraceLine(PyMonitoringState *monitoring_state, PyObject *code_obj, int line, int offset) { + int ret; + PyObject *exc = PyErr_GetRaisedException(); + ret = PyMonitoring_FireLineEvent(monitoring_state, code_obj, offset, line); + if (exc) PyErr_SetRaisedException(exc); + return ret; +} +#endif +#else static int __Pyx_TraceSetupAndCall(PyCodeObject** code, PyFrameObject** frame, PyThreadState* tstate, const char *funcname, const char *srcfile, - int firstlineno) { - PyObject *type, *value, *traceback; - int retval; + int firstlineno, + int skip_event) { if (*frame == NULL || !CYTHON_PROFILE_REUSE_FRAME) { - if (*code == NULL) { + int needs_new_code_obj = (*code == NULL); + if (needs_new_code_obj) { *code = __Pyx_createFrameCodeObject(funcname, srcfile, firstlineno); if (*code == NULL) return 0; } *frame = PyFrame_New( tstate, /*PyThreadState *tstate*/ *code, /*PyCodeObject *code*/ - __pyx_d, /*PyObject *globals*/ + __pyx_mstate_global->__pyx_d, /*PyObject *globals*/ 0 /*PyObject *locals*/ ); + if (needs_new_code_obj && !CYTHON_PROFILE_REUSE_CODEOBJ) + Py_CLEAR(*code); // otherwise the reference is owned externally if (*frame == NULL) return 0; if (CYTHON_TRACE && (*frame)->f_trace == NULL) { Py_INCREF(Py_None); (*frame)->f_trace = Py_None; } -#if PY_VERSION_HEX < 0x030400B1 - } else { - (*frame)->f_tstate = tstate; -#endif } - __Pyx_PyFrame_SetLineNumber(*frame, firstlineno); - retval = 1; - tstate->tracing++; - tstate->use_tracing = 0; - __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); - #if CYTHON_TRACE - if (tstate->c_tracefunc) - retval = tstate->c_tracefunc(tstate->c_traceobj, *frame, PyTrace_CALL, NULL) == 0; - if (retval && tstate->c_profilefunc) - #endif - retval = tstate->c_profilefunc(tstate->c_profileobj, *frame, PyTrace_CALL, NULL) == 0; - tstate->use_tracing = (tstate->c_profilefunc || - (CYTHON_TRACE && tstate->c_tracefunc)); - tstate->tracing--; - if (retval) { + if (!skip_event) { + PyObject *type, *value, *traceback; + int retval = 1; + __Pyx_PyFrame_SetLineNumber(*frame, firstlineno); + __Pyx_EnterTracing(tstate); + __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); + #if CYTHON_TRACE + if (tstate->c_tracefunc) + retval = tstate->c_tracefunc(tstate->c_traceobj, *frame, PyTrace_CALL, NULL) == 0; + if (retval && tstate->c_profilefunc) + #endif + retval = tstate->c_profilefunc(tstate->c_profileobj, *frame, PyTrace_CALL, NULL) == 0; + __Pyx_LeaveTracing(tstate); + if (unlikely(!retval)) { + Py_XDECREF(type); + Py_XDECREF(value); + Py_XDECREF(traceback); + return -1; + } __Pyx_ErrRestoreInState(tstate, type, value, traceback); - return tstate->use_tracing && retval; - } else { - Py_XDECREF(type); - Py_XDECREF(value); - Py_XDECREF(traceback); - return -1; } + return __Pyx_IsTracing(tstate, 0, 0); } -static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno) { - PyCodeObject *py_code = 0; -#if PY_MAJOR_VERSION >= 3 - py_code = PyCode_NewEmpty(srcfile, funcname, firstlineno); - if (likely(py_code)) { - py_code->co_flags |= CO_OPTIMIZED | CO_NEWLOCALS; - } -#else - PyObject *py_srcfile = 0; - PyObject *py_funcname = 0; - py_funcname = PyString_FromString(funcname); - if (unlikely(!py_funcname)) goto bad; - py_srcfile = PyString_FromString(srcfile); - if (unlikely(!py_srcfile)) goto bad; - py_code = PyCode_New( - 0, - 0, - 0, - CO_OPTIMIZED | CO_NEWLOCALS, - __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,*/ - firstlineno, - __pyx_empty_bytes /*PyObject *lnotab*/ - ); -bad: - Py_XDECREF(py_srcfile); - Py_XDECREF(py_funcname); #endif - return py_code; -} #endif -/* 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; +/* PyObjectSetAttrStr */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_setattro)) + return tp->tp_setattro(obj, attr_name, value); + return PyObject_SetAttr(obj, attr_name, value); } -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(__Pyx_is_valid_index(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); + +/* PyFunctionFastCall */ +#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL +static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject *const *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; } - if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { - PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); - Py_INCREF(r); - return r; + fastlocals = __Pyx_PyFrame_GetLocalsplus(f); + for (i = 0; i < na; i++) { + Py_INCREF(*args); + fastlocals[i] = *args++; } - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); -#else - return PySequence_GetItem(o, i); -#endif + result = PyEval_EvalFrameEx(f,0); + ++tstate->recursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; + return result; } -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(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { - PyObject *r = PyList_GET_ITEM(o, n); - Py_INCREF(r); - return r; +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject *const *args, Py_ssize_t nargs, PyObject *kwargs) { + PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); + PyObject *globals = PyFunction_GET_GLOBALS(func); + PyObject *argdefs = PyFunction_GET_DEFAULTS(func); + PyObject *closure; + PyObject *kwdefs; + 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 (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) { + return NULL; + } + if ( + co->co_kwonlyargcount == 0 && + 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; } } - else if (PyTuple_CheckExact(o)) { - Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); - if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { - PyObject *r = PyTuple_GET_ITEM(o, n); - Py_INCREF(r); - return r; + if (kwargs != NULL) { + Py_ssize_t pos, i; + kwtuple = PyTuple_New(2 * nk); + if (kwtuple == NULL) { + result = NULL; + goto done; } - } 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); + 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 - if (is_list || PySequence_Check(o)) { - return PySequence_GetItem(o, i); + else { + kwtuple = NULL; + k = NULL; } -#endif - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); + closure = PyFunction_GET_CLOSURE(func); + kwdefs = PyFunction_GET_KW_DEFAULTS(func); + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); + Py_XDECREF(kwtuple); +done: + Py_LeaveRecursiveCall(); + return result; } +#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; + ternaryfunc call = Py_TYPE(func)->tp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) return NULL; result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); @@ -5193,39 +8557,183 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg } #endif -/* GetTopmostException */ -#if CYTHON_USE_EXC_INFO_STACK -static _PyErr_StackItem * -__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) -{ - _PyErr_StackItem *exc_info = tstate->exc_info; - while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && - exc_info->previous_item != NULL) - { - exc_info = exc_info->previous_item; +/* PyObjectCallMethO */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); + self = __Pyx_CyOrPyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall(" 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 exc_info; + return result; +} +#endif + +/* PyObjectFastCall */ +#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API +static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject * const*args, size_t nargs, PyObject *kwargs) { + PyObject *argstuple; + PyObject *result = 0; + size_t i; + argstuple = PyTuple_New((Py_ssize_t)nargs); + if (unlikely(!argstuple)) return NULL; + for (i = 0; i < nargs; i++) { + Py_INCREF(args[i]); + if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) != (0)) goto bad; + } + result = __Pyx_PyObject_Call(func, argstuple, kwargs); + bad: + Py_DECREF(argstuple); + return result; +} +#endif +#if CYTHON_VECTORCALL && !CYTHON_COMPILING_IN_LIMITED_API + #if PY_VERSION_HEX < 0x03090000 + #define __Pyx_PyVectorcall_Function(callable) _PyVectorcall_Function(callable) + #elif CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE vectorcallfunc __Pyx_PyVectorcall_Function(PyObject *callable) { + PyTypeObject *tp = Py_TYPE(callable); + #if defined(__Pyx_CyFunction_USED) + if (__Pyx_CyFunction_CheckExact(callable)) { + return __Pyx_CyFunction_func_vectorcall(callable); + } + #endif + if (!PyType_HasFeature(tp, Py_TPFLAGS_HAVE_VECTORCALL)) { + return NULL; + } + assert(PyCallable_Check(callable)); + Py_ssize_t offset = tp->tp_vectorcall_offset; + assert(offset > 0); + vectorcallfunc ptr; + memcpy(&ptr, (char *) callable + offset, sizeof(ptr)); + return ptr; +} + #else + #define __Pyx_PyVectorcall_Function(callable) PyVectorcall_Function(callable) + #endif +#endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject *const *args, size_t _nargs, PyObject *kwargs) { + Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs); +#if CYTHON_COMPILING_IN_CPYTHON + if (nargs == 0 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS)) + return __Pyx_PyObject_CallMethO(func, NULL); + } + else if (nargs == 1 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O)) + return __Pyx_PyObject_CallMethO(func, args[0]); + } +#endif + #if PY_VERSION_HEX < 0x030800B1 + #if CYTHON_FAST_PYCCALL + if (PyCFunction_Check(func)) { + if (kwargs) { + return _PyCFunction_FastCallDict(func, args, nargs, kwargs); + } else { + return _PyCFunction_FastCallKeywords(func, args, nargs, NULL); + } + } + if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) { + return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL); + } + #endif + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs); + } + #endif + #endif + if (kwargs == NULL) { + #if CYTHON_VECTORCALL && !CYTHON_COMPILING_IN_LIMITED_API + vectorcallfunc f = __Pyx_PyVectorcall_Function(func); + if (f) { + return f(func, args, _nargs, NULL); + } + #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL + if (__Pyx_CyFunction_CheckExact(func)) { + __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func); + if (f) return f(func, args, _nargs, NULL); + } + #elif CYTHON_COMPILING_IN_LIMITED_API && CYTHON_VECTORCALL + return PyObject_Vectorcall(func, args, _nargs, NULL); + #endif + } + if (nargs == 0) { + return __Pyx_PyObject_Call(func, __pyx_mstate_global->__pyx_empty_tuple, kwargs); + } + #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API + return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs); + #else + return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs); + #endif +} + +/* GetTopmostException */ +#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE +static _PyErr_StackItem * +__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) +{ + _PyErr_StackItem *exc_info = tstate->exc_info; + while ((exc_info->exc_value == NULL || exc_info->exc_value == Py_None) && + exc_info->previous_item != NULL) + { + exc_info = exc_info->previous_item; + } + return exc_info; } #endif /* SaveResetException */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { - #if CYTHON_USE_EXC_INFO_STACK + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + PyObject *exc_value = exc_info->exc_value; + if (exc_value == NULL || exc_value == Py_None) { + *value = NULL; + *type = NULL; + *tb = NULL; + } else { + *value = exc_value; + Py_INCREF(*value); + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + *tb = PyException_GetTraceback(exc_value); + } + #elif CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); *type = exc_info->exc_type; *value = exc_info->exc_value; *tb = exc_info->exc_traceback; - #else + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); + #else *type = tstate->exc_type; *value = tstate->exc_value; *tb = tstate->exc_traceback; - #endif Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); + #endif } static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = tstate->exc_info; + PyObject *tmp_value = exc_info->exc_value; + exc_info->exc_value = value; + Py_XDECREF(tmp_value); + Py_XDECREF(type); + Py_XDECREF(tb); + #else PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; @@ -5246,31 +8754,7 @@ static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); -} -#endif - -/* PyErrExceptionMatches */ -#if CYTHON_FAST_THREAD_STATE -static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { - Py_ssize_t i, n; - n = PyTuple_GET_SIZE(tuple); -#if PY_MAJOR_VERSION >= 3 - for (i=0; icurexc_type; - if (exc_type == err) return 1; - if (unlikely(!exc_type)) return 0; - if (unlikely(PyTuple_Check(err))) - return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); - return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); + #endif } #endif @@ -5281,18 +8765,32 @@ static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) #endif { - PyObject *local_type, *local_value, *local_tb; + PyObject *local_type = NULL, *local_value, *local_tb = NULL; #if CYTHON_FAST_THREAD_STATE PyObject *tmp_type, *tmp_value, *tmp_tb; + #if PY_VERSION_HEX >= 0x030C0000 + local_value = tstate->current_exception; + tstate->current_exception = 0; + #else local_type = tstate->curexc_type; local_value = tstate->curexc_value; local_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; + #endif +#elif __PYX_LIMITED_VERSION_HEX > 0x030C0000 + local_value = PyErr_GetRaisedException(); #else PyErr_Fetch(&local_type, &local_value, &local_tb); #endif +#if __PYX_LIMITED_VERSION_HEX > 0x030C0000 + if (likely(local_value)) { + local_type = (PyObject*) Py_TYPE(local_value); + Py_INCREF(local_type); + local_tb = PyException_GetTraceback(local_value); + } +#else PyErr_NormalizeException(&local_type, &local_value, &local_tb); #if CYTHON_FAST_THREAD_STATE if (unlikely(tstate->curexc_type)) @@ -5300,12 +8798,11 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) if (unlikely(PyErr_Occurred())) #endif goto bad; - #if PY_MAJOR_VERSION >= 3 if (local_tb) { if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) goto bad; } - #endif +#endif // __PYX_LIMITED_VERSION_HEX > 0x030C0000 Py_XINCREF(local_tb); Py_XINCREF(local_type); Py_XINCREF(local_value); @@ -5316,12 +8813,21 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) #if CYTHON_USE_EXC_INFO_STACK { _PyErr_StackItem *exc_info = tstate->exc_info; + #if PY_VERSION_HEX >= 0x030B00a4 + tmp_value = exc_info->exc_value; + exc_info->exc_value = local_value; + tmp_type = NULL; + tmp_tb = NULL; + Py_XDECREF(local_type); + Py_XDECREF(local_tb); + #else tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = local_type; exc_info->exc_value = local_value; exc_info->exc_traceback = local_tb; + #endif } #else tmp_type = tstate->exc_type; @@ -5334,10 +8840,16 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); +#elif __PYX_LIMITED_VERSION_HEX >= 0x030b0000 + PyErr_SetHandledException(local_value); + Py_XDECREF(local_value); + Py_XDECREF(local_type); + Py_XDECREF(local_tb); #else PyErr_SetExcInfo(local_type, local_value, local_tb); #endif return 0; +#if __PYX_LIMITED_VERSION_HEX <= 0x030C0000 bad: *type = 0; *value = 0; @@ -5346,6 +8858,7 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) Py_XDECREF(local_value); Py_XDECREF(local_tb); return -1; +#endif } /* PyDictVersioning */ @@ -5382,25 +8895,26 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) #endif { PyObject *result; -#if !CYTHON_AVOID_BORROWED_REFS -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 - result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } else if (unlikely(PyErr_Occurred())) { +#if CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(!__pyx_m)) { + if (!PyErr_Occurred()) + PyErr_SetNone(PyExc_NameError); return NULL; } -#else - result = PyDict_GetItem(__pyx_d, name); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + result = PyObject_GetAttr(__pyx_m, name); if (likely(result)) { - return __Pyx_NewRef(result); + return result; + } + PyErr_Clear(); +#elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + if (unlikely(__Pyx_PyDict_GetItemRef(__pyx_mstate_global->__pyx_d, name, &result) == -1)) PyErr_Clear(); + __PYX_UPDATE_DICT_CACHE(__pyx_mstate_global->__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return result; } -#endif #else - result = PyObject_GetItem(__pyx_d, name); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + result = _PyDict_GetItem_KnownHash(__pyx_mstate_global->__pyx_d, name, ((PyASCIIObject *) name)->hash); + __PYX_UPDATE_DICT_CACHE(__pyx_mstate_global->__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } @@ -5409,264 +8923,167 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) return __Pyx_GetBuiltinName(name); } -/* PyFunctionFastCall */ -#if CYTHON_FAST_PYCALL -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; +/* PyObjectVectorCallKwBuilder */ +#if CYTHON_VECTORCALL +static int __Pyx_VectorcallBuilder_AddArg(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n) { + (void)__Pyx_PyObject_FastCallDict; + if (__Pyx_PyTuple_SET_ITEM(builder, n, key) != (0)) return -1; + Py_INCREF(key); + args[n] = value; + return 0; +} +CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n) { + (void)__Pyx_VectorcallBuilder_AddArgStr; + if (unlikely(!PyUnicode_Check(key))) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + return -1; } - fastlocals = __Pyx_PyFrame_GetLocalsplus(f); - for (i = 0; i < na; i++) { - Py_INCREF(*args); - fastlocals[i] = *args++; + return __Pyx_VectorcallBuilder_AddArg(key, value, builder, args, n); +} +static int __Pyx_VectorcallBuilder_AddArgStr(const char *key, PyObject *value, PyObject *builder, PyObject **args, int n) { + PyObject *pyKey = PyUnicode_FromString(key); + if (!pyKey) return -1; + return __Pyx_VectorcallBuilder_AddArg(pyKey, value, builder, args, n); +} +#else // CYTHON_VECTORCALL +CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, CYTHON_UNUSED PyObject **args, CYTHON_UNUSED int n) { + if (unlikely(!PyUnicode_Check(key))) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + return -1; } - result = PyEval_EvalFrameEx(f,0); - ++tstate->recursion_depth; - Py_DECREF(f); - --tstate->recursion_depth; - return result; + return PyDict_SetItem(builder, key, value); } -#if 1 || PY_VERSION_HEX < 0x030600B1 -static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t 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; + +/* PyObjectFormatAndDecref */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f) { + if (unlikely(!s)) return NULL; + if (likely(PyUnicode_CheckExact(s))) return s; + return __Pyx_PyObject_FormatAndDecref(s, f); +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f) { 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; + if (unlikely(!s)) return NULL; + result = PyObject_Format(s, f); + Py_DECREF(s); + return result; +} + +/* JoinPyUnicode */ +static PyObject* __Pyx_PyUnicode_Join(PyObject** values, Py_ssize_t value_count, Py_ssize_t result_ulength, + Py_UCS4 max_char) { +#if CYTHON_USE_UNICODE_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + PyObject *result_uval; + int result_ukind, kind_shift; + Py_ssize_t i, char_pos; + void *result_udata; + if (max_char > 1114111) max_char = 1114111; + result_uval = PyUnicode_New(result_ulength, max_char); + if (unlikely(!result_uval)) return NULL; + result_ukind = (max_char <= 255) ? PyUnicode_1BYTE_KIND : (max_char <= 65535) ? PyUnicode_2BYTE_KIND : PyUnicode_4BYTE_KIND; + kind_shift = (result_ukind == PyUnicode_4BYTE_KIND) ? 2 : result_ukind - 1; + result_udata = PyUnicode_DATA(result_uval); + assert(kind_shift == 2 || kind_shift == 1 || kind_shift == 0); + if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - result_ulength < 0)) + goto overflow; + char_pos = 0; + for (i=0; i < value_count; i++) { + int ukind; + Py_ssize_t ulength; + void *udata; + PyObject *uval = values[i]; + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_PyUnicode_READY(uval) == (-1)) + goto bad; + #endif + ulength = __Pyx_PyUnicode_GET_LENGTH(uval); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(ulength < 0)) goto bad; + #endif + if (unlikely(!ulength)) + continue; + if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - ulength < char_pos)) + goto overflow; + ukind = __Pyx_PyUnicode_KIND(uval); + udata = __Pyx_PyUnicode_DATA(uval); + if (ukind == result_ukind) { + memcpy((char *)result_udata + (char_pos << kind_shift), udata, (size_t) (ulength << kind_shift)); + } else { + #if PY_VERSION_HEX >= 0x030d0000 + if (unlikely(PyUnicode_CopyCharacters(result_uval, char_pos, uval, 0, ulength) < 0)) goto bad; + #elif CYTHON_COMPILING_IN_CPYTHON || defined(_PyUnicode_FastCopyCharacters) + _PyUnicode_FastCopyCharacters(result_uval, char_pos, uval, 0, ulength); + #else + Py_ssize_t j; + for (j=0; j < ulength; j++) { + Py_UCS4 uchar = __Pyx_PyUnicode_READ(ukind, udata, j); + __Pyx_PyUnicode_WRITE(result_ukind, result_udata, char_pos+j, uchar); + } + #endif } - 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; + char_pos += ulength; } -#if PY_MAJOR_VERSION >= 3 - result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, kwdefs, closure); + return result_uval; +overflow: + PyErr_SetString(PyExc_OverflowError, "join() result is too long for a Python string"); +bad: + Py_DECREF(result_uval); + return NULL; #else - result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, closure); -#endif - Py_XDECREF(kwtuple); -done: - Py_LeaveRecursiveCall(); + Py_ssize_t i; + PyObject *result = NULL; + PyObject *value_tuple = PyTuple_New(value_count); + if (unlikely(!value_tuple)) return NULL; + CYTHON_UNUSED_VAR(max_char); + CYTHON_UNUSED_VAR(result_ulength); + for (i=0; i__pyx_empty_unicode, value_tuple); +bad: + Py_DECREF(value_tuple); return result; -} #endif -#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 | METH_STACKLESS))); - 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)(void*)meth)) (self, args, nargs, NULL); - } else { - return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); - } } -#endif -/* PyObjectCall2Args */ -static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { - PyObject *args, *result = NULL; - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(function)) { - PyObject *args[2] = {arg1, arg2}; - return __Pyx_PyFunction_FastCall(function, args, 2); - } - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(function)) { - PyObject *args[2] = {arg1, arg2}; - return __Pyx_PyCFunction_FastCall(function, args, 2); - } - #endif - args = PyTuple_New(2); - if (unlikely(!args)) goto done; - Py_INCREF(arg1); - PyTuple_SET_ITEM(args, 0, arg1); - Py_INCREF(arg2); - PyTuple_SET_ITEM(args, 1, arg2); - Py_INCREF(function); - result = __Pyx_PyObject_Call(function, args, NULL); - Py_DECREF(args); - Py_DECREF(function); -done: +/* PyObjectFastCallMethod */ +#if !CYTHON_VECTORCALL || PY_VERSION_HEX < 0x03090000 +static PyObject *__Pyx_PyObject_FastCallMethod(PyObject *name, PyObject *const *args, size_t nargsf) { + PyObject *result; + PyObject *attr = PyObject_GetAttr(args[0], name); + if (unlikely(!attr)) + return NULL; + result = __Pyx_PyObject_FastCall(attr, args+1, nargsf - 1); + Py_DECREF(attr); return result; } - -/* 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 - -/* 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_CyFunction_Check(func))) -#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 +#endif /* SwapException */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; - #if CYTHON_USE_EXC_INFO_STACK + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_value = exc_info->exc_value; + exc_info->exc_value = *value; + if (tmp_value == NULL || tmp_value == Py_None) { + Py_XDECREF(tmp_value); + tmp_value = NULL; + tmp_type = NULL; + tmp_tb = NULL; + } else { + tmp_type = (PyObject*) Py_TYPE(tmp_value); + Py_INCREF(tmp_type); + #if CYTHON_COMPILING_IN_CPYTHON + tmp_tb = ((PyBaseExceptionObject*) tmp_value)->traceback; + Py_XINCREF(tmp_tb); + #else + tmp_tb = PyException_GetTraceback(tmp_value); + #endif + } + #elif CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; @@ -5674,14 +9091,14 @@ static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject * exc_info->exc_type = *type; exc_info->exc_value = *value; exc_info->exc_traceback = *tb; - #else + #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = *type; tstate->exc_value = *value; tstate->exc_traceback = *tb; - #endif + #endif *type = tmp_type; *value = tmp_value; *tb = tmp_tb; @@ -5697,163 +9114,21 @@ static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, } #endif -/* 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; -} - -/* 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); -} - /* WriteUnraisableException */ -static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, - CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename, - int full_traceback, CYTHON_UNUSED int nogil) { +static void __Pyx_WriteUnraisable(const char *name, int clineno, + int lineno, const char *filename, + int full_traceback, int nogil) { PyObject *old_exc, *old_val, *old_tb; PyObject *ctx; __Pyx_PyThreadState_declare -#ifdef WITH_THREAD PyGILState_STATE state; if (nogil) state = PyGILState_Ensure(); -#ifdef _MSC_VER - else state = (PyGILState_STATE)-1; -#endif -#endif + else state = (PyGILState_STATE)0; + CYTHON_UNUSED_VAR(clineno); + CYTHON_UNUSED_VAR(lineno); + CYTHON_UNUSED_VAR(filename); + CYTHON_MAYBE_UNUSED_VAR(nogil); __Pyx_PyThreadState_assign __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); if (full_traceback) { @@ -5861,13 +9136,9 @@ static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, Py_XINCREF(old_val); Py_XINCREF(old_tb); __Pyx_ErrRestore(old_exc, old_val, old_tb); - PyErr_PrintEx(1); + PyErr_PrintEx(0); } - #if PY_MAJOR_VERSION < 3 - ctx = PyString_FromString(name); - #else ctx = PyUnicode_FromString(name); - #endif __Pyx_ErrRestore(old_exc, old_val, old_tb); if (!ctx) { PyErr_WriteUnraisable(Py_None); @@ -5875,100 +9146,70 @@ static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, PyErr_WriteUnraisable(ctx); Py_DECREF(ctx); } -#ifdef WITH_THREAD if (nogil) PyGILState_Release(state); -#endif } -/* ExtTypeTest */ -static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { - if (unlikely(!type)) { - PyErr_SetString(PyExc_SystemError, "Missing type object"); - return 0; +/* TupleAndListFromArray */ +#if !CYTHON_COMPILING_IN_CPYTHON && CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject * +__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + Py_ssize_t i; + if (n <= 0) { + return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_tuple); + } + res = PyTuple_New(n); + if (unlikely(res == NULL)) return NULL; + for (i = 0; i < n; i++) { + if (unlikely(__Pyx_PyTuple_SET_ITEM(res, i, src[i]) < 0)) { + Py_DECREF(res); + return NULL; + } + Py_INCREF(src[i]); } - if (likely(__Pyx_TypeCheck(obj, type))) - return 1; - PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", - Py_TYPE(obj)->tp_name, type->tp_name); - return 0; + return res; } - -/* UnpackUnboundCMethod */ -static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) { - PyObject *method; - method = __Pyx_PyObject_GetAttrStr(target->type, *target->method_name); - if (unlikely(!method)) - return -1; - target->method = method; -#if CYTHON_COMPILING_IN_CPYTHON - #if PY_MAJOR_VERSION >= 3 - if (likely(__Pyx_TypeCheck(method, &PyMethodDescr_Type))) - #endif - { - PyMethodDescrObject *descr = (PyMethodDescrObject*) method; - target->func = descr->d_method->ml_meth; - target->flag = descr->d_method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_STACKLESS); +#elif CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) { + PyObject *v; + Py_ssize_t i; + for (i = 0; i < length; i++) { + v = dest[i] = src[i]; + Py_INCREF(v); } -#endif - return 0; } - -/* CallUnboundCMethod1 */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg) { - if (likely(cfunc->func)) { - int flag = cfunc->flag; - if (flag == METH_O) { - return (*(cfunc->func))(self, arg); - } else if (PY_VERSION_HEX >= 0x030600B1 && flag == METH_FASTCALL) { - if (PY_VERSION_HEX >= 0x030700A0) { - return (*(__Pyx_PyCFunctionFast)(void*)(PyCFunction)cfunc->func)(self, &arg, 1); - } else { - return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, &arg, 1, NULL); - } - } else if (PY_VERSION_HEX >= 0x030700A0 && flag == (METH_FASTCALL | METH_KEYWORDS)) { - return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, &arg, 1, NULL); - } +static CYTHON_INLINE PyObject * +__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_tuple); } - return __Pyx__CallUnboundCMethod1(cfunc, self, arg); + res = PyTuple_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n); + return res; } -#endif -static PyObject* __Pyx__CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg){ - PyObject *args, *result = NULL; - if (unlikely(!cfunc->func && !cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; -#if CYTHON_COMPILING_IN_CPYTHON - if (cfunc->func && (cfunc->flag & METH_VARARGS)) { - args = PyTuple_New(1); - if (unlikely(!args)) goto bad; - Py_INCREF(arg); - PyTuple_SET_ITEM(args, 0, arg); - if (cfunc->flag & METH_KEYWORDS) - result = (*(PyCFunctionWithKeywords)(void*)(PyCFunction)cfunc->func)(self, args, NULL); - else - result = (*cfunc->func)(self, args); - } else { - args = PyTuple_New(2); - if (unlikely(!args)) goto bad; - Py_INCREF(self); - PyTuple_SET_ITEM(args, 0, self); - Py_INCREF(arg); - PyTuple_SET_ITEM(args, 1, arg); - result = __Pyx_PyObject_Call(cfunc->method, args, NULL); +static CYTHON_INLINE PyObject * +__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + return PyList_New(0); } -#else - args = PyTuple_Pack(2, self, arg); - if (unlikely(!args)) goto bad; - result = __Pyx_PyObject_Call(cfunc->method, args, NULL); -#endif -bad: - Py_XDECREF(args); - return result; + res = PyList_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n); + return res; } +#endif /* BytesEquals */ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { -#if CYTHON_COMPILING_IN_PYPY +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL ||\ + !(CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS) return PyObject_RichCompareBool(s1, s2, equals); #else if (s1 == s2) { @@ -5986,7 +9227,7 @@ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int eq return (equals == Py_EQ); } else { int result; -#if CYTHON_USE_UNICODE_INTERNALS +#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000) Py_hash_t hash1, hash2; hash1 = ((PyBytesObject*)s1)->ob_shash; hash2 = ((PyBytesObject*)s2)->ob_shash; @@ -6015,55 +9256,39 @@ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int eq /* UnicodeEquals */ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { -#if CYTHON_COMPILING_IN_PYPY +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL return PyObject_RichCompareBool(s1, s2, equals); #else -#if PY_MAJOR_VERSION < 3 - PyObject* owned_ref = NULL; -#endif int s1_is_unicode, s2_is_unicode; if (s1 == s2) { goto return_eq; } s1_is_unicode = PyUnicode_CheckExact(s1); s2_is_unicode = PyUnicode_CheckExact(s2); -#if PY_MAJOR_VERSION < 3 - if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { - owned_ref = PyUnicode_FromObject(s2); - if (unlikely(!owned_ref)) - return -1; - s2 = owned_ref; - s2_is_unicode = 1; - } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { - owned_ref = PyUnicode_FromObject(s1); - if (unlikely(!owned_ref)) - return -1; - s1 = owned_ref; - s1_is_unicode = 1; - } else if (((!s2_is_unicode) & (!s1_is_unicode))) { - return __Pyx_PyBytes_Equals(s1, s2, equals); - } -#endif if (s1_is_unicode & s2_is_unicode) { - Py_ssize_t length; + Py_ssize_t length, length2; int kind; void *data1, *data2; + #if !CYTHON_COMPILING_IN_LIMITED_API if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) return -1; + #endif length = __Pyx_PyUnicode_GET_LENGTH(s1); - if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(length < 0)) return -1; + #endif + length2 = __Pyx_PyUnicode_GET_LENGTH(s2); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(length2 < 0)) return -1; + #endif + if (length != length2) { goto return_ne; } #if CYTHON_USE_UNICODE_INTERNALS { Py_hash_t hash1, hash2; - #if CYTHON_PEP393_ENABLED hash1 = ((PyASCIIObject*)s1)->hash; hash2 = ((PyASCIIObject*)s2)->hash; - #else - hash1 = ((PyUnicodeObject*)s1)->hash; - hash2 = ((PyUnicodeObject*)s2)->hash; - #endif if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { goto return_ne; } @@ -6081,9 +9306,6 @@ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int goto return_eq; } else { int result = memcmp(data1, data2, (size_t)(length * kind)); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif return (equals == Py_EQ) ? (result == 0) : (result != 0); } } else if ((s1 == Py_None) & s2_is_unicode) { @@ -6093,9 +9315,6 @@ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int } else { int result; PyObject* py_result = PyObject_RichCompare(s1, s2, equals); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif if (!py_result) return -1; result = __Pyx_PyObject_IsTrue(py_result); @@ -6103,491 +9322,3063 @@ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int return result; } return_eq: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif return (equals == Py_EQ); return_ne: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif return (equals == Py_NE); #endif } -/* GetAttr */ -static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { -#if CYTHON_USE_TYPE_SLOTS -#if PY_MAJOR_VERSION >= 3 - if (likely(PyUnicode_Check(n))) +/* fastcall */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) +{ + Py_ssize_t i, n = __Pyx_PyTuple_GET_SIZE(kwnames); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(n == -1)) return NULL; + #endif + for (i = 0; i < n; i++) + { + PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!namei)) return NULL; + #endif + if (s == namei) return kwvalues[i]; + } + for (i = 0; i < n; i++) + { + PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!namei)) return NULL; + #endif + int eq = __Pyx_PyUnicode_Equals(s, namei, Py_EQ); + if (unlikely(eq != 0)) { + if (unlikely(eq < 0)) return NULL; + return kwvalues[i]; + } + } + return NULL; +} +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API +CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { + Py_ssize_t i, nkwargs; + PyObject *dict; +#if !CYTHON_ASSUME_SAFE_SIZE + nkwargs = PyTuple_Size(kwnames); + if (unlikely(nkwargs < 0)) return NULL; #else - if (likely(PyString_Check(n))) + nkwargs = PyTuple_GET_SIZE(kwnames); #endif - return __Pyx_PyObject_GetAttrStr(o, n); + dict = PyDict_New(); + if (unlikely(!dict)) + return NULL; + for (i=0; itype, *target->method_name); + if (unlikely(!method)) + return -1; + result = method; +#if CYTHON_COMPILING_IN_CPYTHON + if (likely(__Pyx_TypeCheck(method, &PyMethodDescr_Type))) + { + PyMethodDescrObject *descr = (PyMethodDescrObject*) method; + target->func = descr->d_method->ml_meth; + target->flag = descr->d_method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_STACKLESS); + } else +#endif #if CYTHON_COMPILING_IN_PYPY - if (!value) { - Py_INCREF(Py_None); - value = Py_None; +#else + if (PyCFunction_Check(method)) +#endif + { + PyObject *self; + int self_found; +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + self = PyObject_GetAttrString(method, "__self__"); + if (!self) { + PyErr_Clear(); } +#else + self = PyCFunction_GET_SELF(method); #endif - PyErr_NormalizeException(&type, &value, &tb); - } else { - if (value) { - PyErr_SetString(PyExc_TypeError, - "instance exception may not have a separate value"); - goto raise_error; + self_found = (self && self != Py_None); +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + Py_XDECREF(self); +#endif + if (self_found) { + PyObject *unbound_method = PyCFunction_New(&__Pyx_UnboundCMethod_Def, method); + if (unlikely(!unbound_method)) return -1; + Py_DECREF(method); + result = unbound_method; } - 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; + } +#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + if (unlikely(target->method)) { + Py_DECREF(result); + } else +#endif + target->method = result; + return 0; +} + +/* CallUnboundCMethod2 */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2) { + int was_initialized = __Pyx_CachedCFunction_GetAndSetInitializing(cfunc); + if (likely(was_initialized == 2 && cfunc->func)) { + PyObject *args[2] = {arg1, arg2}; + if (cfunc->flag == METH_FASTCALL) { + return __Pyx_CallCFunctionFast(cfunc, self, args, 2); } + if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS)) + return __Pyx_CallCFunctionFastWithKeywords(cfunc, self, args, 2, NULL); } - __Pyx_PyThreadState_assign - __Pyx_ErrRestore(type, value, tb); - return; -raise_error: - Py_XDECREF(value); - Py_XDECREF(type); - Py_XDECREF(tb); - return; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + else if (unlikely(was_initialized == 1)) { + __Pyx_CachedCFunction tmp_cfunc = { +#ifndef __cplusplus + 0 +#endif + }; + tmp_cfunc.type = cfunc->type; + tmp_cfunc.method_name = cfunc->method_name; + return __Pyx__CallUnboundCMethod2(&tmp_cfunc, self, arg1, arg2); + } +#endif + PyObject *result = __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2); + __Pyx_CachedCFunction_SetFinishedInitializing(cfunc); + return result; } -#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; +#endif +static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2){ + if (unlikely(!cfunc->func && !cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; +#if CYTHON_COMPILING_IN_CPYTHON + if (cfunc->func && (cfunc->flag & METH_VARARGS)) { + PyObject *result = NULL; + PyObject *args = PyTuple_New(2); + if (unlikely(!args)) return NULL; + Py_INCREF(arg1); + PyTuple_SET_ITEM(args, 0, arg1); + Py_INCREF(arg2); + PyTuple_SET_ITEM(args, 1, arg2); + if (cfunc->flag & METH_KEYWORDS) + result = __Pyx_CallCFunctionWithKeywords(cfunc, self, args, NULL); + else + result = __Pyx_CallCFunction(cfunc, self, args); + Py_DECREF(args); + return result; } - if (value == Py_None) - value = 0; - if (PyExceptionInstance_Check(type)) { - if (value) { - PyErr_SetString(PyExc_TypeError, - "instance exception may not have a separate value"); +#endif + { + PyObject *args[4] = {NULL, self, arg1, arg2}; + return __Pyx_PyObject_FastCall(cfunc->method, args+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); + } +} + +/* ParseKeywords */ +static int __Pyx_ValidateDuplicatePosArgs( + PyObject *kwds, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + const char* function_name) +{ + PyObject ** const *name = argnames; + while (name != first_kw_arg) { + PyObject *key = **name; + int found = PyDict_Contains(kwds, key); + if (unlikely(found)) { + if (found == 1) __Pyx_RaiseDoubleKeywordsError(function_name, key); 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; + name++; + } + return 0; +bad: + return -1; +} +#if CYTHON_USE_UNICODE_INTERNALS +static CYTHON_INLINE int __Pyx_UnicodeKeywordsEqual(PyObject *s1, PyObject *s2) { + int kind; + Py_ssize_t len = PyUnicode_GET_LENGTH(s1); + if (len != PyUnicode_GET_LENGTH(s2)) return 0; + kind = PyUnicode_KIND(s1); + if (kind != PyUnicode_KIND(s2)) return 0; + const void *data1 = PyUnicode_DATA(s1); + const void *data2 = PyUnicode_DATA(s2); + return (memcmp(data1, data2, (size_t) len * (size_t) kind) == 0); +} +#endif +static int __Pyx_MatchKeywordArg_str( + PyObject *key, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + size_t *index_found, + const char *function_name) +{ + PyObject ** const *name; + #if CYTHON_USE_UNICODE_INTERNALS + Py_hash_t key_hash = ((PyASCIIObject*)key)->hash; + if (unlikely(key_hash == -1)) { + key_hash = PyObject_Hash(key); + if (unlikely(key_hash == -1)) + goto bad; + } + #endif + name = first_kw_arg; + while (*name) { + PyObject *name_str = **name; + #if CYTHON_USE_UNICODE_INTERNALS + if (key_hash == ((PyASCIIObject*)name_str)->hash && __Pyx_UnicodeKeywordsEqual(name_str, key)) { + *index_found = (size_t) (name - argnames); + return 1; + } + #else + #if CYTHON_ASSUME_SAFE_SIZE + if (PyUnicode_GET_LENGTH(name_str) == PyUnicode_GET_LENGTH(key)) + #endif + { + int cmp = PyUnicode_Compare(name_str, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + *index_found = (size_t) (name - argnames); + return 1; + } + } + #endif + name++; + } + name = argnames; + while (name != first_kw_arg) { + PyObject *name_str = **name; + #if CYTHON_USE_UNICODE_INTERNALS + if (unlikely(key_hash == ((PyASCIIObject*)name_str)->hash)) { + if (__Pyx_UnicodeKeywordsEqual(name_str, key)) + goto arg_passed_twice; + } + #else + #if CYTHON_ASSUME_SAFE_SIZE + if (PyUnicode_GET_LENGTH(name_str) == PyUnicode_GET_LENGTH(key)) + #endif + { + if (unlikely(name_str == key)) goto arg_passed_twice; + int cmp = PyUnicode_Compare(name_str, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + } + #endif + name++; + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +bad: + return -1; +} +static int __Pyx_MatchKeywordArg_nostr( + PyObject *key, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + size_t *index_found, + const char *function_name) +{ + PyObject ** const *name; + if (unlikely(!PyUnicode_Check(key))) goto invalid_keyword_type; + name = first_kw_arg; + while (*name) { + int cmp = PyObject_RichCompareBool(**name, key, Py_EQ); + if (cmp == 1) { + *index_found = (size_t) (name - argnames); + return 1; + } + if (unlikely(cmp == -1)) goto bad; + name++; + } + name = argnames; + while (name != first_kw_arg) { + int cmp = PyObject_RichCompareBool(**name, key, Py_EQ); + if (unlikely(cmp != 0)) { + if (cmp == 1) goto arg_passed_twice; + else goto bad; + } + name++; + } + 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; +bad: + return -1; +} +static CYTHON_INLINE int __Pyx_MatchKeywordArg( + PyObject *key, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + size_t *index_found, + const char *function_name) +{ + return likely(PyUnicode_CheckExact(key)) ? + __Pyx_MatchKeywordArg_str(key, argnames, first_kw_arg, index_found, function_name) : + __Pyx_MatchKeywordArg_nostr(key, argnames, first_kw_arg, index_found, function_name); +} +static void __Pyx_RejectUnknownKeyword( + PyObject *kwds, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + const char *function_name) +{ + Py_ssize_t pos = 0; + PyObject *key = NULL; + __Pyx_BEGIN_CRITICAL_SECTION(kwds); + while (PyDict_Next(kwds, &pos, &key, NULL)) { + PyObject** const *name = first_kw_arg; + while (*name && (**name != key)) name++; + if (!*name) { + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(key); + #endif + size_t index_found = 0; + int cmp = __Pyx_MatchKeywordArg(key, argnames, first_kw_arg, &index_found, function_name); + if (cmp != 1) { + if (cmp == 0) { + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(key); + #endif + break; } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(key); + #endif } - 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)); + } + __Pyx_END_CRITICAL_SECTION(); + assert(PyErr_Occurred()); +} +static int __Pyx_ParseKeywordDict( + PyObject *kwds, + PyObject ** const argnames[], + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs) +{ + PyObject** const *name; + PyObject** const *first_kw_arg = argnames + num_pos_args; + Py_ssize_t extracted = 0; +#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) + if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return -1; +#endif + name = first_kw_arg; + while (*name && num_kwargs > extracted) { + PyObject * key = **name; + PyObject *value; + int found = 0; + #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + found = PyDict_GetItemRef(kwds, key, &value); + #else + value = PyDict_GetItemWithError(kwds, key); + if (value) { + Py_INCREF(value); + found = 1; + } else { + if (unlikely(PyErr_Occurred())) goto bad; + } + #endif + if (found) { + if (unlikely(found < 0)) goto bad; + values[name-argnames] = value; + extracted++; + } + name++; + } + if (num_kwargs > extracted) { + if (ignore_unknown_kwargs) { + if (unlikely(__Pyx_ValidateDuplicatePosArgs(kwds, argnames, first_kw_arg, function_name) == -1)) goto bad; + } else { + __Pyx_RejectUnknownKeyword(kwds, argnames, first_kw_arg, function_name); + goto bad; + } + } + return 0; +bad: + return -1; +} +static int __Pyx_ParseKeywordDictToDict( + PyObject *kwds, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject** const *name; + PyObject** const *first_kw_arg = argnames + num_pos_args; + Py_ssize_t len; +#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) + if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return -1; +#endif + if (PyDict_Update(kwds2, kwds) < 0) goto bad; + name = first_kw_arg; + while (*name) { + PyObject *key = **name; + PyObject *value; +#if !CYTHON_COMPILING_IN_LIMITED_API && (PY_VERSION_HEX >= 0x030d00A2 || defined(PyDict_Pop)) + int found = PyDict_Pop(kwds2, key, &value); + if (found) { + if (unlikely(found < 0)) goto bad; + values[name-argnames] = value; + } +#elif __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + int found = PyDict_GetItemRef(kwds2, key, &value); + if (found) { + if (unlikely(found < 0)) goto bad; + values[name-argnames] = value; + if (unlikely(PyDict_DelItem(kwds2, key) < 0)) goto bad; + } +#else + #if CYTHON_COMPILING_IN_CPYTHON + value = _PyDict_Pop(kwds2, key, kwds2); + #else + value = __Pyx_CallUnboundCMethod2(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_pop, kwds2, key, kwds2); + #endif + if (value == kwds2) { + Py_DECREF(value); + } else { + if (unlikely(!value)) goto bad; + values[name-argnames] = value; + } +#endif + name++; + } + len = PyDict_Size(kwds2); + if (len > 0) { + return __Pyx_ValidateDuplicatePosArgs(kwds, argnames, first_kw_arg, function_name); + } else if (unlikely(len == -1)) { + goto bad; + } + return 0; +bad: + return -1; +} +static int __Pyx_ParseKeywordsTuple( + PyObject *kwds, + PyObject * const *kwvalues, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs) +{ + PyObject *key = NULL; + PyObject** const * name; + PyObject** const *first_kw_arg = argnames + num_pos_args; + for (Py_ssize_t pos = 0; pos < num_kwargs; pos++) { +#if CYTHON_AVOID_BORROWED_REFS + key = __Pyx_PySequence_ITEM(kwds, pos); +#else + key = __Pyx_PyTuple_GET_ITEM(kwds, pos); +#endif +#if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!key)) goto bad; +#endif + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + PyObject *value = kwvalues[pos]; + values[name-argnames] = __Pyx_NewRef(value); + } else { + size_t index_found = 0; + int cmp = __Pyx_MatchKeywordArg(key, argnames, first_kw_arg, &index_found, function_name); + if (cmp == 1) { + PyObject *value = kwvalues[pos]; + values[index_found] = __Pyx_NewRef(value); + } else { + if (unlikely(cmp == -1)) goto bad; + if (kwds2) { + PyObject *value = kwvalues[pos]; + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else if (!ignore_unknown_kwargs) { + goto invalid_keyword; + } } } - } else { + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(key); + key = NULL; + #endif + } + return 0; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + goto bad; +bad: + #if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(key); + #endif + return -1; +} +static int __Pyx_ParseKeywords( + PyObject *kwds, + PyObject * const *kwvalues, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs) +{ + if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds))) + return __Pyx_ParseKeywordsTuple(kwds, kwvalues, argnames, kwds2, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs); + else if (kwds2) + return __Pyx_ParseKeywordDictToDict(kwds, argnames, kwds2, values, num_pos_args, function_name); + else + return __Pyx_ParseKeywordDict(kwds, argnames, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs); +} + +/* 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); +} + +/* PyObjectCallOneArg */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *args[2] = {NULL, arg}; + return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} + +/* PyObjectFormat */ +#if CYTHON_USE_UNICODE_WRITER +static PyObject* __Pyx_PyObject_Format(PyObject* obj, PyObject* format_spec) { + int ret; + _PyUnicodeWriter writer; + if (likely(PyFloat_CheckExact(obj))) { + _PyUnicodeWriter_Init(&writer); + ret = _PyFloat_FormatAdvancedWriter( + &writer, + obj, + format_spec, 0, PyUnicode_GET_LENGTH(format_spec)); + } else if (likely(PyLong_CheckExact(obj))) { + _PyUnicodeWriter_Init(&writer); + ret = _PyLong_FormatAdvancedWriter( + &writer, + obj, + format_spec, 0, PyUnicode_GET_LENGTH(format_spec)); + } else { + return PyObject_Format(obj, format_spec); + } + if (unlikely(ret == -1)) { + _PyUnicodeWriter_Dealloc(&writer); + return NULL; + } + return _PyUnicodeWriter_Finish(&writer); +} +#endif + +/* PyUnicode_Unicode */ +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_Unicode(PyObject *obj) { + if (unlikely(obj == Py_None)) + obj = __pyx_mstate_global->__pyx_kp_u_None; + return __Pyx_NewRef(obj); +} + +/* ArgTypeTest */ +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +{ + __Pyx_TypeName type_name; + __Pyx_TypeName obj_type_name; + PyObject *extra_info = __pyx_mstate_global->__pyx_empty_unicode; + int from_annotation_subclass = 0; + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + else if (!exact) { + if (likely(__Pyx_TypeCheck(obj, type))) return 1; + } else if (exact == 2) { + if (__Pyx_TypeCheck(obj, type)) { + from_annotation_subclass = 1; + extra_info = __pyx_mstate_global->__pyx_kp_u_Note_that_Cython_is_deliberately; + } + } + type_name = __Pyx_PyType_GetFullyQualifiedName(type); + obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME + ", got " __Pyx_FMT_TYPENAME ")" +#if __PYX_LIMITED_VERSION_HEX < 0x030C0000 + "%s%U" +#endif + , name, type_name, obj_type_name +#if __PYX_LIMITED_VERSION_HEX < 0x030C0000 + , (from_annotation_subclass ? ". " : ""), extra_info +#endif + ); +#if __PYX_LIMITED_VERSION_HEX >= 0x030C0000 + if (exact == 2 && from_annotation_subclass) { + PyObject *res; + PyObject *vargs[2]; + vargs[0] = PyErr_GetRaisedException(); + vargs[1] = extra_info; + res = PyObject_VectorcallMethod(__pyx_mstate_global->__pyx_kp_u_add_note, vargs, 2, NULL); + Py_XDECREF(res); + PyErr_SetRaisedException(vargs[0]); + } +#endif + __Pyx_DECREF_TypeName(type_name); + __Pyx_DECREF_TypeName(obj_type_name); + return 0; +} + +/* DictGetItem */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { + PyObject *value; + if (unlikely(__Pyx_PyDict_GetItemRef(d, key, &value) == 0)) { // no value, no error + if (unlikely(PyTuple_Check(key))) { + PyObject* args = PyTuple_Pack(1, key); + if (likely(args)) { + PyErr_SetObject(PyExc_KeyError, args); + Py_DECREF(args); + } + } else { + PyErr_SetObject(PyExc_KeyError, key); + } + } + return value; +} +#endif + +/* GetAttr3 */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d0000 +static PyObject *__Pyx_GetAttr3Default(PyObject *d) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + return NULL; + __Pyx_PyErr_Clear(); + Py_INCREF(d); + return d; +} +#endif +static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { + PyObject *r; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + int res = PyObject_GetOptionalAttr(o, n, &r); + return (res != 0) ? r : __Pyx_NewRef(d); +#else + #if CYTHON_USE_TYPE_SLOTS + if (likely(PyUnicode_Check(n))) { + r = __Pyx_PyObject_GetAttrStrNoError(o, n); + if (unlikely(!r) && likely(!PyErr_Occurred())) { + r = __Pyx_NewRef(d); + } + return r; + } + #endif + r = PyObject_GetAttr(o, n); + return (likely(r)) ? r : __Pyx_GetAttr3Default(d); +#endif +} + +/* RejectKeywords */ +static void __Pyx_RejectKeywords(const char* function_name, PyObject *kwds) { + PyObject *key = NULL; + if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds))) { + key = __Pyx_PySequence_ITEM(kwds, 0); + } else { + Py_ssize_t pos = 0; +#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) + if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return; +#endif + PyDict_Next(kwds, &pos, &key, NULL); + Py_INCREF(key); + } + if (likely(key)) { + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + Py_DECREF(key); + } +} + +/* RaiseException */ +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 PY_VERSION_HEX >= 0x030C00A6 + PyException_SetTraceback(value, tb); +#elif CYTHON_FAST_THREAD_STATE + 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); + } +#else + 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); +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} + +/* CallTypeTraverse */ +#if !CYTHON_USE_TYPE_SPECS || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x03090000) +#else +static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg) { + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x03090000 + if (__Pyx_get_runtime_version() < 0x03090000) return 0; + #endif + if (!always_call) { + PyTypeObject *base = __Pyx_PyObject_GetSlot(o, tp_base, PyTypeObject*); + unsigned long flags = PyType_GetFlags(base); + if (flags & Py_TPFLAGS_HEAPTYPE) { + return 0; + } + } + Py_VISIT((PyObject*)Py_TYPE(o)); + return 0; +} +#endif + +/* TypeImport */ +#ifndef __PYX_HAVE_RT_ImportType_3_1_3 +#define __PYX_HAVE_RT_ImportType_3_1_3 +static PyTypeObject *__Pyx_ImportType_3_1_3(PyObject *module, const char *module_name, const char *class_name, + size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_1_3 check_size) +{ + PyObject *result = 0; + Py_ssize_t basicsize; + Py_ssize_t itemsize; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_basicsize; + PyObject *py_itemsize; +#endif + result = PyObject_GetAttrString(module, class_name); + if (!result) + goto bad; + if (!PyType_Check(result)) { + PyErr_Format(PyExc_TypeError, + "%.200s.%.200s is not a type object", + module_name, class_name); + goto bad; + } +#if !CYTHON_COMPILING_IN_LIMITED_API + basicsize = ((PyTypeObject *)result)->tp_basicsize; + itemsize = ((PyTypeObject *)result)->tp_itemsize; +#else + if (size == 0) { + return (PyTypeObject *)result; + } + py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); + if (!py_basicsize) + goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; + py_itemsize = PyObject_GetAttrString(result, "__itemsize__"); + if (!py_itemsize) + goto bad; + itemsize = PyLong_AsSsize_t(py_itemsize); + Py_DECREF(py_itemsize); + py_itemsize = 0; + if (itemsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; +#endif + if (itemsize) { + if (size % alignment) { + alignment = size % alignment; + } + if (itemsize < (Py_ssize_t)alignment) + itemsize = (Py_ssize_t)alignment; + } + if ((size_t)(basicsize + itemsize) < size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize+itemsize); + goto bad; + } + if (check_size == __Pyx_ImportType_CheckSize_Error_3_1_3 && + ((size_t)basicsize > size || (size_t)(basicsize + itemsize) < size)) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd-%zd from PyObject", + module_name, class_name, size, basicsize, basicsize+itemsize); + goto bad; + } + else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_1_3 && (size_t)basicsize > size) { + if (PyErr_WarnFormat(NULL, 0, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize) < 0) { + goto bad; + } + } + return (PyTypeObject *)result; +bad: + Py_XDECREF(result); + return NULL; +} +#endif + +/* LimitedApiGetTypeDict */ +#if CYTHON_COMPILING_IN_LIMITED_API +static Py_ssize_t __Pyx_GetTypeDictOffset(void) { + PyObject *tp_dictoffset_o; + Py_ssize_t tp_dictoffset; + tp_dictoffset_o = PyObject_GetAttrString((PyObject*)(&PyType_Type), "__dictoffset__"); + if (unlikely(!tp_dictoffset_o)) return -1; + tp_dictoffset = PyLong_AsSsize_t(tp_dictoffset_o); + Py_DECREF(tp_dictoffset_o); + if (unlikely(tp_dictoffset == 0)) { + PyErr_SetString( + PyExc_TypeError, + "'type' doesn't have a dictoffset"); + return -1; + } else if (unlikely(tp_dictoffset < 0)) { + PyErr_SetString( + PyExc_TypeError, + "'type' has an unexpected negative dictoffset. " + "Please report this as Cython bug"); + return -1; + } + return tp_dictoffset; +} +static PyObject *__Pyx_GetTypeDict(PyTypeObject *tp) { + static Py_ssize_t tp_dictoffset = 0; + if (unlikely(tp_dictoffset == 0)) { + tp_dictoffset = __Pyx_GetTypeDictOffset(); + if (unlikely(tp_dictoffset == -1 && PyErr_Occurred())) { + tp_dictoffset = 0; // try again next time? + return NULL; + } + } + return *(PyObject**)((char*)tp + tp_dictoffset); +} +#endif + +/* SetItemOnTypeDict */ +static int __Pyx__SetItemOnTypeDict(PyTypeObject *tp, PyObject *k, PyObject *v) { + int result; + PyObject *tp_dict; +#if CYTHON_COMPILING_IN_LIMITED_API + tp_dict = __Pyx_GetTypeDict(tp); + if (unlikely(!tp_dict)) return -1; +#else + tp_dict = tp->tp_dict; +#endif + result = PyDict_SetItem(tp_dict, k, v); + if (likely(!result)) { + PyType_Modified(tp); + if (unlikely(PyObject_HasAttr(v, __pyx_mstate_global->__pyx_n_u_set_name))) { + PyObject *setNameResult = PyObject_CallMethodObjArgs(v, __pyx_mstate_global->__pyx_n_u_set_name, (PyObject *) tp, k, NULL); + if (!setNameResult) return -1; + Py_DECREF(setNameResult); + } + } + return result; +} + +/* FixUpExtensionType */ +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) { +#if __PYX_LIMITED_VERSION_HEX > 0x030900B1 + CYTHON_UNUSED_VAR(spec); + CYTHON_UNUSED_VAR(type); + CYTHON_UNUSED_VAR(__Pyx__SetItemOnTypeDict); +#else + const PyType_Slot *slot = spec->slots; + int changed = 0; +#if !CYTHON_COMPILING_IN_LIMITED_API + while (slot && slot->slot && slot->slot != Py_tp_members) + slot++; + if (slot && slot->slot == Py_tp_members) { +#if !CYTHON_COMPILING_IN_CPYTHON + const +#endif // !CYTHON_COMPILING_IN_CPYTHON) + PyMemberDef *memb = (PyMemberDef*) slot->pfunc; + while (memb && memb->name) { + if (memb->name[0] == '_' && memb->name[1] == '_') { + if (strcmp(memb->name, "__weaklistoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_weaklistoffset = memb->offset; + changed = 1; + } + else if (strcmp(memb->name, "__dictoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_dictoffset = memb->offset; + changed = 1; + } +#if CYTHON_METH_FASTCALL + else if (strcmp(memb->name, "__vectorcalloffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); +#if PY_VERSION_HEX >= 0x030800b4 + type->tp_vectorcall_offset = memb->offset; +#else + type->tp_print = (printfunc) memb->offset; +#endif + changed = 1; + } +#endif // CYTHON_METH_FASTCALL +#if !CYTHON_COMPILING_IN_PYPY + else if (strcmp(memb->name, "__module__") == 0) { + PyObject *descr; + assert(memb->type == T_OBJECT); + assert(memb->flags == 0 || memb->flags == READONLY); + descr = PyDescr_NewMember(type, memb); + if (unlikely(!descr)) + return -1; + int set_item_result = PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr); + Py_DECREF(descr); + if (unlikely(set_item_result < 0)) { + return -1; + } + changed = 1; + } +#endif // !CYTHON_COMPILING_IN_PYPY + } + memb++; + } + } +#endif // !CYTHON_COMPILING_IN_LIMITED_API +#if !CYTHON_COMPILING_IN_PYPY + slot = spec->slots; + while (slot && slot->slot && slot->slot != Py_tp_getset) + slot++; + if (slot && slot->slot == Py_tp_getset) { + PyGetSetDef *getset = (PyGetSetDef*) slot->pfunc; + while (getset && getset->name) { + if (getset->name[0] == '_' && getset->name[1] == '_' && strcmp(getset->name, "__module__") == 0) { + PyObject *descr = PyDescr_NewGetSet(type, getset); + if (unlikely(!descr)) + return -1; + #if CYTHON_COMPILING_IN_LIMITED_API + PyObject *pyname = PyUnicode_FromString(getset->name); + if (unlikely(!pyname)) { + Py_DECREF(descr); + return -1; + } + int set_item_result = __Pyx_SetItemOnTypeDict(type, pyname, descr); + Py_DECREF(pyname); + #else + CYTHON_UNUSED_VAR(__Pyx__SetItemOnTypeDict); + int set_item_result = PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr); + #endif + Py_DECREF(descr); + if (unlikely(set_item_result < 0)) { + return -1; + } + changed = 1; + } + ++getset; + } + } +#endif // !CYTHON_COMPILING_IN_PYPY + if (changed) + PyType_Modified(type); +#endif // PY_VERSION_HEX > 0x030900B1 + return 0; +} + +/* PyObjectCallNoArg */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { + PyObject *arg[2] = {NULL, NULL}; + return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} + +/* PyObjectGetMethod */ +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { + PyObject *attr; +#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP + __Pyx_TypeName type_name; + PyTypeObject *tp = Py_TYPE(obj); + PyObject *descr; + descrgetfunc f = NULL; + PyObject **dictptr, *dict; + int meth_found = 0; + assert (*method == NULL); + if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) { + attr = __Pyx_PyObject_GetAttrStr(obj, name); + goto try_unpack; + } + if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) { + return 0; + } + descr = _PyType_Lookup(tp, name); + if (likely(descr != NULL)) { + Py_INCREF(descr); +#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR + if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)) +#else + #ifdef __Pyx_CyFunction_USED + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) + #else + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type))) + #endif +#endif + { + meth_found = 1; + } else { + f = Py_TYPE(descr)->tp_descr_get; + if (f != NULL && PyDescr_IsData(descr)) { + attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); + Py_DECREF(descr); + goto try_unpack; + } + } + } + dictptr = _PyObject_GetDictPtr(obj); + if (dictptr != NULL && (dict = *dictptr) != NULL) { + Py_INCREF(dict); + attr = __Pyx_PyDict_GetItemStr(dict, name); + if (attr != NULL) { + Py_INCREF(attr); + Py_DECREF(dict); + Py_XDECREF(descr); + goto try_unpack; + } + Py_DECREF(dict); + } + if (meth_found) { + *method = descr; + return 1; + } + if (f != NULL) { + attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); + Py_DECREF(descr); + goto try_unpack; + } + if (likely(descr != NULL)) { + *method = descr; + return 0; + } + type_name = __Pyx_PyType_GetFullyQualifiedName(tp); + PyErr_Format(PyExc_AttributeError, + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, name); + __Pyx_DECREF_TypeName(type_name); + return 0; +#else + attr = __Pyx_PyObject_GetAttrStr(obj, name); + goto try_unpack; +#endif +try_unpack: +#if CYTHON_UNPACK_METHODS + if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) { + PyObject *function = PyMethod_GET_FUNCTION(attr); + Py_INCREF(function); + Py_DECREF(attr); + *method = function; + return 1; + } +#endif + *method = attr; + return 0; +} + +/* PyObjectCallMethod0 */ +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { +#if CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000)) + PyObject *args[1] = {obj}; + (void) __Pyx_PyObject_GetMethod; + (void) __Pyx_PyObject_CallOneArg; + (void) __Pyx_PyObject_CallNoArg; + return PyObject_VectorcallMethod(method_name, args, 1 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); +#else + PyObject *method = NULL, *result = NULL; + int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); + if (likely(is_method)) { + result = __Pyx_PyObject_CallOneArg(method, obj); + Py_DECREF(method); + return result; + } + if (unlikely(!method)) goto bad; + result = __Pyx_PyObject_CallNoArg(method); + Py_DECREF(method); +bad: + return result; +#endif +} + +/* ValidateBasesTuple */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) { + Py_ssize_t i, n; +#if CYTHON_ASSUME_SAFE_SIZE + n = PyTuple_GET_SIZE(bases); +#else + n = PyTuple_Size(bases); + if (unlikely(n < 0)) return -1; +#endif + for (i = 1; i < n; i++) + { + PyTypeObject *b; +#if CYTHON_AVOID_BORROWED_REFS + PyObject *b0 = PySequence_GetItem(bases, i); + if (!b0) return -1; +#elif CYTHON_ASSUME_SAFE_MACROS + PyObject *b0 = PyTuple_GET_ITEM(bases, i); +#else + PyObject *b0 = PyTuple_GetItem(bases, i); + if (!b0) return -1; +#endif + b = (PyTypeObject*) b0; + if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) + { + __Pyx_TypeName b_name = __Pyx_PyType_GetFullyQualifiedName(b); + PyErr_Format(PyExc_TypeError, + "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name); + __Pyx_DECREF_TypeName(b_name); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } + if (dictoffset == 0) + { + Py_ssize_t b_dictoffset = 0; +#if CYTHON_USE_TYPE_SLOTS + b_dictoffset = b->tp_dictoffset; +#else + PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__"); + if (!py_b_dictoffset) goto dictoffset_return; + b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset); + Py_DECREF(py_b_dictoffset); + if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return; +#endif + if (b_dictoffset) { + { + __Pyx_TypeName b_name = __Pyx_PyType_GetFullyQualifiedName(b); + PyErr_Format(PyExc_TypeError, + "extension type '%.200s' has no __dict__ slot, " + "but base type '" __Pyx_FMT_TYPENAME "' has: " + "either add 'cdef dict __dict__' to the extension type " + "or add '__slots__ = [...]' to the base type", + type_name, b_name); + __Pyx_DECREF_TypeName(b_name); + } +#if !CYTHON_USE_TYPE_SLOTS + dictoffset_return: +#endif +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } + } +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + } + return 0; +} +#endif + +/* PyType_Ready */ +CYTHON_UNUSED static int __Pyx_PyType_HasMultipleInheritance(PyTypeObject *t) { + while (t) { + PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); + if (bases) { + return 1; + } + t = __Pyx_PyType_GetSlot(t, tp_base, PyTypeObject*); + } + return 0; +} +static int __Pyx_PyType_Ready(PyTypeObject *t) { +#if CYTHON_USE_TYPE_SPECS || !CYTHON_COMPILING_IN_CPYTHON || defined(PYSTON_MAJOR_VERSION) + (void)__Pyx_PyObject_CallMethod0; +#if CYTHON_USE_TYPE_SPECS + (void)__Pyx_validate_bases_tuple; +#endif + return PyType_Ready(t); +#else + int r; + if (!__Pyx_PyType_HasMultipleInheritance(t)) { + return PyType_Ready(t); + } + PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); + if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1)) + return -1; +#if !defined(PYSTON_MAJOR_VERSION) + { + int gc_was_enabled; + #if PY_VERSION_HEX >= 0x030A00b1 + gc_was_enabled = PyGC_Disable(); + (void)__Pyx_PyObject_CallMethod0; + #else + PyObject *ret, *py_status; + PyObject *gc = NULL; + #if (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) &&\ + !CYTHON_COMPILING_IN_GRAAL + gc = PyImport_GetModule(__pyx_mstate_global->__pyx_kp_u_gc); + #endif + if (unlikely(!gc)) gc = PyImport_Import(__pyx_mstate_global->__pyx_kp_u_gc); + if (unlikely(!gc)) return -1; + py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_isenabled); + if (unlikely(!py_status)) { + Py_DECREF(gc); + return -1; + } + gc_was_enabled = __Pyx_PyObject_IsTrue(py_status); + Py_DECREF(py_status); + if (gc_was_enabled > 0) { + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_disable); + if (unlikely(!ret)) { + Py_DECREF(gc); + return -1; + } + Py_DECREF(ret); + } else if (unlikely(gc_was_enabled == -1)) { + Py_DECREF(gc); + return -1; + } + #endif + t->tp_flags |= Py_TPFLAGS_HEAPTYPE; +#if PY_VERSION_HEX >= 0x030A0000 + t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE; +#endif +#else + (void)__Pyx_PyObject_CallMethod0; +#endif + r = PyType_Ready(t); +#if !defined(PYSTON_MAJOR_VERSION) + t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE; + #if PY_VERSION_HEX >= 0x030A00b1 + if (gc_was_enabled) + PyGC_Enable(); + #else + if (gc_was_enabled) { + PyObject *tp, *v, *tb; + PyErr_Fetch(&tp, &v, &tb); + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_enable); + if (likely(ret || r == -1)) { + Py_XDECREF(ret); + PyErr_Restore(tp, v, tb); + } else { + Py_XDECREF(tp); + Py_XDECREF(v); + Py_XDECREF(tb); + r = -1; + } + } + Py_DECREF(gc); + #endif + } +#endif + return r; +#endif +} + +/* DelItemOnTypeDict */ +static int __Pyx__DelItemOnTypeDict(PyTypeObject *tp, PyObject *k) { + int result; + PyObject *tp_dict; +#if CYTHON_COMPILING_IN_LIMITED_API + tp_dict = __Pyx_GetTypeDict(tp); + if (unlikely(!tp_dict)) return -1; +#else + tp_dict = tp->tp_dict; +#endif + result = PyDict_DelItem(tp_dict, k); + if (likely(!result)) PyType_Modified(tp); + return result; +} + +/* SetupReduce */ +static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { + int ret; + PyObject *name_attr; + name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_mstate_global->__pyx_n_u_name); + if (likely(name_attr)) { + ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); + } else { + ret = -1; + } + if (unlikely(ret < 0)) { + PyErr_Clear(); + ret = 0; + } + Py_XDECREF(name_attr); + return ret; +} +static int __Pyx_setup_reduce(PyObject* type_obj) { + int ret = 0; + PyObject *object_reduce = NULL; + PyObject *object_getstate = NULL; + PyObject *object_reduce_ex = NULL; + PyObject *reduce = NULL; + PyObject *reduce_ex = NULL; + PyObject *reduce_cython = NULL; + PyObject *setstate = NULL; + PyObject *setstate_cython = NULL; + PyObject *getstate = NULL; +#if CYTHON_USE_PYTYPE_LOOKUP + getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_getstate); +#else + getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_getstate); + if (!getstate && PyErr_Occurred()) { + goto __PYX_BAD; + } +#endif + if (getstate) { +#if CYTHON_USE_PYTYPE_LOOKUP + object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_getstate); +#else + object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_getstate); + if (!object_getstate && PyErr_Occurred()) { + goto __PYX_BAD; + } +#endif + if (object_getstate != getstate) { + goto __PYX_GOOD; + } + } +#if CYTHON_USE_PYTYPE_LOOKUP + object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; +#else + object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; +#endif + reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_mstate_global->__pyx_n_u_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; + if (reduce_ex == object_reduce_ex) { +#if CYTHON_USE_PYTYPE_LOOKUP + object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_reduce); if (!object_reduce) goto __PYX_BAD; +#else + object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_reduce); if (!object_reduce) goto __PYX_BAD; +#endif + reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_mstate_global->__pyx_n_u_reduce); if (unlikely(!reduce)) goto __PYX_BAD; + if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_mstate_global->__pyx_n_u_reduce_cython)) { + reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_reduce_cython); + if (likely(reduce_cython)) { + ret = __Pyx_SetItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = __Pyx_DelItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + } else if (reduce == object_reduce || PyErr_Occurred()) { + goto __PYX_BAD; + } + setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_setstate); + if (!setstate) PyErr_Clear(); + if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_mstate_global->__pyx_n_u_setstate_cython)) { + setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_setstate_cython); + if (likely(setstate_cython)) { + ret = __Pyx_SetItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = __Pyx_DelItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + } else if (!setstate || PyErr_Occurred()) { + goto __PYX_BAD; + } + } + PyType_Modified((PyTypeObject*)type_obj); + } + } + goto __PYX_GOOD; +__PYX_BAD: + if (!PyErr_Occurred()) { + __Pyx_TypeName type_obj_name = + __Pyx_PyType_GetFullyQualifiedName((PyTypeObject*)type_obj); + PyErr_Format(PyExc_RuntimeError, + "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name); + __Pyx_DECREF_TypeName(type_obj_name); + } + ret = -1; +__PYX_GOOD: +#if !CYTHON_USE_PYTYPE_LOOKUP + Py_XDECREF(object_reduce); + Py_XDECREF(object_reduce_ex); + Py_XDECREF(object_getstate); + Py_XDECREF(getstate); +#endif + Py_XDECREF(reduce); + Py_XDECREF(reduce_ex); + Py_XDECREF(reduce_cython); + Py_XDECREF(setstate); + Py_XDECREF(setstate_cython); + return ret; +} + +/* GetVTable */ +static void* __Pyx_GetVtable(PyTypeObject *type) { + void* ptr; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *ob = PyObject_GetAttr((PyObject *)type, __pyx_mstate_global->__pyx_n_u_pyx_vtable); +#else + PyObject *ob = PyObject_GetItem(type->tp_dict, __pyx_mstate_global->__pyx_n_u_pyx_vtable); +#endif + if (!ob) + goto bad; + ptr = PyCapsule_GetPointer(ob, 0); + if (!ptr && !PyErr_Occurred()) + PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type"); + Py_DECREF(ob); + return ptr; +bad: + Py_XDECREF(ob); + return NULL; +} + +/* Import */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *module = 0; + PyObject *empty_dict = 0; + PyObject *empty_list = 0; + empty_dict = PyDict_New(); + if (unlikely(!empty_dict)) + goto bad; + if (level == -1) { + const char* package_sep = strchr(__Pyx_MODULE_NAME, '.'); + if (package_sep != (0)) { + module = PyImport_ImportModuleLevelObject( + name, __pyx_mstate_global->__pyx_d, empty_dict, from_list, 1); + if (unlikely(!module)) { + if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError))) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + if (!module) { + module = PyImport_ImportModuleLevelObject( + name, __pyx_mstate_global->__pyx_d, empty_dict, from_list, level); + } +bad: + Py_XDECREF(empty_dict); + Py_XDECREF(empty_list); + return module; +} + +/* ImportDottedModule */ +static PyObject *__Pyx__ImportDottedModule_Error(PyObject *name, PyObject *parts_tuple, Py_ssize_t count) { + PyObject *partial_name = NULL, *slice = NULL, *sep = NULL; + Py_ssize_t size; + if (unlikely(PyErr_Occurred())) { + PyErr_Clear(); + } +#if CYTHON_ASSUME_SAFE_SIZE + size = PyTuple_GET_SIZE(parts_tuple); +#else + size = PyTuple_Size(parts_tuple); + if (size < 0) goto bad; +#endif + if (likely(size == count)) { + partial_name = name; + } else { + slice = PySequence_GetSlice(parts_tuple, 0, count); + if (unlikely(!slice)) + goto bad; + sep = PyUnicode_FromStringAndSize(".", 1); + if (unlikely(!sep)) + goto bad; + partial_name = PyUnicode_Join(sep, slice); + } + PyErr_Format( + PyExc_ModuleNotFoundError, + "No module named '%U'", partial_name); +bad: + Py_XDECREF(sep); + Py_XDECREF(slice); + Py_XDECREF(partial_name); + return NULL; +} +static PyObject *__Pyx__ImportDottedModule_Lookup(PyObject *name) { + PyObject *imported_module; +#if (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) ||\ + CYTHON_COMPILING_IN_GRAAL + PyObject *modules = PyImport_GetModuleDict(); + if (unlikely(!modules)) + return NULL; + imported_module = __Pyx_PyDict_GetItemStr(modules, name); + Py_XINCREF(imported_module); +#else + imported_module = PyImport_GetModule(name); +#endif + return imported_module; +} +static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple) { + Py_ssize_t i, nparts; +#if CYTHON_ASSUME_SAFE_SIZE + nparts = PyTuple_GET_SIZE(parts_tuple); +#else + nparts = PyTuple_Size(parts_tuple); + if (nparts < 0) return NULL; +#endif + for (i=1; i < nparts && module; i++) { + PyObject *part, *submodule; +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + part = PyTuple_GET_ITEM(parts_tuple, i); +#else + part = __Pyx_PySequence_ITEM(parts_tuple, i); + if (!part) return NULL; +#endif + submodule = __Pyx_PyObject_GetAttrStrNoError(module, part); +#if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) + Py_DECREF(part); +#endif + Py_DECREF(module); + module = submodule; + } + if (unlikely(!module)) { + return __Pyx__ImportDottedModule_Error(name, parts_tuple, i); + } + return module; +} +static PyObject *__Pyx__ImportDottedModule(PyObject *name, PyObject *parts_tuple) { + PyObject *imported_module; + PyObject *module = __Pyx_Import(name, NULL, 0); + if (!parts_tuple || unlikely(!module)) + return module; + imported_module = __Pyx__ImportDottedModule_Lookup(name); + if (likely(imported_module)) { + Py_DECREF(module); + return imported_module; + } + PyErr_Clear(); + return __Pyx_ImportDottedModule_WalkParts(module, name, parts_tuple); +} +static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple) { +#if CYTHON_COMPILING_IN_CPYTHON + PyObject *module = __Pyx__ImportDottedModule_Lookup(name); + if (likely(module)) { + PyObject *spec = __Pyx_PyObject_GetAttrStrNoError(module, __pyx_mstate_global->__pyx_n_u_spec); + if (likely(spec)) { + PyObject *unsafe = __Pyx_PyObject_GetAttrStrNoError(spec, __pyx_mstate_global->__pyx_n_u_initializing); + if (likely(!unsafe || !__Pyx_PyObject_IsTrue(unsafe))) { + Py_DECREF(spec); + spec = NULL; + } + Py_XDECREF(unsafe); + } + if (likely(!spec)) { + PyErr_Clear(); + return module; + } + Py_DECREF(spec); + Py_DECREF(module); + } else if (PyErr_Occurred()) { + PyErr_Clear(); + } +#endif + return __Pyx__ImportDottedModule(name, parts_tuple); +} + +/* FetchSharedCythonModule */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void) { + return __Pyx_PyImport_AddModuleRef(__PYX_ABI_MODULE_NAME); +} + +/* dict_setdefault */ +static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value, + int is_safe_type) { + PyObject* value; + CYTHON_MAYBE_UNUSED_VAR(is_safe_type); +#if CYTHON_COMPILING_IN_LIMITED_API + value = PyObject_CallMethod(d, "setdefault", "OO", key, default_value); +#elif PY_VERSION_HEX >= 0x030d0000 + PyDict_SetDefaultRef(d, key, default_value, &value); +#else + value = PyDict_SetDefault(d, key, default_value); + if (unlikely(!value)) return NULL; + Py_INCREF(value); +#endif + return value; +} + +/* FetchCommonType */ +#if __PYX_LIMITED_VERSION_HEX < 0x030C0000 +static PyObject* __Pyx_PyType_FromMetaclass(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *result = __Pyx_PyType_FromModuleAndSpec(module, spec, bases); + if (result && metaclass) { + PyObject *old_tp = (PyObject*)Py_TYPE(result); + Py_INCREF((PyObject*)metaclass); +#if __PYX_LIMITED_VERSION_HEX >= 0x03090000 + Py_SET_TYPE(result, metaclass); +#else + result->ob_type = metaclass; +#endif + Py_DECREF(old_tp); + } + return result; +} +#else +#define __Pyx_PyType_FromMetaclass(me, mo, s, b) PyType_FromMetaclass(me, mo, s, b) +#endif +static int __Pyx_VerifyCachedType(PyObject *cached_type, + const char *name, + Py_ssize_t expected_basicsize) { + Py_ssize_t basicsize; + if (!PyType_Check(cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", name); + return -1; + } + if (expected_basicsize == 0) { + return 0; // size is inherited, nothing useful to check + } +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_basicsize; + py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); + if (unlikely(!py_basicsize)) return -1; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = NULL; + if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) return -1; +#else + basicsize = ((PyTypeObject*) cached_type)->tp_basicsize; +#endif + if (basicsize != expected_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + name); + return -1; + } + return 0; +} +static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *abi_module = NULL, *cached_type = NULL, *abi_module_dict, *new_cached_type, *py_object_name; + int get_item_ref_result; + const char* object_name = strrchr(spec->name, '.'); + object_name = object_name ? object_name+1 : spec->name; + py_object_name = PyUnicode_FromString(object_name); + if (!py_object_name) return NULL; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) goto done; + abi_module_dict = PyModule_GetDict(abi_module); + if (!abi_module_dict) goto done; + get_item_ref_result = __Pyx_PyDict_GetItemRef(abi_module_dict, py_object_name, &cached_type); + if (get_item_ref_result == 1) { + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + spec->basicsize) < 0) { + goto bad; + } + goto done; + } else if (unlikely(get_item_ref_result == -1)) { + goto bad; + } + CYTHON_UNUSED_VAR(module); + cached_type = __Pyx_PyType_FromMetaclass(metaclass, abi_module, spec, bases); + if (unlikely(!cached_type)) goto bad; + if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad; + new_cached_type = __Pyx_PyDict_SetDefault(abi_module_dict, py_object_name, cached_type, 1); + if (unlikely(new_cached_type != cached_type)) { + if (unlikely(!new_cached_type)) goto bad; + Py_DECREF(cached_type); + cached_type = new_cached_type; + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + spec->basicsize) < 0) { + goto bad; + } + goto done; + } else { + Py_DECREF(new_cached_type); + } +done: + Py_XDECREF(abi_module); + Py_DECREF(py_object_name); + assert(cached_type == NULL || PyType_Check(cached_type)); + return (PyTypeObject *) cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} + +/* CommonTypesMetaclass */ +static PyObject* __pyx_CommonTypesMetaclass_get_module(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED void* context) { + return PyUnicode_FromString(__PYX_ABI_MODULE_NAME); +} +static PyGetSetDef __pyx_CommonTypesMetaclass_getset[] = { + {"__module__", __pyx_CommonTypesMetaclass_get_module, NULL, NULL, NULL}, + {0, 0, 0, 0, 0} +}; +static PyType_Slot __pyx_CommonTypesMetaclass_slots[] = { + {Py_tp_getset, (void *)__pyx_CommonTypesMetaclass_getset}, + {0, 0} +}; +static PyType_Spec __pyx_CommonTypesMetaclass_spec = { + __PYX_TYPE_MODULE_PREFIX "_common_types_metatype", + 0, + 0, +#if PY_VERSION_HEX >= 0x030A0000 + Py_TPFLAGS_IMMUTABLETYPE | + Py_TPFLAGS_DISALLOW_INSTANTIATION | +#endif + Py_TPFLAGS_DEFAULT, + __pyx_CommonTypesMetaclass_slots +}; +static int __pyx_CommonTypesMetaclass_init(PyObject *module) { + __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module); + PyObject *bases = PyTuple_Pack(1, &PyType_Type); + if (unlikely(!bases)) { + return -1; + } + mstate->__pyx_CommonTypesMetaclassType = __Pyx_FetchCommonTypeFromSpec(NULL, module, &__pyx_CommonTypesMetaclass_spec, bases); + if (unlikely(mstate->__pyx_CommonTypesMetaclassType == NULL)) { + return -1; + } + return 0; +} + +/* PyMethodNew */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + PyObject *result; + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + #if __PYX_LIMITED_VERSION_HEX >= 0x030C0000 + { + PyObject *args[] = {func, self}; + result = PyObject_Vectorcall(__pyx_mstate_global->__Pyx_CachedMethodType, args, 2, NULL); + } + #else + result = PyObject_CallFunctionObjArgs(__pyx_mstate_global->__Pyx_CachedMethodType, func, self, NULL); + #endif + return result; +} +#else +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + return PyMethod_New(func, self); +} +#endif + +/* PyVectorcallFastCallDict */ +#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL) +static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) +{ + PyObject *res = NULL; + PyObject *kwnames; + PyObject **newargs; + PyObject **kwvalues; + Py_ssize_t i, pos; + size_t j; + PyObject *key, *value; + unsigned long keys_are_strings; + #if !CYTHON_ASSUME_SAFE_SIZE + Py_ssize_t nkw = PyDict_Size(kw); + if (unlikely(nkw == -1)) return NULL; + #else + Py_ssize_t nkw = PyDict_GET_SIZE(kw); + #endif + newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0])); + if (unlikely(newargs == NULL)) { + PyErr_NoMemory(); + return NULL; + } + for (j = 0; j < nargs; j++) newargs[j] = args[j]; + kwnames = PyTuple_New(nkw); + if (unlikely(kwnames == NULL)) { + PyMem_Free(newargs); + return NULL; + } + kwvalues = newargs + nargs; + pos = i = 0; + keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS; + while (PyDict_Next(kw, &pos, &key, &value)) { + keys_are_strings &= + #if CYTHON_COMPILING_IN_LIMITED_API + PyType_GetFlags(Py_TYPE(key)); + #else + Py_TYPE(key)->tp_flags; + #endif + Py_INCREF(key); + Py_INCREF(value); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(PyTuple_SetItem(kwnames, i, key) < 0)) goto cleanup; + #else + PyTuple_SET_ITEM(kwnames, i, key); + #endif + kwvalues[i] = value; + i++; + } + if (unlikely(!keys_are_strings)) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + goto cleanup; + } + res = vc(func, newargs, nargs, kwnames); +cleanup: + Py_DECREF(kwnames); + for (i = 0; i < nkw; i++) + Py_DECREF(kwvalues[i]); + PyMem_Free(newargs); + return res; +} +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) +{ + Py_ssize_t kw_size = + likely(kw == NULL) ? + 0 : +#if !CYTHON_ASSUME_SAFE_SIZE + PyDict_Size(kw); +#else + PyDict_GET_SIZE(kw); +#endif + if (kw_size == 0) { + return vc(func, args, nargs, NULL); + } +#if !CYTHON_ASSUME_SAFE_SIZE + else if (unlikely(kw_size == -1)) { + return NULL; + } +#endif + return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); +} +#endif + +/* CythonFunctionShared */ +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunctionNoMethod(PyObject *func, void (*cfunc)(void)) { + if (__Pyx_CyFunction_Check(func)) { + return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc; + } else if (PyCFunction_Check(func)) { + return PyCFunction_GetFunction(func) == (PyCFunction) cfunc; + } + return 0; +} +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) { + if ((PyObject*)Py_TYPE(func) == __pyx_mstate_global->__Pyx_CachedMethodType) { + int result; + PyObject *newFunc = PyObject_GetAttr(func, __pyx_mstate_global->__pyx_n_u_func); + if (unlikely(!newFunc)) { + PyErr_Clear(); // It's only an optimization, so don't throw an error + return 0; + } + result = __Pyx__IsSameCyOrCFunctionNoMethod(newFunc, cfunc); + Py_DECREF(newFunc); + return result; + } + return __Pyx__IsSameCyOrCFunctionNoMethod(func, cfunc); +} +#else +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) { + if (PyMethod_Check(func)) { + func = PyMethod_GET_FUNCTION(func); + } + return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +} +#endif +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) { +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + __Pyx_Py_XDECREF_SET( + __Pyx_CyFunction_GetClassObj(f), + ((classobj) ? __Pyx_NewRef(classobj) : NULL)); +#else + __Pyx_Py_XDECREF_SET( + ((PyCMethodObject *) (f))->mm_class, + (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL)); +#endif +} +static PyObject * +__Pyx_CyFunction_get_doc_locked(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_doc == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_doc = PyObject_GetAttrString(op->func, "__doc__"); + if (unlikely(!op->func_doc)) return NULL; +#else + if (((PyCFunctionObject*)op)->m_ml->ml_doc) { + op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); + if (unlikely(op->func_doc == NULL)) + return NULL; + } else { + Py_INCREF(Py_None); + return Py_None; + } +#endif + } + Py_INCREF(op->func_doc); + return op->func_doc; +} +static PyObject * +__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) { + PyObject *result; + CYTHON_UNUSED_VAR(closure); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_doc_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (value == NULL) { + value = Py_None; + } + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_doc, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_name_locked(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_name == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_name = PyObject_GetAttrString(op->func, "__name__"); +#else + op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); +#endif + if (unlikely(op->func_name == NULL)) + return NULL; + } + Py_INCREF(op->func_name); + return op->func_name; +} +static PyObject * +__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) +{ + PyObject *result = NULL; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_name_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_name, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + PyObject *result; + __Pyx_BEGIN_CRITICAL_SECTION(op); + Py_INCREF(op->func_qualname); + result = op->func_qualname; + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_qualname, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_dict_locked(__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 PyObject * +__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + PyObject *result; + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_dict_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + 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; + } + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_dict, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + Py_INCREF(op->func_globals); + return op->func_globals; +} +static PyObject * +__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(op); + CYTHON_UNUSED_VAR(context); + Py_INCREF(Py_None); + return Py_None; +} +static PyObject * +__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context) +{ + PyObject* result = (op->func_code) ? op->func_code : Py_None; + CYTHON_UNUSED_VAR(context); + 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 = __Pyx_PySequence_ITEM(res, 0); + if (unlikely(!op->defaults_tuple)) result = -1; + else { + op->defaults_kwdict = __Pyx_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, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyTuple_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__defaults__ must be set to a tuple object"); + return -1; + } + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->defaults_tuple, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_defaults_locked(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_tuple; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_tuple; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = NULL; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_defaults_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyDict_Check(value))) { PyErr_SetString(PyExc_TypeError, - "raise: exception class must be a subclass of BaseException"); - goto bad; + "__kwdefaults__ must be set to a dict object"); + return -1; } - 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); + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults_locked(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_kwdict; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_kwdict; } else { - PyErr_SetString(PyExc_TypeError, - "exception causes must derive from " - "BaseException"); - goto bad; + result = Py_None; } - 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); + Py_INCREF(result); + return result; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_kwdefaults_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value || value == Py_None) { + value = NULL; + } else if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__annotations__ must be set to a dict object"); + return -1; + } + Py_XINCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_annotations, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_annotations_locked(__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 PyObject * +__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { + PyObject *result; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_annotations_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static PyObject * +__Pyx_CyFunction_get_is_coroutine_value(__pyx_CyFunctionObject *op) { + int is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; + if (is_coroutine) { + PyObject *is_coroutine_value, *module, *fromlist, *marker = __pyx_mstate_global->__pyx_n_u_is_coroutine; + fromlist = PyList_New(1); + if (unlikely(!fromlist)) return NULL; + Py_INCREF(marker); +#if CYTHON_ASSUME_SAFE_MACROS + PyList_SET_ITEM(fromlist, 0, marker); #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); + if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) { + Py_DECREF(marker); + Py_DECREF(fromlist); + return NULL; } #endif + module = PyImport_ImportModuleLevelObject(__pyx_mstate_global->__pyx_n_u_asyncio_coroutines, NULL, NULL, fromlist, 0); + Py_DECREF(fromlist); + if (unlikely(!module)) goto ignore; + is_coroutine_value = __Pyx_PyObject_GetAttrStr(module, marker); + Py_DECREF(module); + if (likely(is_coroutine_value)) { + return is_coroutine_value; + } +ignore: + PyErr_Clear(); } -bad: - Py_XDECREF(owned_instance); - return; + return __Pyx_PyBool_FromLong(is_coroutine); +} +static PyObject * +__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { + PyObject *result; + CYTHON_UNUSED_VAR(context); + if (op->func_is_coroutine) { + return __Pyx_NewRef(op->func_is_coroutine); + } + result = __Pyx_CyFunction_get_is_coroutine_value(op); + if (unlikely(!result)) + return NULL; + __Pyx_BEGIN_CRITICAL_SECTION(op); + if (op->func_is_coroutine) { + Py_DECREF(result); + result = __Pyx_NewRef(op->func_is_coroutine); + } else { + op->func_is_coroutine = __Pyx_NewRef(result); + } + __Pyx_END_CRITICAL_SECTION(); + return result; } +static void __Pyx_CyFunction_raise_argument_count_error(__pyx_CyFunctionObject *func, const char* message, Py_ssize_t size) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_name = __Pyx_CyFunction_get_name(func, NULL); + if (!py_name) return; + PyErr_Format(PyExc_TypeError, + "%.200S() %s (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, message, size); + Py_DECREF(py_name); +#else + const char* name = ((PyCFunctionObject*)func)->m_ml->ml_name; + PyErr_Format(PyExc_TypeError, + "%.200s() %s (%" CYTHON_FORMAT_SSIZE_T "d given)", + name, message, size); #endif - -/* TypeImport */ -#ifndef __PYX_HAVE_RT_ImportType -#define __PYX_HAVE_RT_ImportType -static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, - size_t size, enum __Pyx_ImportType_CheckSize check_size) +} +static void __Pyx_CyFunction_raise_type_error(__pyx_CyFunctionObject *func, const char* message) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_name = __Pyx_CyFunction_get_name(func, NULL); + if (!py_name) return; + PyErr_Format(PyExc_TypeError, + "%.200S() %s", + py_name, message); + Py_DECREF(py_name); +#else + const char* name = ((PyCFunctionObject*)func)->m_ml->ml_name; + PyErr_Format(PyExc_TypeError, + "%.200s() %s", + name, message); +#endif +} +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject * +__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_GetAttrString(op->func, "__module__"); +} +static int +__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_SetAttrString(op->func, "__module__", value); +} +#endif +static PyGetSetDef __pyx_CyFunction_getsets[] = { + {"func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {"__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {"func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {"__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {"__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, + {"func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {"__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {"func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {"__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {"func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {"__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {"func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {"__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {"func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {"__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {"__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {"__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {"_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0}, +#if CYTHON_COMPILING_IN_LIMITED_API + {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0}, +#endif + {0, 0, 0, 0, 0} +}; +static PyMemberDef __pyx_CyFunction_members[] = { +#if !CYTHON_COMPILING_IN_LIMITED_API + {"__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, +#endif + {"__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, +#if CYTHON_METH_FASTCALL +#if CYTHON_BACKPORT_VECTORCALL || CYTHON_COMPILING_IN_LIMITED_API + {"__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, +#else + {"__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + {"__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, +#else + {"__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, +#endif +#endif + {0, 0, 0, 0, 0} +}; +static PyObject * +__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args) { - PyObject *result = 0; - char warning[200]; - Py_ssize_t basicsize; -#ifdef Py_LIMITED_API - PyObject *py_basicsize; + PyObject *result = NULL; + CYTHON_UNUSED_VAR(args); + __Pyx_BEGIN_CRITICAL_SECTION(m); + Py_INCREF(m->func_qualname); + result = m->func_qualname; + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} +}; +#if CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) +#else +#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist) #endif - result = PyObject_GetAttrString(module, class_name); - if (!result) - goto bad; - if (!PyType_Check(result)) { - PyErr_Format(PyExc_TypeError, - "%.200s.%.200s is not a type object", - module_name, class_name); - goto bad; - } -#ifndef Py_LIMITED_API - basicsize = ((PyTypeObject *)result)->tp_basicsize; +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { +#if !CYTHON_COMPILING_IN_LIMITED_API + PyCFunctionObject *cf = (PyCFunctionObject*) op; +#endif + if (unlikely(op == NULL)) + return NULL; +#if CYTHON_COMPILING_IN_LIMITED_API + op->func = PyCFunction_NewEx(ml, (PyObject*)op, module); + if (unlikely(!op->func)) return NULL; +#endif + op->flags = flags; + __Pyx_CyFunction_weakreflist(op) = NULL; +#if !CYTHON_COMPILING_IN_LIMITED_API + cf->m_ml = ml; + cf->m_self = (PyObject *) op; +#endif + Py_XINCREF(closure); + op->func_closure = closure; +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_XINCREF(module); + cf->m_module = module; +#endif + op->func_dict = NULL; + op->func_name = NULL; + Py_INCREF(qualname); + op->func_qualname = qualname; + op->func_doc = NULL; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + op->func_classobj = NULL; #else - py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); - if (!py_basicsize) - goto bad; - basicsize = PyLong_AsSsize_t(py_basicsize); - Py_DECREF(py_basicsize); - py_basicsize = 0; - if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) - goto bad; + ((PyCMethodObject*)op)->mm_class = NULL; +#endif + op->func_globals = globals; + Py_INCREF(op->func_globals); + Py_XINCREF(code); + op->func_code = code; + op->defaults = NULL; + op->defaults_tuple = NULL; + op->defaults_kwdict = NULL; + op->defaults_getter = NULL; + op->func_annotations = NULL; + op->func_is_coroutine = NULL; +#if CYTHON_METH_FASTCALL + switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) { + case METH_NOARGS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS; + break; + case METH_O: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O; + break; + case METH_METHOD | METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD; + break; + case METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS; + break; + case METH_VARARGS | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = NULL; + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + Py_DECREF(op); + return NULL; + } #endif - if ((size_t)basicsize < size) { - PyErr_Format(PyExc_ValueError, - "%.200s.%.200s size changed, may indicate binary incompatibility. " - "Expected %zd from C header, got %zd from PyObject", - module_name, class_name, size, basicsize); - goto bad; + return (PyObject *) op; +} +static int +__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) +{ + Py_CLEAR(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_CLEAR(m->func); +#else + Py_CLEAR(((PyCFunctionObject*)m)->m_module); +#endif + 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); +#if !CYTHON_COMPILING_IN_LIMITED_API +#if PY_VERSION_HEX < 0x030900B1 + Py_CLEAR(__Pyx_CyFunction_GetClassObj(m)); +#else + { + PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class; + ((PyCMethodObject *) (m))->mm_class = NULL; + Py_XDECREF(cls); } - if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) { - PyErr_Format(PyExc_ValueError, - "%.200s.%.200s size changed, may indicate binary incompatibility. " - "Expected %zd from C header, got %zd from PyObject", - module_name, class_name, size, basicsize); - goto bad; +#endif +#endif + Py_CLEAR(m->defaults_tuple); + Py_CLEAR(m->defaults_kwdict); + Py_CLEAR(m->func_annotations); + Py_CLEAR(m->func_is_coroutine); + Py_CLEAR(m->defaults); + return 0; +} +static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + if (__Pyx_CyFunction_weakreflist(m) != NULL) + PyObject_ClearWeakRefs((PyObject *) m); + __Pyx_CyFunction_clear(m); + __Pyx_PyHeapTypeObject_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) +{ + { + int e = __Pyx_call_type_traverse((PyObject*)m, 1, visit, arg); + if (e) return e; } - else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) { - PyOS_snprintf(warning, sizeof(warning), - "%s.%s size changed, may indicate binary incompatibility. " - "Expected %zd from C header, got %zd from PyObject", - module_name, class_name, size, basicsize); - if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; + Py_VISIT(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(m->func); +#else + Py_VISIT(((PyCFunctionObject*)m)->m_module); +#endif + Py_VISIT(m->func_dict); + __Pyx_VISIT_CONST(m->func_name); + __Pyx_VISIT_CONST(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + __Pyx_VISIT_CONST(m->func_code); +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(__Pyx_CyFunction_GetClassObj(m)); +#endif + Py_VISIT(m->defaults_tuple); + Py_VISIT(m->defaults_kwdict); + Py_VISIT(m->func_is_coroutine); + Py_VISIT(m->defaults); + return 0; +} +static PyObject* +__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) +{ + PyObject *repr; + __Pyx_BEGIN_CRITICAL_SECTION(op); + repr = PyUnicode_FromFormat("", + op->func_qualname, (void *)op); + __Pyx_END_CRITICAL_SECTION(); + return repr; +} +static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *f = ((__pyx_CyFunctionObject*)func)->func; + PyCFunction meth; + int flags; + meth = PyCFunction_GetFunction(f); + if (unlikely(!meth)) return NULL; + flags = PyCFunction_GetFlags(f); + if (unlikely(flags < 0)) return NULL; +#else + PyCFunctionObject* f = (PyCFunctionObject*)func; + PyCFunction meth = f->m_ml->ml_meth; + int flags = f->m_ml->ml_flags; +#endif + Py_ssize_t size; + switch (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)(void(*)(void))meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_SIZE + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 0)) + return (*meth)(self, NULL); + __Pyx_CyFunction_raise_argument_count_error( + (__pyx_CyFunctionObject*)func, + "takes no arguments", size); + return NULL; + } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_SIZE + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 1)) { + PyObject *result, *arg0; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + arg0 = PyTuple_GET_ITEM(arg, 0); + #else + arg0 = __Pyx_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; + } + __Pyx_CyFunction_raise_argument_count_error( + (__pyx_CyFunctionObject*)func, + "takes exactly one argument", size); + return NULL; + } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + return NULL; } - return (PyTypeObject *)result; -bad: - Py_XDECREF(result); + __Pyx_CyFunction_raise_type_error( + (__pyx_CyFunctionObject*)func, "takes no keyword arguments"); return NULL; } -#endif - -/* PyObject_GenericGetAttrNoDict */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { - PyErr_Format(PyExc_AttributeError, -#if PY_MAJOR_VERSION >= 3 - "'%.50s' object has no attribute '%U'", - tp->tp_name, attr_name); +static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *self, *result; +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; #else - "'%.50s' object has no attribute '%.400s'", - tp->tp_name, PyString_AS_STRING(attr_name)); + self = ((PyCFunctionObject*)func)->m_self; #endif - return NULL; + result = __Pyx_CyFunction_CallMethod(func, self, arg, kw); + return result; } -static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { - PyObject *descr; - PyTypeObject *tp = Py_TYPE(obj); - if (unlikely(!PyString_Check(attr_name))) { - return PyObject_GenericGetAttr(obj, attr_name); +static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { + PyObject *result; + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; +#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL) + __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); + if (vc) { +#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE + return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw); +#else + (void) &__Pyx_PyVectorcall_FastCallDict; + return PyVectorcall_Call(func, args, kw); +#endif } - assert(!tp->tp_dictoffset); - descr = _PyType_Lookup(tp, attr_name); - if (unlikely(!descr)) { - return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); +#endif + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + Py_ssize_t argc; + PyObject *new_args; + PyObject *self; +#if CYTHON_ASSUME_SAFE_SIZE + argc = PyTuple_GET_SIZE(args); +#else + argc = PyTuple_Size(args); + if (unlikely(argc < 0)) return NULL; +#endif + 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); + PyErr_Format(PyExc_TypeError, + "unbound method %.200S() needs an argument", + cyfunc->func_qualname); + return NULL; + } + result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); + Py_DECREF(new_args); + } else { + result = __Pyx_CyFunction_Call(func, args, kw); } - Py_INCREF(descr); - #if PY_MAJOR_VERSION < 3 - if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) - #endif - { - descrgetfunc f = Py_TYPE(descr)->tp_descr_get; - if (unlikely(f)) { - PyObject *res = f(descr, obj, (PyObject *)tp); - Py_DECREF(descr); - return res; + return result; +} +#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL) +static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames) +{ + int ret = 0; + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + if (unlikely(nargs < 1)) { + __Pyx_CyFunction_raise_type_error( + cyfunc, "needs an argument"); + return -1; } + ret = 1; + } + if (unlikely(kwnames) && unlikely(__Pyx_PyTuple_GET_SIZE(kwnames))) { + __Pyx_CyFunction_raise_type_error( + cyfunc, "takes no keyword arguments"); + return -1; } - return descr; + return ret; } +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); #endif - -/* SetupReduce */ -static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { - int ret; - PyObject *name_attr; - name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name); - if (likely(name_attr)) { - ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); - } else { - ret = -1; - } - if (unlikely(ret < 0)) { - PyErr_Clear(); - ret = 0; - } - Py_XDECREF(name_attr); - return ret; + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif + break; + default: + return NULL; + } + if (unlikely(nargs != 0)) { + __Pyx_CyFunction_raise_argument_count_error( + cyfunc, "takes no arguments", nargs); + return NULL; + } + return meth(self, NULL); } -static int __Pyx_setup_reduce(PyObject* type_obj) { - int ret = 0; - PyObject *object_reduce = NULL; - PyObject *object_reduce_ex = NULL; - PyObject *reduce = NULL; - PyObject *reduce_ex = NULL; - PyObject *reduce_cython = NULL; - PyObject *setstate = NULL; - PyObject *setstate_cython = NULL; -#if CYTHON_USE_PYTYPE_LOOKUP - if (_PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate)) goto GOOD; +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif + break; + default: + return NULL; + } + if (unlikely(nargs != 1)) { + __Pyx_CyFunction_raise_argument_count_error( + cyfunc, "takes exactly one argument", nargs); + return NULL; + } + return meth(self, args[0]); +} +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; #else - if (PyObject_HasAttr(type_obj, __pyx_n_s_getstate)) goto GOOD; + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); #endif -#if CYTHON_USE_PYTYPE_LOOKUP - object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto BAD; + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; #else - object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto BAD; -#endif - reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto BAD; - if (reduce_ex == object_reduce_ex) { -#if CYTHON_USE_PYTYPE_LOOKUP - object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto BAD; + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; #else - object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto BAD; + self = ((PyCFunctionObject*)cyfunc)->m_self; #endif - reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto BAD; - if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { - reduce_cython = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_cython); if (unlikely(!reduce_cython)) goto BAD; - ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto BAD; - ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto BAD; - setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate); - if (!setstate) PyErr_Clear(); - if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { - setstate_cython = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate_cython); if (unlikely(!setstate_cython)) goto BAD; - ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto BAD; - ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto BAD; - } - PyType_Modified((PyTypeObject*)type_obj); - } + break; + default: + return NULL; } - goto GOOD; -BAD: - if (!PyErr_Occurred()) - PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name); - ret = -1; -GOOD: -#if !CYTHON_USE_PYTYPE_LOOKUP - Py_XDECREF(object_reduce); - Py_XDECREF(object_reduce_ex); -#endif - Py_XDECREF(reduce); - Py_XDECREF(reduce_ex); - Py_XDECREF(reduce_cython); - Py_XDECREF(setstate); - Py_XDECREF(setstate_cython); - return ret; + return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))meth)(self, args, nargs, kwnames); } - -/* GetVTable */ -static void* __Pyx_GetVtable(PyObject *dict) { - void* ptr; - PyObject *ob = PyObject_GetItem(dict, __pyx_n_s_pyx_vtable); - if (!ob) - goto bad; -#if PY_VERSION_HEX >= 0x02070000 - ptr = PyCapsule_GetPointer(ob, 0); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc); +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; #else - ptr = PyCObject_AsVoidPtr(ob); + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); #endif - if (!ptr && !PyErr_Occurred()) - PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type"); - Py_DECREF(ob); - return ptr; -bad: - Py_XDECREF(ob); - return NULL; + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif + break; + default: + return NULL; + } + return ((__Pyx_PyCMethod)(void(*)(void))meth)(self, cls, args, (size_t)nargs, kwnames); } - -/* 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; +#endif +static PyType_Slot __pyx_CyFunctionType_slots[] = { + {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc}, + {Py_tp_repr, (void *)__Pyx_CyFunction_repr}, + {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod}, + {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse}, + {Py_tp_clear, (void *)__Pyx_CyFunction_clear}, + {Py_tp_methods, (void *)__pyx_CyFunction_methods}, + {Py_tp_members, (void *)__pyx_CyFunction_members}, + {Py_tp_getset, (void *)__pyx_CyFunction_getsets}, + {Py_tp_descr_get, (void *)__Pyx_PyMethod_New}, + {0, 0}, +}; +static PyType_Spec __pyx_CyFunctionType_spec = { + __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, +#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR + Py_TPFLAGS_METHOD_DESCRIPTOR | +#endif +#if CYTHON_METH_FASTCALL +#if defined(Py_TPFLAGS_HAVE_VECTORCALL) + Py_TPFLAGS_HAVE_VECTORCALL | +#elif defined(_Py_TPFLAGS_HAVE_VECTORCALL) + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif +#endif // CYTHON_METH_FASTCALL +#if PY_VERSION_HEX >= 0x030A0000 + Py_TPFLAGS_IMMUTABLETYPE | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + __pyx_CyFunctionType_slots +}; +static int __pyx_CyFunction_init(PyObject *module) { + __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module); + mstate->__pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec( + mstate->__pyx_CommonTypesMetaclassType, module, &__pyx_CyFunctionType_spec, NULL); + if (unlikely(mstate->__pyx_CyFunctionType == NULL)) { + return -1; } - 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, (PyObject *)NULL); - Py_DECREF(py_level); - #else - module = PyImport_ImportModuleLevelObject( - name, global_dict, empty_dict, list, level); - #endif - } + return 0; +} +static CYTHON_INLINE PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func, PyTypeObject *defaults_type) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults = PyObject_CallObject((PyObject*)defaults_type, NULL); // _PyObject_New(defaults_type); + if (unlikely(!m->defaults)) + return NULL; + 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); +} + +/* CythonFunction */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + PyObject *op = __Pyx_CyFunction_Init( + PyObject_GC_New(__pyx_CyFunctionObject, __pyx_mstate_global->__pyx_CyFunctionType), + ml, flags, qualname, closure, module, globals, code + ); + if (likely(op)) { + PyObject_GC_Track(op); } -bad: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(py_import); - #endif - Py_XDECREF(empty_list); - Py_XDECREF(empty_dict); - return module; + return op; } /* CLineInTraceback */ -#ifndef CYTHON_CLINE_IN_TRACEBACK +#if CYTHON_CLINE_IN_TRACEBACK && CYTHON_CLINE_IN_TRACEBACK_RUNTIME static int __Pyx_CLineForTraceback(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)) { + CYTHON_MAYBE_UNUSED_VAR(tstate); + if (unlikely(!__pyx_mstate_global->__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); + cython_runtime_dict = _PyObject_GetDictPtr(__pyx_mstate_global->__pyx_cython_runtime); if (likely(cython_runtime_dict)) { + __Pyx_BEGIN_CRITICAL_SECTION(*cython_runtime_dict); __PYX_PY_DICT_LOOKUP_IF_MODIFIED( use_cline, *cython_runtime_dict, - __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) + __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_mstate_global->__pyx_n_u_cline_in_traceback)) + Py_XINCREF(use_cline); + __Pyx_END_CRITICAL_SECTION(); } else #endif { - PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_mstate_global->__pyx_cython_runtime, __pyx_mstate_global->__pyx_n_u_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; + Py_INCREF(use_cline); Py_DECREF(use_cline_obj); } else { PyErr_Clear(); @@ -6596,11 +12387,12 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { } if (!use_cline) { c_line = 0; - PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); + (void) PyObject_SetAttr(__pyx_mstate_global->__pyx_cython_runtime, __pyx_mstate_global->__pyx_n_u_cline_in_traceback, Py_False); } else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { c_line = 0; } + Py_XDECREF(use_cline); __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); return c_line; } @@ -6628,117 +12420,195 @@ static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int co return mid + 1; } } -static PyCodeObject *__pyx_find_code_object(int code_line) { - PyCodeObject* code_object; +static __Pyx_CachedCodeObjectType *__pyx__find_code_object(struct __Pyx_CodeObjectCache *code_cache, int code_line) { + __Pyx_CachedCodeObjectType* code_object; int pos; - if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + if (unlikely(!code_line) || unlikely(!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)) { + pos = __pyx_bisect_code_objects(code_cache->entries, code_cache->count, code_line); + if (unlikely(pos >= code_cache->count) || unlikely(code_cache->entries[pos].code_line != code_line)) { return NULL; } - code_object = __pyx_code_cache.entries[pos].code_object; + code_object = 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) { +static __Pyx_CachedCodeObjectType *__pyx_find_code_object(int code_line) { +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && !CYTHON_ATOMICS + (void)__pyx__find_code_object; + return NULL; // Most implementation should have atomics. But otherwise, don't make it thread-safe, just miss. +#else + struct __Pyx_CodeObjectCache *code_cache = &__pyx_mstate_global->__pyx_code_cache; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_nonatomic_int_type old_count = __pyx_atomic_incr_acq_rel(&code_cache->accessor_count); + if (old_count < 0) { + __pyx_atomic_decr_acq_rel(&code_cache->accessor_count); + return NULL; + } +#endif + __Pyx_CachedCodeObjectType *result = __pyx__find_code_object(code_cache, code_line); +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_atomic_decr_acq_rel(&code_cache->accessor_count); +#endif + return result; +#endif +} +static void __pyx__insert_code_object(struct __Pyx_CodeObjectCache *code_cache, int code_line, __Pyx_CachedCodeObjectType* code_object) +{ int pos, i; - __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + __Pyx_CodeObjectCacheEntry* entries = 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; + code_cache->entries = entries; + code_cache->max_count = 64; + 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; + pos = __pyx_bisect_code_objects(code_cache->entries, code_cache->count, code_line); + if ((pos < code_cache->count) && unlikely(code_cache->entries[pos].code_line == code_line)) { + __Pyx_CachedCodeObjectType* tmp = entries[pos].code_object; entries[pos].code_object = code_object; + Py_INCREF(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; + if (code_cache->count == code_cache->max_count) { + int new_max = code_cache->max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( - __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); + 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; + code_cache->entries = entries; + code_cache->max_count = new_max; } - for (i=__pyx_code_cache.count; i>pos; i--) { + for (i=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++; + code_cache->count++; Py_INCREF(code_object); } +static void __pyx_insert_code_object(int code_line, __Pyx_CachedCodeObjectType* code_object) { +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && !CYTHON_ATOMICS + (void)__pyx__insert_code_object; + return; // Most implementation should have atomics. But otherwise, don't make it thread-safe, just fail. +#else + struct __Pyx_CodeObjectCache *code_cache = &__pyx_mstate_global->__pyx_code_cache; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_nonatomic_int_type expected = 0; + if (!__pyx_atomic_int_cmp_exchange(&code_cache->accessor_count, &expected, INT_MIN)) { + return; + } +#endif + __pyx__insert_code_object(code_cache, code_line, code_object); +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_atomic_sub(&code_cache->accessor_count, INT_MIN); +#endif +#endif +} /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API && !defined(PYPY_VERSION) + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict, + PyObject *firstlineno, PyObject *name) { + PyObject *replace = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL; + replace = PyObject_GetAttrString(code, "replace"); + if (likely(replace)) { + PyObject *result = PyObject_Call(replace, __pyx_mstate_global->__pyx_empty_tuple, scratch_dict); + Py_DECREF(replace); + return result; + } + PyErr_Clear(); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL; + PyObject *replace = NULL, *getframe = NULL, *frame = NULL; + PyObject *exc_type, *exc_value, *exc_traceback; + int success = 0; + if (c_line) { + (void) __pyx_cfilenm; + (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); + } + PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); + code_object = __pyx_find_code_object(c_line ? -c_line : py_line); + if (!code_object) { + code_object = Py_CompileString("_getframe()", filename, Py_eval_input); + if (unlikely(!code_object)) goto bad; + py_py_line = PyLong_FromLong(py_line); + if (unlikely(!py_py_line)) goto bad; + py_funcname = PyUnicode_FromString(funcname); + if (unlikely(!py_funcname)) goto bad; + dict = PyDict_New(); + if (unlikely(!dict)) goto bad; + { + PyObject *old_code_object = code_object; + code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname); + Py_DECREF(old_code_object); + } + if (unlikely(!code_object)) goto bad; + __pyx_insert_code_object(c_line ? -c_line : py_line, code_object); + } else { + dict = PyDict_New(); + } + getframe = PySys_GetObject("_getframe"); + if (unlikely(!getframe)) goto bad; + if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad; + frame = PyEval_EvalCode(code_object, dict, dict); + if (unlikely(!frame) || frame == Py_None) goto bad; + success = 1; + bad: + PyErr_Restore(exc_type, exc_value, exc_traceback); + Py_XDECREF(code_object); + Py_XDECREF(py_py_line); + Py_XDECREF(py_funcname); + Py_XDECREF(dict); + Py_XDECREF(replace); + if (success) { + PyTraceBack_Here( + (struct _frame*)frame); + } + Py_XDECREF(frame); +} +#else 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; + PyCodeObject *py_code = NULL; + PyObject *py_funcname = NULL; 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; + funcname = PyUnicode_AsUTF8(py_funcname); + if (!funcname) goto bad; } - 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); + py_code = PyCode_NewEmpty(filename, funcname, py_line); + Py_XDECREF(py_funcname); return py_code; bad: - Py_XDECREF(py_srcfile); Py_XDECREF(py_funcname); return NULL; } @@ -6747,20 +12617,30 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, PyCodeObject *py_code = 0; PyFrameObject *py_frame = 0; PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject *ptype, *pvalue, *ptraceback; 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) { + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); py_code = __Pyx_CreateCodeObjectForTraceback( funcname, c_line, py_line, filename); - if (!py_code) goto bad; + if (!py_code) { + /* If the code object creation fails, then we should clear the + fetched exception references and propagate the new exception */ + Py_XDECREF(ptype); + Py_XDECREF(pvalue); + Py_XDECREF(ptraceback); + goto bad; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); __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,*/ + __pyx_mstate_global->__pyx_d, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); if (!py_frame) goto bad; @@ -6770,37 +12650,7 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, Py_XDECREF(py_code); Py_XDECREF(py_frame); } - -/* CIntToPy */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { - const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; - const int is_unsigned = neg_one > const_zero; - if (is_unsigned) { - if (sizeof(int) < sizeof(long)) { - return PyInt_FromLong((long) value); - } else if (sizeof(int) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { - return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); -#endif - } - } else { - if (sizeof(int) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= 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(int), - little, !is_unsigned); - } -} /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ @@ -6824,183 +12674,319 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { return (target_type) value;\ } -/* CIntFromPy */ -static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { - const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; +/* CIntToPy */ +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_int(int value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif const int is_unsigned = neg_one > const_zero; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { + if (is_unsigned) { if (sizeof(int) < sizeof(long)) { - __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + return PyLong_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyLong_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 + if (is_unsigned) { + return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; + return PyLong_FromNativeBytes(bytes, sizeof(value), -1); + } +#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 + int one = 1; int little = (int)*(unsigned char *)&one; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); +#else + int one = 1; int little = (int)*(unsigned char *)&one; + PyObject *from_bytes, *result = NULL, *kwds = NULL; + PyObject *py_bytes = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + { + PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str }; + if (!is_unsigned) { + kwds = __Pyx_MakeVectorcallBuilderKwds(1); + if (!kwds) goto limited_bad; + if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad; } - return (int) val; + result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); } - } else + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; #endif - if (likely(PyLong_Check(x))) { - if (is_unsigned) { + } +} + +/* CIntFromPy */ +static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (unlikely(!PyLong_Check(x))) { + int val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (int) -1; + val = __Pyx_PyLong_As_int(tmp); + Py_DECREF(tmp); + return val; + } + 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]) + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { case 2: - if (8 * sizeof(int) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + 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) { + } 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) { + 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) { + } 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) { + 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) { + } 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; - } +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 + 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; - } + { + 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)) + 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)) + } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif - } - } else { + } + } 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]) + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { case -2: - if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + 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) { + } 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) { + 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) { + } 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) { + 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) { + } 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) { + 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) { + } 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) { + 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) { + } 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) { + 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) { + } 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)) + 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)) + } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif - } + } + } + { + int val; + int ret = -1; +#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } +#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (int) -1; + assert(PyLong_CheckExact(v)); } { -#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); + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { Py_DECREF(v); - if (likely(!ret)) - return val; + return (int) -1; } + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (int) -1; + } else { + stepval = v; + } + v = NULL; + val = (int) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((int) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((int) idigit) << bits; + } + if (!is_unsigned) { + if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); #endif + if (unlikely(ret)) 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: @@ -7013,23 +12999,69 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { return (int) -1; } +/* FormatTypeName */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 +static __Pyx_TypeName +__Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp) +{ + PyObject *module = NULL, *name = NULL, *result = NULL; + #if __PYX_LIMITED_VERSION_HEX < 0x030b0000 + name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_mstate_global->__pyx_n_u_qualname); + #else + name = PyType_GetQualName(tp); + #endif + if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) goto bad; + module = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_mstate_global->__pyx_n_u_module); + if (unlikely(module == NULL) || unlikely(!PyUnicode_Check(module))) goto bad; + if (PyUnicode_CompareWithASCIIString(module, "builtins") == 0) { + result = name; + name = NULL; + goto done; + } + result = PyUnicode_FromFormat("%U.%U", module, name); + if (unlikely(result == NULL)) goto bad; + done: + Py_XDECREF(name); + Py_XDECREF(module); + return result; + bad: + PyErr_Clear(); + if (name) { + result = name; + name = NULL; + } else { + result = __Pyx_NewRef(__pyx_mstate_global->__pyx_kp_u__5); + } + goto done; +} +#endif + /* CIntToPy */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { - const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { - return PyInt_FromLong((long) value); + return PyLong_FromLong((long) value); } else if (sizeof(long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG +#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY } 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); + return PyLong_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); @@ -7037,190 +13069,288 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { } } { - int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 + if (is_unsigned) { + return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); + } else { + return PyLong_FromNativeBytes(bytes, sizeof(value), -1); + } +#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 + int one = 1; int little = (int)*(unsigned char *)&one; return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); +#else + int one = 1; int little = (int)*(unsigned char *)&one; + PyObject *from_bytes, *result = NULL, *kwds = NULL; + PyObject *py_bytes = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + { + PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str }; + if (!is_unsigned) { + kwds = __Pyx_MakeVectorcallBuilderKwds(1); + if (!kwds) goto limited_bad; + if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad; + } + result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); + } + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif } } /* CIntFromPy */ -static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { - const long neg_one = (long) ((long) 0 - (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 +static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" #endif - if (likely(PyLong_Check(x))) { - if (is_unsigned) { + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (unlikely(!PyLong_Check(x))) { + long val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (long) -1; + val = __Pyx_PyLong_As_long(tmp); + Py_DECREF(tmp); + return val; + } + 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]) + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { case 2: - if (8 * sizeof(long) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + 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) { + } 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) { + 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) { + } 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) { + 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) { + } 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; - } +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 + 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; - } + { + 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)) + 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)) + } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif - } - } else { + } + } 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]) + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { case -2: - if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + 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) { + } 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) { + 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) { + } 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) { + 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) { + } 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) { + 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) { + } 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) { + 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) { + } 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) { + 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) { + } 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)) + 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)) + } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif - } + } + } + { + long val; + int ret = -1; +#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } +#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (long) -1; + assert(PyLong_CheckExact(v)); } { -#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); + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { Py_DECREF(v); - if (likely(!ret)) - return val; + return (long) -1; } + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (long) -1; + } else { + stepval = v; + } + v = NULL; + val = (long) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((long) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((long) idigit) << bits; + } + if (!is_unsigned) { + if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); #endif + if (unlikely(ret)) 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: @@ -7237,7 +13367,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { - a = a->tp_base; + a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*); if (a == b) return 1; } @@ -7258,51 +13388,38 @@ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { } 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; +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (cls == a || cls == b) return 1; + mro = cls->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + PyObject *base = PyTuple_GET_ITEM(mro, i); + if (base == (PyObject *)a || base == (PyObject *)b) + return 1; } + return 0; } - __Pyx_ErrRestore(exception, value, tb); - return res; + return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b); } -#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); + if (exc_type1) { + return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2); + } else { + return __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; i= 0x030b0000 + return Py_Version & ~0xFFUL; +#else + static unsigned long __Pyx_cached_runtime_version = 0; + if (__Pyx_cached_runtime_version == 0) { + const char* rt_version = Py_GetVersion(); + unsigned long version = 0; + unsigned long factor = 0x01000000UL; + unsigned int digit = 0; + int i = 0; + while (factor) { + while ('0' <= rt_version[i] && rt_version[i] <= '9') { + digit = digit * 10 + (unsigned int) (rt_version[i] - '0'); + ++i; + } + version += factor * digit; + if (rt_version[i] != '.') + break; + digit = 0; + factor >>= 8; + ++i; + } + __Pyx_cached_runtime_version = version; + } + return __Pyx_cached_runtime_version; +#endif +} + /* CheckBinaryVersion */ -static int __Pyx_check_binary_version(void) { - char ctversion[4], rtversion[4]; - PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); - PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); - if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) { + const unsigned long MAJOR_MINOR = 0xFFFF0000UL; + if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR)) + return 0; + if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR))) + return 1; + { char message[200]; PyOS_snprintf(message, sizeof(message), - "compiletime version %s of module '%.100s' " - "does not match runtime version %s", - ctversion, __Pyx_MODULE_NAME, rtversion); + "compile time Python version %d.%d " + "of module '%.100s' " + "%s " + "runtime version %d.%d", + (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF), + __Pyx_MODULE_NAME, + (allow_newer) ? "was newer than" : "does not match", + (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF) + ); return PyErr_WarnEx(NULL, message, 1); } - return 0; } /* FunctionImport */ -#ifndef __PYX_HAVE_RT_ImportFunction -#define __PYX_HAVE_RT_ImportFunction -static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) { +#ifndef __PYX_HAVE_RT_ImportFunction_3_1_3 +#define __PYX_HAVE_RT_ImportFunction_3_1_3 +static int __Pyx_ImportFunction_3_1_3(PyObject *module, const char *funcname, void (**f)(void), const char *sig) { PyObject *d = 0; PyObject *cobj = 0; union { void (*fp)(void); void *p; } tmp; - d = PyObject_GetAttrString(module, (char *)"__pyx_capi__"); + d = PyObject_GetAttrString(module, "__pyx_capi__"); if (!d) goto bad; +#if (defined(Py_LIMITED_API) && Py_LIMITED_API >= 0x030d0000) || (!defined(Py_LIMITED_API) && PY_VERSION_HEX >= 0x030d0000) + PyDict_GetItemStringRef(d, funcname, &cobj); +#else cobj = PyDict_GetItemString(d, funcname); + Py_XINCREF(cobj); +#endif if (!cobj) { PyErr_Format(PyExc_ImportError, "%.200s does not export expected C function %.200s", PyModule_GetName(module), funcname); goto bad; } -#if PY_VERSION_HEX >= 0x02070000 if (!PyCapsule_IsValid(cobj, sig)) { PyErr_Format(PyExc_TypeError, "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", @@ -7377,97 +13535,229 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (** goto bad; } tmp.p = PyCapsule_GetPointer(cobj, sig); -#else - {const char *desc, *s1, *s2; - desc = (const char *)PyCObject_GetDesc(cobj); - if (!desc) - goto bad; - s1 = desc; s2 = sig; - while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; } - if (*s1 != *s2) { - PyErr_Format(PyExc_TypeError, - "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", - PyModule_GetName(module), funcname, sig, desc); - goto bad; - } - tmp.p = PyCObject_AsVoidPtr(cobj);} -#endif *f = tmp.fp; if (!(*f)) goto bad; Py_DECREF(d); + Py_DECREF(cobj); return 0; bad: Py_XDECREF(d); + Py_XDECREF(cobj); return -1; } #endif -/* InitStrings */ -static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { - while (t->p) { - #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); +/* NewCodeObj */ +#if CYTHON_COMPILING_IN_LIMITED_API + static PyObject* __Pyx__PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyObject *exception_table = NULL; + PyObject *types_module=NULL, *code_type=NULL, *result=NULL; + #if __PYX_LIMITED_VERSION_HEX < 0x030b0000 + PyObject *version_info; + PyObject *py_minor_version = NULL; + #endif + long minor_version = 0; + PyObject *type, *value, *traceback; + PyErr_Fetch(&type, &value, &traceback); + #if __PYX_LIMITED_VERSION_HEX >= 0x030b0000 + minor_version = 11; + #else + if (!(version_info = PySys_GetObject("version_info"))) goto end; + if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; + minor_version = PyLong_AsLong(py_minor_version); + Py_DECREF(py_minor_version); + if (minor_version == -1 && PyErr_Occurred()) goto end; + #endif + if (!(types_module = PyImport_ImportModule("types"))) goto end; + if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; + if (minor_version <= 7) { + (void)p; + result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOOO", a, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else if (minor_version <= 10) { + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOOO", a,p, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); } else { - *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOOOO", a,p, k, l, s, f, code, + c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); } - #else - if (t->is_unicode | t->is_str) { + end: + Py_XDECREF(code_type); + Py_XDECREF(exception_table); + Py_XDECREF(types_module); + if (type) { + PyErr_Restore(type, value, traceback); + } + return result; + } +#elif PY_VERSION_HEX >= 0x030B0000 + static PyCodeObject* __Pyx__PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyCodeObject *result; + result = + #if PY_VERSION_HEX >= 0x030C0000 + PyUnstable_Code_NewWithPosOnlyArgs + #else + PyCode_NewWithPosOnlyArgs + #endif + (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, __pyx_mstate_global->__pyx_empty_bytes); + return result; + } +#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx__PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#else + #define __Pyx__PyCode_New(a, p, 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) +#endif +static PyObject* __Pyx_PyCode_New( + const __Pyx_PyCode_New_function_description descr, + PyObject * const *varnames, + PyObject *filename, + PyObject *funcname, + const char *line_table, + PyObject *tuple_dedup_map +) { + PyObject *code_obj = NULL, *varnames_tuple_dedup = NULL, *code_bytes = NULL, *line_table_bytes = NULL; + Py_ssize_t var_count = (Py_ssize_t) descr.nlocals; + PyObject *varnames_tuple = PyTuple_New(var_count); + if (unlikely(!varnames_tuple)) return NULL; + for (Py_ssize_t i=0; i < var_count; i++) { + Py_INCREF(varnames[i]); + if (__Pyx_PyTuple_SET_ITEM(varnames_tuple, i, varnames[i]) != (0)) goto done; + } + #if CYTHON_COMPILING_IN_LIMITED_API + varnames_tuple_dedup = PyDict_GetItem(tuple_dedup_map, varnames_tuple); + if (!varnames_tuple_dedup) { + if (unlikely(PyDict_SetItem(tuple_dedup_map, varnames_tuple, varnames_tuple) < 0)) goto done; + varnames_tuple_dedup = varnames_tuple; + } + #else + varnames_tuple_dedup = PyDict_SetDefault(tuple_dedup_map, varnames_tuple, varnames_tuple); + if (unlikely(!varnames_tuple_dedup)) goto done; + #endif + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(varnames_tuple_dedup); + #endif + if (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table != NULL + && !CYTHON_COMPILING_IN_GRAAL) { + line_table_bytes = PyBytes_FromStringAndSize(line_table, descr.line_table_length); + if (unlikely(!line_table_bytes)) goto done; + Py_ssize_t code_len = (descr.line_table_length * 2 + 4) & ~3; + code_bytes = PyBytes_FromStringAndSize(NULL, code_len); + if (unlikely(!code_bytes)) goto done; + char* c_code_bytes = PyBytes_AsString(code_bytes); + if (unlikely(!c_code_bytes)) goto done; + memset(c_code_bytes, 0, (size_t) code_len); + } + code_obj = (PyObject*) __Pyx__PyCode_New( + (int) descr.argcount, + (int) descr.num_posonly_args, + (int) descr.num_kwonly_args, + (int) descr.nlocals, + 0, + (int) descr.flags, + code_bytes ? code_bytes : __pyx_mstate_global->__pyx_empty_bytes, + __pyx_mstate_global->__pyx_empty_tuple, + __pyx_mstate_global->__pyx_empty_tuple, + varnames_tuple_dedup, + __pyx_mstate_global->__pyx_empty_tuple, + __pyx_mstate_global->__pyx_empty_tuple, + filename, + funcname, + (int) descr.first_line, + (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table_bytes) ? line_table_bytes : __pyx_mstate_global->__pyx_empty_bytes + ); +done: + Py_XDECREF(code_bytes); + Py_XDECREF(line_table_bytes); + #if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(varnames_tuple_dedup); + #endif + Py_DECREF(varnames_tuple); + return code_obj; +} + +/* InitStrings */ +static int __Pyx_InitStrings(__Pyx_StringTabEntry const *t, PyObject **target, const char* const* encoding_names) { + while (t->s) { + PyObject *str; + if (t->is_unicode) { if (t->intern) { - *t->p = PyUnicode_InternFromString(t->s); + str = PyUnicode_InternFromString(t->s); } else if (t->encoding) { - *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + str = PyUnicode_Decode(t->s, t->n - 1, encoding_names[t->encoding], NULL); } else { - *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + str = PyUnicode_FromStringAndSize(t->s, t->n - 1); } } else { - *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + str = PyBytes_FromStringAndSize(t->s, t->n - 1); } - #endif - if (!*t->p) + if (!str) return -1; - if (PyObject_Hash(*t->p) == -1) + *target = str; + if (PyObject_Hash(str) == -1) return -1; ++t; + ++target; } return 0; } +#include +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) { + size_t len = strlen(s); + if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) { + PyErr_SetString(PyExc_OverflowError, "byte string is too long"); + return -1; + } + return (Py_ssize_t) len; +} static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { - return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return __Pyx_PyUnicode_FromStringAndSize(c_str, len); +} +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) { + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return PyByteArray_FromStringAndSize(c_str, len); } 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 +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 +static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; +#if CYTHON_COMPILING_IN_LIMITED_API { - 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; - } + const char* result; + Py_ssize_t unicode_length; + CYTHON_MAYBE_UNUSED_VAR(unicode_length); // only for __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + #if __PYX_LIMITED_VERSION_HEX < 0x030A0000 + if (unlikely(PyArg_Parse(o, "s#", &result, length) < 0)) return NULL; + #else + result = PyUnicode_AsUTF8AndSize(o, length); + #endif + #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + unicode_length = PyUnicode_GetLength(o); + if (unlikely(unicode_length < 0)) return NULL; + if (unlikely(unicode_length != *length)) { + PyUnicode_AsASCIIString(o); + return NULL; } + #endif + return result; } -#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); @@ -7479,25 +13769,25 @@ static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py #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)) { +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 + if (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)) { +#if (CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS) || (CYTHON_COMPILING_IN_PYPY && (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))) *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); - } else +#else + *length = PyByteArray_Size(o); + if (*length == -1) return NULL; + return PyByteArray_AsString(o); #endif + } else { char* result; int r = PyBytes_AsStringAndSize(o, &result, length); @@ -7520,95 +13810,66 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { Py_DECREF(x); return retval; } -static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { -#if PY_MAJOR_VERSION >= 3 +static PyObject* __Pyx_PyNumber_LongWrongResultType(PyObject* result) { + __Pyx_TypeName result_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(result)); 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)) { + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME "). " + "The ability to return an instance of a strict subclass of int is deprecated, " + "and may be removed in a future version of Python.", + result_type_name)) { + __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } + __Pyx_DECREF_TypeName(result_type_name); return result; } -#endif PyErr_Format(PyExc_TypeError, - "__%.4s__ returned non-%.4s (type %.200s)", - type_name, type_name, Py_TYPE(result)->tp_name); + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ")", + result_type_name); + __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } -static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Long(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); + 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); + res = m->nb_int(x); } - #endif #else if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { - res = PyNumber_Int(x); + res = PyNumber_Long(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); - } + if (unlikely(!PyLong_CheckExact(res))) { + return __Pyx_PyNumber_LongWrongResultType(res); + } } else if (!PyErr_Occurred()) { - PyErr_SetString(PyExc_TypeError, - "an integer is required"); + 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(b); - } -#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; + if (likely(__Pyx_PyLong_IsCompact(b))) { + return __Pyx_PyLong_CompactValue(b); } else { + const digit* digits = __Pyx_PyLong_Digits(b); + const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b); switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { @@ -7647,16 +13908,356 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { } x = PyNumber_Index(b); if (!x) return -1; - ival = PyInt_AsSsize_t(x); + ival = PyLong_AsSsize_t(x); Py_DECREF(x); return ival; } +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { + if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { + return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o); + } else { + Py_ssize_t ival; + PyObject *x; + x = PyNumber_Index(o); + if (!x) return -1; + ival = PyLong_AsLong(x); + Py_DECREF(x); + return ival; + } +} +static CYTHON_INLINE PyObject *__Pyx_Owned_Py_None(int b) { + CYTHON_UNUSED_VAR(b); + return __Pyx_NewRef(Py_None); +} 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); +static CYTHON_INLINE PyObject * __Pyx_PyLong_FromSize_t(size_t ival) { + return PyLong_FromSize_t(ival); +} + + +/* MultiPhaseInitModuleState */ +#if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE +#ifndef CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +#if (CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX >= 0x030C0000) + #define CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE 1 +#else + #define CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE 0 +#endif +#endif +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE && !CYTHON_ATOMICS +#error "Module state with PEP489 requires atomics. Currently that's one of\ + C11, C++11, gcc atomic intrinsics or MSVC atomic intrinsics" +#endif +#if !CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +#define __Pyx_ModuleStateLookup_Lock() +#define __Pyx_ModuleStateLookup_Unlock() +#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d0000 +static PyMutex __Pyx_ModuleStateLookup_mutex = {0}; +#define __Pyx_ModuleStateLookup_Lock() PyMutex_Lock(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() PyMutex_Unlock(&__Pyx_ModuleStateLookup_mutex) +#elif defined(__cplusplus) && __cplusplus >= 201103L +#include +static std::mutex __Pyx_ModuleStateLookup_mutex; +#define __Pyx_ModuleStateLookup_Lock() __Pyx_ModuleStateLookup_mutex.lock() +#define __Pyx_ModuleStateLookup_Unlock() __Pyx_ModuleStateLookup_mutex.unlock() +#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ > 201112L) && !defined(__STDC_NO_THREADS__) +#include +static mtx_t __Pyx_ModuleStateLookup_mutex; +static once_flag __Pyx_ModuleStateLookup_mutex_once_flag = ONCE_FLAG_INIT; +static void __Pyx_ModuleStateLookup_initialize_mutex(void) { + mtx_init(&__Pyx_ModuleStateLookup_mutex, mtx_plain); +} +#define __Pyx_ModuleStateLookup_Lock()\ + call_once(&__Pyx_ModuleStateLookup_mutex_once_flag, __Pyx_ModuleStateLookup_initialize_mutex);\ + mtx_lock(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() mtx_unlock(&__Pyx_ModuleStateLookup_mutex) +#elif defined(HAVE_PTHREAD_H) +#include +static pthread_mutex_t __Pyx_ModuleStateLookup_mutex = PTHREAD_MUTEX_INITIALIZER; +#define __Pyx_ModuleStateLookup_Lock() pthread_mutex_lock(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() pthread_mutex_unlock(&__Pyx_ModuleStateLookup_mutex) +#elif defined(_WIN32) +#include // synchapi.h on its own doesn't work +static SRWLOCK __Pyx_ModuleStateLookup_mutex = SRWLOCK_INIT; +#define __Pyx_ModuleStateLookup_Lock() AcquireSRWLockExclusive(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() ReleaseSRWLockExclusive(&__Pyx_ModuleStateLookup_mutex) +#else +#error "No suitable lock available for CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE.\ + Requires C standard >= C11, or C++ standard >= C++11,\ + or pthreads, or the Windows 32 API, or Python >= 3.13." +#endif +typedef struct { + int64_t id; + PyObject *module; +} __Pyx_InterpreterIdAndModule; +typedef struct { + char interpreter_id_as_index; + Py_ssize_t count; + Py_ssize_t allocated; + __Pyx_InterpreterIdAndModule table[1]; +} __Pyx_ModuleStateLookupData; +#define __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE 32 +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +static __pyx_atomic_int_type __Pyx_ModuleStateLookup_read_counter = 0; +#endif +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +static __pyx_atomic_ptr_type __Pyx_ModuleStateLookup_data = 0; +#else +static __Pyx_ModuleStateLookupData* __Pyx_ModuleStateLookup_data = NULL; +#endif +static __Pyx_InterpreterIdAndModule* __Pyx_State_FindModuleStateLookupTableLowerBound( + __Pyx_InterpreterIdAndModule* table, + Py_ssize_t count, + int64_t interpreterId) { + __Pyx_InterpreterIdAndModule* begin = table; + __Pyx_InterpreterIdAndModule* end = begin + count; + if (begin->id == interpreterId) { + return begin; + } + while ((end - begin) > __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE) { + __Pyx_InterpreterIdAndModule* halfway = begin + (end - begin)/2; + if (halfway->id == interpreterId) { + return halfway; + } + if (halfway->id < interpreterId) { + begin = halfway; + } else { + end = halfway; + } + } + for (; begin < end; ++begin) { + if (begin->id >= interpreterId) return begin; + } + return begin; +} +static PyObject *__Pyx_State_FindModule(CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get()); + if (interpreter_id == -1) return NULL; +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData* data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data); + { + __pyx_atomic_incr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); + if (likely(data)) { + __Pyx_ModuleStateLookupData* new_data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_acquire(&__Pyx_ModuleStateLookup_data); + if (likely(data == new_data)) { + goto read_finished; + } + } + __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); + __Pyx_ModuleStateLookup_Lock(); + __pyx_atomic_incr_relaxed(&__Pyx_ModuleStateLookup_read_counter); + data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data); + __Pyx_ModuleStateLookup_Unlock(); + } + read_finished:; +#else + __Pyx_ModuleStateLookupData* data = __Pyx_ModuleStateLookup_data; +#endif + __Pyx_InterpreterIdAndModule* found = NULL; + if (unlikely(!data)) goto end; + if (data->interpreter_id_as_index) { + if (interpreter_id < data->count) { + found = data->table+interpreter_id; + } + } else { + found = __Pyx_State_FindModuleStateLookupTableLowerBound( + data->table, data->count, interpreter_id); + } + end: + { + PyObject *result=NULL; + if (found && found->id == interpreter_id) { + result = found->module; + } +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); +#endif + return result; + } +} +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +static void __Pyx_ModuleStateLookup_wait_until_no_readers(void) { + while (__pyx_atomic_load(&__Pyx_ModuleStateLookup_read_counter) != 0); +} +#else +#define __Pyx_ModuleStateLookup_wait_until_no_readers() +#endif +static int __Pyx_State_AddModuleInterpIdAsIndex(__Pyx_ModuleStateLookupData **old_data, PyObject* module, int64_t interpreter_id) { + Py_ssize_t to_allocate = (*old_data)->allocated; + while (to_allocate <= interpreter_id) { + if (to_allocate == 0) to_allocate = 1; + else to_allocate *= 2; + } + __Pyx_ModuleStateLookupData *new_data = *old_data; + if (to_allocate != (*old_data)->allocated) { + new_data = (__Pyx_ModuleStateLookupData *)realloc( + *old_data, + sizeof(__Pyx_ModuleStateLookupData)+(to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule)); + if (!new_data) { + PyErr_NoMemory(); + return -1; + } + for (Py_ssize_t i = new_data->allocated; i < to_allocate; ++i) { + new_data->table[i].id = i; + new_data->table[i].module = NULL; + } + new_data->allocated = to_allocate; + } + new_data->table[interpreter_id].module = module; + if (new_data->count < interpreter_id+1) { + new_data->count = interpreter_id+1; + } + *old_data = new_data; + return 0; +} +static void __Pyx_State_ConvertFromInterpIdAsIndex(__Pyx_ModuleStateLookupData *data) { + __Pyx_InterpreterIdAndModule *read = data->table; + __Pyx_InterpreterIdAndModule *write = data->table; + __Pyx_InterpreterIdAndModule *end = read + data->count; + for (; readmodule) { + write->id = read->id; + write->module = read->module; + ++write; + } + } + data->count = write - data->table; + for (; writeid = 0; + write->module = NULL; + } + data->interpreter_id_as_index = 0; +} +static int __Pyx_State_AddModule(PyObject* module, CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get()); + if (interpreter_id == -1) return -1; + int result = 0; + __Pyx_ModuleStateLookup_Lock(); +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData *old_data = (__Pyx_ModuleStateLookupData *) + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0); +#else + __Pyx_ModuleStateLookupData *old_data = __Pyx_ModuleStateLookup_data; +#endif + __Pyx_ModuleStateLookupData *new_data = old_data; + if (!new_data) { + new_data = (__Pyx_ModuleStateLookupData *)calloc(1, sizeof(__Pyx_ModuleStateLookupData)); + if (!new_data) { + result = -1; + PyErr_NoMemory(); + goto end; + } + new_data->allocated = 1; + new_data->interpreter_id_as_index = 1; + } + __Pyx_ModuleStateLookup_wait_until_no_readers(); + if (new_data->interpreter_id_as_index) { + if (interpreter_id < __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE) { + result = __Pyx_State_AddModuleInterpIdAsIndex(&new_data, module, interpreter_id); + goto end; + } + __Pyx_State_ConvertFromInterpIdAsIndex(new_data); + } + { + Py_ssize_t insert_at = 0; + { + __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound( + new_data->table, new_data->count, interpreter_id); + assert(lower_bound); + insert_at = lower_bound - new_data->table; + if (unlikely(insert_at < new_data->count && lower_bound->id == interpreter_id)) { + lower_bound->module = module; + goto end; // already in table, nothing more to do + } + } + if (new_data->count+1 >= new_data->allocated) { + Py_ssize_t to_allocate = (new_data->count+1)*2; + new_data = + (__Pyx_ModuleStateLookupData*)realloc( + new_data, + sizeof(__Pyx_ModuleStateLookupData) + + (to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule)); + if (!new_data) { + result = -1; + new_data = old_data; + PyErr_NoMemory(); + goto end; + } + new_data->allocated = to_allocate; + } + ++new_data->count; + int64_t last_id = interpreter_id; + PyObject *last_module = module; + for (Py_ssize_t i=insert_at; icount; ++i) { + int64_t current_id = new_data->table[i].id; + new_data->table[i].id = last_id; + last_id = current_id; + PyObject *current_module = new_data->table[i].module; + new_data->table[i].module = last_module; + last_module = current_module; + } + } + end: +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, new_data); +#else + __Pyx_ModuleStateLookup_data = new_data; +#endif + __Pyx_ModuleStateLookup_Unlock(); + return result; +} +static int __Pyx_State_RemoveModule(CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get()); + if (interpreter_id == -1) return -1; + __Pyx_ModuleStateLookup_Lock(); +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData *data = (__Pyx_ModuleStateLookupData *) + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0); +#else + __Pyx_ModuleStateLookupData *data = __Pyx_ModuleStateLookup_data; +#endif + if (data->interpreter_id_as_index) { + if (interpreter_id < data->count) { + data->table[interpreter_id].module = NULL; + } + goto done; + } + { + __Pyx_ModuleStateLookup_wait_until_no_readers(); + __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound( + data->table, data->count, interpreter_id); + if (!lower_bound) goto done; + if (lower_bound->id != interpreter_id) goto done; + __Pyx_InterpreterIdAndModule *end = data->table+data->count; + for (;lower_boundid = (lower_bound+1)->id; + lower_bound->module = (lower_bound+1)->module; + } + } + --data->count; + if (data->count == 0) { + free(data); + data = NULL; + } + done: +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, data); +#else + __Pyx_ModuleStateLookup_data = data; +#endif + __Pyx_ModuleStateLookup_Unlock(); + return 0; } +#endif + +/* #### Code section: utility_code_pragmas_end ### */ +#ifdef _MSC_VER +#pragma warning( pop ) +#endif + +/* #### Code section: end ### */ #endif /* Py_PYTHON_H */ diff --git a/src/hunter/_tracer.pxd b/src/hunter/_tracer.pxd index f115f3a8..49e8e60c 100644 --- a/src/hunter/_tracer.pxd +++ b/src/hunter/_tracer.pxd @@ -1,28 +1,26 @@ -# cython: language_level=3str cimport cython from cpython.pystate cimport Py_tracefunc +from cpython.ref cimport PyObject -cdef extern from "frameobject.h": - ctypedef struct PyObject +ctypedef extern FrameType - ctypedef class types.CodeType[object PyCodeObject]: - cdef object co_filename - cdef int co_firstlineno - - ctypedef class types.FrameType[object PyFrameObject]: - cdef CodeType f_code - cdef PyObject *f_trace - cdef object f_globals - cdef object f_locals - cdef int f_lineno +cdef extern from *: + void PyEval_SetTrace(Py_tracefunc, PyObject*) + void PyEval_SetProfile(Py_tracefunc, PyObject*) - void PyEval_SetTrace(Py_tracefunc func, PyObject *obj) + ctypedef extern class types.CodeType[object PyCodeObject, check_size ignore]: + cdef object co_filename + cdef object co_name + cdef int co_argcount cdef extern from "pystate.h": ctypedef struct PyThreadState: - PyObject *c_traceobj + PyObject* c_traceobj + PyObject* c_profileobj Py_tracefunc c_tracefunc + Py_tracefunc c_profilefunc + @cython.final cdef class Tracer: @@ -30,6 +28,7 @@ cdef class Tracer: readonly object handler readonly object previous readonly object threading_support + readonly bint profiling_mode readonly int depth readonly int calls diff --git a/src/hunter/_tracer.pyx b/src/hunter/_tracer.pyx index 4baace23..6e91c39e 100644 --- a/src/hunter/_tracer.pyx +++ b/src/hunter/_tracer.pyx @@ -1,66 +1,74 @@ -# cython: linetrace=True, language_level=3str +# cython: linetrace=True, language_level=3str, freethreading_compatible=True import threading import traceback -from cpython cimport pystate -from cpython.ref cimport Py_INCREF -from cpython.ref cimport Py_CLEAR from cpython.pystate cimport PyThreadState_Get - +from cpython.pystate cimport PyFrameObject from ._event cimport Event - from ._predicates cimport fast_call -from ._predicates cimport From -from ._predicates cimport When - import hunter __all__ = 'Tracer', -cdef tuple KIND_NAMES = ('call', 'exception', 'line', 'return', 'c_call', 'c_exception', 'c_return') - - -cdef int trace_func(Tracer self, FrameType frame, int kind, PyObject *arg) except -1: - if frame.f_trace is not self: - Py_CLEAR(frame.f_trace) - Py_INCREF(self) - frame.f_trace = self - +cdef dict KIND_INTS = { + 'call': 0, + 'exception': 1, + 'line': 2, + 'return': 3, + 'c_call': 4, + 'c_exception': 5, + 'c_return': 6, +} + +cdef int trace_func(PyObject* tracer, PyFrameObject* frame, int kind, PyObject* arg) noexcept: + cdef Tracer self = tracer + cdef FrameType frame_object = frame + + frame_object.f_trace = self handler = self.handler + if handler is None: # the tracer was stopped + # make sure it's uninstalled even for running threads + if self.profiling_mode: + PyEval_SetProfile(NULL, NULL) + else: + PyEval_SetTrace(NULL, NULL) + return 0 + if kind == 3 and self.depth > 0: self.depth -= 1 - cdef Event event = Event(frame, KIND_NAMES[kind], None if arg is NULL else arg, self) - + cdef Event event = Event( frame, kind, None if arg is NULL else arg, self.depth, self.calls, self.threading_support) try: fast_call(handler, event) except Exception as exc: traceback.print_exc(file=hunter._default_stream) - hunter._default_stream.write('Disabling tracer because handler {} failed ({!r}).\n\n'.format( - handler, exc)) + hunter._default_stream.write('Disabling tracer because handler %r failed (%r) at %r.\n\n' % ( + handler, exc, event)) self.stop() return 0 if kind == 0: self.depth += 1 self.calls += 1 + return 0 cdef class Tracer: - def __cinit__(self, threading_support=None): + def __cinit__(self, threading_support=None, profiling_mode=False): self.handler = None self.previous = None self._previousfunc = NULL self._threading_previous = None self.threading_support = threading_support + self.profiling_mode = profiling_mode self.depth = 0 self.calls = 0 def __dealloc__(self): cdef PyThreadState *state = PyThreadState_Get() - if state.c_traceobj is self: + if state.c_traceobj is self: self.stop() def __repr__(self): @@ -73,38 +81,62 @@ cdef class Tracer: '' if self.previous is None else repr(self.previous), ) - def __call__(self, frame, kind, arg): - trace_func(self, frame, KIND_NAMES.index(kind), arg) - if kind == 'call': - PyEval_SetTrace( trace_func, self) + def __call__(self, frame, str kind, arg): + trace_func( self, frame, KIND_INTS[kind], arg) + if kind == 0: + PyEval_SetTrace(trace_func, self) return self def trace(self, predicate): - cdef PyThreadState *state = PyThreadState_Get() self.handler = predicate - if self.threading_support is None or self.threading_support: - self._threading_previous = getattr(threading, '_trace_hook', None) - threading.settrace(self) - if state.c_traceobj is NULL: - self.previous = None - self._previousfunc = NULL + cdef PyThreadState *state = PyThreadState_Get() + + if self.profiling_mode: + if self.threading_support is None or self.threading_support: + self._threading_previous = getattr(threading, '_profile_hook', None) + threading.setprofile(self) + if state.c_profileobj is NULL: + self.previous = None + self._previousfunc = NULL + else: + self.previous = (state.c_profileobj) + self._previousfunc = state.c_profilefunc + PyEval_SetProfile(trace_func, self) else: - self.previous = (state.c_traceobj) - self._previousfunc = state.c_tracefunc - PyEval_SetTrace( trace_func, self) + if self.threading_support is None or self.threading_support: + self._threading_previous = getattr(threading, '_trace_hook', None) + threading.settrace(self) + if state.c_traceobj is NULL: + self.previous = None + self._previousfunc = NULL + else: + self.previous = (state.c_traceobj) + self._previousfunc = state.c_tracefunc + PyEval_SetTrace(trace_func, self) return self def stop(self): if self.handler is not None: - if self.previous is None: - PyEval_SetTrace(NULL, NULL) + if self.profiling_mode: + if self.previous is None: + PyEval_SetProfile(NULL, NULL) + else: + PyEval_SetProfile(self._previousfunc, self.previous) + self.handler = self.previous = None + self._previousfunc = NULL + if self.threading_support is None or self.threading_support: + threading.setprofile(self._threading_previous) + self._threading_previous = None else: - PyEval_SetTrace(self._previousfunc, self.previous) - self.handler = self.previous = None - self._previousfunc = NULL - if self.threading_support is None or self.threading_support: - threading.settrace(self._threading_previous) - self._threading_previous = None + if self.previous is None: + PyEval_SetTrace(NULL, NULL) + else: + PyEval_SetTrace(self._previousfunc, self.previous) + self.handler = self.previous = None + self._previousfunc = NULL + if self.threading_support is None or self.threading_support: + threading.settrace(self._threading_previous) + self._threading_previous = None def __enter__(self): return self diff --git a/src/hunter/actions.py b/src/hunter/actions.py index 63b2c054..359505cc 100644 --- a/src/hunter/actions.py +++ b/src/hunter/actions.py @@ -1,5 +1,4 @@ -from __future__ import absolute_import - +# ruff: noqa: B008 import collections import opcode import os @@ -7,8 +6,7 @@ from collections import defaultdict from itertools import islice from os import getpid - -from colorama import AnsiToWin32 +from typing import ClassVar from . import config from .util import BUILTIN_SYMBOLS @@ -16,31 +14,36 @@ from .util import CODE_COLORS from .util import MISSING from .util import OTHER_COLORS -from .util import PY3 -from .util import StringType from .util import builtins +from .util import frame_iterator +from .util import get_arguments from .util import iter_symbols from .util import safe_repr +from .vendor.colorama import AnsiToWin32 try: from threading import get_ident except ImportError: from thread import get_ident -__all__ = ['Action', 'Debugger', 'Manhole', 'CodePrinter', 'CallPrinter', 'VarsPrinter'] +__all__ = [ + 'Action', + 'CallPrinter', + 'CodePrinter', + 'Debugger', + 'Manhole', + 'VarsPrinter', +] -BUILTIN_REPR_FUNCS = { - 'repr': repr, - 'safe_repr': safe_repr -} +BUILTIN_REPR_FUNCS = {'repr': repr, 'safe_repr': safe_repr} -class Action(object): +class Action: def __call__(self, event): - raise NotImplementedError() + raise NotImplementedError -class LazyImportPdb(object): +class LazyImportPdb: def __repr__(self): return "" @@ -48,6 +51,7 @@ def __repr__(self): def __call__(self, **kwargs): from pdb import Pdb + return Pdb(**kwargs) @@ -61,17 +65,13 @@ def __init__(self, klass=config.Default('klass', LazyImportPdb()), **kwargs): self.kwargs = kwargs def __eq__(self, other): - return ( - type(self) is type(other) and - self.klass == other.klass and - self.kwargs == other.kwargs - ) + return type(self) is type(other) and self.klass == other.klass and self.kwargs == other.kwargs def __str__(self): - return '{0.__class__.__name__}(klass={0.klass}, kwargs={0.kwargs})'.format(self) + return f'{self.__class__.__name__}(klass={self.klass}, kwargs={self.kwargs})' def __repr__(self): - return '{0.__class__.__name__}(klass={0.klass!r}, kwargs={0.kwargs!r})'.format(self) + return f'{self.__class__.__name__}(klass={self.klass!r}, kwargs={self.kwargs!r})' def __call__(self, event): """ @@ -88,13 +88,14 @@ def __eq__(self, other): return type(self) is type(other) and self.options == other.options def __str__(self): - return '{0.__class__.__name__}(options={0.options})'.format(self) + return f'{self.__class__.__name__}(options={self.options})' def __repr__(self): - return '{0.__class__.__name__}(options={0.options!r})'.format(self) + return f'{self.__class__.__name__}(options={self.options!r})' def __call__(self, event): import manhole + inst = manhole.install(strict=False, thread=False, **self.options) inst.handle_oneshot() @@ -103,7 +104,8 @@ class ColorStreamAction(Action): """ Baseclass for your custom action. Just implement your own ``__call__``. """ - _stream_cache = {} + + _stream_cache: ClassVar = {} _stream = None _tty = None _repr_func = None @@ -111,15 +113,17 @@ class ColorStreamAction(Action): OTHER_COLORS = OTHER_COLORS EVENT_COLORS = CODE_COLORS - def __init__(self, - stream=config.Default('stream', None), - force_colors=config.Default('force_colors', False), - force_pid=config.Default('force_pid', False), - filename_alignment=config.Default('filename_alignment', 40), - thread_alignment=config.Default('thread_alignment', 12), - pid_alignment=config.Default('pid_alignment', 9), - repr_limit=config.Default('repr_limit', 1024), - repr_func=config.Default('repr_func', 'safe_repr')): + def __init__( + self, + stream=config.Default('stream', None), + force_colors=config.Default('force_colors', False), + force_pid=config.Default('force_pid', False), + filename_alignment=config.Default('filename_alignment', 40), + thread_alignment=config.Default('thread_alignment', 12), + pid_alignment=config.Default('pid_alignment', 9), + repr_limit=config.Default('repr_limit', 1024), + repr_func=config.Default('repr_func', 'safe_repr'), + ): self.force_colors = config.resolve(force_colors) self.force_pid = config.resolve(force_pid) stream = config.resolve(stream) @@ -147,16 +151,20 @@ def __eq__(self, other): ) def __str__(self): - return '{0.__class__.__name__}(stream={0.stream}, force_colors={0.force_colors}, ' \ - 'filename_alignment={0.filename_alignment}, thread_alignment={0.thread_alignment}, ' \ - 'pid_alignment={0.pid_alignment} repr_limit={0.repr_limit}, ' \ - 'repr_func={0.repr_func})'.format(self) + return ( + f'{self.__class__.__name__}(stream={self.stream}, force_colors={self.force_colors}, ' + f'filename_alignment={self.filename_alignment}, thread_alignment={self.thread_alignment}, ' + f'pid_alignment={self.pid_alignment} repr_limit={self.repr_limit}, ' + f'repr_func={self.repr_func})' + ) def __repr__(self): - return '{0.__class__.__name__}(stream={0.stream!r}, force_colors={0.force_colors!r}, ' \ - 'filename_alignment={0.filename_alignment!r}, thread_alignment={0.thread_alignment!r}, ' \ - 'pid_alignment={0.pid_alignment!r} repr_limit={0.repr_limit!r}, ' \ - 'repr_func={0.repr_func!r})'.format(self) + return ( + f'{self.__class__.__name__}(stream={self.stream!r}, force_colors={self.force_colors!r}, ' + f'filename_alignment={self.filename_alignment!r}, thread_alignment={self.thread_alignment!r}, ' + f'pid_alignment={self.pid_alignment!r} repr_limit={self.repr_limit!r}, ' + f'repr_func={self.repr_func!r})' + ) @property def stream(self): @@ -164,7 +172,7 @@ def stream(self): @stream.setter def stream(self, value): - if isinstance(value, StringType): + if isinstance(value, str): if value in self._stream_cache: value = self._stream_cache[value] else: @@ -179,8 +187,8 @@ def stream(self, value): else: self._tty = False self._stream = value - self.event_colors = {key: '' for key in self.EVENT_COLORS} - self.other_colors = {key: '' for key in self.OTHER_COLORS} + self.event_colors = dict.fromkeys(self.EVENT_COLORS, '') + self.other_colors = dict.fromkeys(self.OTHER_COLORS, '') @property def repr_func(self): @@ -193,7 +201,7 @@ def repr_func(self, value): elif value in BUILTIN_REPR_FUNCS: self._repr_func = BUILTIN_REPR_FUNCS[value] else: - raise TypeError('Expected a callable or either "repr" or "safe_repr" strings, not {!r}.'.format(value)) + raise TypeError(f'Expected a callable or either "repr" or "safe_repr" strings, not {value!r}.') def try_str(self, obj): """ @@ -244,12 +252,13 @@ def try_source(self, event, full=False): """ source = event.fullsource if full else event.source if source.startswith('??? NO SOURCE: '): - return '{SOURCE-FAILURE}??? NO SOURCE: {SOURCE-DETAIL}{}'.format(source[15:], **self.other_colors), + return '{SOURCE-FAILURE}??? NO SOURCE: {SOURCE-DETAIL}{}'.format(source[15:], **self.other_colors) elif source: return source else: - return '{SOURCE-FAILURE}??? NO SOURCE: {SOURCE-DETAIL}Source code string for module {!r} is empty.'.format( - event.module, **self.other_colors) + return '{SOURCE-FAILURE}??? NO SOURCE: {SOURCE-DETAIL}Source code string for {!r} is empty.'.format( + event.filename, **self.other_colors + ) def filename_prefix(self, event=None): """ @@ -258,13 +267,16 @@ def filename_prefix(self, event=None): Returns: string """ if event: - filename = event.filename or '' + filename = event.filename + if filename == '?': + filename = '{SOURCE-FAILURE}?'.format(**self.other_colors) + lineno = '{COLON}:{LINENO}{:<5}'.format(event.lineno, **self.other_colors) + if len(filename) > self.filename_alignment: - filename = '[...]{}'.format(filename[5 - self.filename_alignment:]) - return '{:>{}}{COLON}:{LINENO}{:<5} '.format( - filename, self.filename_alignment, event.lineno, **self.other_colors) + filename = f'[...]{filename[5 - self.filename_alignment :]}' + return '{:>{}}{} '.format(filename, self.filename_alignment, lineno, **self.other_colors) else: - return '{:>{}} '.format('', self.filename_alignment) + return f'{"":>{self.filename_alignment}} ' def pid_prefix(self): """ @@ -272,11 +284,11 @@ def pid_prefix(self): """ pid = getpid() if self.force_pid or self.seen_pid != pid: - pid = '[{}]'.format(pid) + pid = f'[{pid}]' pid_align = self.pid_alignment else: pid = pid_align = '' - return '{:{}}'.format(pid, pid_align) + return f'{pid:{pid_align}}' def thread_prefix(self, event): """ @@ -291,7 +303,7 @@ def thread_prefix(self, event): threading_support = len(self.seen_threads) > 1 thread_name = threading.current_thread().name if threading_support else '' thread_align = self.thread_alignment if threading_support else '' - return '{:{}}'.format(thread_name, thread_align) + return f'{thread_name:{thread_align}}' def output(self, format_str, *args, **kwargs): """ @@ -329,10 +341,10 @@ def output(self, format_str, *args, **kwargs): Returns: string """ - self.stream.write(format_str.format( - *args, - **dict(self.other_colors, **kwargs) - )) + self.stream.write(format_str.format(*args, **dict(self.other_colors, **kwargs))) + + def cleanup(self): + pass class CodePrinter(ColorStreamAction): @@ -417,11 +429,17 @@ class CallPrinter(CodePrinter): .. versionadded:: 1.2.0 """ + EVENT_COLORS = CALL_COLORS + locals: ClassVar = defaultdict(list) + + @classmethod + def cleanup(cls): + cls.locals = defaultdict(list) + def __init__(self, *args, **kwargs): - super(CallPrinter, self).__init__(*args, **kwargs) - self.locals = defaultdict(list) + super().__init__(*args, **kwargs) def __call__(self, event): """ @@ -438,50 +456,98 @@ def __call__(self, event): filename_prefix = self.filename_prefix(event) if event.kind == 'call': - code = event.code - stack.append(ident) - self.output( - '{}{}{}{KIND}{:9} {}{COLOR}=>{NORMAL} {}({}{COLOR}{NORMAL}){RESET}\n', - pid_prefix, - thread_prefix, - filename_prefix, - event.kind, - ' ' * (len(stack) - 1), - event.function, - ', '.join('{VARS}{VARS-NAME}{0}{VARS}={RESET}{1}'.format( - var, - self.try_str(event.locals.get(var, MISSING)) if event.detached else self.try_repr(event.locals.get(var, MISSING)), - **self.other_colors - ) for var in code.co_varnames[:code.co_argcount]), - COLOR=self.event_colors.get(event.kind), - ) + if event.builtin: + self.output( + '{}{}{}{KIND}{:9} {}{COLOR} >{BUILTIN} {}.{}: {}{RESET}\n', + pid_prefix, + thread_prefix, + filename_prefix, + event.kind, + ' ' * (len(stack) - 1), + event.module, + event.function, + self.try_source(event).strip(), + COLOR=self.event_colors.get(event.kind), + ) + else: + code = event.code + stack.append(ident) + self.output( + '{}{}{}{KIND}{:9} {}{COLOR}=>{NORMAL} {}({}{COLOR}{NORMAL}){RESET}\n', + pid_prefix, + thread_prefix, + filename_prefix, + event.kind, + ' ' * (len(stack) - 1), + event.function, + ', '.join( + '{VARS}{0}{VARS-NAME}{1}{VARS}={RESET}{2}'.format( + prefix, + var_display, + ( + self.try_str(event.locals.get(var_lookup, MISSING)) + if event.detached + else self.try_repr(event.locals.get(var_lookup, MISSING)) + ), + **self.other_colors, + ) + for prefix, var_lookup, var_display in get_arguments(code) + ), + COLOR=self.event_colors.get(event.kind), + ) elif event.kind == 'exception': - self.output( - '{}{}{}{KIND}{:9} {}{COLOR} !{NORMAL} {}: {RESET}{}\n', - pid_prefix, - thread_prefix, - filename_prefix, - event.kind, - ' ' * (len(stack) - 1), - event.function, - self.try_str(event.arg) if event.detached else self.try_repr(event.arg), - COLOR=self.event_colors.get(event.kind), - ) - + if event.builtin: + self.output( + '{}{}{}{KIND}{:9} {}{COLOR} ! {BUILTIN}{}.{}{RESET}\n', + pid_prefix, + thread_prefix, + filename_prefix, + event.kind, + ' ' * (len(stack) - 1), + event.module, + event.function, + COLOR=self.event_colors.get(event.kind), + ) + else: + self.output( + '{}{}{}{KIND}{:9} {}{COLOR} !{NORMAL} {}: {RESET}{}\n', + pid_prefix, + thread_prefix, + filename_prefix, + event.kind, + ' ' * (len(stack) - 1), + event.function, + self.try_str(event.arg) if event.detached else self.try_repr(event.arg), + COLOR=self.event_colors.get(event.kind), + ) elif event.kind == 'return': - self.output( - '{}{}{}{KIND}{:9} {}{COLOR}<={NORMAL} {}: {RESET}{}\n', - pid_prefix, - thread_prefix, - filename_prefix, - event.kind, - ' ' * (len(stack) - 1), - event.function, - self.try_str(event.arg) if event.detached else self.try_repr(event.arg), - COLOR=self.event_colors.get(event.kind), - ) - if stack and stack[-1] == ident: - stack.pop() + if event.builtin: + self.output( + '{}{}{}{KIND}{:9} {}{COLOR} <{BUILTIN} {}.{}{RESET}\n', + pid_prefix, + thread_prefix, + filename_prefix, + event.kind, + ' ' * (len(stack) - 1), + event.module, + event.function, + COLOR=self.event_colors.get(event.kind), + ) + else: + self.output( + '{}{}{}{KIND}{:9} {}{COLOR}<={NORMAL} {}{}{RESET}{}\n', + pid_prefix, + thread_prefix, + filename_prefix, + event.kind, + ' ' * (len(stack) - 1), + event.function, + '' if event.builtin else ': ', + '' if event.builtin else (self.try_str(event.arg) if event.detached else self.try_repr(event.arg)), + COLOR=self.event_colors.get(event.kind), + ) + if stack and stack[-1] == ident: + stack.pop() else: self.output( '{}{}{}{KIND}{:9} {RESET}{}{}{RESET}\n', @@ -512,11 +578,8 @@ class VarsPrinter(ColorStreamAction): def __init__(self, *names, **options): if not names: raise TypeError('VarsPrinter requires at least one variable name/expression.') - self.names = { - name: set(iter_symbols(name)) - for name in names - } - super(VarsPrinter, self).__init__(**options) + self.names = {name: set(iter_symbols(name)) for name in names} + super().__init__(**options) def __call__(self, event): """ @@ -536,7 +599,7 @@ def __call__(self, event): for code, symbols in self.names.items(): try: obj = eval(code, dict(vars(builtins), **event.globals), event.locals) - except AttributeError: + except (AttributeError, KeyError): continue except Exception as exc: printout = '{INTERNAL-FAILURE}FAILED EVAL: {INTERNAL-DETAIL}{!r}'.format(exc, **self.other_colors) @@ -586,7 +649,7 @@ class VarsSnooper(ColorStreamAction): """ def __init__(self, **options): - super(VarsSnooper, self).__init__(**options) + super().__init__(**options) self.stored_reprs = defaultdict(dict) def __call__(self, event): @@ -600,10 +663,7 @@ def __call__(self, event): filename_prefix = self.filename_prefix(event) empty_filename_prefix = self.filename_prefix() - current_reprs = { - name: self.try_str(value) if event.detached else self.try_repr(value) - for name, value in event.locals.items() - } + current_reprs = {name: self.try_str(value) if event.detached else self.try_repr(value) for name, value in event.locals.items()} scope_key = event.code or event.function scope = self.stored_reprs[scope_key] for name, current_repr in sorted(current_reprs.items()): @@ -657,10 +717,13 @@ def __call__(self, event): current_repr, ) if event.kind == 'return': - del self.stored_reprs[scope_key] + if scope_key in self.stored_reprs: + del self.stored_reprs[scope_key] -RETURN_VALUE = opcode.opmap['RETURN_VALUE'] +RETURN_OPCODES = (opcode.opmap['RETURN_VALUE'],) +if 'RETURN_CONST' in opcode.opmap: + RETURN_OPCODES += (opcode.opmap['RETURN_CONST'],) class ErrorSnooper(CodePrinter): @@ -704,7 +767,7 @@ def __init__(self, *args, **kwargs): self.max_depth = kwargs.pop('max_depth', 0) self.origin = None self.events = None - super(ErrorSnooper, self).__init__(*args, **kwargs) + super().__init__(*args, **kwargs) def __call__(self, event): if self.max_backlog: @@ -729,26 +792,33 @@ def __call__(self, event): detached_event = event.detach(self.try_repr) self.events.append(detached_event) if event.depth == self.origin.depth - 1: # stop if the same function returned (depth is -1) - if (event.code.co_code[event.frame.f_lasti] if PY3 else ord(event.code.co_code[event.frame.f_lasti])) == RETURN_VALUE: + if event.instruction in RETURN_OPCODES: self.dump_events() - self.output("{BRIGHT}{fore(BLACK)}{} function exit{RESET}\n", "-" * 46) + self.output( + '{BRIGHT}{fore(BLACK)}{} function exit{RESET}\n', + '-' * 46, + ) self.origin = None self.events = None elif event.depth > self.origin.depth + self.max_depth: # too many details return elif len(self.events) > self.max_events: self.dump_events() - self.output("{BRIGHT}{fore(BLACK)}{} too many lines{RESET}\n", "-" * 46) + self.output('{BRIGHT}{fore(BLACK)}{} too many lines{RESET}\n', '-' * 46) else: if detached_event is None: detached_event = event.detach(self.try_repr) self.events.append(detached_event) def dump_events(self): - self.output("{BRIGHT}{fore(BLUE)}{} tracing {fore(YELLOW)}{}{fore(BLUE)} on {fore(RED)}{}{RESET}\n", - ">" * 46, self.origin.function, self.origin.arg) + self.output( + '{BRIGHT}{fore(BLUE)}{} tracing {fore(YELLOW)}{}{fore(BLUE)} on {fore(RED)}{}{RESET}\n', + '>' * 46, + self.origin.function, + self.origin.arg, + ) for event in self.events: - super(ErrorSnooper, self).__call__(event) + super().__call__(event) self.origin = None self.events = None @@ -771,7 +841,7 @@ class StackPrinter(ColorStreamAction): def __init__(self, depth=15, limit=2, **options): self.limit = limit self.depth = depth - super(StackPrinter, self).__init__(**options) + super().__init__(**options) def __call__(self, event): """ @@ -783,34 +853,23 @@ def __call__(self, event): sep = os.path.sep if event.frame and event.frame.f_back: - template = '{}{}{}{CONT}:{BRIGHT}{fore(BLUE)}%s {KIND}<={RESET} %s' % ( + template = '{{}}{{}}{{}}{{CONT}}:{{BRIGHT}}{{fore(BLUE)}}{} {{KIND}}<={{RESET}} {}'.format( event.function, ' {KIND}<={RESET} '.join( - '%s{CONT}:{RESET}%s{CONT}:{BRIGHT}{fore(BLUE)}%s' % ( - '/'.join(frame.f_code.co_filename.split(sep)[-self.limit:]), + '{}{{CONT}}:{{RESET}}{}{{CONT}}:{{BRIGHT}}{{fore(BLUE)}}{}'.format( + '/'.join(frame.f_code.co_filename.split(sep)[-self.limit :]), frame.f_lineno, - frame.f_code.co_name + frame.f_code.co_name, ) - for frame in islice(self.frame_iterator(event.frame.f_back), self.depth) - ) + for frame in islice(frame_iterator(event.frame.f_back), self.depth) + ), ) else: - template = '{}{}{}{CONT}:{BRIGHT}{fore(BLUE)}%s {KIND}<= {BRIGHT}{fore(YELLOW)}no frames available {NORMAL}(detached=%s)' % ( - event.function, - event.detached, - ) - template += "{RESET}\n" + template = f'{{}}{{}}{{}}{{CONT}}:{{BRIGHT}}{{fore(BLUE)}}{event.function} {{KIND}}<= {{BRIGHT}}{{fore(YELLOW)}}no frames available {{NORMAL}}(detached={event.detached})' + template += '{RESET}\n' self.output( template, pid_prefix, thread_prefix, filename_prefix, ) - - def frame_iterator(self, frame): - """ - Yields frames till there are no more. - """ - while frame: - yield frame - frame = frame.f_back diff --git a/src/hunter/backports/inspect.py b/src/hunter/backports/inspect.py deleted file mode 100644 index 668b482d..00000000 --- a/src/hunter/backports/inspect.py +++ /dev/null @@ -1,162 +0,0 @@ -import types - -_sentinel = object() - - -def _check_instance(obj, attr): - instance_dict = {} - try: - instance_dict = object.__getattribute__(obj, "__dict__") - except AttributeError: - pass - return dict.get(instance_dict, attr, _sentinel) - - -def _check_class(klass, attr): - for entry in _static_getmro(klass): - if _shadowed_dict(type(entry)) is _sentinel: - try: - return entry.__dict__[attr] - except KeyError: - pass - return _sentinel - - -def _is_type(obj): - try: - _static_getmro(obj) - except TypeError: - return False - return True - - -def _shadowed_dict_newstyle(klass): - dict_attr = type.__dict__["__dict__"] - for entry in _static_getmro(klass): - try: - class_dict = dict_attr.__get__(entry)["__dict__"] - except KeyError: - pass - else: - if not (type(class_dict) is types.GetSetDescriptorType and # noqa - class_dict.__name__ == "__dict__" and - class_dict.__objclass__ is entry): - return class_dict - return _sentinel - - -def _static_getmro_newstyle(klass): - return type.__dict__['__mro__'].__get__(klass) - - -def _shadowed_dict(klass): - """ - In Python 2 __dict__ is not overwritable: - - class Foo(object): pass - setattr(Foo, '__dict__', 4) - - Traceback (most recent call last): - File "", line 1, in - TypeError: __dict__ must be a dictionary object - - It applies to both newstyle and oldstyle classes: - - class Foo(object): pass - setattr(Foo, '__dict__', 4) - Traceback (most recent call last): - File "", line 1, in - AttributeError: attribute '__dict__' of 'type' objects is not writable - - It also applies to instances of those objects. However to keep things - straight forward, newstyle classes always use the complicated way of - accessing it while oldstyle classes just use getattr. - """ - if type(klass) is _oldstyle_class_type: - return getattr(klass, '__dict__', _sentinel) - return _shadowed_dict_newstyle(klass) - - -class _OldStyleClass: - pass - - -_oldstyle_instance_type = type(_OldStyleClass()) -_oldstyle_class_type = type(_OldStyleClass) - - -def _get_type(obj): - type_ = object.__getattribute__(obj, '__class__') - if type_ is _oldstyle_instance_type: - # Somehow for old style classes we need to access it directly. - return obj.__class__ - return type_ - - -def _static_getmro(klass): - if type(klass) is _oldstyle_class_type: - def oldstyle_mro(klass): - """ - Oldstyle mro is a really simplistic way of look up mro: - https://stackoverflow.com/questions/54867/what-is-the-difference-between-old-style-and-new-style-classes-in-python - """ - yield klass - for base in klass.__bases__: - for yield_from in oldstyle_mro(base): - yield yield_from - - return oldstyle_mro(klass) - - return _static_getmro_newstyle(klass) - - -def _safe_hasattr(obj, name): - return _check_class(_get_type(obj), name) is not _sentinel - - -def _safe_is_data_descriptor(obj): - return _safe_hasattr(obj, '__set__') or _safe_hasattr(obj, '__delete__') - - -def getattr_static(obj, attr, default=_sentinel): - """Retrieve attributes without triggering dynamic lookup via the - descriptor protocol, __getattr__ or __getattribute__. - - Note: this function may not be able to retrieve all attributes - that getattr can fetch (like dynamically created attributes) - and may find attributes that getattr can't (like descriptors - that raise AttributeError). It can also return descriptor objects - instead of instance members in some cases. See the - documentation for details. - """ - instance_result = _sentinel - if not _is_type(obj): - klass = _get_type(obj) - dict_attr = _shadowed_dict(klass) - if dict_attr is _sentinel or type(dict_attr) is types.MemberDescriptorType: # noqa - instance_result = _check_instance(obj, attr) - else: - klass = obj - - klass_result = _check_class(klass, attr) - - if instance_result is not _sentinel and klass_result is not _sentinel: - if _safe_hasattr(klass_result, '__get__') and _safe_is_data_descriptor(klass_result): - return klass_result - - if instance_result is not _sentinel: - return instance_result - if klass_result is not _sentinel: - return klass_result - - if obj is klass: - # for types we check the metaclass too - for entry in _static_getmro(type(klass)): - if _shadowed_dict(type(entry)) is _sentinel: - try: - return entry.__dict__[attr] - except KeyError: - pass - if default is not _sentinel: - return default - raise AttributeError(attr) diff --git a/src/hunter/config.py b/src/hunter/config.py index 0d734ba8..95bcd791 100644 --- a/src/hunter/config.py +++ b/src/hunter/config.py @@ -1,10 +1,11 @@ -class Default(object): +class Default: def __init__(self, key, fallback_value): self.key = key self.fallback_value = fallback_value def resolve(self): from . import _default_config + return _default_config.get(self.key, self.fallback_value) def __str__(self): diff --git a/src/hunter/const.py b/src/hunter/const.py index 32a37731..9f0bdc4a 100644 --- a/src/hunter/const.py +++ b/src/hunter/const.py @@ -1,15 +1,26 @@ +import collections import os import site import stat import sys -from distutils.sysconfig import get_python_lib +import sysconfig SITE_PACKAGES_PATHS = set() -if hasattr(site, 'getsitepackages'): - SITE_PACKAGES_PATHS.update(site.getsitepackages()) +for scheme in sysconfig.get_scheme_names(): + if scheme == 'posix_home': + # it would appear this scheme is not for site-packages + continue + for name in ['platlib', 'purelib']: + try: + SITE_PACKAGES_PATHS.add(sysconfig.get_path(name, scheme)) + except KeyError: + pass if hasattr(site, 'getusersitepackages'): SITE_PACKAGES_PATHS.add(site.getusersitepackages()) -SITE_PACKAGES_PATHS.add(get_python_lib()) +if sys.version_info < (3, 10): + from distutils.sysconfig import get_python_lib + + SITE_PACKAGES_PATHS.add(get_python_lib()) SITE_PACKAGES_PATHS.add(os.path.dirname(os.path.dirname(__file__))) SITE_PACKAGES_PATHS = tuple(SITE_PACKAGES_PATHS) @@ -21,8 +32,14 @@ sys.exec_prefix, os.path.dirname(os.__file__), os.path.dirname(stat.__file__), + os.path.dirname(collections.__file__), } -for prop in 'real_prefix', 'real_exec_prefix', 'base_prefix', 'base_exec_prefix': +for prop in ( + 'real_prefix', + 'real_exec_prefix', + 'base_prefix', + 'base_exec_prefix', +): if hasattr(sys, prop): SYS_PREFIX_PATHS.add(getattr(sys, prop)) diff --git a/src/hunter/event.py b/src/hunter/event.py index 25a03e0d..73d62245 100644 --- a/src/hunter/event.py +++ b/src/hunter/event.py @@ -1,12 +1,11 @@ -from __future__ import absolute_import - import linecache -import tokenize from functools import partial from os.path import basename from os.path import exists from os.path import splitext from threading import current_thread +from tokenize import TokenError +from tokenize import generate_tokens from .const import SITE_PACKAGES_PATHS from .const import SYS_PREFIX_PATHS @@ -17,10 +16,10 @@ from .util import get_main_thread from .util import if_same_code -__all__ = 'Event', +__all__ = ('Event',) -class Event(object): +class Event: """ A wrapper object for Frame objects. Instances of this are passed to your custom functions or predicates. @@ -34,13 +33,23 @@ class Event(object): tracer (:class:`hunter.tracer.Tracer`): The :class:`~hunter.tracer.Tracer` instance that created the event. Needed for the ``calls`` and ``depth`` fields. """ + frame = None kind = None arg = None depth = None calls = None - - def __init__(self, frame, kind, arg, tracer): + builtin = None + + def __init__( + self, + frame, + kind, + arg, + depth, + calls, + threading_support, + ): #: The original Frame object. #: #: .. note:: @@ -49,8 +58,18 @@ def __init__(self, frame, kind, arg, tracer): #: You may access it from your custom predicate though. self.frame = frame - #: The kind of the event, could be one of ``'call'``, ``'line'``, ``'return'``, ``'exception'``, - #: ``'c_call'``, ``'c_return'``, or ``'c_exception'``. + if kind.startswith('c_'): + kind = kind[2:] + builtin = True + else: + builtin = False + + #: If kind of the event is one of ``'c_call'``, ``'c_return'``, or ``'c_exception'`` then this will be True. + #: + #: :type: bool + self.builtin = builtin + + #: The kind of the event, could be one of ``'call'``, ``'line'``, ``'return'``, ``'exception'``. #: #: :type: str self.kind = kind @@ -58,15 +77,15 @@ def __init__(self, frame, kind, arg, tracer): #: A value that depends on ``kind`` self.arg = arg - #: Tracing depth (increases on calls, decreases on returns) + #: Tracing depth (increases on calls, decreases on returns). #: #: :type: int - self.depth = tracer.depth + self.depth = depth #: A counter for total number of calls up to this Event. #: #: :type: int - self.calls = tracer.calls + self.calls = calls #: A copy of the :attr:`hunter.tracer.Tracer.threading_support` flag. #: @@ -75,23 +94,24 @@ def __init__(self, frame, kind, arg, tracer): #: Not allowed in the builtin predicates. You may access it from your custom predicate though. #: #: :type: bool or None - self.threading_support = tracer.threading_support + self.threading_support = threading_support #: Flag that is ``True`` if the event was created with :meth:`~hunter.event.Event.detach`. #: #: :type: bool self.detached = False - def __eq__(self, other): + def __repr__(self): return ( - type(self) == type(other) and - self.kind == other.kind and - self.depth == other.depth and - self.function == other.function and - self.module == other.module and - self.filename == other.filename + f'' ) + def __eq__(self, other): + return self is other + + def __reduce__(self): + raise TypeError("cannot pickle 'hunter.event.Event' object") + def detach(self, value_filter=None): """ Return a copy of the event with references to live objects (like the frame) removed. You should use this if you @@ -125,6 +145,7 @@ def __call__(self, event): event.__dict__['stdlib'] = self.stdlib event.__dict__['threadid'] = self.threadid event.__dict__['threadname'] = self.threadname + event.__dict__['instruction'] = self.instruction if value_filter: event.__dict__['arg'] = value_filter(self.arg) @@ -139,6 +160,7 @@ def __call__(self, event): event.calls = self.calls event.depth = self.depth event.kind = self.kind + event.builtin = self.builtin event.detached = True @@ -149,6 +171,17 @@ def clone(self): event.__dict__ = dict(self.__dict__) return event + @cached_property + def instruction(self): + """ + Last byte instruction. If no bytecode was used (Cython code) then it returns ``None``. + Depending on Python version it might be an int or a single char string. + + :type: int or single char string or None + """ + if self.frame.f_code.co_code and len(self.frame.f_code.co_code) > self.frame.f_lasti >= 0: + return self.frame.f_code.co_code[self.frame.f_lasti] + @cached_property def threadid(self): """ @@ -183,6 +216,9 @@ def locals(self): :type: dict """ + if self.builtin: + return {} + return self.frame.f_locals @cached_property @@ -192,6 +228,9 @@ def globals(self): :type: dict """ + if self.builtin: + return {} + return self.frame.f_globals @cached_property @@ -201,7 +240,10 @@ def function(self): :type: str """ - return self.code.co_name + if self.builtin: + return self.arg.__name__ + else: + return self.code.co_name @cached_property def function_object(self): @@ -217,6 +259,9 @@ def function_object(self): :type: function or None """ # Based on MonkeyType's get_func + if self.builtin: + return self.builtin + code = self.code if code.co_name is None: return None @@ -248,10 +293,12 @@ def module(self): :type: str """ - module = self.frame.f_globals.get('__name__', '') + if self.builtin: + module = self.arg.__module__ + else: + module = self.frame.f_globals.get('__name__', '') if module is None: - module = '' - + module = '?' return module @cached_property @@ -262,11 +309,15 @@ def filename(self): :type: str """ + # if self.builtin: + # return '' + # if self.builtin: + # return '' filename = self.frame.f_code.co_filename if not filename: filename = self.frame.f_globals.get('__file__') if not filename: - filename = '' + filename = '?' if filename.endswith(('.pyc', '.pyo')): filename = filename[:-1] elif filename.endswith('$py.class'): # Jython @@ -331,18 +382,25 @@ def fullsource(self): if self.kind == 'call' and self.code.co_name != '': lines = [] try: - for _, token, _, _, line in tokenize.generate_tokens(partial( - next, - yield_lines(self.filename, self.frame.f_globals, self.lineno - 1, lines.append) - )): + for _, token, _, _, _ in generate_tokens( + partial( + next, + yield_lines( + self.filename, + self.frame.f_globals, + self.lineno - 1, + lines.append, + ), + ) + ): if token in ('def', 'class', 'lambda'): return ''.join(lines) - except tokenize.TokenError: + except TokenError: pass return linecache.getline(self.filename, self.lineno, self.frame.f_globals) except Exception as exc: - return '??? NO SOURCE: {!r}'.format(exc) + return f'??? NO SOURCE: {exc!r}' @cached_property def source(self): @@ -354,24 +412,29 @@ def source(self): :type: str """ if self.filename.endswith(('.so', '.pyd')): - return '??? NO SOURCE: not reading binary {} file'.format(splitext(basename(self.filename))[1]) + return f'??? NO SOURCE: not reading binary {splitext(basename(self.filename))[1]} file' try: return linecache.getline(self.filename, self.lineno, self.frame.f_globals) except Exception as exc: - return '??? NO SOURCE: {!r}'.format(exc) + return f'??? NO SOURCE: {exc!r}' __getitem__ = object.__getattribute__ -def yield_lines(filename, module_globals, start, collector, - limit=10, - leading_whitespace_re=LEADING_WHITESPACE_RE): +def yield_lines( + filename, + module_globals, + start, + collector, + limit=10, + leading_whitespace_re=LEADING_WHITESPACE_RE, +): dedent = None amount = 0 - for line in linecache.getlines(filename, module_globals)[start:start + limit]: + for line in linecache.getlines(filename, module_globals)[start : start + limit]: if dedent is None: dedent = leading_whitespace_re.findall(line) - dedent = dedent[0] if dedent else "" + dedent = dedent[0] if dedent else '' amount = len(dedent) elif not line.startswith(dedent): break diff --git a/src/hunter/predicates.py b/src/hunter/predicates.py index 5382b49e..dfa6e0e2 100644 --- a/src/hunter/predicates.py +++ b/src/hunter/predicates.py @@ -1,12 +1,11 @@ -from __future__ import absolute_import - +import collections import inspect import re from itertools import chain from .actions import Action +from .actions import ColorStreamAction from .event import Event -from .util import StringType __all__ = ( 'And', @@ -17,48 +16,59 @@ 'When', ) -ALLOWED_KEYS = tuple(sorted( - i for i in Event.__dict__.keys() - if not i.startswith('_') and i not in ('tracer', 'thread', 'frame') -)) +ALLOWED_KEYS = tuple(sorted(i for i in Event.__dict__.keys() if not i.startswith('_') and i not in ('tracer', 'thread', 'frame'))) ALLOWED_OPERATORS = ( - 'startswith', 'endswith', 'in', 'contains', 'regex', - 'sw', 'ew', 'has', 'rx', - 'gt', 'gte', 'lt', 'lte', + 'startswith', + 'endswith', + 'in', + 'contains', + 'regex', + 'sw', + 'ew', + 'has', + 'rx', + 'gt', + 'gte', + 'lt', + 'lte', ) -class Query(object): +class BasePredicate: + pass + + +class Query: """ - A query class. + Event-filtering predicate. - See :class:`hunter.event.Event` for fields that can be filtered on. + See :class:`hunter.event.Event` for details about the fields that can be filtered on. + + Args: + query: criteria to match on. + + Accepted arguments: + ``arg``, + ``builtin``, + ``calls``, + ``code``, + ``depth``, + ``filename``, + ``frame``, + ``fullsource``, + ``function``, + ``globals``, + ``kind``, + ``lineno``, + ``locals``, + ``module``, + ``source``, + ``stdlib``, + ``threadid``, + ``threadname``. """ def __init__(self, **query): - """ - Args: - query: criteria to match on. - - Accepted arguments: - ``arg``, - ``calls``, - ``code``, - ``depth``, - ``filename``, - ``frame``, - ``fullsource``, - ``function``, - ``globals``, - ``kind``, - ``lineno``, - ``locals``, - ``module``, - ``source``, - ``stdlib``, - ``threadid``, - ``threadname``. - """ query_eq = {} query_startswith = {} query_endswith = {} @@ -74,21 +84,21 @@ def __init__(self, **query): parts = [p for p in key.split('_') if p] count = len(parts) if count > 2: - raise TypeError('Unexpected argument %r. Must be one of %s with optional operators like: %s' % ( - key, ALLOWED_KEYS, ALLOWED_OPERATORS - )) + raise TypeError( + f'Unexpected argument {key!r}. Must be one of {ALLOWED_KEYS} with optional operators like: {ALLOWED_OPERATORS}' + ) elif count == 2: prefix, operator = parts if operator in ('startswith', 'sw'): - if not isinstance(value, StringType): + if not isinstance(value, str): if not isinstance(value, (list, set, tuple)): - raise ValueError('Value %r for %r is invalid. Must be a string, list, tuple or set.' % (value, key)) + raise ValueError(f'Value {value!r} for {key!r} is invalid. Must be a string, list, tuple or set.') value = tuple(value) mapping = query_startswith elif operator in ('endswith', 'ew'): - if not isinstance(value, StringType): + if not isinstance(value, str): if not isinstance(value, (list, set, tuple)): - raise ValueError('Value %r for %r is invalid. Must be a string, list, tuple or set.' % (value, key)) + raise ValueError(f'Value {value!r} for {key!r} is invalid. Must be a string, list, tuple or set.') value = tuple(value) mapping = query_endswith elif operator == 'in': @@ -107,13 +117,13 @@ def __init__(self, **query): elif operator == 'gte': mapping = query_gte else: - raise TypeError('Unexpected operator %r. Must be one of %s.' % (operator, ALLOWED_OPERATORS)) + raise TypeError(f'Unexpected operator {operator!r}. Must be one of {ALLOWED_OPERATORS}.') else: mapping = query_eq prefix = key if prefix not in ALLOWED_KEYS: - raise TypeError('Unexpected argument %r. Must be one of %s.' % (key, ALLOWED_KEYS)) + raise TypeError(f'Unexpected argument {key!r}. Must be one of {ALLOWED_KEYS}.') mapping[prefix] = value @@ -129,9 +139,9 @@ def __init__(self, **query): self.query_gte = tuple(sorted(query_gte.items())) def __str__(self): - return 'Query(%s)' % ( + return 'Query(%s)' % ( # noqa: UP031 ', '.join( - ', '.join('%s%s=%r' % (key, kind, value) for key, value in mapping) + ', '.join(f'{key}{kind}={value!r}' for key, value in mapping) for kind, mapping in [ ('', self.query_eq), ('_in', self.query_in), @@ -143,13 +153,15 @@ def __str__(self): ('_lte', self.query_lte), ('_gt', self.query_gt), ('_gte', self.query_gte), - ] if mapping + ] + if mapping ) ) def __repr__(self): - return '' % ' '.join( - fmt % (mapping,) for fmt, mapping in [ + return '' % ' '.join( # noqa: UP031 + fmt % (mapping,) + for fmt, mapping in [ ('query_eq=%r', self.query_eq), ('query_in=%r', self.query_in), ('query_contains=%r', self.query_contains), @@ -160,7 +172,8 @@ def __repr__(self): ('query_lte=%r', self.query_lte), ('query_gt=%r', self.query_gt), ('query_gte=%r', self.query_gte), - ] if mapping + ] + if mapping ) def __eq__(self, other): @@ -178,21 +191,6 @@ def __eq__(self, other): and self.query_gte == other.query_gte ) - def __hash__(self): - return hash(( - 'Query', - self.query_eq, - self.query_in, - self.query_contains, - self.query_startswith, - self.query_endswith, - self.query_regex, - self.query_lt, - self.query_lte, - self.query_gt, - self.query_gte, - )) - def __call__(self, event): """ Handles event. Returns True if all criteria matched. @@ -271,9 +269,9 @@ def __rand__(self, other): return And(other, self) -class When(object): +class When: """ - Runs ``actions`` when ``condition(event)`` is ``True``. + Conditional predicate. Runs ``actions`` when ``condition(event)`` is ``True``. Actions take a single ``event`` argument. """ @@ -282,28 +280,19 @@ def __init__(self, condition, *actions): if not actions: raise TypeError('Must give at least one action.') self.condition = condition - self.actions = tuple( - action() if inspect.isclass(action) and issubclass(action, Action) else action - for action in actions) + self.actions = tuple(action() if inspect.isclass(action) and issubclass(action, Action) else action for action in actions) def __str__(self): - return 'When(%s, %s)' % ( + return 'When({}, {})'.format( self.condition, - ', '.join(repr(p) for p in self.actions) + ', '.join(repr(p) for p in self.actions), ) def __repr__(self): - return '' % (self.condition, self.actions) + return f'' def __eq__(self, other): - return ( - isinstance(other, When) - and self.condition == other.condition - and self.actions == other.actions - ) - - def __hash__(self): - return hash(('When', self.condition, self.actions)) + return isinstance(other, When) and self.condition == other.condition and self.actions == other.actions def __call__(self, event): """ @@ -347,7 +336,7 @@ def __rand__(self, other): return And(other, self) -class From(object): +class From: """ From-point filtering mechanism. Switches on to running the predicate after condition matches, and switches off when the depth goes lower than the initial level. @@ -356,57 +345,49 @@ class From(object): ``event`` will return ``predicate(event)`` until ``event.depth - watermark`` is equal to the depth that was saved. Args: - condition (callable): A callable that returns True/False or a :class:`~hunter.predicates.Query` object. - predicate (callable): Optional callable that returns True/False or a :class:`~hunter.predicates.Query` object to + condition (callable): Optional :class:`~hunter.predicates.Query` object or a callable that returns True/False. + predicate (callable): Optional :class:`~hunter.predicates.Query` object or a callable that returns True/False to run after ``condition`` first returns ``True``. Note that this predicate will be called with a event-copy that has adjusted :attr:`~hunter.event.Event.depth` and :attr:`~hunter.event.Event.calls` to the initial point where the ``condition`` matched. In other words they will be relative. watermark (int): Depth difference to switch off and wait again on ``condition``. + + See Also: + :class:`hunter.predicates.Backlog` """ def __init__(self, condition, predicate=None, watermark=0): self.condition = condition self.predicate = predicate self.watermark = watermark - self.origin_depth = None - self.origin_calls = None + self._origin_depth = None + self._origin_calls = None def __str__(self): - return 'From(%s, %s, watermark=%s)' % ( - self.condition, self.predicate, self.watermark - ) + return f'From({self.condition}, {self.predicate}, watermark={self.watermark})' def __repr__(self): - return '' % ( - self.condition, self.predicate, self.watermark - ) + return f'' def __eq__(self, other): - return ( - isinstance(other, From) - and self.condition == other.condition - and self.predicate == other.predicate - ) - - def __hash__(self): - return hash(('From', self.condition, self.predicate)) + return isinstance(other, From) and self.condition == other.condition and self.predicate == other.predicate def __call__(self, event): """ Handles the event. """ - if self.origin_depth is None: + if self._origin_depth is None: if self.condition(event): - self.origin_depth = event.depth - self.origin_calls = event.calls + self._origin_depth = event.depth + self._origin_calls = event.calls delta_depth = delta_calls = 0 else: return False else: - delta_depth = event.depth - self.origin_depth - delta_calls = event.calls - self.origin_calls + delta_depth = event.depth - self._origin_depth + delta_calls = event.calls - self._origin_calls if delta_depth < self.watermark: - self.origin_depth = None + self._origin_depth = None return False if self.predicate is None: return True @@ -447,28 +428,22 @@ def __rand__(self, other): return And(other, self) -class And(object): +class And: """ - Returns ``False`` at the first sub-predicate that returns ``False``, otherwise returns ``True``. + Logical conjunction. Returns ``False`` at the first sub-predicate that returns ``False``, otherwise returns ``True``. """ def __init__(self, *predicates): self.predicates = predicates def __str__(self): - return 'And(%s)' % ', '.join(str(p) for p in self.predicates) + return f'And({", ".join(str(p) for p in self.predicates)})' def __repr__(self): - return '' % (self.predicates,) + return f'' def __eq__(self, other): - return ( - isinstance(other, And) - and self.predicates == other.predicates - ) - - def __hash__(self): - return hash(('And', self.predicates)) + return isinstance(other, And) and self.predicates == other.predicates def __call__(self, event): """ @@ -490,7 +465,12 @@ def __and__(self, other): """ Convenience API so you can do ``And(...) & other``. It converts that to ``And(..., other)``. """ - return And(*chain(self.predicates, other.predicates if isinstance(other, And) else (other,))) + return And( + *chain( + self.predicates, + other.predicates if isinstance(other, And) else (other,), + ) + ) def __invert__(self): """ @@ -511,28 +491,22 @@ def __rand__(self, other): return And(other, *self.predicates) -class Or(object): +class Or: """ - Returns ``True`` after the first sub-predicate that returns ``True``. + Logical disjunction. Returns ``True`` after the first sub-predicate that returns ``True``. """ def __init__(self, *predicates): self.predicates = predicates def __str__(self): - return 'Or(%s)' % ', '.join(str(p) for p in self.predicates) + return f'Or({", ".join(str(p) for p in self.predicates)})' def __repr__(self): - return '' % (self.predicates,) + return f'' def __eq__(self, other): - return ( - isinstance(other, Or) - and self.predicates == other.predicates - ) - - def __hash__(self): - return hash(('Or', self.predicates)) + return isinstance(other, Or) and self.predicates == other.predicates def __call__(self, event): """ @@ -548,7 +522,12 @@ def __or__(self, other): """ Convenience API so you can do ``Or(...) | other``. It converts that to ``Or(..., other)``. """ - return Or(*chain(self.predicates, other.predicates if isinstance(other, Or) else (other,))) + return Or( + *chain( + self.predicates, + other.predicates if isinstance(other, Or) else (other,), + ) + ) def __and__(self, other): """ @@ -575,28 +554,22 @@ def __rand__(self, other): return And(other, self) -class Not(object): +class Not: """ - Simply returns ``not predicate(event)``. + Logical complement (negation). Simply returns ``not predicate(event)``. """ def __init__(self, predicate): self.predicate = predicate def __str__(self): - return 'Not(%s)' % self.predicate + return f'Not({self.predicate})' def __repr__(self): - return '' % self.predicate + return f'' def __eq__(self, other): - return ( - isinstance(other, Not) - and self.predicate == other.predicate - ) - - def __hash__(self): - return hash(('Not', self.predicate)) + return isinstance(other, Not) and self.predicate == other.predicate def __call__(self, event): """ @@ -643,3 +616,200 @@ def __rand__(self, other): Convenience API so you can do ``other & Not(...)``. It converts that to ``And(other, Not(...))``. """ return And(other, self) + + +class Backlog: + """ + Until-point buffering mechanism. It will buffer detached events up to the given ``size`` and display them + using the given ``action`` when ``condition`` returns True. + + This is a complement to :class:`~hunter.predicates.From` - essentially working the other way. While :class:`~hunter.predicates.From` + shows events after something interesting occurred the Backlog will show events prior to something interesting occurring. + + If the depth delta from the first event in the backlog and the event that matched the condition is less + than the given ``stack`` then it will create fake call events to be passed to the action before the events + from the backlog are passed in. + + Using a ``filter`` or pre-filtering is recommended to reduce storage work and improve tracing speed. Pre-filtering means that you use + Backlog inside a :class:`~hunter.When` or `:class:`~hunter.And` - effectively reducing the number of Events that get to the Backlog. + + Args: + condition (callable): Optional :class:`~hunter.predicates.Query` object or a callable that returns True/False. + size (int): Number of events that the backlog stores. Effectively this is the ``maxlen`` for the internal deque. + stack (int): Stack size to fill. Setting this to ``0`` disables creating fake call events. + vars (bool): Makes global/local variables available in the stored events. + This is an expensive option - it will use ``action.try_repr`` on all the variables. + strip (bool): If this option is set then the backlog will be cleared every time an event matching the ``condition`` is found. + Disabling this may show more context every time an event matching the ``condition`` is found but said context may also be + duplicated across multiple matches. + action (ColorStreamAction): A ColorStreamAction to display the stored events when an event matching the ``condition`` is found. + filter (callable): Optional :class:`~hunter.predicates.Query` object or a callable that returns True/False to filter the stored + events with. + + See Also: + :class:`hunter.predicates.From` + """ + + def __init__( + self, + condition, + size=100, + stack=10, + vars=False, + strip=True, + action=None, + filter=None, + ): + self.action = action() if inspect.isclass(action) and issubclass(action, Action) else action + if not isinstance(self.action, ColorStreamAction): + raise TypeError(f'Action {self.action!r} must be a ColorStreamAction.') + self.condition = condition + self.queue = collections.deque(maxlen=size) + self.size = size + self.stack = stack + self.strip = strip + self.vars = vars + self._try_repr = self.action.try_repr if self.vars else None + self._filter = filter + + def __call__(self, event): + """ + Handles the event. + """ + result = self.condition(event) + if result: + if self.queue: + self.action.cleanup() + + first_event = self.queue[0] + first_depth = first_event.depth + backlog_call_depth = event.depth - first_depth + first_is_call = first_event.kind == 'call' # note that True is 1, thus the following math is valid + missing_depth = min( + first_depth, + max(0, self.stack - backlog_call_depth + first_is_call), + ) + if missing_depth: + if first_is_call and first_event.frame is not None: + first_frame = first_event.frame.f_back + else: + first_frame = first_event.frame + if first_frame is not None: + stack_events = collections.deque() # a new deque because self.queue is limited, we can't add while it's full + frame = first_frame + depth_delta = 0 + while frame and depth_delta < missing_depth: + stack_event = Event( + frame=frame, + kind='call', + arg=None, + threading_support=event.threading_support, + depth=first_depth - depth_delta - 1, + calls=-1, + ) + if not self.vars: + # noinspection PyPropertyAccess + stack_event.locals = {} + stack_event.globals = {} + stack_event.detached = True + stack_events.appendleft(stack_event) + frame = frame.f_back + depth_delta += 1 + for stack_event in stack_events: + if self._filter is None or self._filter(stack_event): + self.action(stack_event) + for backlog_event in self.queue: + if self._filter is None: + self.action(backlog_event) + elif self._filter(backlog_event): + self.action(backlog_event) + self.queue.clear() + else: + if self.strip and event.depth < 1: + # Looks like we're back to depth 0 for some reason. + # Delete everything because we don't want to see what is likely just a long stream of useless returns. + self.queue.clear() + if self._filter is None or self._filter(event): + detached_event = event.detach(self._try_repr) + detached_event.frame = event.frame + self.queue.append(detached_event) + + return result + + def __str__(self): + return f'Backlog({self.condition}, size={self.size}, stack={self.stack}, vars={self.vars}, action={self.action}, filter={self._filter})' + + def __repr__(self): + return f'' + + def __eq__(self, other): + return ( + isinstance(other, Backlog) + and self.condition == other.condition + and self.size == other.size + and self.stack == other.stack + and self.vars == other.vars + and self.action == other.action + ) + + def __or__(self, other): + """ + Convenience API so you can do ``Backlog(...) | other``. It converts that to ``Or(Backlog(...), other)``. + """ + return Or(self, other) + + def __and__(self, other): + """ + Convenience API so you can do ``Backlog(...) & other``. It converts that to ``And(Backlog(...), other))``. + """ + return And(self, other) + + def __invert__(self): + """ + Convenience API so you can do ``~Backlog(...)``. It converts that to ``Not(Backlog(...))``. + """ + return Backlog( + Not(self.condition), + size=self.size, + stack=self.stack, + vars=self.vars, + action=self.action, + filter=self._filter, + ) + + def __ror__(self, other): + """ + Convenience API so you can do ``other | Backlog(...)``. It converts that to ``Or(other, Backlog(...))``. + """ + return Or(other, self) + + def __rand__(self, other): + """ + Convenience API so you can do ``other & Backlog(...)``. It converts that to ``And(other, Backlog(...))``. + """ + return And(other, self) + + def filter(self, *predicates, **kwargs): + """ + Returns another Backlog instance with extra output filtering. If the current instance already + have filters they will be merged by using an :class:`~hunter.predicates.And` predicate. + + Args: + *predicates (callables): Callables that returns True/False or :class:`~hunter.predicates.Query` objects. + **kwargs: Arguments that may be passed to :class:`~hunter.predicates.Query`. + + Returns: A new :class:`~hunter.predicates.Backlog` instance. + """ + from hunter import _merge + + if self._filter is not None: + predicates = (self._filter, *predicates) + + return Backlog( + self.condition, + size=self.size, + stack=self.stack, + vars=self.vars, + action=self.action, + filter=_merge(*predicates, **kwargs), + ) diff --git a/src/hunter/remote.py b/src/hunter/remote.py index 561c1feb..4b0497bd 100644 --- a/src/hunter/remote.py +++ b/src/hunter/remote.py @@ -1,5 +1,4 @@ -from __future__ import print_function - +# ruff: noqa: S103 S108 S603 import argparse import errno import json @@ -23,7 +22,7 @@ from manhole import get_peercred from manhole.cli import parse_signal -__all__ = 'install', +__all__ = ('install',) def install(**kwargs): @@ -32,7 +31,7 @@ def install(**kwargs): manhole.install(**kwargs) -class RemoteStream(object): +class RemoteStream: def __init__(self, path, isatty, encoding): self._sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) self._sock.connect(path) @@ -48,8 +47,10 @@ def write(self, data): data = data.decode('ascii', 'replace') self._sock.send(data.encode(self._encoding)) except Exception as exc: - print('Hunter failed to send trace output {!r} (encoding: {!r}): {!r}. Stopping tracer.'.format( - data, self._encoding, exc), file=sys.stderr) + print( + f'Hunter failed to send trace output {data!r} (encoding: {self._encoding!r}): {exc!r}. Stopping tracer.', + file=sys.stderr, + ) hunter.stop() def flush(self): @@ -77,12 +78,20 @@ def manhole_bootstrap(args, activation_payload, deactivation_payload): def gdb_bootstrap(args, activation_payload, deactivation_payload): print('WARNING: Using GDB may deadlock the process or create unpredictable results!') activation_command = [ - 'gdb', '-p', str(args.pid), '-batch', - '-ex', 'call (void)Py_AddPendingCall(PyRun_SimpleString, {})'.format(json.dumps(activation_payload)), + 'gdb', + '-p', + str(args.pid), + '-batch', + '-ex', + f'call (void)Py_AddPendingCall(PyRun_SimpleString, {json.dumps(activation_payload)})', ] deactivation_command = [ - 'gdb', '-p', str(args.pid), '-batch', - '-ex', 'call (void)Py_AddPendingCall(PyRun_SimpleString, {})'.format(json.dumps(deactivation_payload)), + 'gdb', + '-p', + str(args.pid), + '-batch', + '-ex', + f'call (void)Py_AddPendingCall(PyRun_SimpleString, {json.dumps(deactivation_payload)})', ] check_call(activation_command) try: @@ -95,19 +104,25 @@ def connect_manhole(pid, timeout, signal): os.kill(pid, signal) start = time.time() - uds_path = '/tmp/manhole-{}'.format(pid) + uds_path = f'/tmp/manhole-{pid}' conn = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) conn.settimeout(timeout) while time.time() - start < timeout: try: conn.connect(uds_path) - except (OSError, socket.error) as exc: + except OSError as exc: if exc.errno not in (errno.ENOENT, errno.ECONNREFUSED): - print('Failed to connect to {!r}: {!r}'.format(uds_path, exc), file=sys.stderr) + print( + f'Failed to connect to {uds_path!r}: {exc!r}', + file=sys.stderr, + ) else: break else: - print('Failed to connect to {!r}: Timeout'.format(uds_path), file=sys.stderr) + print( + f'Failed to connect to {uds_path!r}: Timeout', + file=sys.stderr, + ) sys.exit(5) return conn @@ -116,38 +131,63 @@ def activate(sink_path, isatty, encoding, options): stream = hunter._default_stream = RemoteStream(sink_path, isatty, encoding) try: stream.write('Output stream active. Starting tracer ...\n\n') - eval('hunter.trace({})'.format(options)) + eval(f'hunter.trace({options})') except Exception as exc: - stream.write('Failed to activate: {!r}. {}\n'.format( - exc, - 'Tracer options where: {}.'.format(options) if options else 'No tracer options.' - )) + stream.write( + 'Failed to activate: {!r}. {}\n'.format( + exc, + f'Tracer options where: {options}.' if options else 'No tracer options.', + ) + ) hunter._default_stream = sys.stderr raise def deactivate(): - hunter._default_config = sys.stderr + hunter._default_stream = sys.stderr hunter.stop() parser = argparse.ArgumentParser(description='Trace a process.') -parser.add_argument('-p', '--pid', metavar='PID', type=int, required=True, - help='A numerical process id.') +parser.add_argument( + '-p', + '--pid', + metavar='PID', + type=int, + required=True, + help='A numerical process id.', +) parser.add_argument('options', metavar='OPTIONS', nargs='*') -parser.add_argument('-t', '--timeout', dest='timeout', default=1, type=float, - help='Timeout to use. Default: %(default)s seconds.') -parser.add_argument('--gdb', dest='gdb', action='store_true', - help='Use GDB to activate tracing. WARNING: it may deadlock the process!') -parser.add_argument('-s', '--signal', dest='signal', type=parse_signal, metavar='SIGNAL', default=signal.SIGURG, - help='Send the given SIGNAL to the process before connecting. Default: %(default)s.') +parser.add_argument( + '-t', + '--timeout', + dest='timeout', + default=1, + type=float, + help='Timeout to use. Default: %(default)s seconds.', +) +parser.add_argument( + '--gdb', + dest='gdb', + action='store_true', + help='Use GDB to activate tracing. WARNING: it may deadlock the process!', +) +parser.add_argument( + '-s', + '--signal', + dest='signal', + type=parse_signal, + metavar='SIGNAL', + default=signal.SIGURG, + help='Send the given SIGNAL to the process before connecting. Default: %(default)s.', +) def main(): args = parser.parse_args() sink = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) - sink_path = '/tmp/hunter-{}'.format(os.getpid()) + sink_path = f'/tmp/hunter-{os.getpid()}' sink.bind(sink_path) sink.listen(1) os.chmod(sink_path, 0o777) @@ -159,7 +199,7 @@ def main(): sink_path, sys.stdout.isatty(), encoding, - ','.join(i.strip(',') for i in args.options) + ','.join(i.strip(',') for i in args.options), ) with bootstrapper(args, payload, 'from hunter import remote; remote.deactivate()'): conn, _ = sink.accept() @@ -167,10 +207,12 @@ def main(): pid, _, _ = get_peercred(conn) if pid: if pid != args.pid: - raise Exception('Unexpected pid {!r} connected to output socket. Was expecting {!r}.'.format( - pid, args.pid)) + raise Exception(f'Unexpected pid {pid!r} connected to output socket. Was expecting {args.pid!r}.') else: - print('WARNING: Failed to get pid of connected process.', file=sys.stderr) + print( + 'WARNING: Failed to get pid of connected process.', + file=sys.stderr, + ) data = conn.recv(1024) while data: stdout.write(data) diff --git a/src/hunter/tracer.py b/src/hunter/tracer.py index d83579e5..b7279ab4 100644 --- a/src/hunter/tracer.py +++ b/src/hunter/tracer.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import - import sys import threading import traceback @@ -8,17 +6,18 @@ from .event import Event -__all__ = 'Tracer', +__all__ = ('Tracer',) -class Tracer(object): +class Tracer: """ Tracer object. Args: threading_support (bool): Hooks the tracer into ``threading.settrace`` as well if True. """ - def __init__(self, threading_support=None): + + def __init__(self, threading_support=None, profiling_mode=False): self._handler = None self._previous = None self._threading_previous = None @@ -28,6 +27,11 @@ def __init__(self, threading_support=None): #: :type: bool self.threading_support = threading_support + #: True if profiling mode was enabled. Should be considered read-only. + #: + #: :type: bool + self.profiling_mode = profiling_mode + #: Tracing depth (increases on calls, decreases on returns) #: #: :type: int @@ -53,7 +57,7 @@ def previous(self): return self._previous def __repr__(self): - return '' % ( + return ''.format( id(self), self.threading_support, '' if self._handler is None else 'handler=', @@ -74,12 +78,12 @@ def __call__(self, frame, kind, arg): if self._handler is not None: if kind == 'return' and self.depth > 0: self.depth -= 1 + event = Event(frame, kind, arg, self.depth, self.calls, self.threading_support) try: - self._handler(Event(frame, kind, arg, self)) + self._handler(event) except Exception as exc: traceback.print_exc(file=hunter._default_stream) - hunter._default_stream.write('Disabling tracer because handler {} failed ({!r}).\n\n'.format( - self._handler, exc)) + hunter._default_stream.write(f'Disabling tracer because handler {self._handler!r} failed ({exc!r}) at {event!r}.\n\n') self.stop() return if kind == 'call': @@ -98,11 +102,18 @@ def trace(self, predicate): self """ self._handler = predicate - if self.threading_support is None or self.threading_support: - self._threading_previous = getattr(threading, '_trace_hook', None) - threading.settrace(self) - self._previous = sys.gettrace() - sys.settrace(self) + if self.profiling_mode: + if self.threading_support is None or self.threading_support: + self._threading_previous = getattr(threading, '_profile_hook', None) + threading.setprofile(self) + self._previous = sys.getprofile() + sys.setprofile(self) + else: + if self.threading_support is None or self.threading_support: + self._threading_previous = getattr(threading, '_trace_hook', None) + threading.settrace(self) + self._previous = sys.gettrace() + sys.settrace(self) return self def stop(self): @@ -110,11 +121,18 @@ def stop(self): Stop tracing. Reinstalls the :attr:`~hunter.tracer.Tracer.previous` tracer. """ if self._handler is not None: - sys.settrace(self._previous) - self._handler = self._previous = None - if self.threading_support is None or self.threading_support: - threading.settrace(self._threading_previous) - self._threading_previous = None + if self.profiling_mode: + sys.setprofile(self._previous) + self._handler = self._previous = None + if self.threading_support is None or self.threading_support: + threading.setprofile(self._threading_previous) + self._threading_previous = None + else: + sys.settrace(self._previous) + self._handler = self._previous = None + if self.threading_support is None or self.threading_support: + threading.settrace(self._threading_previous) + self._threading_previous = None def __enter__(self): """ diff --git a/src/hunter/util.py b/src/hunter/util.py index 3372e763..e25d0d58 100644 --- a/src/hunter/util.py +++ b/src/hunter/util.py @@ -1,49 +1,32 @@ import ast +import builtins import re -import sys import types import weakref from collections import Counter from collections import OrderedDict from collections import defaultdict from collections import deque - -from colorama import Back -from colorama import Fore -from colorama import Style - -try: - import __builtin__ as builtins -except ImportError: - import builtins - -try: - from inspect import getattr_static -except ImportError: - from .backports.inspect import getattr_static - -try: - from threading import main_thread -except ImportError: - from threading import _shutdown - - get_main_thread = weakref.ref( - _shutdown.__self__ if hasattr(_shutdown, '__self__') else _shutdown.im_self) - del _shutdown -else: - get_main_thread = weakref.ref(main_thread()) +from datetime import date +from datetime import datetime +from datetime import time +from datetime import timedelta +from inspect import CO_VARARGS +from inspect import CO_VARKEYWORDS +from inspect import getattr_static +from re import RegexFlag +from threading import main_thread + +from .vendor.colorama import Back +from .vendor.colorama import Fore +from .vendor.colorama import Style + +InstanceType = type(object()) try: - from types import InstanceType + from re import Pattern except ImportError: - InstanceType = object() - -PY3 = sys.version_info[0] == 3 - -if PY3: - StringType = str, -else: - StringType = basestring, # noqa + Pattern = type(re.compile('')) OTHER_COLORS = { 'COLON': Style.BRIGHT + Fore.BLACK, @@ -56,7 +39,7 @@ 'INTERNAL-DETAIL': Fore.WHITE, 'SOURCE-FAILURE': Style.BRIGHT + Back.YELLOW + Fore.YELLOW, 'SOURCE-DETAIL': Fore.WHITE, - + 'BUILTIN': Style.NORMAL + Fore.MAGENTA, 'RESET': Style.RESET_ALL, } for name, group in [ @@ -65,7 +48,7 @@ ('back', Back), ]: for key in dir(group): - OTHER_COLORS['{}({})'.format(name, key) if name else key] = getattr(group, key) + OTHER_COLORS[f'{name}({key})' if name else key] = getattr(group, key) CALL_COLORS = { 'call': Style.BRIGHT + Fore.BLUE, 'line': Fore.RESET, @@ -83,8 +66,37 @@ CYTHON_SUFFIX_RE = re.compile(r'([.].+)?[.](so|pyd)$', re.IGNORECASE) LEADING_WHITESPACE_RE = re.compile('(^[ \t]*)(?:[^ \t\n])', re.MULTILINE) +get_main_thread = weakref.ref(main_thread()) + + +def get_arguments(code): + co_varnames = code.co_varnames + co_argcount = code.co_argcount + co_kwonlyargcount = code.co_kwonlyargcount + kwonlyargs = co_varnames[co_argcount : co_argcount + co_kwonlyargcount] + for arg in co_varnames[:co_argcount]: + yield '', arg, arg + co_argcount += co_kwonlyargcount + if code.co_flags & CO_VARARGS: + arg = co_varnames[co_argcount] + yield '*', arg, arg + co_argcount = co_argcount + 1 + for arg in kwonlyargs: + yield '', arg, arg + if code.co_flags & CO_VARKEYWORDS: + arg = co_varnames[co_argcount] + yield '**', arg, arg + + +def flatten(something): + if isinstance(something, (list, tuple)): + for element in something: + yield from flatten(element) + else: + yield something + -class cached_property(object): +class cached_property: def __init__(self, func): self.func = func self.__doc__ = func.__doc__ @@ -145,43 +157,75 @@ def safe_repr(obj, maxdepth=5): newdepth = maxdepth - 1 # only represent exact builtins - # (subclasses can have side-effects due to __class__ as a property, __instancecheck__, __subclasscheck__ etc) + # (subclasses can have side effects due to __class__ as a property, __instancecheck__, __subclasscheck__ etc.) if obj_type is dict: - return '{%s}' % ', '.join('%s: %s' % ( - safe_repr(k, maxdepth), - safe_repr(v, newdepth) - ) for k, v in obj.items()) + return f'{{{", ".join(f"{safe_repr(k, maxdepth)}: {safe_repr(v, newdepth)}" for k, v in obj.items())}}}' elif obj_type is list: - return '[%s]' % ', '.join(safe_repr(i, newdepth) for i in obj) + return f'[{", ".join(safe_repr(i, newdepth) for i in obj)}]' elif obj_type is tuple: - return '(%s%s)' % (', '.join(safe_repr(i, newdepth) for i in obj), ',' if len(obj) == 1 else '') + return f'({", ".join(safe_repr(i, newdepth) for i in obj)}{"," if len(obj) == 1 else ""})' elif obj_type is set: - return '{%s}' % ', '.join(safe_repr(i, newdepth) for i in obj) + return f'{{{", ".join(safe_repr(i, newdepth) for i in obj)}}}' elif obj_type is frozenset: - return '%s({%s})' % (obj_type.__name__, ', '.join(safe_repr(i, newdepth) for i in obj)) + return f'{obj_type.__name__}({{{", ".join(safe_repr(i, newdepth) for i in obj)}}})' elif obj_type is deque: - return '%s([%s])' % (obj_type.__name__, ', '.join(safe_repr(i, newdepth) for i in obj)) + return f'{obj_type.__name__}([{", ".join(safe_repr(i, newdepth) for i in obj)}])' elif obj_type in (Counter, OrderedDict, defaultdict): - return '%s({%s})' % ( - obj_type.__name__, - ', '.join('%s: %s' % ( - safe_repr(k, maxdepth), - safe_repr(v, newdepth) - ) for k, v in obj.items()) + return f'{obj_type.__name__}({{{", ".join(f"{safe_repr(k, maxdepth)}: {safe_repr(v, newdepth)}" for k, v in obj.items())}}})' + elif obj_type is Pattern: + if obj.flags: + return f're.compile({safe_repr(obj.pattern)}, flags={RegexFlag(obj.flags)})' + else: + return f're.compile({safe_repr(obj.pattern)})' + elif obj_type in (date, timedelta): + return repr(obj) + elif obj_type is datetime: + return ( + f'{obj_type.__name__}(' + f'{obj.year:d}, ' + f'{obj.month:d}, ' + f'{obj.day:d}, ' + f'{obj.hour:d}, ' + f'{obj.minute:d}, ' + f'{obj.second:d}, ' + f'{obj.microsecond:d}, ' + f'tzinfo={safe_repr(obj.tzinfo)}{f", fold={safe_repr(obj.fold)}" if hasattr(obj, "fold") else ""})' ) - elif obj_type is types.MethodType: # noqa + elif obj_type is time: + return ( + f'{obj_type.__name__}(' + f'{obj.hour:d}, ' + f'{obj.minute:d}, ' + f'{obj.second:d}, ' + f'{obj.microsecond:d}, ' + f'tzinfo={safe_repr(obj.tzinfo)}{f", fold={safe_repr(obj.fold)}" if hasattr(obj, "fold") else ""})' + ) + elif obj_type is types.MethodType: self = obj.__self__ name = getattr(obj, '__qualname__', None) if name is None: name = obj.__name__ - return '<%sbound method %s of %s>' % ('un' if self is None else '', name, safe_repr(self, newdepth)) + return f'<{"un" if self is None else ""}bound method {name} of {safe_repr(self, newdepth)}>' elif obj_type_type is type and BaseException in obj_type.__mro__: - return '%s(%s)' % (obj_type.__name__, ', '.join(safe_repr(i, newdepth) for i in obj.args)) - elif obj_type_type is type and obj_type is not InstanceType and obj_type.__module__ in (builtins.__name__, 'io', 'socket', '_socket'): + return f'{obj_type.__name__}({", ".join(safe_repr(i, newdepth) for i in obj.args)})' + elif ( + obj_type_type is type + and obj_type is not InstanceType + and obj_type.__module__ in (builtins.__name__, 'io', 'socket', '_socket', 'zoneinfo', 'decimal') + ): # hardcoded list of safe things. note that isinstance ain't used # (we don't trust subclasses to do the right thing in __repr__) return repr(obj) else: # if the object has a __dict__ then it's probably an instance of a pure python class, assume bad things - # with side-effects will be going on in __repr__ - use the default instead (object.__repr__) + # with side effects will be going on in __repr__ - use the default instead (object.__repr__) return object.__repr__(obj) + + +def frame_iterator(frame): + """ + Yields frames till there are no more. + """ + while frame: + yield frame + frame = frame.f_back diff --git a/src/hunter/backports/__init__.py b/src/hunter/vendor/__init__.py similarity index 100% rename from src/hunter/backports/__init__.py rename to src/hunter/vendor/__init__.py diff --git a/src/hunter/vendor/_compat.h b/src/hunter/vendor/_compat.h new file mode 100644 index 00000000..3320f68e --- /dev/null +++ b/src/hunter/vendor/_compat.h @@ -0,0 +1,2283 @@ +// Header file providing new C API functions to old Python versions. +// +// File distributed under the Zero Clause BSD (0BSD) license. +// Copyright Contributors to the pythoncapi_compat project. +// +// Homepage: +// https://github.com/python/pythoncapi_compat +// +// Latest version: +// https://raw.githubusercontent.com/python/pythoncapi-compat/main/pythoncapi_compat.h +// +// SPDX-License-Identifier: 0BSD + +#ifndef PYTHONCAPI_COMPAT +#define PYTHONCAPI_COMPAT + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include // offsetof() + +// Python 3.11.0b4 added PyFrame_Back() to Python.h +#if PY_VERSION_HEX < 0x030b00B4 && !defined(PYPY_VERSION) +# include "frameobject.h" // PyFrameObject, PyFrame_GetBack() +#endif +#if PY_VERSION_HEX < 0x030C00A3 +# include // T_SHORT, READONLY +#endif + + +#ifndef _Py_CAST +# define _Py_CAST(type, expr) ((type)(expr)) +#endif + +// Static inline functions should use _Py_NULL rather than using directly NULL +// to prevent C++ compiler warnings. On C23 and newer and on C++11 and newer, +// _Py_NULL is defined as nullptr. +#ifndef _Py_NULL +# if (defined (__STDC_VERSION__) && __STDC_VERSION__ > 201710L) \ + || (defined(__cplusplus) && __cplusplus >= 201103) +# define _Py_NULL nullptr +# else +# define _Py_NULL NULL +# endif +#endif + +// Cast argument to PyObject* type. +#ifndef _PyObject_CAST +# define _PyObject_CAST(op) _Py_CAST(PyObject*, op) +#endif + +#ifndef Py_BUILD_ASSERT +# define Py_BUILD_ASSERT(cond) \ + do { \ + (void)sizeof(char [1 - 2 * !(cond)]); \ + } while(0) +#endif + + +// bpo-42262 added Py_NewRef() to Python 3.10.0a3 +#if PY_VERSION_HEX < 0x030A00A3 && !defined(Py_NewRef) +static inline PyObject* _Py_NewRef(PyObject *obj) +{ + Py_INCREF(obj); + return obj; +} +#define Py_NewRef(obj) _Py_NewRef(_PyObject_CAST(obj)) +#endif + + +// bpo-42262 added Py_XNewRef() to Python 3.10.0a3 +#if PY_VERSION_HEX < 0x030A00A3 && !defined(Py_XNewRef) +static inline PyObject* _Py_XNewRef(PyObject *obj) +{ + Py_XINCREF(obj); + return obj; +} +#define Py_XNewRef(obj) _Py_XNewRef(_PyObject_CAST(obj)) +#endif + + +// bpo-39573 added Py_SET_REFCNT() to Python 3.9.0a4 +#if PY_VERSION_HEX < 0x030900A4 && !defined(Py_SET_REFCNT) +static inline void _Py_SET_REFCNT(PyObject *ob, Py_ssize_t refcnt) +{ + ob->ob_refcnt = refcnt; +} +#define Py_SET_REFCNT(ob, refcnt) _Py_SET_REFCNT(_PyObject_CAST(ob), refcnt) +#endif + + +// Py_SETREF() and Py_XSETREF() were added to Python 3.5.2. +// It is excluded from the limited C API. +#if (PY_VERSION_HEX < 0x03050200 && !defined(Py_SETREF)) && !defined(Py_LIMITED_API) +#define Py_SETREF(dst, src) \ + do { \ + PyObject **_tmp_dst_ptr = _Py_CAST(PyObject**, &(dst)); \ + PyObject *_tmp_dst = (*_tmp_dst_ptr); \ + *_tmp_dst_ptr = _PyObject_CAST(src); \ + Py_DECREF(_tmp_dst); \ + } while (0) + +#define Py_XSETREF(dst, src) \ + do { \ + PyObject **_tmp_dst_ptr = _Py_CAST(PyObject**, &(dst)); \ + PyObject *_tmp_dst = (*_tmp_dst_ptr); \ + *_tmp_dst_ptr = _PyObject_CAST(src); \ + Py_XDECREF(_tmp_dst); \ + } while (0) +#endif + + +// bpo-43753 added Py_Is(), Py_IsNone(), Py_IsTrue() and Py_IsFalse() +// to Python 3.10.0b1. +#if PY_VERSION_HEX < 0x030A00B1 && !defined(Py_Is) +# define Py_Is(x, y) ((x) == (y)) +#endif +#if PY_VERSION_HEX < 0x030A00B1 && !defined(Py_IsNone) +# define Py_IsNone(x) Py_Is(x, Py_None) +#endif +#if (PY_VERSION_HEX < 0x030A00B1 || defined(PYPY_VERSION)) && !defined(Py_IsTrue) +# define Py_IsTrue(x) Py_Is(x, Py_True) +#endif +#if (PY_VERSION_HEX < 0x030A00B1 || defined(PYPY_VERSION)) && !defined(Py_IsFalse) +# define Py_IsFalse(x) Py_Is(x, Py_False) +#endif + + +// bpo-39573 added Py_SET_TYPE() to Python 3.9.0a4 +#if PY_VERSION_HEX < 0x030900A4 && !defined(Py_SET_TYPE) +static inline void _Py_SET_TYPE(PyObject *ob, PyTypeObject *type) +{ + ob->ob_type = type; +} +#define Py_SET_TYPE(ob, type) _Py_SET_TYPE(_PyObject_CAST(ob), type) +#endif + + +// bpo-39573 added Py_SET_SIZE() to Python 3.9.0a4 +#if PY_VERSION_HEX < 0x030900A4 && !defined(Py_SET_SIZE) +static inline void _Py_SET_SIZE(PyVarObject *ob, Py_ssize_t size) +{ + ob->ob_size = size; +} +#define Py_SET_SIZE(ob, size) _Py_SET_SIZE((PyVarObject*)(ob), size) +#endif + + +// bpo-40421 added PyFrame_GetCode() to Python 3.9.0b1 +#if PY_VERSION_HEX < 0x030900B1 || defined(PYPY_VERSION) +static inline PyCodeObject* PyFrame_GetCode(PyFrameObject *frame) +{ + assert(frame != _Py_NULL); + assert(frame->f_code != _Py_NULL); + return _Py_CAST(PyCodeObject*, Py_NewRef(frame->f_code)); +} +#endif + +static inline PyCodeObject* _PyFrame_GetCodeBorrow(PyFrameObject *frame) +{ + PyCodeObject *code = PyFrame_GetCode(frame); + Py_DECREF(code); + return code; +} + + +// bpo-40421 added PyFrame_GetBack() to Python 3.9.0b1 +#if PY_VERSION_HEX < 0x030900B1 && !defined(PYPY_VERSION) +static inline PyFrameObject* PyFrame_GetBack(PyFrameObject *frame) +{ + assert(frame != _Py_NULL); + return _Py_CAST(PyFrameObject*, Py_XNewRef(frame->f_back)); +} +#endif + +#if !defined(PYPY_VERSION) +static inline PyFrameObject* _PyFrame_GetBackBorrow(PyFrameObject *frame) +{ + PyFrameObject *back = PyFrame_GetBack(frame); + Py_XDECREF(back); + return back; +} +#endif + + +// bpo-40421 added PyFrame_GetLocals() to Python 3.11.0a7 +#if PY_VERSION_HEX < 0x030B00A7 && !defined(PYPY_VERSION) +static inline PyObject* PyFrame_GetLocals(PyFrameObject *frame) +{ +#if PY_VERSION_HEX >= 0x030400B1 + if (PyFrame_FastToLocalsWithError(frame) < 0) { + return NULL; + } +#else + PyFrame_FastToLocals(frame); +#endif + return Py_NewRef(frame->f_locals); +} +#endif + + +// bpo-40421 added PyFrame_GetGlobals() to Python 3.11.0a7 +#if PY_VERSION_HEX < 0x030B00A7 && !defined(PYPY_VERSION) +static inline PyObject* PyFrame_GetGlobals(PyFrameObject *frame) +{ + return Py_NewRef(frame->f_globals); +} +#endif + + +// bpo-40421 added PyFrame_GetBuiltins() to Python 3.11.0a7 +#if PY_VERSION_HEX < 0x030B00A7 && !defined(PYPY_VERSION) +static inline PyObject* PyFrame_GetBuiltins(PyFrameObject *frame) +{ + return Py_NewRef(frame->f_builtins); +} +#endif + + +// bpo-40421 added PyFrame_GetLasti() to Python 3.11.0b1 +#if PY_VERSION_HEX < 0x030B00B1 && !defined(PYPY_VERSION) +static inline int PyFrame_GetLasti(PyFrameObject *frame) +{ +#if PY_VERSION_HEX >= 0x030A00A7 + // bpo-27129: Since Python 3.10.0a7, f_lasti is an instruction offset, + // not a bytes offset anymore. Python uses 16-bit "wordcode" (2 bytes) + // instructions. + if (frame->f_lasti < 0) { + return -1; + } + return frame->f_lasti * 2; +#else + return frame->f_lasti; +#endif +} +#endif + + +// gh-91248 added PyFrame_GetVar() to Python 3.12.0a2 +#if PY_VERSION_HEX < 0x030C00A2 && !defined(PYPY_VERSION) +static inline PyObject* PyFrame_GetVar(PyFrameObject *frame, PyObject *name) +{ + PyObject *locals, *value; + + locals = PyFrame_GetLocals(frame); + if (locals == NULL) { + return NULL; + } +#if PY_VERSION_HEX >= 0x03000000 + value = PyDict_GetItemWithError(locals, name); +#else + value = _PyDict_GetItemWithError(locals, name); +#endif + Py_DECREF(locals); + + if (value == NULL) { + if (PyErr_Occurred()) { + return NULL; + } +#if PY_VERSION_HEX >= 0x03000000 + PyErr_Format(PyExc_NameError, "variable %R does not exist", name); +#else + PyErr_SetString(PyExc_NameError, "variable does not exist"); +#endif + return NULL; + } + return Py_NewRef(value); +} +#endif + + +// gh-91248 added PyFrame_GetVarString() to Python 3.12.0a2 +#if PY_VERSION_HEX < 0x030C00A2 && !defined(PYPY_VERSION) +static inline PyObject* +PyFrame_GetVarString(PyFrameObject *frame, const char *name) +{ + PyObject *name_obj, *value; +#if PY_VERSION_HEX >= 0x03000000 + name_obj = PyUnicode_FromString(name); +#else + name_obj = PyString_FromString(name); +#endif + if (name_obj == NULL) { + return NULL; + } + value = PyFrame_GetVar(frame, name_obj); + Py_DECREF(name_obj); + return value; +} +#endif + + +// bpo-39947 added PyThreadState_GetInterpreter() to Python 3.9.0a5 +#if PY_VERSION_HEX < 0x030900A5 || (defined(PYPY_VERSION) && PY_VERSION_HEX < 0x030B0000) +static inline PyInterpreterState * +PyThreadState_GetInterpreter(PyThreadState *tstate) +{ + assert(tstate != _Py_NULL); + return tstate->interp; +} +#endif + + +// bpo-40429 added PyThreadState_GetFrame() to Python 3.9.0b1 +#if PY_VERSION_HEX < 0x030900B1 && !defined(PYPY_VERSION) +static inline PyFrameObject* PyThreadState_GetFrame(PyThreadState *tstate) +{ + assert(tstate != _Py_NULL); + return _Py_CAST(PyFrameObject *, Py_XNewRef(tstate->frame)); +} +#endif + +#if !defined(PYPY_VERSION) +static inline PyFrameObject* +_PyThreadState_GetFrameBorrow(PyThreadState *tstate) +{ + PyFrameObject *frame = PyThreadState_GetFrame(tstate); + Py_XDECREF(frame); + return frame; +} +#endif + + +// bpo-39947 added PyInterpreterState_Get() to Python 3.9.0a5 +#if PY_VERSION_HEX < 0x030900A5 || defined(PYPY_VERSION) +static inline PyInterpreterState* PyInterpreterState_Get(void) +{ + PyThreadState *tstate; + PyInterpreterState *interp; + + tstate = PyThreadState_GET(); + if (tstate == _Py_NULL) { + Py_FatalError("GIL released (tstate is NULL)"); + } + interp = tstate->interp; + if (interp == _Py_NULL) { + Py_FatalError("no current interpreter"); + } + return interp; +} +#endif + + +// bpo-39947 added PyInterpreterState_Get() to Python 3.9.0a6 +#if 0x030700A1 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x030900A6 && !defined(PYPY_VERSION) +static inline uint64_t PyThreadState_GetID(PyThreadState *tstate) +{ + assert(tstate != _Py_NULL); + return tstate->id; +} +#endif + +// bpo-43760 added PyThreadState_EnterTracing() to Python 3.11.0a2 +#if PY_VERSION_HEX < 0x030B00A2 && !defined(PYPY_VERSION) +static inline void PyThreadState_EnterTracing(PyThreadState *tstate) +{ + tstate->tracing++; +#if PY_VERSION_HEX >= 0x030A00A1 + tstate->cframe->use_tracing = 0; +#else + tstate->use_tracing = 0; +#endif +} +#endif + +// bpo-43760 added PyThreadState_LeaveTracing() to Python 3.11.0a2 +#if PY_VERSION_HEX < 0x030B00A2 && !defined(PYPY_VERSION) +static inline void PyThreadState_LeaveTracing(PyThreadState *tstate) +{ + int use_tracing = (tstate->c_tracefunc != _Py_NULL + || tstate->c_profilefunc != _Py_NULL); + tstate->tracing--; +#if PY_VERSION_HEX >= 0x030A00A1 + tstate->cframe->use_tracing = use_tracing; +#else + tstate->use_tracing = use_tracing; +#endif +} +#endif + + +// bpo-37194 added PyObject_CallNoArgs() to Python 3.9.0a1 +// PyObject_CallNoArgs() added to PyPy 3.9.16-v7.3.11 +#if !defined(PyObject_CallNoArgs) && PY_VERSION_HEX < 0x030900A1 +static inline PyObject* PyObject_CallNoArgs(PyObject *func) +{ + return PyObject_CallFunctionObjArgs(func, NULL); +} +#endif + + +// bpo-39245 made PyObject_CallOneArg() public (previously called +// _PyObject_CallOneArg) in Python 3.9.0a4 +// PyObject_CallOneArg() added to PyPy 3.9.16-v7.3.11 +#if !defined(PyObject_CallOneArg) && PY_VERSION_HEX < 0x030900A4 +static inline PyObject* PyObject_CallOneArg(PyObject *func, PyObject *arg) +{ + return PyObject_CallFunctionObjArgs(func, arg, NULL); +} +#endif + + +// bpo-1635741 added PyModule_AddObjectRef() to Python 3.10.0a3 +#if PY_VERSION_HEX < 0x030A00A3 +static inline int +PyModule_AddObjectRef(PyObject *module, const char *name, PyObject *value) +{ + int res; + + if (!value && !PyErr_Occurred()) { + // PyModule_AddObject() raises TypeError in this case + PyErr_SetString(PyExc_SystemError, + "PyModule_AddObjectRef() must be called " + "with an exception raised if value is NULL"); + return -1; + } + + Py_XINCREF(value); + res = PyModule_AddObject(module, name, value); + if (res < 0) { + Py_XDECREF(value); + } + return res; +} +#endif + + +// bpo-40024 added PyModule_AddType() to Python 3.9.0a5 +#if PY_VERSION_HEX < 0x030900A5 +static inline int PyModule_AddType(PyObject *module, PyTypeObject *type) +{ + const char *name, *dot; + + if (PyType_Ready(type) < 0) { + return -1; + } + + // inline _PyType_Name() + name = type->tp_name; + assert(name != _Py_NULL); + dot = strrchr(name, '.'); + if (dot != _Py_NULL) { + name = dot + 1; + } + + return PyModule_AddObjectRef(module, name, _PyObject_CAST(type)); +} +#endif + + +// bpo-40241 added PyObject_GC_IsTracked() to Python 3.9.0a6. +// bpo-4688 added _PyObject_GC_IS_TRACKED() to Python 2.7.0a2. +#if PY_VERSION_HEX < 0x030900A6 && !defined(PYPY_VERSION) +static inline int PyObject_GC_IsTracked(PyObject* obj) +{ + return (PyObject_IS_GC(obj) && _PyObject_GC_IS_TRACKED(obj)); +} +#endif + +// bpo-40241 added PyObject_GC_IsFinalized() to Python 3.9.0a6. +// bpo-18112 added _PyGCHead_FINALIZED() to Python 3.4.0 final. +#if PY_VERSION_HEX < 0x030900A6 && PY_VERSION_HEX >= 0x030400F0 && !defined(PYPY_VERSION) +static inline int PyObject_GC_IsFinalized(PyObject *obj) +{ + PyGC_Head *gc = _Py_CAST(PyGC_Head*, obj) - 1; + return (PyObject_IS_GC(obj) && _PyGCHead_FINALIZED(gc)); +} +#endif + + +// bpo-39573 added Py_IS_TYPE() to Python 3.9.0a4 +#if PY_VERSION_HEX < 0x030900A4 && !defined(Py_IS_TYPE) +static inline int _Py_IS_TYPE(PyObject *ob, PyTypeObject *type) { + return Py_TYPE(ob) == type; +} +#define Py_IS_TYPE(ob, type) _Py_IS_TYPE(_PyObject_CAST(ob), type) +#endif + + +// bpo-46906 added PyFloat_Pack2() and PyFloat_Unpack2() to Python 3.11a7. +// bpo-11734 added _PyFloat_Pack2() and _PyFloat_Unpack2() to Python 3.6.0b1. +// Python 3.11a2 moved _PyFloat_Pack2() and _PyFloat_Unpack2() to the internal +// C API: Python 3.11a2-3.11a6 versions are not supported. +#if 0x030600B1 <= PY_VERSION_HEX && PY_VERSION_HEX <= 0x030B00A1 && !defined(PYPY_VERSION) +static inline int PyFloat_Pack2(double x, char *p, int le) +{ return _PyFloat_Pack2(x, (unsigned char*)p, le); } + +static inline double PyFloat_Unpack2(const char *p, int le) +{ return _PyFloat_Unpack2((const unsigned char *)p, le); } +#endif + + +// bpo-46906 added PyFloat_Pack4(), PyFloat_Pack8(), PyFloat_Unpack4() and +// PyFloat_Unpack8() to Python 3.11a7. +// Python 3.11a2 moved _PyFloat_Pack4(), _PyFloat_Pack8(), _PyFloat_Unpack4() +// and _PyFloat_Unpack8() to the internal C API: Python 3.11a2-3.11a6 versions +// are not supported. +#if PY_VERSION_HEX <= 0x030B00A1 && !defined(PYPY_VERSION) +static inline int PyFloat_Pack4(double x, char *p, int le) +{ return _PyFloat_Pack4(x, (unsigned char*)p, le); } + +static inline int PyFloat_Pack8(double x, char *p, int le) +{ return _PyFloat_Pack8(x, (unsigned char*)p, le); } + +static inline double PyFloat_Unpack4(const char *p, int le) +{ return _PyFloat_Unpack4((const unsigned char *)p, le); } + +static inline double PyFloat_Unpack8(const char *p, int le) +{ return _PyFloat_Unpack8((const unsigned char *)p, le); } +#endif + + +// gh-92154 added PyCode_GetCode() to Python 3.11.0b1 +#if PY_VERSION_HEX < 0x030B00B1 && !defined(PYPY_VERSION) +static inline PyObject* PyCode_GetCode(PyCodeObject *code) +{ + return Py_NewRef(code->co_code); +} +#endif + + +// gh-95008 added PyCode_GetVarnames() to Python 3.11.0rc1 +#if PY_VERSION_HEX < 0x030B00C1 && !defined(PYPY_VERSION) +static inline PyObject* PyCode_GetVarnames(PyCodeObject *code) +{ + return Py_NewRef(code->co_varnames); +} +#endif + +// gh-95008 added PyCode_GetFreevars() to Python 3.11.0rc1 +#if PY_VERSION_HEX < 0x030B00C1 && !defined(PYPY_VERSION) +static inline PyObject* PyCode_GetFreevars(PyCodeObject *code) +{ + return Py_NewRef(code->co_freevars); +} +#endif + +// gh-95008 added PyCode_GetCellvars() to Python 3.11.0rc1 +#if PY_VERSION_HEX < 0x030B00C1 && !defined(PYPY_VERSION) +static inline PyObject* PyCode_GetCellvars(PyCodeObject *code) +{ + return Py_NewRef(code->co_cellvars); +} +#endif + + +// Py_UNUSED() was added to Python 3.4.0b2. +#if PY_VERSION_HEX < 0x030400B2 && !defined(Py_UNUSED) +# if defined(__GNUC__) || defined(__clang__) +# define Py_UNUSED(name) _unused_ ## name __attribute__((unused)) +# else +# define Py_UNUSED(name) _unused_ ## name +# endif +#endif + + +// gh-105922 added PyImport_AddModuleRef() to Python 3.13.0a1 +#if PY_VERSION_HEX < 0x030D00A0 +static inline PyObject* PyImport_AddModuleRef(const char *name) +{ + return Py_XNewRef(PyImport_AddModule(name)); +} +#endif + + +// gh-105927 added PyWeakref_GetRef() to Python 3.13.0a1 +#if PY_VERSION_HEX < 0x030D0000 +static inline int PyWeakref_GetRef(PyObject *ref, PyObject **pobj) +{ + PyObject *obj; + if (ref != NULL && !PyWeakref_Check(ref)) { + *pobj = NULL; + PyErr_SetString(PyExc_TypeError, "expected a weakref"); + return -1; + } + obj = PyWeakref_GetObject(ref); + if (obj == NULL) { + // SystemError if ref is NULL + *pobj = NULL; + return -1; + } + if (obj == Py_None) { + *pobj = NULL; + return 0; + } + *pobj = Py_NewRef(obj); + return 1; +} +#endif + + +// bpo-36974 added PY_VECTORCALL_ARGUMENTS_OFFSET to Python 3.8b1 +#ifndef PY_VECTORCALL_ARGUMENTS_OFFSET +# define PY_VECTORCALL_ARGUMENTS_OFFSET (_Py_CAST(size_t, 1) << (8 * sizeof(size_t) - 1)) +#endif + +// bpo-36974 added PyVectorcall_NARGS() to Python 3.8b1 +#if PY_VERSION_HEX < 0x030800B1 +static inline Py_ssize_t PyVectorcall_NARGS(size_t n) +{ + return n & ~PY_VECTORCALL_ARGUMENTS_OFFSET; +} +#endif + + +// gh-105922 added PyObject_Vectorcall() to Python 3.9.0a4 +#if PY_VERSION_HEX < 0x030900A4 +static inline PyObject* +PyObject_Vectorcall(PyObject *callable, PyObject *const *args, + size_t nargsf, PyObject *kwnames) +{ +#if PY_VERSION_HEX >= 0x030800B1 && !defined(PYPY_VERSION) + // bpo-36974 added _PyObject_Vectorcall() to Python 3.8.0b1 + return _PyObject_Vectorcall(callable, args, nargsf, kwnames); +#else + PyObject *posargs = NULL, *kwargs = NULL; + PyObject *res; + Py_ssize_t nposargs, nkwargs, i; + + if (nargsf != 0 && args == NULL) { + PyErr_BadInternalCall(); + goto error; + } + if (kwnames != NULL && !PyTuple_Check(kwnames)) { + PyErr_BadInternalCall(); + goto error; + } + + nposargs = (Py_ssize_t)PyVectorcall_NARGS(nargsf); + if (kwnames) { + nkwargs = PyTuple_GET_SIZE(kwnames); + } + else { + nkwargs = 0; + } + + posargs = PyTuple_New(nposargs); + if (posargs == NULL) { + goto error; + } + if (nposargs) { + for (i=0; i < nposargs; i++) { + PyTuple_SET_ITEM(posargs, i, Py_NewRef(*args)); + args++; + } + } + + if (nkwargs) { + kwargs = PyDict_New(); + if (kwargs == NULL) { + goto error; + } + + for (i = 0; i < nkwargs; i++) { + PyObject *key = PyTuple_GET_ITEM(kwnames, i); + PyObject *value = *args; + args++; + if (PyDict_SetItem(kwargs, key, value) < 0) { + goto error; + } + } + } + else { + kwargs = NULL; + } + + res = PyObject_Call(callable, posargs, kwargs); + Py_DECREF(posargs); + Py_XDECREF(kwargs); + return res; + +error: + Py_DECREF(posargs); + Py_XDECREF(kwargs); + return NULL; +#endif +} +#endif + + +// gh-106521 added PyObject_GetOptionalAttr() and +// PyObject_GetOptionalAttrString() to Python 3.13.0a1 +#if PY_VERSION_HEX < 0x030D00A1 +static inline int +PyObject_GetOptionalAttr(PyObject *obj, PyObject *attr_name, PyObject **result) +{ + // bpo-32571 added _PyObject_LookupAttr() to Python 3.7.0b1 +#if PY_VERSION_HEX >= 0x030700B1 && !defined(PYPY_VERSION) + return _PyObject_LookupAttr(obj, attr_name, result); +#else + *result = PyObject_GetAttr(obj, attr_name); + if (*result != NULL) { + return 1; + } + if (!PyErr_Occurred()) { + return 0; + } + if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + return 0; + } + return -1; +#endif +} + +static inline int +PyObject_GetOptionalAttrString(PyObject *obj, const char *attr_name, PyObject **result) +{ + PyObject *name_obj; + int rc; +#if PY_VERSION_HEX >= 0x03000000 + name_obj = PyUnicode_FromString(attr_name); +#else + name_obj = PyString_FromString(attr_name); +#endif + if (name_obj == NULL) { + *result = NULL; + return -1; + } + rc = PyObject_GetOptionalAttr(obj, name_obj, result); + Py_DECREF(name_obj); + return rc; +} +#endif + + +// gh-106307 added PyObject_GetOptionalAttr() and +// PyMapping_GetOptionalItemString() to Python 3.13.0a1 +#if PY_VERSION_HEX < 0x030D00A1 +static inline int +PyMapping_GetOptionalItem(PyObject *obj, PyObject *key, PyObject **result) +{ + *result = PyObject_GetItem(obj, key); + if (*result) { + return 1; + } + if (!PyErr_ExceptionMatches(PyExc_KeyError)) { + return -1; + } + PyErr_Clear(); + return 0; +} + +static inline int +PyMapping_GetOptionalItemString(PyObject *obj, const char *key, PyObject **result) +{ + PyObject *key_obj; + int rc; +#if PY_VERSION_HEX >= 0x03000000 + key_obj = PyUnicode_FromString(key); +#else + key_obj = PyString_FromString(key); +#endif + if (key_obj == NULL) { + *result = NULL; + return -1; + } + rc = PyMapping_GetOptionalItem(obj, key_obj, result); + Py_DECREF(key_obj); + return rc; +} +#endif + +// gh-108511 added PyMapping_HasKeyWithError() and +// PyMapping_HasKeyStringWithError() to Python 3.13.0a1 +#if PY_VERSION_HEX < 0x030D00A1 +static inline int +PyMapping_HasKeyWithError(PyObject *obj, PyObject *key) +{ + PyObject *res; + int rc = PyMapping_GetOptionalItem(obj, key, &res); + Py_XDECREF(res); + return rc; +} + +static inline int +PyMapping_HasKeyStringWithError(PyObject *obj, const char *key) +{ + PyObject *res; + int rc = PyMapping_GetOptionalItemString(obj, key, &res); + Py_XDECREF(res); + return rc; +} +#endif + + +// gh-108511 added PyObject_HasAttrWithError() and +// PyObject_HasAttrStringWithError() to Python 3.13.0a1 +#if PY_VERSION_HEX < 0x030D00A1 +static inline int +PyObject_HasAttrWithError(PyObject *obj, PyObject *attr) +{ + PyObject *res; + int rc = PyObject_GetOptionalAttr(obj, attr, &res); + Py_XDECREF(res); + return rc; +} + +static inline int +PyObject_HasAttrStringWithError(PyObject *obj, const char *attr) +{ + PyObject *res; + int rc = PyObject_GetOptionalAttrString(obj, attr, &res); + Py_XDECREF(res); + return rc; +} +#endif + + +// gh-106004 added PyDict_GetItemRef() and PyDict_GetItemStringRef() +// to Python 3.13.0a1 +#if PY_VERSION_HEX < 0x030D00A1 +static inline int +PyDict_GetItemRef(PyObject *mp, PyObject *key, PyObject **result) +{ +#if PY_VERSION_HEX >= 0x03000000 + PyObject *item = PyDict_GetItemWithError(mp, key); +#else + PyObject *item = _PyDict_GetItemWithError(mp, key); +#endif + if (item != NULL) { + *result = Py_NewRef(item); + return 1; // found + } + if (!PyErr_Occurred()) { + *result = NULL; + return 0; // not found + } + *result = NULL; + return -1; +} + +static inline int +PyDict_GetItemStringRef(PyObject *mp, const char *key, PyObject **result) +{ + int res; +#if PY_VERSION_HEX >= 0x03000000 + PyObject *key_obj = PyUnicode_FromString(key); +#else + PyObject *key_obj = PyString_FromString(key); +#endif + if (key_obj == NULL) { + *result = NULL; + return -1; + } + res = PyDict_GetItemRef(mp, key_obj, result); + Py_DECREF(key_obj); + return res; +} +#endif + + +// gh-106307 added PyModule_Add() to Python 3.13.0a1 +#if PY_VERSION_HEX < 0x030D00A1 +static inline int +PyModule_Add(PyObject *mod, const char *name, PyObject *value) +{ + int res = PyModule_AddObjectRef(mod, name, value); + Py_XDECREF(value); + return res; +} +#endif + + +// gh-108014 added Py_IsFinalizing() to Python 3.13.0a1 +// bpo-1856 added _Py_Finalizing to Python 3.2.1b1. +// _Py_IsFinalizing() was added to PyPy 7.3.0. +#if (0x030201B1 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x030D00A1) \ + && (!defined(PYPY_VERSION_NUM) || PYPY_VERSION_NUM >= 0x7030000) +static inline int Py_IsFinalizing(void) +{ +#if PY_VERSION_HEX >= 0x030700A1 + // _Py_IsFinalizing() was added to Python 3.7.0a1. + return _Py_IsFinalizing(); +#else + return (_Py_Finalizing != NULL); +#endif +} +#endif + + +// gh-108323 added PyDict_ContainsString() to Python 3.13.0a1 +#if PY_VERSION_HEX < 0x030D00A1 +static inline int PyDict_ContainsString(PyObject *op, const char *key) +{ + PyObject *key_obj = PyUnicode_FromString(key); + if (key_obj == NULL) { + return -1; + } + int res = PyDict_Contains(op, key_obj); + Py_DECREF(key_obj); + return res; +} +#endif + + +// gh-108445 added PyLong_AsInt() to Python 3.13.0a1 +#if PY_VERSION_HEX < 0x030D00A1 +static inline int PyLong_AsInt(PyObject *obj) +{ +#ifdef PYPY_VERSION + long value = PyLong_AsLong(obj); + if (value == -1 && PyErr_Occurred()) { + return -1; + } + if (value < (long)INT_MIN || (long)INT_MAX < value) { + PyErr_SetString(PyExc_OverflowError, + "Python int too large to convert to C int"); + return -1; + } + return (int)value; +#else + return _PyLong_AsInt(obj); +#endif +} +#endif + + +// gh-107073 added PyObject_VisitManagedDict() to Python 3.13.0a1 +#if PY_VERSION_HEX < 0x030D00A1 +static inline int +PyObject_VisitManagedDict(PyObject *obj, visitproc visit, void *arg) +{ + PyObject **dict = _PyObject_GetDictPtr(obj); + if (dict == NULL || *dict == NULL) { + return -1; + } + Py_VISIT(*dict); + return 0; +} + +static inline void +PyObject_ClearManagedDict(PyObject *obj) +{ + PyObject **dict = _PyObject_GetDictPtr(obj); + if (dict == NULL || *dict == NULL) { + return; + } + Py_CLEAR(*dict); +} +#endif + +// gh-108867 added PyThreadState_GetUnchecked() to Python 3.13.0a1 +// Python 3.5.2 added _PyThreadState_UncheckedGet(). +#if PY_VERSION_HEX >= 0x03050200 && PY_VERSION_HEX < 0x030D00A1 +static inline PyThreadState* +PyThreadState_GetUnchecked(void) +{ + return _PyThreadState_UncheckedGet(); +} +#endif + +// gh-110289 added PyUnicode_EqualToUTF8() and PyUnicode_EqualToUTF8AndSize() +// to Python 3.13.0a1 +#if PY_VERSION_HEX < 0x030D00A1 +static inline int +PyUnicode_EqualToUTF8AndSize(PyObject *unicode, const char *str, Py_ssize_t str_len) +{ + Py_ssize_t len; + const void *utf8; + PyObject *exc_type, *exc_value, *exc_tb; + int res; + + // API cannot report errors so save/restore the exception + PyErr_Fetch(&exc_type, &exc_value, &exc_tb); + + // Python 3.3.0a1 added PyUnicode_AsUTF8AndSize() +#if PY_VERSION_HEX >= 0x030300A1 + if (PyUnicode_IS_ASCII(unicode)) { + utf8 = PyUnicode_DATA(unicode); + len = PyUnicode_GET_LENGTH(unicode); + } + else { + utf8 = PyUnicode_AsUTF8AndSize(unicode, &len); + if (utf8 == NULL) { + // Memory allocation failure. The API cannot report error, + // so ignore the exception and return 0. + res = 0; + goto done; + } + } + + if (len != str_len) { + res = 0; + goto done; + } + res = (memcmp(utf8, str, (size_t)len) == 0); +#else + PyObject *bytes = PyUnicode_AsUTF8String(unicode); + if (bytes == NULL) { + // Memory allocation failure. The API cannot report error, + // so ignore the exception and return 0. + res = 0; + goto done; + } + +#if PY_VERSION_HEX >= 0x03000000 + len = PyBytes_GET_SIZE(bytes); + utf8 = PyBytes_AS_STRING(bytes); +#else + len = PyString_GET_SIZE(bytes); + utf8 = PyString_AS_STRING(bytes); +#endif + if (len != str_len) { + Py_DECREF(bytes); + res = 0; + goto done; + } + + res = (memcmp(utf8, str, (size_t)len) == 0); + Py_DECREF(bytes); +#endif + +done: + PyErr_Restore(exc_type, exc_value, exc_tb); + return res; +} + +static inline int +PyUnicode_EqualToUTF8(PyObject *unicode, const char *str) +{ + return PyUnicode_EqualToUTF8AndSize(unicode, str, (Py_ssize_t)strlen(str)); +} +#endif + + +// gh-111138 added PyList_Extend() and PyList_Clear() to Python 3.13.0a2 +#if PY_VERSION_HEX < 0x030D00A2 +static inline int +PyList_Extend(PyObject *list, PyObject *iterable) +{ + return PyList_SetSlice(list, PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, iterable); +} + +static inline int +PyList_Clear(PyObject *list) +{ + return PyList_SetSlice(list, 0, PY_SSIZE_T_MAX, NULL); +} +#endif + +// gh-111262 added PyDict_Pop() and PyDict_PopString() to Python 3.13.0a2 +#if PY_VERSION_HEX < 0x030D00A2 +static inline int +PyDict_Pop(PyObject *dict, PyObject *key, PyObject **result) +{ + PyObject *value; + + if (!PyDict_Check(dict)) { + PyErr_BadInternalCall(); + if (result) { + *result = NULL; + } + return -1; + } + + // bpo-16991 added _PyDict_Pop() to Python 3.5.0b2. + // Python 3.6.0b3 changed _PyDict_Pop() first argument type to PyObject*. + // Python 3.13.0a1 removed _PyDict_Pop(). +#if defined(PYPY_VERSION) || PY_VERSION_HEX < 0x030500b2 || PY_VERSION_HEX >= 0x030D0000 + value = PyObject_CallMethod(dict, "pop", "O", key); +#elif PY_VERSION_HEX < 0x030600b3 + value = _PyDict_Pop(_Py_CAST(PyDictObject*, dict), key, NULL); +#else + value = _PyDict_Pop(dict, key, NULL); +#endif + if (value == NULL) { + if (result) { + *result = NULL; + } + if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_KeyError)) { + return -1; + } + PyErr_Clear(); + return 0; + } + if (result) { + *result = value; + } + else { + Py_DECREF(value); + } + return 1; +} + +static inline int +PyDict_PopString(PyObject *dict, const char *key, PyObject **result) +{ + PyObject *key_obj = PyUnicode_FromString(key); + if (key_obj == NULL) { + if (result != NULL) { + *result = NULL; + } + return -1; + } + + int res = PyDict_Pop(dict, key_obj, result); + Py_DECREF(key_obj); + return res; +} +#endif + + +#if PY_VERSION_HEX < 0x030200A4 +// Python 3.2.0a4 added Py_hash_t type +typedef Py_ssize_t Py_hash_t; +#endif + + +// gh-111545 added Py_HashPointer() to Python 3.13.0a3 +#if PY_VERSION_HEX < 0x030D00A3 +static inline Py_hash_t Py_HashPointer(const void *ptr) +{ +#if PY_VERSION_HEX >= 0x030900A4 && !defined(PYPY_VERSION) + return _Py_HashPointer(ptr); +#else + return _Py_HashPointer(_Py_CAST(void*, ptr)); +#endif +} +#endif + + +// Python 3.13a4 added a PyTime API. +// Use the private API added to Python 3.5. +#if PY_VERSION_HEX < 0x030D00A4 && PY_VERSION_HEX >= 0x03050000 +typedef _PyTime_t PyTime_t; +#define PyTime_MIN _PyTime_MIN +#define PyTime_MAX _PyTime_MAX + +static inline double PyTime_AsSecondsDouble(PyTime_t t) +{ return _PyTime_AsSecondsDouble(t); } + +static inline int PyTime_Monotonic(PyTime_t *result) +{ return _PyTime_GetMonotonicClockWithInfo(result, NULL); } + +static inline int PyTime_Time(PyTime_t *result) +{ return _PyTime_GetSystemClockWithInfo(result, NULL); } + +static inline int PyTime_PerfCounter(PyTime_t *result) +{ +#if PY_VERSION_HEX >= 0x03070000 && !defined(PYPY_VERSION) + return _PyTime_GetPerfCounterWithInfo(result, NULL); +#elif PY_VERSION_HEX >= 0x03070000 + // Call time.perf_counter_ns() and convert Python int object to PyTime_t. + // Cache time.perf_counter_ns() function for best performance. + static PyObject *func = NULL; + if (func == NULL) { + PyObject *mod = PyImport_ImportModule("time"); + if (mod == NULL) { + return -1; + } + + func = PyObject_GetAttrString(mod, "perf_counter_ns"); + Py_DECREF(mod); + if (func == NULL) { + return -1; + } + } + + PyObject *res = PyObject_CallNoArgs(func); + if (res == NULL) { + return -1; + } + long long value = PyLong_AsLongLong(res); + Py_DECREF(res); + + if (value == -1 && PyErr_Occurred()) { + return -1; + } + + Py_BUILD_ASSERT(sizeof(value) >= sizeof(PyTime_t)); + *result = (PyTime_t)value; + return 0; +#else + // Call time.perf_counter() and convert C double to PyTime_t. + // Cache time.perf_counter() function for best performance. + static PyObject *func = NULL; + if (func == NULL) { + PyObject *mod = PyImport_ImportModule("time"); + if (mod == NULL) { + return -1; + } + + func = PyObject_GetAttrString(mod, "perf_counter"); + Py_DECREF(mod); + if (func == NULL) { + return -1; + } + } + + PyObject *res = PyObject_CallNoArgs(func); + if (res == NULL) { + return -1; + } + double d = PyFloat_AsDouble(res); + Py_DECREF(res); + + if (d == -1.0 && PyErr_Occurred()) { + return -1; + } + + // Avoid floor() to avoid having to link to libm + *result = (PyTime_t)(d * 1e9); + return 0; +#endif +} + +#endif + +// gh-111389 added hash constants to Python 3.13.0a5. These constants were +// added first as private macros to Python 3.4.0b1 and PyPy 7.3.8. +#if (!defined(PyHASH_BITS) \ + && ((!defined(PYPY_VERSION) && PY_VERSION_HEX >= 0x030400B1) \ + || (defined(PYPY_VERSION) && PY_VERSION_HEX >= 0x03070000 \ + && PYPY_VERSION_NUM >= 0x07030800))) +# define PyHASH_BITS _PyHASH_BITS +# define PyHASH_MODULUS _PyHASH_MODULUS +# define PyHASH_INF _PyHASH_INF +# define PyHASH_IMAG _PyHASH_IMAG +#endif + + +// gh-111545 added Py_GetConstant() and Py_GetConstantBorrowed() +// to Python 3.13.0a6 +#if PY_VERSION_HEX < 0x030D00A6 && !defined(Py_CONSTANT_NONE) + +#define Py_CONSTANT_NONE 0 +#define Py_CONSTANT_FALSE 1 +#define Py_CONSTANT_TRUE 2 +#define Py_CONSTANT_ELLIPSIS 3 +#define Py_CONSTANT_NOT_IMPLEMENTED 4 +#define Py_CONSTANT_ZERO 5 +#define Py_CONSTANT_ONE 6 +#define Py_CONSTANT_EMPTY_STR 7 +#define Py_CONSTANT_EMPTY_BYTES 8 +#define Py_CONSTANT_EMPTY_TUPLE 9 + +static inline PyObject* Py_GetConstant(unsigned int constant_id) +{ + static PyObject* constants[Py_CONSTANT_EMPTY_TUPLE + 1] = {NULL}; + + if (constants[Py_CONSTANT_NONE] == NULL) { + constants[Py_CONSTANT_NONE] = Py_None; + constants[Py_CONSTANT_FALSE] = Py_False; + constants[Py_CONSTANT_TRUE] = Py_True; + constants[Py_CONSTANT_ELLIPSIS] = Py_Ellipsis; + constants[Py_CONSTANT_NOT_IMPLEMENTED] = Py_NotImplemented; + + constants[Py_CONSTANT_ZERO] = PyLong_FromLong(0); + if (constants[Py_CONSTANT_ZERO] == NULL) { + goto fatal_error; + } + + constants[Py_CONSTANT_ONE] = PyLong_FromLong(1); + if (constants[Py_CONSTANT_ONE] == NULL) { + goto fatal_error; + } + + constants[Py_CONSTANT_EMPTY_STR] = PyUnicode_FromStringAndSize("", 0); + if (constants[Py_CONSTANT_EMPTY_STR] == NULL) { + goto fatal_error; + } + + constants[Py_CONSTANT_EMPTY_BYTES] = PyBytes_FromStringAndSize("", 0); + if (constants[Py_CONSTANT_EMPTY_BYTES] == NULL) { + goto fatal_error; + } + + constants[Py_CONSTANT_EMPTY_TUPLE] = PyTuple_New(0); + if (constants[Py_CONSTANT_EMPTY_TUPLE] == NULL) { + goto fatal_error; + } + // goto dance to avoid compiler warnings about Py_FatalError() + goto init_done; + +fatal_error: + // This case should never happen + Py_FatalError("Py_GetConstant() failed to get constants"); + } + +init_done: + if (constant_id <= Py_CONSTANT_EMPTY_TUPLE) { + return Py_NewRef(constants[constant_id]); + } + else { + PyErr_BadInternalCall(); + return NULL; + } +} + +static inline PyObject* Py_GetConstantBorrowed(unsigned int constant_id) +{ + PyObject *obj = Py_GetConstant(constant_id); + Py_XDECREF(obj); + return obj; +} +#endif + + +// gh-114329 added PyList_GetItemRef() to Python 3.13.0a4 +#if PY_VERSION_HEX < 0x030D00A4 +static inline PyObject * +PyList_GetItemRef(PyObject *op, Py_ssize_t index) +{ + PyObject *item = PyList_GetItem(op, index); + Py_XINCREF(item); + return item; +} +#endif + + +// gh-114329 added PyList_GetItemRef() to Python 3.13.0a4 +#if PY_VERSION_HEX < 0x030D00A4 +static inline int +PyDict_SetDefaultRef(PyObject *d, PyObject *key, PyObject *default_value, + PyObject **result) +{ + PyObject *value; + if (PyDict_GetItemRef(d, key, &value) < 0) { + // get error + if (result) { + *result = NULL; + } + return -1; + } + if (value != NULL) { + // present + if (result) { + *result = value; + } + else { + Py_DECREF(value); + } + return 1; + } + + // missing: set the item + if (PyDict_SetItem(d, key, default_value) < 0) { + // set error + if (result) { + *result = NULL; + } + return -1; + } + if (result) { + *result = Py_NewRef(default_value); + } + return 0; +} +#endif + +#if PY_VERSION_HEX < 0x030D00B3 +# define Py_BEGIN_CRITICAL_SECTION(op) { +# define Py_END_CRITICAL_SECTION() } +# define Py_BEGIN_CRITICAL_SECTION2(a, b) { +# define Py_END_CRITICAL_SECTION2() } +#endif + +#if PY_VERSION_HEX < 0x030E0000 && PY_VERSION_HEX >= 0x03060000 && !defined(PYPY_VERSION) +typedef struct PyUnicodeWriter PyUnicodeWriter; + +static inline void PyUnicodeWriter_Discard(PyUnicodeWriter *writer) +{ + _PyUnicodeWriter_Dealloc((_PyUnicodeWriter*)writer); + PyMem_Free(writer); +} + +static inline PyUnicodeWriter* PyUnicodeWriter_Create(Py_ssize_t length) +{ + if (length < 0) { + PyErr_SetString(PyExc_ValueError, + "length must be positive"); + return NULL; + } + + const size_t size = sizeof(_PyUnicodeWriter); + PyUnicodeWriter *pub_writer = (PyUnicodeWriter *)PyMem_Malloc(size); + if (pub_writer == _Py_NULL) { + PyErr_NoMemory(); + return _Py_NULL; + } + _PyUnicodeWriter *writer = (_PyUnicodeWriter *)pub_writer; + + _PyUnicodeWriter_Init(writer); + if (_PyUnicodeWriter_Prepare(writer, length, 127) < 0) { + PyUnicodeWriter_Discard(pub_writer); + return NULL; + } + writer->overallocate = 1; + return pub_writer; +} + +static inline PyObject* PyUnicodeWriter_Finish(PyUnicodeWriter *writer) +{ + PyObject *str = _PyUnicodeWriter_Finish((_PyUnicodeWriter*)writer); + assert(((_PyUnicodeWriter*)writer)->buffer == NULL); + PyMem_Free(writer); + return str; +} + +static inline int +PyUnicodeWriter_WriteChar(PyUnicodeWriter *writer, Py_UCS4 ch) +{ + if (ch > 0x10ffff) { + PyErr_SetString(PyExc_ValueError, + "character must be in range(0x110000)"); + return -1; + } + + return _PyUnicodeWriter_WriteChar((_PyUnicodeWriter*)writer, ch); +} + +static inline int +PyUnicodeWriter_WriteStr(PyUnicodeWriter *writer, PyObject *obj) +{ + PyObject *str = PyObject_Str(obj); + if (str == NULL) { + return -1; + } + + int res = _PyUnicodeWriter_WriteStr((_PyUnicodeWriter*)writer, str); + Py_DECREF(str); + return res; +} + +static inline int +PyUnicodeWriter_WriteRepr(PyUnicodeWriter *writer, PyObject *obj) +{ + PyObject *str = PyObject_Repr(obj); + if (str == NULL) { + return -1; + } + + int res = _PyUnicodeWriter_WriteStr((_PyUnicodeWriter*)writer, str); + Py_DECREF(str); + return res; +} + +static inline int +PyUnicodeWriter_WriteUTF8(PyUnicodeWriter *writer, + const char *str, Py_ssize_t size) +{ + if (size < 0) { + size = (Py_ssize_t)strlen(str); + } + + PyObject *str_obj = PyUnicode_FromStringAndSize(str, size); + if (str_obj == _Py_NULL) { + return -1; + } + + int res = _PyUnicodeWriter_WriteStr((_PyUnicodeWriter*)writer, str_obj); + Py_DECREF(str_obj); + return res; +} + +static inline int +PyUnicodeWriter_WriteASCII(PyUnicodeWriter *writer, + const char *str, Py_ssize_t size) +{ + if (size < 0) { + size = (Py_ssize_t)strlen(str); + } + + return _PyUnicodeWriter_WriteASCIIString((_PyUnicodeWriter*)writer, + str, size); +} + +static inline int +PyUnicodeWriter_WriteWideChar(PyUnicodeWriter *writer, + const wchar_t *str, Py_ssize_t size) +{ + if (size < 0) { + size = (Py_ssize_t)wcslen(str); + } + + PyObject *str_obj = PyUnicode_FromWideChar(str, size); + if (str_obj == _Py_NULL) { + return -1; + } + + int res = _PyUnicodeWriter_WriteStr((_PyUnicodeWriter*)writer, str_obj); + Py_DECREF(str_obj); + return res; +} + +static inline int +PyUnicodeWriter_WriteSubstring(PyUnicodeWriter *writer, PyObject *str, + Py_ssize_t start, Py_ssize_t end) +{ + if (!PyUnicode_Check(str)) { + PyErr_Format(PyExc_TypeError, "expect str, not %s", + Py_TYPE(str)->tp_name); + return -1; + } + if (start < 0 || start > end) { + PyErr_Format(PyExc_ValueError, "invalid start argument"); + return -1; + } + if (end > PyUnicode_GET_LENGTH(str)) { + PyErr_Format(PyExc_ValueError, "invalid end argument"); + return -1; + } + + return _PyUnicodeWriter_WriteSubstring((_PyUnicodeWriter*)writer, str, + start, end); +} + +static inline int +PyUnicodeWriter_Format(PyUnicodeWriter *writer, const char *format, ...) +{ + va_list vargs; + va_start(vargs, format); + PyObject *str = PyUnicode_FromFormatV(format, vargs); + va_end(vargs); + if (str == _Py_NULL) { + return -1; + } + + int res = _PyUnicodeWriter_WriteStr((_PyUnicodeWriter*)writer, str); + Py_DECREF(str); + return res; +} +#endif // PY_VERSION_HEX < 0x030E0000 + +// gh-116560 added PyLong_GetSign() to Python 3.14.0a0 +#if PY_VERSION_HEX < 0x030E00A0 +static inline int PyLong_GetSign(PyObject *obj, int *sign) +{ + if (!PyLong_Check(obj)) { + PyErr_Format(PyExc_TypeError, "expect int, got %s", Py_TYPE(obj)->tp_name); + return -1; + } + + *sign = _PyLong_Sign(obj); + return 0; +} +#endif + +// gh-126061 added PyLong_IsPositive/Negative/Zero() to Python in 3.14.0a2 +#if PY_VERSION_HEX < 0x030E00A2 +static inline int PyLong_IsPositive(PyObject *obj) +{ + if (!PyLong_Check(obj)) { + PyErr_Format(PyExc_TypeError, "expected int, got %s", Py_TYPE(obj)->tp_name); + return -1; + } + return _PyLong_Sign(obj) == 1; +} + +static inline int PyLong_IsNegative(PyObject *obj) +{ + if (!PyLong_Check(obj)) { + PyErr_Format(PyExc_TypeError, "expected int, got %s", Py_TYPE(obj)->tp_name); + return -1; + } + return _PyLong_Sign(obj) == -1; +} + +static inline int PyLong_IsZero(PyObject *obj) +{ + if (!PyLong_Check(obj)) { + PyErr_Format(PyExc_TypeError, "expected int, got %s", Py_TYPE(obj)->tp_name); + return -1; + } + return _PyLong_Sign(obj) == 0; +} +#endif + + +// gh-124502 added PyUnicode_Equal() to Python 3.14.0a0 +#if PY_VERSION_HEX < 0x030E00A0 +static inline int PyUnicode_Equal(PyObject *str1, PyObject *str2) +{ + if (!PyUnicode_Check(str1)) { + PyErr_Format(PyExc_TypeError, "first argument must be str, not %s", + Py_TYPE(str1)->tp_name); + return -1; + } + if (!PyUnicode_Check(str2)) { + PyErr_Format(PyExc_TypeError, "second argument must be str, not %s", + Py_TYPE(str2)->tp_name); + return -1; + } + +#if PY_VERSION_HEX >= 0x030d0000 && !defined(PYPY_VERSION) + PyAPI_FUNC(int) _PyUnicode_Equal(PyObject *str1, PyObject *str2); + + return _PyUnicode_Equal(str1, str2); +#elif PY_VERSION_HEX >= 0x03060000 && !defined(PYPY_VERSION) + return _PyUnicode_EQ(str1, str2); +#elif PY_VERSION_HEX >= 0x03090000 && defined(PYPY_VERSION) + return _PyUnicode_EQ(str1, str2); +#else + return (PyUnicode_Compare(str1, str2) == 0); +#endif +} +#endif + + +// gh-121645 added PyBytes_Join() to Python 3.14.0a0 +#if PY_VERSION_HEX < 0x030E00A0 +static inline PyObject* PyBytes_Join(PyObject *sep, PyObject *iterable) +{ + return _PyBytes_Join(sep, iterable); +} +#endif + + +#if PY_VERSION_HEX < 0x030E00A0 +static inline Py_hash_t Py_HashBuffer(const void *ptr, Py_ssize_t len) +{ +#if PY_VERSION_HEX >= 0x03000000 && !defined(PYPY_VERSION) + PyAPI_FUNC(Py_hash_t) _Py_HashBytes(const void *src, Py_ssize_t len); + + return _Py_HashBytes(ptr, len); +#else + Py_hash_t hash; + PyObject *bytes = PyBytes_FromStringAndSize((const char*)ptr, len); + if (bytes == NULL) { + return -1; + } + hash = PyObject_Hash(bytes); + Py_DECREF(bytes); + return hash; +#endif +} +#endif + + +#if PY_VERSION_HEX < 0x030E00A0 +static inline int PyIter_NextItem(PyObject *iter, PyObject **item) +{ + iternextfunc tp_iternext; + + assert(iter != NULL); + assert(item != NULL); + + tp_iternext = Py_TYPE(iter)->tp_iternext; + if (tp_iternext == NULL) { + *item = NULL; + PyErr_Format(PyExc_TypeError, "expected an iterator, got '%s'", + Py_TYPE(iter)->tp_name); + return -1; + } + + if ((*item = tp_iternext(iter))) { + return 1; + } + if (!PyErr_Occurred()) { + return 0; + } + if (PyErr_ExceptionMatches(PyExc_StopIteration)) { + PyErr_Clear(); + return 0; + } + return -1; +} +#endif + + +#if PY_VERSION_HEX < 0x030E00A0 +static inline PyObject* PyLong_FromInt32(int32_t value) +{ + Py_BUILD_ASSERT(sizeof(long) >= 4); + return PyLong_FromLong(value); +} + +static inline PyObject* PyLong_FromInt64(int64_t value) +{ + Py_BUILD_ASSERT(sizeof(long long) >= 8); + return PyLong_FromLongLong(value); +} + +static inline PyObject* PyLong_FromUInt32(uint32_t value) +{ + Py_BUILD_ASSERT(sizeof(unsigned long) >= 4); + return PyLong_FromUnsignedLong(value); +} + +static inline PyObject* PyLong_FromUInt64(uint64_t value) +{ + Py_BUILD_ASSERT(sizeof(unsigned long long) >= 8); + return PyLong_FromUnsignedLongLong(value); +} + +static inline int PyLong_AsInt32(PyObject *obj, int32_t *pvalue) +{ + Py_BUILD_ASSERT(sizeof(int) == 4); + int value = PyLong_AsInt(obj); + if (value == -1 && PyErr_Occurred()) { + return -1; + } + *pvalue = (int32_t)value; + return 0; +} + +static inline int PyLong_AsInt64(PyObject *obj, int64_t *pvalue) +{ + Py_BUILD_ASSERT(sizeof(long long) == 8); + long long value = PyLong_AsLongLong(obj); + if (value == -1 && PyErr_Occurred()) { + return -1; + } + *pvalue = (int64_t)value; + return 0; +} + +static inline int PyLong_AsUInt32(PyObject *obj, uint32_t *pvalue) +{ + Py_BUILD_ASSERT(sizeof(long) >= 4); + unsigned long value = PyLong_AsUnsignedLong(obj); + if (value == (unsigned long)-1 && PyErr_Occurred()) { + return -1; + } +#if SIZEOF_LONG > 4 + if ((unsigned long)UINT32_MAX < value) { + PyErr_SetString(PyExc_OverflowError, + "Python int too large to convert to C uint32_t"); + return -1; + } +#endif + *pvalue = (uint32_t)value; + return 0; +} + +static inline int PyLong_AsUInt64(PyObject *obj, uint64_t *pvalue) +{ + Py_BUILD_ASSERT(sizeof(long long) == 8); + unsigned long long value = PyLong_AsUnsignedLongLong(obj); + if (value == (unsigned long long)-1 && PyErr_Occurred()) { + return -1; + } + *pvalue = (uint64_t)value; + return 0; +} +#endif + + +// gh-102471 added import and export API for integers to 3.14.0a2. +#if PY_VERSION_HEX < 0x030E00A2 && PY_VERSION_HEX >= 0x03000000 && !defined(PYPY_VERSION) +// Helpers to access PyLongObject internals. +static inline void +_PyLong_SetSignAndDigitCount(PyLongObject *op, int sign, Py_ssize_t size) +{ +#if PY_VERSION_HEX >= 0x030C0000 + op->long_value.lv_tag = (uintptr_t)(1 - sign) | ((uintptr_t)(size) << 3); +#elif PY_VERSION_HEX >= 0x030900A4 + Py_SET_SIZE(op, sign * size); +#else + Py_SIZE(op) = sign * size; +#endif +} + +static inline Py_ssize_t +_PyLong_DigitCount(const PyLongObject *op) +{ +#if PY_VERSION_HEX >= 0x030C0000 + return (Py_ssize_t)(op->long_value.lv_tag >> 3); +#else + return _PyLong_Sign((PyObject*)op) < 0 ? -Py_SIZE(op) : Py_SIZE(op); +#endif +} + +static inline digit* +_PyLong_GetDigits(const PyLongObject *op) +{ +#if PY_VERSION_HEX >= 0x030C0000 + return (digit*)(op->long_value.ob_digit); +#else + return (digit*)(op->ob_digit); +#endif +} + +typedef struct PyLongLayout { + uint8_t bits_per_digit; + uint8_t digit_size; + int8_t digits_order; + int8_t digit_endianness; +} PyLongLayout; + +typedef struct PyLongExport { + int64_t value; + uint8_t negative; + Py_ssize_t ndigits; + const void *digits; + Py_uintptr_t _reserved; +} PyLongExport; + +typedef struct PyLongWriter PyLongWriter; + +static inline const PyLongLayout* +PyLong_GetNativeLayout(void) +{ + static const PyLongLayout PyLong_LAYOUT = { + PyLong_SHIFT, + sizeof(digit), + -1, // least significant first + PY_LITTLE_ENDIAN ? -1 : 1, + }; + + return &PyLong_LAYOUT; +} + +static inline int +PyLong_Export(PyObject *obj, PyLongExport *export_long) +{ + if (!PyLong_Check(obj)) { + memset(export_long, 0, sizeof(*export_long)); + PyErr_Format(PyExc_TypeError, "expected int, got %s", + Py_TYPE(obj)->tp_name); + return -1; + } + + // Fast-path: try to convert to a int64_t + PyLongObject *self = (PyLongObject*)obj; + int overflow; +#if SIZEOF_LONG == 8 + long value = PyLong_AsLongAndOverflow(obj, &overflow); +#else + // Windows has 32-bit long, so use 64-bit long long instead + long long value = PyLong_AsLongLongAndOverflow(obj, &overflow); +#endif + Py_BUILD_ASSERT(sizeof(value) == sizeof(int64_t)); + // the function cannot fail since obj is a PyLongObject + assert(!(value == -1 && PyErr_Occurred())); + + if (!overflow) { + export_long->value = value; + export_long->negative = 0; + export_long->ndigits = 0; + export_long->digits = 0; + export_long->_reserved = 0; + } + else { + export_long->value = 0; + export_long->negative = _PyLong_Sign(obj) < 0; + export_long->ndigits = _PyLong_DigitCount(self); + if (export_long->ndigits == 0) { + export_long->ndigits = 1; + } + export_long->digits = _PyLong_GetDigits(self); + export_long->_reserved = (Py_uintptr_t)Py_NewRef(obj); + } + return 0; +} + +static inline void +PyLong_FreeExport(PyLongExport *export_long) +{ + PyObject *obj = (PyObject*)export_long->_reserved; + + if (obj) { + export_long->_reserved = 0; + Py_DECREF(obj); + } +} + +static inline PyLongWriter* +PyLongWriter_Create(int negative, Py_ssize_t ndigits, void **digits) +{ + if (ndigits <= 0) { + PyErr_SetString(PyExc_ValueError, "ndigits must be positive"); + return NULL; + } + assert(digits != NULL); + + PyLongObject *obj = _PyLong_New(ndigits); + if (obj == NULL) { + return NULL; + } + _PyLong_SetSignAndDigitCount(obj, negative?-1:1, ndigits); + + *digits = _PyLong_GetDigits(obj); + return (PyLongWriter*)obj; +} + +static inline void +PyLongWriter_Discard(PyLongWriter *writer) +{ + PyLongObject *obj = (PyLongObject *)writer; + + assert(Py_REFCNT(obj) == 1); + Py_DECREF(obj); +} + +static inline PyObject* +PyLongWriter_Finish(PyLongWriter *writer) +{ + PyObject *obj = (PyObject *)writer; + PyLongObject *self = (PyLongObject*)obj; + Py_ssize_t j = _PyLong_DigitCount(self); + Py_ssize_t i = j; + int sign = _PyLong_Sign(obj); + + assert(Py_REFCNT(obj) == 1); + + // Normalize and get singleton if possible + while (i > 0 && _PyLong_GetDigits(self)[i-1] == 0) { + --i; + } + if (i != j) { + if (i == 0) { + sign = 0; + } + _PyLong_SetSignAndDigitCount(self, sign, i); + } + if (i <= 1) { + long val = sign * (long)(_PyLong_GetDigits(self)[0]); + Py_DECREF(obj); + return PyLong_FromLong(val); + } + + return obj; +} +#endif + + +#if PY_VERSION_HEX < 0x030C00A3 +# define Py_T_SHORT T_SHORT +# define Py_T_INT T_INT +# define Py_T_LONG T_LONG +# define Py_T_FLOAT T_FLOAT +# define Py_T_DOUBLE T_DOUBLE +# define Py_T_STRING T_STRING +# define _Py_T_OBJECT T_OBJECT +# define Py_T_CHAR T_CHAR +# define Py_T_BYTE T_BYTE +# define Py_T_UBYTE T_UBYTE +# define Py_T_USHORT T_USHORT +# define Py_T_UINT T_UINT +# define Py_T_ULONG T_ULONG +# define Py_T_STRING_INPLACE T_STRING_INPLACE +# define Py_T_BOOL T_BOOL +# define Py_T_OBJECT_EX T_OBJECT_EX +# define Py_T_LONGLONG T_LONGLONG +# define Py_T_ULONGLONG T_ULONGLONG +# define Py_T_PYSSIZET T_PYSSIZET + +# if PY_VERSION_HEX >= 0x03000000 && !defined(PYPY_VERSION) +# define _Py_T_NONE T_NONE +# endif + +# define Py_READONLY READONLY +# define Py_AUDIT_READ READ_RESTRICTED +# define _Py_WRITE_RESTRICTED PY_WRITE_RESTRICTED +#endif + + +// gh-127350 added Py_fopen() and Py_fclose() to Python 3.14a4 +#if PY_VERSION_HEX < 0x030E00A4 +static inline FILE* Py_fopen(PyObject *path, const char *mode) +{ +#if 0x030400A2 <= PY_VERSION_HEX && !defined(PYPY_VERSION) + PyAPI_FUNC(FILE*) _Py_fopen_obj(PyObject *path, const char *mode); + + return _Py_fopen_obj(path, mode); +#else + FILE *f; + PyObject *bytes; +#if PY_VERSION_HEX >= 0x03000000 + if (!PyUnicode_FSConverter(path, &bytes)) { + return NULL; + } +#else + if (!PyString_Check(path)) { + PyErr_SetString(PyExc_TypeError, "except str"); + return NULL; + } + bytes = Py_NewRef(path); +#endif + const char *path_bytes = PyBytes_AS_STRING(bytes); + + f = fopen(path_bytes, mode); + Py_DECREF(bytes); + + if (f == NULL) { + PyErr_SetFromErrnoWithFilenameObject(PyExc_OSError, path); + return NULL; + } + return f; +#endif +} + +static inline int Py_fclose(FILE *file) +{ + return fclose(file); +} +#endif + + +#if 0x03090000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x030E0000 && !defined(PYPY_VERSION) +static inline PyObject* +PyConfig_Get(const char *name) +{ + typedef enum { + _PyConfig_MEMBER_INT, + _PyConfig_MEMBER_UINT, + _PyConfig_MEMBER_ULONG, + _PyConfig_MEMBER_BOOL, + _PyConfig_MEMBER_WSTR, + _PyConfig_MEMBER_WSTR_OPT, + _PyConfig_MEMBER_WSTR_LIST, + } PyConfigMemberType; + + typedef struct { + const char *name; + size_t offset; + PyConfigMemberType type; + const char *sys_attr; + } PyConfigSpec; + +#define PYTHONCAPI_COMPAT_SPEC(MEMBER, TYPE, sys_attr) \ + {#MEMBER, offsetof(PyConfig, MEMBER), \ + _PyConfig_MEMBER_##TYPE, sys_attr} + + static const PyConfigSpec config_spec[] = { + PYTHONCAPI_COMPAT_SPEC(argv, WSTR_LIST, "argv"), + PYTHONCAPI_COMPAT_SPEC(base_exec_prefix, WSTR_OPT, "base_exec_prefix"), + PYTHONCAPI_COMPAT_SPEC(base_executable, WSTR_OPT, "_base_executable"), + PYTHONCAPI_COMPAT_SPEC(base_prefix, WSTR_OPT, "base_prefix"), + PYTHONCAPI_COMPAT_SPEC(bytes_warning, UINT, _Py_NULL), + PYTHONCAPI_COMPAT_SPEC(exec_prefix, WSTR_OPT, "exec_prefix"), + PYTHONCAPI_COMPAT_SPEC(executable, WSTR_OPT, "executable"), + PYTHONCAPI_COMPAT_SPEC(inspect, BOOL, _Py_NULL), +#if 0x030C0000 <= PY_VERSION_HEX + PYTHONCAPI_COMPAT_SPEC(int_max_str_digits, UINT, _Py_NULL), +#endif + PYTHONCAPI_COMPAT_SPEC(interactive, BOOL, _Py_NULL), + PYTHONCAPI_COMPAT_SPEC(module_search_paths, WSTR_LIST, "path"), + PYTHONCAPI_COMPAT_SPEC(optimization_level, UINT, _Py_NULL), + PYTHONCAPI_COMPAT_SPEC(parser_debug, BOOL, _Py_NULL), + PYTHONCAPI_COMPAT_SPEC(platlibdir, WSTR, "platlibdir"), + PYTHONCAPI_COMPAT_SPEC(prefix, WSTR_OPT, "prefix"), + PYTHONCAPI_COMPAT_SPEC(pycache_prefix, WSTR_OPT, "pycache_prefix"), + PYTHONCAPI_COMPAT_SPEC(quiet, BOOL, _Py_NULL), +#if 0x030B0000 <= PY_VERSION_HEX + PYTHONCAPI_COMPAT_SPEC(stdlib_dir, WSTR_OPT, "_stdlib_dir"), +#endif + PYTHONCAPI_COMPAT_SPEC(use_environment, BOOL, _Py_NULL), + PYTHONCAPI_COMPAT_SPEC(verbose, UINT, _Py_NULL), + PYTHONCAPI_COMPAT_SPEC(warnoptions, WSTR_LIST, "warnoptions"), + PYTHONCAPI_COMPAT_SPEC(write_bytecode, BOOL, _Py_NULL), + PYTHONCAPI_COMPAT_SPEC(xoptions, WSTR_LIST, "_xoptions"), + PYTHONCAPI_COMPAT_SPEC(buffered_stdio, BOOL, _Py_NULL), + PYTHONCAPI_COMPAT_SPEC(check_hash_pycs_mode, WSTR, _Py_NULL), +#if 0x030B0000 <= PY_VERSION_HEX + PYTHONCAPI_COMPAT_SPEC(code_debug_ranges, BOOL, _Py_NULL), +#endif + PYTHONCAPI_COMPAT_SPEC(configure_c_stdio, BOOL, _Py_NULL), +#if 0x030D0000 <= PY_VERSION_HEX + PYTHONCAPI_COMPAT_SPEC(cpu_count, INT, _Py_NULL), +#endif + PYTHONCAPI_COMPAT_SPEC(dev_mode, BOOL, _Py_NULL), + PYTHONCAPI_COMPAT_SPEC(dump_refs, BOOL, _Py_NULL), +#if 0x030B0000 <= PY_VERSION_HEX + PYTHONCAPI_COMPAT_SPEC(dump_refs_file, WSTR_OPT, _Py_NULL), +#endif +#ifdef Py_GIL_DISABLED + PYTHONCAPI_COMPAT_SPEC(enable_gil, INT, _Py_NULL), +#endif + PYTHONCAPI_COMPAT_SPEC(faulthandler, BOOL, _Py_NULL), + PYTHONCAPI_COMPAT_SPEC(filesystem_encoding, WSTR, _Py_NULL), + PYTHONCAPI_COMPAT_SPEC(filesystem_errors, WSTR, _Py_NULL), + PYTHONCAPI_COMPAT_SPEC(hash_seed, ULONG, _Py_NULL), + PYTHONCAPI_COMPAT_SPEC(home, WSTR_OPT, _Py_NULL), + PYTHONCAPI_COMPAT_SPEC(import_time, BOOL, _Py_NULL), + PYTHONCAPI_COMPAT_SPEC(install_signal_handlers, BOOL, _Py_NULL), + PYTHONCAPI_COMPAT_SPEC(isolated, BOOL, _Py_NULL), +#ifdef MS_WINDOWS + PYTHONCAPI_COMPAT_SPEC(legacy_windows_stdio, BOOL, _Py_NULL), +#endif + PYTHONCAPI_COMPAT_SPEC(malloc_stats, BOOL, _Py_NULL), +#if 0x030A0000 <= PY_VERSION_HEX + PYTHONCAPI_COMPAT_SPEC(orig_argv, WSTR_LIST, "orig_argv"), +#endif + PYTHONCAPI_COMPAT_SPEC(parse_argv, BOOL, _Py_NULL), + PYTHONCAPI_COMPAT_SPEC(pathconfig_warnings, BOOL, _Py_NULL), +#if 0x030C0000 <= PY_VERSION_HEX + PYTHONCAPI_COMPAT_SPEC(perf_profiling, UINT, _Py_NULL), +#endif + PYTHONCAPI_COMPAT_SPEC(program_name, WSTR, _Py_NULL), + PYTHONCAPI_COMPAT_SPEC(run_command, WSTR_OPT, _Py_NULL), + PYTHONCAPI_COMPAT_SPEC(run_filename, WSTR_OPT, _Py_NULL), + PYTHONCAPI_COMPAT_SPEC(run_module, WSTR_OPT, _Py_NULL), +#if 0x030B0000 <= PY_VERSION_HEX + PYTHONCAPI_COMPAT_SPEC(safe_path, BOOL, _Py_NULL), +#endif + PYTHONCAPI_COMPAT_SPEC(show_ref_count, BOOL, _Py_NULL), + PYTHONCAPI_COMPAT_SPEC(site_import, BOOL, _Py_NULL), + PYTHONCAPI_COMPAT_SPEC(skip_source_first_line, BOOL, _Py_NULL), + PYTHONCAPI_COMPAT_SPEC(stdio_encoding, WSTR, _Py_NULL), + PYTHONCAPI_COMPAT_SPEC(stdio_errors, WSTR, _Py_NULL), + PYTHONCAPI_COMPAT_SPEC(tracemalloc, UINT, _Py_NULL), +#if 0x030B0000 <= PY_VERSION_HEX + PYTHONCAPI_COMPAT_SPEC(use_frozen_modules, BOOL, _Py_NULL), +#endif + PYTHONCAPI_COMPAT_SPEC(use_hash_seed, BOOL, _Py_NULL), + PYTHONCAPI_COMPAT_SPEC(user_site_directory, BOOL, _Py_NULL), +#if 0x030A0000 <= PY_VERSION_HEX + PYTHONCAPI_COMPAT_SPEC(warn_default_encoding, BOOL, _Py_NULL), +#endif + }; + +#undef PYTHONCAPI_COMPAT_SPEC + + const PyConfigSpec *spec; + int found = 0; + for (size_t i=0; i < sizeof(config_spec) / sizeof(config_spec[0]); i++) { + spec = &config_spec[i]; + if (strcmp(spec->name, name) == 0) { + found = 1; + break; + } + } + if (found) { + if (spec->sys_attr != NULL) { + PyObject *value = PySys_GetObject(spec->sys_attr); + if (value == NULL) { + PyErr_Format(PyExc_RuntimeError, "lost sys.%s", spec->sys_attr); + return NULL; + } + return Py_NewRef(value); + } + + PyAPI_FUNC(const PyConfig*) _Py_GetConfig(void); + + const PyConfig *config = _Py_GetConfig(); + void *member = (char *)config + spec->offset; + switch (spec->type) { + case _PyConfig_MEMBER_INT: + case _PyConfig_MEMBER_UINT: + { + int value = *(int *)member; + return PyLong_FromLong(value); + } + case _PyConfig_MEMBER_BOOL: + { + int value = *(int *)member; + return PyBool_FromLong(value != 0); + } + case _PyConfig_MEMBER_ULONG: + { + unsigned long value = *(unsigned long *)member; + return PyLong_FromUnsignedLong(value); + } + case _PyConfig_MEMBER_WSTR: + case _PyConfig_MEMBER_WSTR_OPT: + { + wchar_t *wstr = *(wchar_t **)member; + if (wstr != NULL) { + return PyUnicode_FromWideChar(wstr, -1); + } + else { + return Py_NewRef(Py_None); + } + } + case _PyConfig_MEMBER_WSTR_LIST: + { + const PyWideStringList *list = (const PyWideStringList *)member; + PyObject *tuple = PyTuple_New(list->length); + if (tuple == NULL) { + return NULL; + } + + for (Py_ssize_t i = 0; i < list->length; i++) { + PyObject *item = PyUnicode_FromWideChar(list->items[i], -1); + if (item == NULL) { + Py_DECREF(tuple); + return NULL; + } + PyTuple_SET_ITEM(tuple, i, item); + } + return tuple; + } + default: + Py_UNREACHABLE(); + } + } + + PyErr_Format(PyExc_ValueError, "unknown config option name: %s", name); + return NULL; +} + +static inline int +PyConfig_GetInt(const char *name, int *value) +{ + PyObject *obj = PyConfig_Get(name); + if (obj == NULL) { + return -1; + } + + if (!PyLong_Check(obj)) { + Py_DECREF(obj); + PyErr_Format(PyExc_TypeError, "config option %s is not an int", name); + return -1; + } + + int as_int = PyLong_AsInt(obj); + Py_DECREF(obj); + if (as_int == -1 && PyErr_Occurred()) { + PyErr_Format(PyExc_OverflowError, + "config option %s value does not fit into a C int", name); + return -1; + } + + *value = as_int; + return 0; +} +#endif // PY_VERSION_HEX > 0x03090000 && !defined(PYPY_VERSION) + + +#if PY_VERSION_HEX < 0x030F0000 +static inline PyObject* +PySys_GetAttrString(const char *name) +{ +#if PY_VERSION_HEX >= 0x03000000 + PyObject *value = Py_XNewRef(PySys_GetObject(name)); +#else + PyObject *value = Py_XNewRef(PySys_GetObject((char*)name)); +#endif + if (value != NULL) { + return value; + } + if (!PyErr_Occurred()) { + PyErr_Format(PyExc_RuntimeError, "lost sys.%s", name); + } + return NULL; +} + +static inline PyObject* +PySys_GetAttr(PyObject *name) +{ +#if PY_VERSION_HEX >= 0x03000000 + const char *name_str = PyUnicode_AsUTF8(name); +#else + const char *name_str = PyString_AsString(name); +#endif + if (name_str == NULL) { + return NULL; + } + + return PySys_GetAttrString(name_str); +} + +static inline int +PySys_GetOptionalAttrString(const char *name, PyObject **value) +{ +#if PY_VERSION_HEX >= 0x03000000 + *value = Py_XNewRef(PySys_GetObject(name)); +#else + *value = Py_XNewRef(PySys_GetObject((char*)name)); +#endif + if (*value != NULL) { + return 1; + } + return 0; +} + +static inline int +PySys_GetOptionalAttr(PyObject *name, PyObject **value) +{ +#if PY_VERSION_HEX >= 0x03000000 + const char *name_str = PyUnicode_AsUTF8(name); +#else + const char *name_str = PyString_AsString(name); +#endif + if (name_str == NULL) { + *value = NULL; + return -1; + } + + return PySys_GetOptionalAttrString(name_str, value); +} +#endif // PY_VERSION_HEX < 0x030F00A1 + + +#ifdef __cplusplus +} +#endif +#endif // PYTHONCAPI_COMPAT diff --git a/src/hunter/vendor/colorama/__init__.py b/src/hunter/vendor/colorama/__init__.py new file mode 100644 index 00000000..b149ed79 --- /dev/null +++ b/src/hunter/vendor/colorama/__init__.py @@ -0,0 +1,6 @@ +# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file. +from .initialise import init, deinit, reinit, colorama_text +from .ansi import Fore, Back, Style, Cursor +from .ansitowin32 import AnsiToWin32 + +__version__ = '0.4.4' diff --git a/src/hunter/vendor/colorama/ansi.py b/src/hunter/vendor/colorama/ansi.py new file mode 100644 index 00000000..11ec695f --- /dev/null +++ b/src/hunter/vendor/colorama/ansi.py @@ -0,0 +1,102 @@ +# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file. +''' +This module generates ANSI character codes to printing colors to terminals. +See: http://en.wikipedia.org/wiki/ANSI_escape_code +''' + +CSI = '\033[' +OSC = '\033]' +BEL = '\a' + + +def code_to_chars(code): + return CSI + str(code) + 'm' + +def set_title(title): + return OSC + '2;' + title + BEL + +def clear_screen(mode=2): + return CSI + str(mode) + 'J' + +def clear_line(mode=2): + return CSI + str(mode) + 'K' + + +class AnsiCodes(object): + def __init__(self): + # the subclasses declare class attributes which are numbers. + # Upon instantiation we define instance attributes, which are the same + # as the class attributes but wrapped with the ANSI escape sequence + for name in dir(self): + if not name.startswith('_'): + value = getattr(self, name) + setattr(self, name, code_to_chars(value)) + + +class AnsiCursor(object): + def UP(self, n=1): + return CSI + str(n) + 'A' + def DOWN(self, n=1): + return CSI + str(n) + 'B' + def FORWARD(self, n=1): + return CSI + str(n) + 'C' + def BACK(self, n=1): + return CSI + str(n) + 'D' + def POS(self, x=1, y=1): + return CSI + str(y) + ';' + str(x) + 'H' + + +class AnsiFore(AnsiCodes): + BLACK = 30 + RED = 31 + GREEN = 32 + YELLOW = 33 + BLUE = 34 + MAGENTA = 35 + CYAN = 36 + WHITE = 37 + RESET = 39 + + # These are fairly well supported, but not part of the standard. + LIGHTBLACK_EX = 90 + LIGHTRED_EX = 91 + LIGHTGREEN_EX = 92 + LIGHTYELLOW_EX = 93 + LIGHTBLUE_EX = 94 + LIGHTMAGENTA_EX = 95 + LIGHTCYAN_EX = 96 + LIGHTWHITE_EX = 97 + + +class AnsiBack(AnsiCodes): + BLACK = 40 + RED = 41 + GREEN = 42 + YELLOW = 43 + BLUE = 44 + MAGENTA = 45 + CYAN = 46 + WHITE = 47 + RESET = 49 + + # These are fairly well supported, but not part of the standard. + LIGHTBLACK_EX = 100 + LIGHTRED_EX = 101 + LIGHTGREEN_EX = 102 + LIGHTYELLOW_EX = 103 + LIGHTBLUE_EX = 104 + LIGHTMAGENTA_EX = 105 + LIGHTCYAN_EX = 106 + LIGHTWHITE_EX = 107 + + +class AnsiStyle(AnsiCodes): + BRIGHT = 1 + DIM = 2 + NORMAL = 22 + RESET_ALL = 0 + +Fore = AnsiFore() +Back = AnsiBack() +Style = AnsiStyle() +Cursor = AnsiCursor() diff --git a/src/hunter/vendor/colorama/ansitowin32.py b/src/hunter/vendor/colorama/ansitowin32.py new file mode 100644 index 00000000..6039a054 --- /dev/null +++ b/src/hunter/vendor/colorama/ansitowin32.py @@ -0,0 +1,258 @@ +# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file. +import re +import sys +import os + +from .ansi import AnsiFore, AnsiBack, AnsiStyle, Style, BEL +from .winterm import WinTerm, WinColor, WinStyle +from .win32 import windll, winapi_test + + +winterm = None +if windll is not None: + winterm = WinTerm() + + +class StreamWrapper(object): + ''' + Wraps a stream (such as stdout), acting as a transparent proxy for all + attribute access apart from method 'write()', which is delegated to our + Converter instance. + ''' + def __init__(self, wrapped, converter): + # double-underscore everything to prevent clashes with names of + # attributes on the wrapped stream object. + self.__wrapped = wrapped + self.__convertor = converter + + def __getattr__(self, name): + return getattr(self.__wrapped, name) + + def __enter__(self, *args, **kwargs): + # special method lookup bypasses __getattr__/__getattribute__, see + # https://stackoverflow.com/questions/12632894/why-doesnt-getattr-work-with-exit + # thus, contextlib magic methods are not proxied via __getattr__ + return self.__wrapped.__enter__(*args, **kwargs) + + def __exit__(self, *args, **kwargs): + return self.__wrapped.__exit__(*args, **kwargs) + + def write(self, text): + self.__convertor.write(text) + + def isatty(self): + stream = self.__wrapped + if 'PYCHARM_HOSTED' in os.environ: + if stream is not None and (stream is sys.__stdout__ or stream is sys.__stderr__): + return True + try: + stream_isatty = stream.isatty + except AttributeError: + return False + else: + return stream_isatty() + + @property + def closed(self): + stream = self.__wrapped + try: + return stream.closed + except AttributeError: + return True + + +class AnsiToWin32(object): + ''' + Implements a 'write()' method which, on Windows, will strip ANSI character + sequences from the text, and if outputting to a tty, will convert them into + win32 function calls. + ''' + ANSI_CSI_RE = re.compile('\001?\033\\[((?:\\d|;)*)([a-zA-Z])\002?') # Control Sequence Introducer + ANSI_OSC_RE = re.compile('\001?\033\\]([^\a]*)(\a)\002?') # Operating System Command + + def __init__(self, wrapped, convert=None, strip=None, autoreset=False): + # The wrapped stream (normally sys.stdout or sys.stderr) + self.wrapped = wrapped + + # should we reset colors to defaults after every .write() + self.autoreset = autoreset + + # create the proxy wrapping our output stream + self.stream = StreamWrapper(wrapped, self) + + on_windows = os.name == 'nt' + # We test if the WinAPI works, because even if we are on Windows + # we may be using a terminal that doesn't support the WinAPI + # (e.g. Cygwin Terminal). In this case it's up to the terminal + # to support the ANSI codes. + conversion_supported = on_windows and winapi_test() + + # should we strip ANSI sequences from our output? + if strip is None: + strip = conversion_supported or (not self.stream.closed and not self.stream.isatty()) + self.strip = strip + + # should we should convert ANSI sequences into win32 calls? + if convert is None: + convert = conversion_supported and not self.stream.closed and self.stream.isatty() + self.convert = convert + + # dict of ansi codes to win32 functions and parameters + self.win32_calls = self.get_win32_calls() + + # are we wrapping stderr? + self.on_stderr = self.wrapped is sys.stderr + + def should_wrap(self): + ''' + True if this class is actually needed. If false, then the output + stream will not be affected, nor will win32 calls be issued, so + wrapping stdout is not actually required. This will generally be + False on non-Windows platforms, unless optional functionality like + autoreset has been requested using kwargs to init() + ''' + return self.convert or self.strip or self.autoreset + + def get_win32_calls(self): + if self.convert and winterm: + return { + AnsiStyle.RESET_ALL: (winterm.reset_all, ), + AnsiStyle.BRIGHT: (winterm.style, WinStyle.BRIGHT), + AnsiStyle.DIM: (winterm.style, WinStyle.NORMAL), + AnsiStyle.NORMAL: (winterm.style, WinStyle.NORMAL), + AnsiFore.BLACK: (winterm.fore, WinColor.BLACK), + AnsiFore.RED: (winterm.fore, WinColor.RED), + AnsiFore.GREEN: (winterm.fore, WinColor.GREEN), + AnsiFore.YELLOW: (winterm.fore, WinColor.YELLOW), + AnsiFore.BLUE: (winterm.fore, WinColor.BLUE), + AnsiFore.MAGENTA: (winterm.fore, WinColor.MAGENTA), + AnsiFore.CYAN: (winterm.fore, WinColor.CYAN), + AnsiFore.WHITE: (winterm.fore, WinColor.GREY), + AnsiFore.RESET: (winterm.fore, ), + AnsiFore.LIGHTBLACK_EX: (winterm.fore, WinColor.BLACK, True), + AnsiFore.LIGHTRED_EX: (winterm.fore, WinColor.RED, True), + AnsiFore.LIGHTGREEN_EX: (winterm.fore, WinColor.GREEN, True), + AnsiFore.LIGHTYELLOW_EX: (winterm.fore, WinColor.YELLOW, True), + AnsiFore.LIGHTBLUE_EX: (winterm.fore, WinColor.BLUE, True), + AnsiFore.LIGHTMAGENTA_EX: (winterm.fore, WinColor.MAGENTA, True), + AnsiFore.LIGHTCYAN_EX: (winterm.fore, WinColor.CYAN, True), + AnsiFore.LIGHTWHITE_EX: (winterm.fore, WinColor.GREY, True), + AnsiBack.BLACK: (winterm.back, WinColor.BLACK), + AnsiBack.RED: (winterm.back, WinColor.RED), + AnsiBack.GREEN: (winterm.back, WinColor.GREEN), + AnsiBack.YELLOW: (winterm.back, WinColor.YELLOW), + AnsiBack.BLUE: (winterm.back, WinColor.BLUE), + AnsiBack.MAGENTA: (winterm.back, WinColor.MAGENTA), + AnsiBack.CYAN: (winterm.back, WinColor.CYAN), + AnsiBack.WHITE: (winterm.back, WinColor.GREY), + AnsiBack.RESET: (winterm.back, ), + AnsiBack.LIGHTBLACK_EX: (winterm.back, WinColor.BLACK, True), + AnsiBack.LIGHTRED_EX: (winterm.back, WinColor.RED, True), + AnsiBack.LIGHTGREEN_EX: (winterm.back, WinColor.GREEN, True), + AnsiBack.LIGHTYELLOW_EX: (winterm.back, WinColor.YELLOW, True), + AnsiBack.LIGHTBLUE_EX: (winterm.back, WinColor.BLUE, True), + AnsiBack.LIGHTMAGENTA_EX: (winterm.back, WinColor.MAGENTA, True), + AnsiBack.LIGHTCYAN_EX: (winterm.back, WinColor.CYAN, True), + AnsiBack.LIGHTWHITE_EX: (winterm.back, WinColor.GREY, True), + } + return dict() + + def write(self, text): + if self.strip or self.convert: + self.write_and_convert(text) + else: + self.wrapped.write(text) + self.wrapped.flush() + if self.autoreset: + self.reset_all() + + + def reset_all(self): + if self.convert: + self.call_win32('m', (0,)) + elif not self.strip and not self.stream.closed: + self.wrapped.write(Style.RESET_ALL) + + + def write_and_convert(self, text): + ''' + Write the given text to our wrapped stream, stripping any ANSI + sequences from the text, and optionally converting them into win32 + calls. + ''' + cursor = 0 + text = self.convert_osc(text) + for match in self.ANSI_CSI_RE.finditer(text): + start, end = match.span() + self.write_plain_text(text, cursor, start) + self.convert_ansi(*match.groups()) + cursor = end + self.write_plain_text(text, cursor, len(text)) + + + def write_plain_text(self, text, start, end): + if start < end: + self.wrapped.write(text[start:end]) + self.wrapped.flush() + + + def convert_ansi(self, paramstring, command): + if self.convert: + params = self.extract_params(command, paramstring) + self.call_win32(command, params) + + + def extract_params(self, command, paramstring): + if command in 'Hf': + params = tuple(int(p) if len(p) != 0 else 1 for p in paramstring.split(';')) + while len(params) < 2: + # defaults: + params = params + (1,) + else: + params = tuple(int(p) for p in paramstring.split(';') if len(p) != 0) + if len(params) == 0: + # defaults: + if command in 'JKm': + params = (0,) + elif command in 'ABCD': + params = (1,) + + return params + + + def call_win32(self, command, params): + if command == 'm': + for param in params: + if param in self.win32_calls: + func_args = self.win32_calls[param] + func = func_args[0] + args = func_args[1:] + kwargs = dict(on_stderr=self.on_stderr) + func(*args, **kwargs) + elif command in 'J': + winterm.erase_screen(params[0], on_stderr=self.on_stderr) + elif command in 'K': + winterm.erase_line(params[0], on_stderr=self.on_stderr) + elif command in 'Hf': # cursor position - absolute + winterm.set_cursor_position(params, on_stderr=self.on_stderr) + elif command in 'ABCD': # cursor position - relative + n = params[0] + # A - up, B - down, C - forward, D - back + x, y = {'A': (0, -n), 'B': (0, n), 'C': (n, 0), 'D': (-n, 0)}[command] + winterm.cursor_adjust(x, y, on_stderr=self.on_stderr) + + + def convert_osc(self, text): + for match in self.ANSI_OSC_RE.finditer(text): + start, end = match.span() + text = text[:start] + text[end:] + paramstring, command = match.groups() + if command == BEL: + if paramstring.count(";") == 1: + params = paramstring.split(";") + # 0 - change title and icon (we will only change title) + # 1 - change icon (we don't support this) + # 2 - change title + if params[0] in '02': + winterm.set_title(params[1]) + return text diff --git a/src/hunter/vendor/colorama/initialise.py b/src/hunter/vendor/colorama/initialise.py new file mode 100644 index 00000000..430d0668 --- /dev/null +++ b/src/hunter/vendor/colorama/initialise.py @@ -0,0 +1,80 @@ +# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file. +import atexit +import contextlib +import sys + +from .ansitowin32 import AnsiToWin32 + + +orig_stdout = None +orig_stderr = None + +wrapped_stdout = None +wrapped_stderr = None + +atexit_done = False + + +def reset_all(): + if AnsiToWin32 is not None: # Issue #74: objects might become None at exit + AnsiToWin32(orig_stdout).reset_all() + + +def init(autoreset=False, convert=None, strip=None, wrap=True): + + if not wrap and any([autoreset, convert, strip]): + raise ValueError('wrap=False conflicts with any other arg=True') + + global wrapped_stdout, wrapped_stderr + global orig_stdout, orig_stderr + + orig_stdout = sys.stdout + orig_stderr = sys.stderr + + if sys.stdout is None: + wrapped_stdout = None + else: + sys.stdout = wrapped_stdout = \ + wrap_stream(orig_stdout, convert, strip, autoreset, wrap) + if sys.stderr is None: + wrapped_stderr = None + else: + sys.stderr = wrapped_stderr = \ + wrap_stream(orig_stderr, convert, strip, autoreset, wrap) + + global atexit_done + if not atexit_done: + atexit.register(reset_all) + atexit_done = True + + +def deinit(): + if orig_stdout is not None: + sys.stdout = orig_stdout + if orig_stderr is not None: + sys.stderr = orig_stderr + + +@contextlib.contextmanager +def colorama_text(*args, **kwargs): + init(*args, **kwargs) + try: + yield + finally: + deinit() + + +def reinit(): + if wrapped_stdout is not None: + sys.stdout = wrapped_stdout + if wrapped_stderr is not None: + sys.stderr = wrapped_stderr + + +def wrap_stream(stream, convert, strip, autoreset, wrap): + if wrap: + wrapper = AnsiToWin32(stream, + convert=convert, strip=strip, autoreset=autoreset) + if wrapper.should_wrap(): + stream = wrapper.stream + return stream diff --git a/src/hunter/vendor/colorama/win32.py b/src/hunter/vendor/colorama/win32.py new file mode 100644 index 00000000..c2d83603 --- /dev/null +++ b/src/hunter/vendor/colorama/win32.py @@ -0,0 +1,152 @@ +# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file. + +# from winbase.h +STDOUT = -11 +STDERR = -12 + +try: + import ctypes + from ctypes import LibraryLoader + windll = LibraryLoader(ctypes.WinDLL) + from ctypes import wintypes +except (AttributeError, ImportError): + windll = None + SetConsoleTextAttribute = lambda *_: None + winapi_test = lambda *_: None +else: + from ctypes import byref, Structure, c_char, POINTER + + COORD = wintypes._COORD + + class CONSOLE_SCREEN_BUFFER_INFO(Structure): + """struct in wincon.h.""" + _fields_ = [ + ("dwSize", COORD), + ("dwCursorPosition", COORD), + ("wAttributes", wintypes.WORD), + ("srWindow", wintypes.SMALL_RECT), + ("dwMaximumWindowSize", COORD), + ] + def __str__(self): + return '(%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)' % ( + self.dwSize.Y, self.dwSize.X + , self.dwCursorPosition.Y, self.dwCursorPosition.X + , self.wAttributes + , self.srWindow.Top, self.srWindow.Left, self.srWindow.Bottom, self.srWindow.Right + , self.dwMaximumWindowSize.Y, self.dwMaximumWindowSize.X + ) + + _GetStdHandle = windll.kernel32.GetStdHandle + _GetStdHandle.argtypes = [ + wintypes.DWORD, + ] + _GetStdHandle.restype = wintypes.HANDLE + + _GetConsoleScreenBufferInfo = windll.kernel32.GetConsoleScreenBufferInfo + _GetConsoleScreenBufferInfo.argtypes = [ + wintypes.HANDLE, + POINTER(CONSOLE_SCREEN_BUFFER_INFO), + ] + _GetConsoleScreenBufferInfo.restype = wintypes.BOOL + + _SetConsoleTextAttribute = windll.kernel32.SetConsoleTextAttribute + _SetConsoleTextAttribute.argtypes = [ + wintypes.HANDLE, + wintypes.WORD, + ] + _SetConsoleTextAttribute.restype = wintypes.BOOL + + _SetConsoleCursorPosition = windll.kernel32.SetConsoleCursorPosition + _SetConsoleCursorPosition.argtypes = [ + wintypes.HANDLE, + COORD, + ] + _SetConsoleCursorPosition.restype = wintypes.BOOL + + _FillConsoleOutputCharacterA = windll.kernel32.FillConsoleOutputCharacterA + _FillConsoleOutputCharacterA.argtypes = [ + wintypes.HANDLE, + c_char, + wintypes.DWORD, + COORD, + POINTER(wintypes.DWORD), + ] + _FillConsoleOutputCharacterA.restype = wintypes.BOOL + + _FillConsoleOutputAttribute = windll.kernel32.FillConsoleOutputAttribute + _FillConsoleOutputAttribute.argtypes = [ + wintypes.HANDLE, + wintypes.WORD, + wintypes.DWORD, + COORD, + POINTER(wintypes.DWORD), + ] + _FillConsoleOutputAttribute.restype = wintypes.BOOL + + _SetConsoleTitleW = windll.kernel32.SetConsoleTitleW + _SetConsoleTitleW.argtypes = [ + wintypes.LPCWSTR + ] + _SetConsoleTitleW.restype = wintypes.BOOL + + def _winapi_test(handle): + csbi = CONSOLE_SCREEN_BUFFER_INFO() + success = _GetConsoleScreenBufferInfo( + handle, byref(csbi)) + return bool(success) + + def winapi_test(): + return any(_winapi_test(h) for h in + (_GetStdHandle(STDOUT), _GetStdHandle(STDERR))) + + def GetConsoleScreenBufferInfo(stream_id=STDOUT): + handle = _GetStdHandle(stream_id) + csbi = CONSOLE_SCREEN_BUFFER_INFO() + success = _GetConsoleScreenBufferInfo( + handle, byref(csbi)) + return csbi + + def SetConsoleTextAttribute(stream_id, attrs): + handle = _GetStdHandle(stream_id) + return _SetConsoleTextAttribute(handle, attrs) + + def SetConsoleCursorPosition(stream_id, position, adjust=True): + position = COORD(*position) + # If the position is out of range, do nothing. + if position.Y <= 0 or position.X <= 0: + return + # Adjust for Windows' SetConsoleCursorPosition: + # 1. being 0-based, while ANSI is 1-based. + # 2. expecting (x,y), while ANSI uses (y,x). + adjusted_position = COORD(position.Y - 1, position.X - 1) + if adjust: + # Adjust for viewport's scroll position + sr = GetConsoleScreenBufferInfo(STDOUT).srWindow + adjusted_position.Y += sr.Top + adjusted_position.X += sr.Left + # Resume normal processing + handle = _GetStdHandle(stream_id) + return _SetConsoleCursorPosition(handle, adjusted_position) + + def FillConsoleOutputCharacter(stream_id, char, length, start): + handle = _GetStdHandle(stream_id) + char = c_char(char.encode()) + length = wintypes.DWORD(length) + num_written = wintypes.DWORD(0) + # Note that this is hard-coded for ANSI (vs wide) bytes. + success = _FillConsoleOutputCharacterA( + handle, char, length, start, byref(num_written)) + return num_written.value + + def FillConsoleOutputAttribute(stream_id, attr, length, start): + ''' FillConsoleOutputAttribute( hConsole, csbi.wAttributes, dwConSize, coordScreen, &cCharsWritten )''' + handle = _GetStdHandle(stream_id) + attribute = wintypes.WORD(attr) + length = wintypes.DWORD(length) + num_written = wintypes.DWORD(0) + # Note that this is hard-coded for ANSI (vs wide) bytes. + return _FillConsoleOutputAttribute( + handle, attribute, length, start, byref(num_written)) + + def SetConsoleTitle(title): + return _SetConsoleTitleW(title) diff --git a/src/hunter/vendor/colorama/winterm.py b/src/hunter/vendor/colorama/winterm.py new file mode 100644 index 00000000..0fdb4ec4 --- /dev/null +++ b/src/hunter/vendor/colorama/winterm.py @@ -0,0 +1,169 @@ +# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file. +from . import win32 + + +# from wincon.h +class WinColor(object): + BLACK = 0 + BLUE = 1 + GREEN = 2 + CYAN = 3 + RED = 4 + MAGENTA = 5 + YELLOW = 6 + GREY = 7 + +# from wincon.h +class WinStyle(object): + NORMAL = 0x00 # dim text, dim background + BRIGHT = 0x08 # bright text, dim background + BRIGHT_BACKGROUND = 0x80 # dim text, bright background + +class WinTerm(object): + + def __init__(self): + self._default = win32.GetConsoleScreenBufferInfo(win32.STDOUT).wAttributes + self.set_attrs(self._default) + self._default_fore = self._fore + self._default_back = self._back + self._default_style = self._style + # In order to emulate LIGHT_EX in windows, we borrow the BRIGHT style. + # So that LIGHT_EX colors and BRIGHT style do not clobber each other, + # we track them separately, since LIGHT_EX is overwritten by Fore/Back + # and BRIGHT is overwritten by Style codes. + self._light = 0 + + def get_attrs(self): + return self._fore + self._back * 16 + (self._style | self._light) + + def set_attrs(self, value): + self._fore = value & 7 + self._back = (value >> 4) & 7 + self._style = value & (WinStyle.BRIGHT | WinStyle.BRIGHT_BACKGROUND) + + def reset_all(self, on_stderr=None): + self.set_attrs(self._default) + self.set_console(attrs=self._default) + self._light = 0 + + def fore(self, fore=None, light=False, on_stderr=False): + if fore is None: + fore = self._default_fore + self._fore = fore + # Emulate LIGHT_EX with BRIGHT Style + if light: + self._light |= WinStyle.BRIGHT + else: + self._light &= ~WinStyle.BRIGHT + self.set_console(on_stderr=on_stderr) + + def back(self, back=None, light=False, on_stderr=False): + if back is None: + back = self._default_back + self._back = back + # Emulate LIGHT_EX with BRIGHT_BACKGROUND Style + if light: + self._light |= WinStyle.BRIGHT_BACKGROUND + else: + self._light &= ~WinStyle.BRIGHT_BACKGROUND + self.set_console(on_stderr=on_stderr) + + def style(self, style=None, on_stderr=False): + if style is None: + style = self._default_style + self._style = style + self.set_console(on_stderr=on_stderr) + + def set_console(self, attrs=None, on_stderr=False): + if attrs is None: + attrs = self.get_attrs() + handle = win32.STDOUT + if on_stderr: + handle = win32.STDERR + win32.SetConsoleTextAttribute(handle, attrs) + + def get_position(self, handle): + position = win32.GetConsoleScreenBufferInfo(handle).dwCursorPosition + # Because Windows coordinates are 0-based, + # and win32.SetConsoleCursorPosition expects 1-based. + position.X += 1 + position.Y += 1 + return position + + def set_cursor_position(self, position=None, on_stderr=False): + if position is None: + # I'm not currently tracking the position, so there is no default. + # position = self.get_position() + return + handle = win32.STDOUT + if on_stderr: + handle = win32.STDERR + win32.SetConsoleCursorPosition(handle, position) + + def cursor_adjust(self, x, y, on_stderr=False): + handle = win32.STDOUT + if on_stderr: + handle = win32.STDERR + position = self.get_position(handle) + adjusted_position = (position.Y + y, position.X + x) + win32.SetConsoleCursorPosition(handle, adjusted_position, adjust=False) + + def erase_screen(self, mode=0, on_stderr=False): + # 0 should clear from the cursor to the end of the screen. + # 1 should clear from the cursor to the beginning of the screen. + # 2 should clear the entire screen, and move cursor to (1,1) + handle = win32.STDOUT + if on_stderr: + handle = win32.STDERR + csbi = win32.GetConsoleScreenBufferInfo(handle) + # get the number of character cells in the current buffer + cells_in_screen = csbi.dwSize.X * csbi.dwSize.Y + # get number of character cells before current cursor position + cells_before_cursor = csbi.dwSize.X * csbi.dwCursorPosition.Y + csbi.dwCursorPosition.X + if mode == 0: + from_coord = csbi.dwCursorPosition + cells_to_erase = cells_in_screen - cells_before_cursor + elif mode == 1: + from_coord = win32.COORD(0, 0) + cells_to_erase = cells_before_cursor + elif mode == 2: + from_coord = win32.COORD(0, 0) + cells_to_erase = cells_in_screen + else: + # invalid mode + return + # fill the entire screen with blanks + win32.FillConsoleOutputCharacter(handle, ' ', cells_to_erase, from_coord) + # now set the buffer's attributes accordingly + win32.FillConsoleOutputAttribute(handle, self.get_attrs(), cells_to_erase, from_coord) + if mode == 2: + # put the cursor where needed + win32.SetConsoleCursorPosition(handle, (1, 1)) + + def erase_line(self, mode=0, on_stderr=False): + # 0 should clear from the cursor to the end of the line. + # 1 should clear from the cursor to the beginning of the line. + # 2 should clear the entire line. + handle = win32.STDOUT + if on_stderr: + handle = win32.STDERR + csbi = win32.GetConsoleScreenBufferInfo(handle) + if mode == 0: + from_coord = csbi.dwCursorPosition + cells_to_erase = csbi.dwSize.X - csbi.dwCursorPosition.X + elif mode == 1: + from_coord = win32.COORD(0, csbi.dwCursorPosition.Y) + cells_to_erase = csbi.dwCursorPosition.X + elif mode == 2: + from_coord = win32.COORD(0, csbi.dwCursorPosition.Y) + cells_to_erase = csbi.dwSize.X + else: + # invalid mode + return + # fill the entire screen with blanks + win32.FillConsoleOutputCharacter(handle, ' ', cells_to_erase, from_coord) + # now set the buffer's attributes accordingly + win32.FillConsoleOutputAttribute(handle, self.get_attrs(), cells_to_erase, from_coord) + + def set_title(self, title): + win32.SetConsoleTitle(title) diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 00000000..2e311072 --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,17 @@ +import sys + +import pytest + +from hunter.actions import CallPrinter + + +@pytest.fixture(autouse=True) +def cleanup_CallPrinter(): + CallPrinter.cleanup() + + +@pytest.fixture(autouse=True) +def cleanup_samples(): + for mod in list(sys.modules): + if mod.startswith('sample'): + del sys.modules[mod] diff --git a/tests/eviltracer.pxd b/tests/eviltracer.pxd new file mode 100644 index 00000000..2fe9e112 --- /dev/null +++ b/tests/eviltracer.pxd @@ -0,0 +1,24 @@ +# cython: language_level=3str +cimport cython + + +cdef extern from "vendor/_compat.h": + """ + #if PY_VERSION_HEX >= 0x030B00A7 + #define Py_BUILD_CORE + #include "internal/pycore_frame.h" + #endif + """ + + ctypedef struct PyObject + + ctypedef class types.FrameType[object PyFrameObject, check_size ignore]: + pass + + +@cython.final +cdef class EvilTracer: + cdef readonly object _calls + cdef readonly object handler + cdef readonly object _tracer + cdef readonly int _stopped diff --git a/tests/eviltracer.pyx b/tests/eviltracer.pyx new file mode 100644 index 00000000..81d6aeb5 --- /dev/null +++ b/tests/eviltracer.pyx @@ -0,0 +1,36 @@ +# cython: language_level=3str, c_string_encoding=ascii, freethreading_compatible=True +import hunter + +from hunter._event cimport Event +from hunter._event cimport fast_detach + + +cdef class EvilTracer: + is_pure = False + + def __init__(self, *args, **kwargs): + self._calls = [] + threading_support = kwargs.pop('threading_support', False) + clear_env_var = kwargs.pop('clear_env_var', False) + self.handler = hunter._prepare_predicate(*args, **kwargs) + self._tracer = hunter.trace(self._append, threading_support=threading_support, clear_env_var=clear_env_var) + self._stopped = False + + def _append(self, Event event): + if self._stopped: + return + detached_event = fast_detach(event, lambda obj: obj) + detached_event.detached = False + detached_event.frame = event.frame + self._calls.append(detached_event) + + def __enter__(self): + self._stopped = False + return self + + def __exit__(self, exc_type, exc_val, exc_tb): + self._stopped = True + self._tracer.stop() + predicate = self.handler + for call in self._calls: + predicate(call) diff --git a/tests/sample.py b/tests/sample.py index 1a1b2027..8000ab4c 100644 --- a/tests/sample.py +++ b/tests/sample.py @@ -1,6 +1,8 @@ -if __name__ == "__main__": +if __name__ == '__main__': import os + a = os.path.join('a', 'b') + def foo(): return os.path.join('a', 'b') diff --git a/tests/sample2.py b/tests/sample2.py index 6b96aacf..9a0be3fe 100644 --- a/tests/sample2.py +++ b/tests/sample2.py @@ -1,5 +1,5 @@ # -*- encoding: utf-8 -*- -if __name__ == "__main__": # ăăăă +if __name__ == '__main__': # ăăăă import functools def deco(opt): @@ -7,7 +7,9 @@ def decorator(func): @functools.wraps(func) def wrapper(*args): return func(*args) + return wrapper + return decorator @deco(1) @@ -18,12 +20,12 @@ def foo(*args): foo( 'aăă', - 'b' + 'b', ) try: None( 'a', - 'b' + 'b', ) # dăh! except: pass diff --git a/tests/sample3.py b/tests/sample3.py index d2c2f68f..b58764ba 100644 --- a/tests/sample3.py +++ b/tests/sample3.py @@ -14,6 +14,7 @@ def b(): x = Bad() raise Exception(x) + a() try: b() diff --git a/tests/sample5.pyx b/tests/sample5.pyx index 119e9924..93f67988 100644 --- a/tests/sample5.pyx +++ b/tests/sample5.pyx @@ -1,8 +1,12 @@ -# cython: linetrace=True, language_level=3 -foo = bar = lambda x: x +# cython: linetrace=True, language_level=3str, freethreading_compatible=True +a = b = lambda x: x -@foo -@bar + +@a +@b def foo(): return 1 + +def bar(): + foo() diff --git a/tests/sample7.py b/tests/sample7.py index 66daec1f..13c8f157 100644 --- a/tests/sample7.py +++ b/tests/sample7.py @@ -30,5 +30,5 @@ def five(): return i -if __name__ == "__main__": +if __name__ == '__main__': one() diff --git a/tests/sample7args.py b/tests/sample7args.py new file mode 100644 index 00000000..3a20dfb8 --- /dev/null +++ b/tests/sample7args.py @@ -0,0 +1,57 @@ +from __future__ import print_function + + +def one(a=123, b='234', c={'3': [4, '5']}): + for i in range(1): # one + a = b = c['side'] = 'effect' + two() + + +def two(a=123, b='234', c={'3': [4, '5']}): + for i in range(1): # two + a = b = c['side'] = 'effect' + three() + + +def three(a=123, b='234', c={'3': [4, '5']}): + for i in range(1): # three + a = b = c['side'] = 'effect' + four() + + +def four(a=123, b='234', c={'3': [4, '5']}): + for i in range(1): # four + a = b = c['side'] = 'effect' + five() + + +def five(a=123, b='234', c={'3': [4, '5']}): + six() + six() + six() + a = b = c['side'] = in_five = 'effect' + for i in range(1): # five + return i # five + + +def six(): + pass + + +if __name__ == '__main__': + from hunter import * + + from utils import DebugCallPrinter + + trace( + Backlog( + stack=15, + vars=True, + action=DebugCallPrinter(' [' + 'backlog' + ']'), + function='five', + ).filter(~Q(function='six')), + action=DebugCallPrinter, + ) + one() + one() # make sure Backlog is reusable (doesn't have storage side-effects) + stop() diff --git a/tests/sample8errors.py b/tests/sample8errors.py index bd51b73c..a3057c0a 100644 --- a/tests/sample8errors.py +++ b/tests/sample8errors.py @@ -31,8 +31,8 @@ def silenced2(): def silenced3(): try: error() - finally: - return "mwhahaha" + except: + return 'mwhahaha' def silenced4(): diff --git a/tests/target.py b/tests/samplemanhole.py similarity index 60% rename from tests/target.py rename to tests/samplemanhole.py index 3a1e0b71..e4c2ac7f 100644 --- a/tests/target.py +++ b/tests/samplemanhole.py @@ -1,5 +1,4 @@ import os -import sys import time @@ -9,10 +8,9 @@ def stuff(): if __name__ == '__main__': - if sys.argv[1] == 'manhole': - from hunter import remote + from hunter import remote - remote.install() + remote.install() while True: stuff() diff --git a/tests/samplepdb.py b/tests/samplepdb.py new file mode 100644 index 00000000..2b22cdab --- /dev/null +++ b/tests/samplepdb.py @@ -0,0 +1,57 @@ +import os +import sys + +import hunter + + +def on_postmortem(): + print('Raising stuff ...', os.getpid()) + try: + raise Exception('BOOM!') + except Exception: + pdb.post_mortem() + + +def on_settrace(): + print('Doing stuff ...', os.getpid()) + pdb.set_trace() + + +def one(): + for i in range(2): # one + two() + + +def two(): + for i in range(2): # two + three() + + +def three(): + print('Debugme!') + + +def on_debugger(): + one() + + +if __name__ == '__main__': + if sys.argv[1] == 'pdb': + import pdb + from pdb import Pdb + elif sys.argv[1] == 'ipdb': + import ipdb as pdb + + Pdb = lambda: pdb + + if sys.argv[2] == 'debugger': + with hunter.trace(source__has='Debugme!', action=hunter.Debugger(Pdb)): + on_debugger() + else: + with hunter.trace(module='samplepdb'): + if sys.argv[2] == 'postmortem': + on_postmortem() + elif sys.argv[2] == 'settrace': + on_settrace() + else: + raise RuntimeError(sys.argv) diff --git a/tests/setup.py b/tests/setup.py index 59357ecb..28b332dd 100644 --- a/tests/setup.py +++ b/tests/setup.py @@ -4,6 +4,7 @@ from __future__ import print_function import os +import sys from glob import glob from os.path import dirname from os.path import join @@ -22,19 +23,28 @@ if __name__ == '__main__': setup( + long_description='', package_dir={'': 'tests'}, zip_safe=False, - setup_requires=[ - 'cython', - ] if Cython else [], - ext_modules=[ - Extension( - splitext(relpath(path, 'tests').replace(os.sep, '.'))[0], - sources=[path], - include_dirs=[dirname(path)], - define_macros=[('CYTHON_TRACE', '1')] - ) - for root, _, _ in os.walk('tests') - for path in glob(join(root, '*.pyx' if Cython else '*.c')) - ], + setup_requires=( + [ + 'cython', + ] + if Cython + else [] + ), + ext_modules=( + [] + if hasattr(sys, 'pypy_version_info') + else [ + Extension( + splitext(relpath(path, 'tests').replace(os.sep, '.'))[0], + sources=[path], + include_dirs=[dirname(path), 'src', 'src/hunter'], + define_macros=[('CYTHON_TRACE', '1'), ('CYTHON_USE_SYS_MONITORING', '0')], + ) + for root, _, _ in os.walk('tests') + for path in glob(join(root, '*.pyx' if Cython else '*.c')) + ] + ), ) diff --git a/tests/simple.py b/tests/simple.py index 760c4149..a8796d46 100644 --- a/tests/simple.py +++ b/tests/simple.py @@ -1,19 +1,17 @@ -""" s@tart +"""s@tart 1 2 3 4 """ # end -class Foo(object): + +class Foo: @staticmethod def a(*args): return args - b = staticmethod( - lambda *a: - a - ) + b = staticmethod(lambda *a: a) def deco(_): diff --git a/tests/test_config.py b/tests/test_config.py index 8997115c..eccab331 100644 --- a/tests/test_config.py +++ b/tests/test_config.py @@ -5,31 +5,82 @@ import hunter -@pytest.mark.parametrize('config', [ - ('foobar', (('x',), {'y': 1}), {}, - '''Failed to load hunter config from PYTHONHUNTERCONFIG 'foobar': NameError'''), - ('foobar=1', (('x',), {'y': 1}), {}, '''Discarded config from PYTHONHUNTERCONFIG foobar=1: '''), - ('foobar=1, force_colors=1', (('x',), {'y': 1}), {'force_colors': 1}, - '''Discarded config from PYTHONHUNTERCONFIG foobar=1: '''), - ('klass=123', (('x',), {'y': 1}), {'klass': 123}, ''), - ('stream=123', (('x',), {'y': 1}), {'stream': 123}, ''), - ('force_colors=123', (('x',), {'y': 1}), {'force_colors': 123}, ''), - ('filename_alignment=123', (('x',), {'y': 1}), {'filename_alignment': 123}, ''), - ('thread_alignment=123', (('x',), {'y': 1}), {'thread_alignment': 123}, ''), - ('repr_limit=123', (('x',), {'y': 1}), {'repr_limit': 123}, ''), - ('stdlib=0', (('x',), {'y': 1, 'stdlib': 0}), {}, ''), - ('clear_env_var=1', (('x',), {'y': 1, 'clear_env_var': 1}), {}, ''), - ('threading_support=1', (('x',), {'y': 1, 'threading_support': 1}), {}, ''), - ('threads_support=1', (('x',), {'y': 1, 'threads_support': 1}), {}, ''), - ('thread_support=1', (('x',), {'y': 1, 'thread_support': 1}), {}, ''), - ('threadingsupport=1', (('x',), {'y': 1, 'threadingsupport': 1}), {}, ''), - ('threadssupport=1', (('x',), {'y': 1, 'threadssupport': 1}), {}, ''), - ('threadsupport=1', (('x',), {'y': 1, 'threadsupport': 1}), {}, ''), - ('threading=1', (('x',), {'y': 1, 'threading': 1}), {}, ''), - ('threads=1', (('x',), {'y': 1, 'threads': 1}), {}, ''), - ('thread=1', (('x',), {'y': 1, 'thread': 1}), {}, ''), - ('', (('x',), {'y': 1}), {}, ''), -]) +@pytest.fixture(autouse=True) +def cleanup(): + hunter._default_trace_args = None + hunter._default_config.clear() + yield + hunter._default_trace_args = None + hunter._default_config.clear() + + +@pytest.mark.parametrize( + 'config', + [ + ( + 'foobar', + (('x',), {'y': 1}), + {}, + """Failed to load hunter config from PYTHONHUNTERCONFIG 'foobar': NameError""", + ), + ( + 'foobar=1', + (('x',), {'y': 1}), + {}, + """Discarded config from PYTHONHUNTERCONFIG foobar=1: """, + ), + ( + 'foobar=1, force_colors=1', + (('x',), {'y': 1}), + {'force_colors': 1}, + """Discarded config from PYTHONHUNTERCONFIG foobar=1: """, + ), + ('klass=123', (('x',), {'y': 1}), {'klass': 123}, ''), + ('stream=123', (('x',), {'y': 1}), {'stream': 123}, ''), + ('force_colors=123', (('x',), {'y': 1}), {'force_colors': 123}, ''), + ( + 'filename_alignment=123', + (('x',), {'y': 1}), + {'filename_alignment': 123}, + '', + ), + ( + 'thread_alignment=123', + (('x',), {'y': 1}), + {'thread_alignment': 123}, + '', + ), + ('repr_limit=123', (('x',), {'y': 1}), {'repr_limit': 123}, ''), + ('stdlib=0', (('x',), {'y': 1, 'stdlib': 0}), {}, ''), + ('clear_env_var=1', (('x',), {'y': 1, 'clear_env_var': 1}), {}, ''), + ( + 'threading_support=1', + (('x',), {'y': 1, 'threading_support': 1}), + {}, + '', + ), + ( + 'threads_support=1', + (('x',), {'y': 1, 'threads_support': 1}), + {}, + '', + ), + ('thread_support=1', (('x',), {'y': 1, 'thread_support': 1}), {}, ''), + ( + 'threadingsupport=1', + (('x',), {'y': 1, 'threadingsupport': 1}), + {}, + '', + ), + ('threadssupport=1', (('x',), {'y': 1, 'threadssupport': 1}), {}, ''), + ('threadsupport=1', (('x',), {'y': 1, 'threadsupport': 1}), {}, ''), + ('threading=1', (('x',), {'y': 1, 'threading': 1}), {}, ''), + ('threads=1', (('x',), {'y': 1, 'threads': 1}), {}, ''), + ('thread=1', (('x',), {'y': 1, 'thread': 1}), {}, ''), + ('', (('x',), {'y': 1}), {}, ''), + ], + ids=lambda x: repr(x), +) def test_config(monkeypatch, config, capsys): env, result, defaults, stderr = config monkeypatch.setitem(os.environ, 'PYTHONHUNTERCONFIG', env) diff --git a/tests/test_cookbook.py b/tests/test_cookbook.py index 0e8c71cf..982f6576 100644 --- a/tests/test_cookbook.py +++ b/tests/test_cookbook.py @@ -1,18 +1,17 @@ -import collections import contextlib import functools -import opcode import os import sys from logging import getLogger +from time import time import aspectlib import pytest import hunter -from hunter import CallPrinter -from hunter import CodePrinter -from hunter import VarsSnooper +from hunter.actions import RETURN_OPCODES +from hunter.actions import ColorStreamAction +from hunter.util import safe_repr try: from cStringIO import StringIO @@ -21,7 +20,7 @@ logger = getLogger(__name__) -pytest_plugins = 'pytester', +pytest_plugins = ('pytester',) def nothin(x): @@ -69,5 +68,126 @@ def no_probe(*args, **kwargs): @pytest.mark.parametrize('impl', [fast_probe, brief_probe, no_probe]) def test_probe(impl, benchmark): - with impl('%s.baz' % __name__, hunter.VarsPrinter('foo', stream=open(os.devnull, 'w')), kind="return", depth=0): - benchmark(bar) + with open(os.devnull, 'w') as stream: + with impl( + '%s.baz' % __name__, + hunter.VarsPrinter('foo', stream=stream), + kind='return', + depth=0, + ): + benchmark(bar) + + +class ProfileAction(ColorStreamAction): + # using ColorStreamAction brings this more in line with the other actions + # (stream option, coloring and such, see the other examples for colors) + def __init__(self, **kwargs): + self.timings = {} + super(ProfileAction, self).__init__(**kwargs) + + def __call__(self, event): + current_time = time() + # include event.builtin in the id so we don't have problems + # with Python reusing frame objects from the previous call for builtin calls + frame_id = id(event.frame), str(event.builtin) + + if event.kind == 'call': + self.timings[frame_id] = current_time, None + elif frame_id in self.timings: + start_time, exception = self.timings.pop(frame_id) + + # try to find a complete function name for display + function_object = event.function_object + if event.builtin: + function = '.{}'.format(event.arg.__name__) + elif function_object: + if hasattr(function_object, '__qualname__'): + function = '{}.{}'.format( + function_object.__module__, + function_object.__qualname__, + ) + else: + function = '{}.{}'.format(function_object.__module__, function_object.__name__) + else: + function = event.function + + if event.kind == 'exception': + # store the exception + # (there will be a followup 'return' event in which we deal with it) + self.timings[frame_id] = start_time, event.arg + elif event.kind == 'return': + delta = current_time - start_time + if event.instruction in RETURN_OPCODES: + # exception was discarded + self.output( + '{fore(BLUE)}{} returned: {}. Duration: {:.4f}s{RESET}\n', + function, + safe_repr(event.arg), + delta, + ) + else: + self.output( + '{fore(RED)}{} raised exception: {}. Duration: {:.4f}s{RESET}\n', + function, + safe_repr(exception), + delta, + ) + + +@pytest.mark.xfail( + sys.version_info.major == 3 and sys.version_info.minor == 12, + reason='broken on 3.12, fixme', +) +@pytest.mark.parametrize( + 'options', + [{'kind__in': ['call', 'return', 'exception']}, {'profile': True}], + ids=['kind__in=call,return,exception', 'profile=True'], +) +def test_profile(LineMatcher, options): + stream = StringIO() + with hunter.trace(action=ProfileAction(stream=stream), **options): + from sample8errors import notsilenced + from sample8errors import silenced1 + from sample8errors import silenced3 + from sample8errors import silenced4 + + silenced1() + print('Done silenced1') + silenced3() + print('Done silenced3') + silenced4() + print('Done silenced4') + + try: + notsilenced() + except ValueError: + print('Done not silenced') + + lm = LineMatcher(stream.getvalue().splitlines()) + if 'profile' in options: + lm.fnmatch_lines( + [ + 'sample8errors.error raised exception: None. Duration: ?.????s', + 'sample8errors.silenced1 returned: None. Duration: ?.????s', + 'sample8errors.error raised exception: None. Duration: ?.????s', + "sample8errors.silenced3 returned: 'mwhahaha'. Duration: ?.????s", + 'sample8errors.error raised exception: None. Duration: ?.????s', + '.repr raised exception: None. Duration: ?.????s', + 'sample8errors.silenced4 returned: None. Duration: ?.????s', + 'sample8errors.error raised exception: None. Duration: ?.????s', + 'sample8errors.notsilenced raised exception: None. Duration: ?.????s', + ] + ) + else: + lm.fnmatch_lines( + [ + 'sample8errors.error raised exception: (*RuntimeError*, *). Duration: ?.????s', + 'sample8errors.silenced1 returned: None. Duration: ?.????s', + 'sample8errors.error raised exception: (*RuntimeError*, *). Duration: ?.????s', + "sample8errors.silenced3 returned: 'mwhahaha'. Duration: ?.????s", + 'sample8errors.error raised exception: (*RuntimeError*, *). Duration: ?.????s', + 'sample8errors.silenced4 returned: None. Duration: ?.????s', + 'sample8errors.error raised exception: (*RuntimeError*, *). Duration: ?.????s', + 'sample8errors.notsilenced raised exception: (*ValueError(RuntimeError*, *). Duration: ?.????s', + ] + ) diff --git a/tests/test_integration.py b/tests/test_integration.py index 2c152a3c..03e05a2d 100644 --- a/tests/test_integration.py +++ b/tests/test_integration.py @@ -7,153 +7,165 @@ from pprint import pprint import pytest +from process_tests import TestProcess +from process_tests import dump_on_error +from process_tests import wait_for_strings -import hunter +from hunter import Backlog from hunter import CallPrinter from hunter import CodePrinter from hunter import Debugger from hunter import ErrorSnooper from hunter import Q +from hunter import StackPrinter +from hunter import Tracer from hunter import VarsPrinter from hunter import VarsSnooper from hunter import When -from hunter.actions import StackPrinter +from hunter import trace +from hunter import wrap + +from utils import TIMEOUT +from utils import DebugCallPrinter try: from cStringIO import StringIO except ImportError: from io import StringIO -pytest_plugins = 'pytester', - - -def _get_func_spec(func): - if hasattr(inspect, 'signature'): - return str(inspect.signature(func)) - if hasattr(inspect, 'getfullargspec'): - spec = inspect.getfullargspec(func) - else: - spec = inspect.getargspec(func) - return inspect.formatargspec(spec.args, spec.varargs) +pytest_plugins = ('pytester',) +@pytest.mark.xfail('cover' in os.getenv('TOX_ENV_NAME', ''), reason='develop envs are incomplete') def test_pth_activation(): module_name = os.path.__name__ - expected_module = '{0}.py'.format(module_name) - hunter_env = 'action=CodePrinter,module={!r},function="join"'.format(module_name) - func_spec = _get_func_spec(os.path.join) - expected_call = 'call def join{0}:'.format(func_spec) - + expected_module = '{0}'.format(module_name) + hunter_env = 'action=CallPrinter,module={!r},function="join"'.format(module_name) + expected_call = 'call => join(' + env = dict(os.environ, PYTHONHUNTER=hunter_env) + env.pop('COVERAGE_PROCESS_START', None) + env.pop('COV_CORE_SOURCE', None) output = subprocess.check_output( - ['python', os.path.join(os.path.dirname(__file__), 'sample.py')], - env=dict(os.environ, PYTHONHUNTER=hunter_env), + [sys.executable, os.path.join(os.path.dirname(__file__), 'sample.py')], + env=env, stderr=subprocess.STDOUT, ) assert expected_module.encode() in output assert expected_call.encode() in output +@pytest.mark.xfail('cover' in os.getenv('TOX_ENV_NAME', ''), reason='develop envs are incomplete') def test_pth_sample4(): env = dict(os.environ, PYTHONHUNTER='CodePrinter') env.pop('COVERAGE_PROCESS_START', None) env.pop('COV_CORE_SOURCE', None) output = subprocess.check_output( - ['python', os.path.join(os.path.dirname(__file__), 'sample4.py')], + [ + sys.executable, + os.path.join(os.path.dirname(__file__), 'sample4.py'), + ], env=env, stderr=subprocess.STDOUT, ) assert output +@pytest.mark.xfail('cover' in os.getenv('TOX_ENV_NAME', ''), reason='develop envs are incomplete') def test_pth_sample2(LineMatcher): env = dict(os.environ, PYTHONHUNTER="module='__main__',action=CodePrinter") env.pop('COVERAGE_PROCESS_START', None) env.pop('COV_CORE_SOURCE', None) output = subprocess.check_output( - ['python', os.path.join(os.path.dirname(__file__), 'sample2.py')], + [ + sys.executable, + os.path.join(os.path.dirname(__file__), 'sample2.py'), + ], env=env, stderr=subprocess.STDOUT, ) lm = LineMatcher(output.decode('utf-8').splitlines()) - lm.fnmatch_lines([ - '*tests*sample2.py:* call if __name__ == "__main__": #*', - '*tests*sample2.py:* line if __name__ == "__main__": #*', - '*tests*sample2.py:* line import functools', - '*tests*sample2.py:* line def deco(opt):', - '*tests*sample2.py:* line @deco(1)', - '*tests*sample2.py:* call def deco(opt):', - '*tests*sample2.py:* line def decorator(func):', - '*tests*sample2.py:* line return decorator', - '*tests*sample2.py:* return return decorator', - '* * ... return value: sys.getsizeof: *', + '*test_integration.py:* return * < sys.getsizeof', + ] + ) + else: + lm.fnmatch_lines( + [ + '*test_integration.py:* call * > *builtin*.getattr: *', + '*test_integration.py:* return * < *builtin*.getattr', + ] + ) def test_tracing_reinstall(LineMatcher): lines = StringIO() - with hunter.trace(CodePrinter(stream=lines)): + with trace(CodePrinter(stream=lines)): + def foo(): a = 2 sys.settrace(sys.gettrace()) @@ -189,26 +233,27 @@ def bar(): bar() print(lines.getvalue()) lm = LineMatcher(lines.getvalue().splitlines()) - lm.fnmatch_lines([ - "*test_*.py:* call def bar():", - "*test_*.py:* line a = 1", - "*test_*.py:* line foo()", - "*test_*.py:* call def foo():", - "*test_*.py:* line a = 2", - "*test_*.py:* line sys.settrace(sys.gettrace())", - "*test_*.py:* line a = 3", - "*test_*.py:* return a = 3", - "* ... return value: None", - "*test_*.py:* line a = 4", - "*test_*.py:* return a = 4", - "* ... return value: None", - - ]) + lm.fnmatch_lines( + [ + '*test_*.py:* call def bar():', + '*test_*.py:* line a = 1', + '*test_*.py:* line foo()', + '*test_*.py:* call def foo():', + '*test_*.py:* line a = 2', + '*test_*.py:* line sys.settrace(sys.gettrace())', + '*test_*.py:* line a = 3', + '*test_*.py:* return a = 3', + '* ... return value: None', + '*test_*.py:* line a = 4', + '*test_*.py:* return a = 4', + '* ... return value: None', + ] + ) def test_tracer_autostop(): - with hunter.trace(lambda: garbage) as tracer: - if os.environ.get("SETUPPY_CFLAGS") == "-DCYTHON_TRACE=1": + with trace(lambda: garbage) as tracer: + if os.environ.get('SETUPPY_EXT_COVERAGE') == 'yes': assert sys.gettrace() is not tracer else: assert sys.gettrace() is None @@ -226,24 +271,30 @@ def main(): else: os._exit(0) # child - with hunter.trace(actions=[Action(force_pid=force_pid, stream=sys.stdout), - VarsPrinter('a', force_pid=force_pid, stream=sys.stdout)], - stdlib=False, - threading_support=True): + with trace( + actions=[ + Action(force_pid=force_pid, stream=sys.stdout), + VarsPrinter('a', force_pid=force_pid, stream=sys.stdout), + ], + stdlib=False, + threading_support=True, + ): main() out, err = capfd.readouterr() print('OUT', out) print('ERR', err) lm = LineMatcher(out.splitlines()) prefix = '[[]*[]] *' if force_pid else '' - lm.fnmatch_lines_random([ - prefix + "MainThread *test_*.py:* line * a = 1", - prefix + "MainThread *test_*.py:* line * if pid:", - prefix + "MainThread *test_*.py:* line * [[]a => 1[]]", - prefix + "MainThread *test_*.py:* line * os.waitpid(pid, 0)", - "[[]*[]] *MainThread *test_*.py:* line * os._exit(0) # child", - "[[]*[]] *MainThread *test_*.py:* line * [[]a => 1[]]", - ]) + lm.fnmatch_lines_random( + [ + prefix + 'MainThread *test_*.py:* line * a = 1', + prefix + 'MainThread *test_*.py:* line * if pid:', + prefix + 'MainThread *test_*.py:* line * [[]a => 1[]]', + prefix + 'MainThread *test_*.py:* line * os.waitpid(pid, 0)', + '[[]*[]] *MainThread *test_*.py:* line * os._exit(0) # child', + '[[]*[]] *MainThread *test_*.py:* line * [[]a => 1[]]', + ] + ) def test_debugger(LineMatcher): @@ -257,14 +308,17 @@ def __init__(self, foobar=1): def set_trace(self, frame): calls.append(frame.f_code.co_name) - with hunter.trace( + with trace( lambda event: event.locals.get('node') == 'Foobar', module=__name__, function='foo', - actions=[CodePrinter, - VarsPrinter('a', 'node', 'foo', 'test_debugger', stream=out), - Debugger(klass=FakePDB, foobar=2)] + actions=[ + CodePrinter, + VarsPrinter('a', 'node', 'foo', 'test_debugger', stream=out), + Debugger(klass=FakePDB, foobar=2), + ], ): + def foo(): a = 1 node = 'Foobar' @@ -277,18 +331,21 @@ def foo(): assert calls == [2, 'foo'] lm = LineMatcher(out.getvalue().splitlines()) pprint(lm.lines) - lm.fnmatch_lines_random([ - "* [[]test_debugger => 'Foobar'[]]", - "* [[]a => 1[]]", - ]) + lm.fnmatch_lines_random( + [ + '* [[]test_debugger => 'Foobar'[]]", + '* [[]a => 1[]]', + ] + ) @pytest.mark.parametrize('depth', [2, 3, 4], ids='depth_lt={}'.format) def test_depth_limit(LineMatcher, depth): buff = StringIO() from sample7 import one - tracer = hunter.Tracer() + + tracer = Tracer() predicate = When(Q(depth_lt=depth), CallPrinter(stream=buff)) try: tracer.trace(predicate) @@ -297,15 +354,17 @@ def test_depth_limit(LineMatcher, depth): tracer.stop() output = buff.getvalue() lm = LineMatcher(output.splitlines()) - lm.fnmatch_lines([ - "* call => one()", - "* line for i in range(1): # one", - "* line two()", - "* call => two()", - "* return <= two: None", - "* line for i in range(1): # one", - "* return <= one: None", - ]) + lm.fnmatch_lines( + [ + '* call => one()', + '* line for i in range(1): # one', + '* line two()', + '* call => two()', + '* return <= two: None', + '* line for i in range(1): # one', + '* return <= one: None', + ] + ) if depth < 3: assert 'three' not in output if depth < 4: @@ -314,22 +373,28 @@ def test_depth_limit(LineMatcher, depth): assert 'five' not in output +@pytest.mark.xfail('cover' in os.getenv('TOX_ENV_NAME', ''), reason='develop envs are incomplete') @pytest.mark.parametrize('depth', [2, 3, 4], ids='depth_lt={}'.format) def test_depth_limit_subprocess(LineMatcher, depth): hunter_env = "action=CallPrinter,depth_lt={!r},kind_in=['call','return'],stdlib=0".format(depth + 1) output = subprocess.check_output( - ['python', os.path.join(os.path.dirname(__file__), 'sample7.py')], + [ + sys.executable, + os.path.join(os.path.dirname(__file__), 'sample7.py'), + ], env=dict(os.environ, PYTHONHUNTER=hunter_env, COV_CORE_DATAFILE=''), stderr=subprocess.STDOUT, ) output = output.decode('utf8') lm = LineMatcher(output.splitlines()) - lm.fnmatch_lines([ - "* call * => one()", - "* call * => two()", - "* return * <= two: None", - "* return * <= one: None", - ]) + lm.fnmatch_lines( + [ + '* call * => one()', + '* call * => two()', + '* return * <= two: None', + '* return * <= one: None', + ] + ) if depth < 3: assert '=> three' not in output if depth < 4: @@ -342,7 +407,7 @@ def test_varssnooper(LineMatcher): lines = StringIO() snooper = VarsSnooper(stream=lines) - @hunter.wrap(actions=[snooper, CodePrinter(stream=lines)]) + @wrap(actions=[snooper, CodePrinter(stream=lines)]) def a(): foo = bar = b = 1 b = 2 @@ -354,245 +419,413 @@ def a(): print(lines.getvalue()) lm = LineMatcher(lines.getvalue().splitlines()) - lm.fnmatch_lines([ - "*test_*.py* line foo = bar = b = 1", - "*test_*.py* line [[]b := 1[]]", - "* * ... [[]bar := 1[]]", - "* * ... [[]foo := 1[]]", - "*test_*.py* line b = 2", - "*test_*.py* line [[]b : 1 => 2[]]", - "*test_*.py* line foo = 3", - "*test_*.py* line [[]foo : 1 => 3[]]", - "*test_*.py* line foo = bar = 4", - "*test_*.py* line [[]bar : 1 => 4[]]", - "* * ... [[]foo : 3 => 4[]]", - "*test_*.py* line return b", - "*test_*.py* return return b", - "* * ... return value: 2", - ]) + lm.fnmatch_lines( + [ + '*test_*.py* line foo = bar = b = 1', + '*test_*.py* line [[]b := 1[]]', + '* * ... [[]bar := 1[]]', + '* * ... [[]foo := 1[]]', + '*test_*.py* line b = 2', + '*test_*.py* line [[]b : 1 => 2[]]', + '*test_*.py* line foo = 3', + '*test_*.py* line [[]foo : 1 => 3[]]', + '*test_*.py* line foo = bar = 4', + '*test_*.py* line [[]bar : 1 => 4[]]', + '* * ... [[]foo : 3 => 4[]]', + '*test_*.py* line return b', + '*test_*.py* return return b', + '* * ... return value: 2', + ] + ) assert snooper.stored_reprs == {} +@pytest.mark.xfail( + sys.version_info.major == 3 and sys.version_info.minor == 12, + reason='broken on 3.12, fixme', +) def test_errorsnooper(LineMatcher): lines = StringIO() snooper = ErrorSnooper(stream=lines, max_backlog=50, max_events=100) - @hunter.wrap(actions=[snooper]) + @wrap(actions=[snooper]) def a(): - from sample8errors import silenced1, silenced2, silenced3, silenced4, notsilenced + from sample8errors import notsilenced + from sample8errors import silenced1 + from sample8errors import silenced2 + from sample8errors import silenced3 + from sample8errors import silenced4 silenced1() - print("Done silenced1") + print('Done silenced1') silenced2() - print("Done silenced2") + print('Done silenced2') silenced3() - print("Done silenced3") + print('Done silenced3') silenced4() - print("Done silenced4") + print('Done silenced4') try: notsilenced() except ValueError: - print("Done not silenced") + print('Done not silenced') a() print(lines.getvalue()) lm = LineMatcher(lines.getvalue().splitlines()) - lm.fnmatch_lines([ - "*>>>>>>>>>>>>>>>>>>>>>> tracing silenced1 on (*RuntimeError*)", - "*test_*.py:* line silenced1()", - "*sample8errors.py:14 call def silenced1():", - "*sample8errors.py:15 line try:", - "*sample8errors.py:16 line error()", - "*sample8errors.py:6 call def error():", - "*sample8errors.py:7 line raise RuntimeError()", - "*sample8errors.py:7 exception raise RuntimeError()", - "* ... exception value: (*RuntimeError*)", - "*sample8errors.py:7 return raise RuntimeError()", - "* ... return value: None", - "*sample8errors.py:16 exception error()", - "* ... exception value: (*RuntimeError*)", - "*sample8errors.py:17 line except Exception:", - "*sample8errors.py:18 line pass", - "*sample8errors.py:18 return pass", - "* ... return value: None", - "*---------------------- function exit", - - "*>>>>>>>>>>>>>>>>>>>>>> tracing silenced2 on (*RuntimeError*)", - '*test_*.py:* line print("Done silenced1")', - "*test_*.py:* line silenced2()", - "*sample8errors.py:21 call def silenced2():", - "*sample8errors.py:22 line try:", - "*sample8errors.py:23 line error()", - "*sample8errors.py:6 call def error():", - "*sample8errors.py:7 line raise RuntimeError()", - "*sample8errors.py:7 exception raise RuntimeError()", - "* ... exception value: (*RuntimeError*)", - "*sample8errors.py:7 return raise RuntimeError()", - "* ... return value: None", - "*sample8errors.py:23 exception error()", - "* ... exception value: (*RuntimeError*)", - "*sample8errors.py:24 line except Exception as exc:", - "*sample8errors.py:25 line log(exc)", - "*sample8errors.py:10 call def log(msg):", - "*sample8errors.py:11 return print(msg)", - "* ... return value: None", - "*sample8errors.py:26 line for i in range(*):", - "*sample8errors.py:27 line log(i)", - "*sample8errors.py:10 call def log(msg):", - "*sample8errors.py:11 return print(msg)", - "* ... return value: None", - "*sample8errors.py:26 line for i in range(*):", - "*sample8errors.py:27 line log(i)", - "*sample8errors.py:10 call def log(msg):", - "*sample8errors.py:11 return print(msg)", - "* ... return value: None", - "*sample8errors.py:26 line for i in range(*):", - "*sample8errors.py:27 line log(i)", - "*sample8errors.py:10 call def log(msg):", - "*sample8errors.py:11 return print(msg)", - "* ... return value: None", - "*sample8errors.py:26 line for i in range(*):", - "*---------------------- too many lines", - - "*>>>>>>>>>>>>>>>>>>>>>> tracing silenced3 on (*RuntimeError*)", - '*test_*.py:* line print("Done silenced2")', - "*test_*.py:* line silenced3()", - "*sample8errors.py:31 call def silenced3():", - "*sample8errors.py:32 line try:", - "*sample8errors.py:33 line error()", - "*sample8errors.py:6 call def error():", - "*sample8errors.py:7 line raise RuntimeError()", - "*sample8errors.py:7 exception raise RuntimeError()", - "* ... exception value: (*RuntimeError*)", - "*sample8errors.py:7 return raise RuntimeError()", - "* ... return value: None", - "*sample8errors.py:33 exception error()", - "* ... exception value: (*RuntimeError*)", - '*sample8errors.py:35 line return "mwhahaha"', - '*sample8errors.py:35 return return "mwhahaha"', - "* ... return value: 'mwhahaha'", - "*---------------------- function exit", - - "*>>>>>>>>>>>>>>>>>>>>>> tracing silenced4 on (*RuntimeError*)", - '*test_*.py:* line print("Done silenced3")', - "*test_*.py:* line silenced4()", - "*sample8errors.py:38 call def silenced4():", - "*sample8errors.py:39 line try:", - "*sample8errors.py:40 line error()", - "*sample8errors.py:6 call def error():", - "*sample8errors.py:7 line raise RuntimeError()", - "*sample8errors.py:7 exception raise RuntimeError()", - "* ... exception value: (*RuntimeError*)", - "*sample8errors.py:7 return raise RuntimeError()", - "* ... return value: None", - "*sample8errors.py:40 exception error()", - "* ... exception value: (*RuntimeError*)", - "*sample8errors.py:41 line except Exception as exc:", - "*sample8errors.py:42 line logger.info(repr(exc))", - "*__init__.py:* call def info(self, msg, *args, **kwargs):", - "*sample8errors.py:42 return logger.info(repr(exc))", - "* ... return value: None", - "*---------------------- function exit", - ]) + lm.fnmatch_lines( + [ + '*>>>>>>>>>>>>>>>>>>>>>> tracing silenced1 on (*RuntimeError*)', + '*test_*.py:* line silenced1()', + '*sample8errors.py:14 call def silenced1():', + '*sample8errors.py:15 line try:', + '*sample8errors.py:16 line error()', + '*sample8errors.py:6 call def error():', + '*sample8errors.py:7 line raise RuntimeError()', + '*sample8errors.py:7 exception raise RuntimeError()', + '* ... exception value: (*RuntimeError*)', + '*sample8errors.py:7 return raise RuntimeError()', + '* ... return value: None', + '*sample8errors.py:16 exception error()', + '* ... exception value: (*RuntimeError*)', + '*sample8errors.py:17 line except Exception:', + '*sample8errors.py:18 line pass', + '*sample8errors.py:18 return pass', + '* ... return value: None', + '*---------------------- function exit', + '*>>>>>>>>>>>>>>>>>>>>>> tracing silenced2 on (*RuntimeError*)', + "*test_*.py:* line print('Done silenced1')", + '*test_*.py:* line silenced2()', + '*sample8errors.py:21 call def silenced2():', + '*sample8errors.py:22 line try:', + '*sample8errors.py:23 line error()', + '*sample8errors.py:6 call def error():', + '*sample8errors.py:7 line raise RuntimeError()', + '*sample8errors.py:7 exception raise RuntimeError()', + '* ... exception value: (*RuntimeError*)', + '*sample8errors.py:7 return raise RuntimeError()', + '* ... return value: None', + '*sample8errors.py:23 exception error()', + '* ... exception value: (*RuntimeError*)', + '*sample8errors.py:24 line except Exception as exc:', + '*sample8errors.py:25 line log(exc)', + '*sample8errors.py:10 call def log(msg):', + '*sample8errors.py:11 return print(msg)', + '* ... return value: None', + '*sample8errors.py:26 line for i in range(*):', + '*sample8errors.py:27 line log(i)', + '*---------------------- too many lines', + '*>>>>>>>>>>>>>>>>>>>>>> tracing silenced3 on (*RuntimeError*)', + "*test_*.py:* line print('Done silenced2')", + '*test_*.py:* line silenced3()', + '*sample8errors.py:31 call def silenced3():', + '*sample8errors.py:32 line try:', + '*sample8errors.py:33 line error()', + '*sample8errors.py:6 call def error():', + '*sample8errors.py:7 line raise RuntimeError()', + '*sample8errors.py:7 exception raise RuntimeError()', + '* ... exception value: (*RuntimeError*)', + '*sample8errors.py:7 return raise RuntimeError()', + '* ... return value: None', + '*sample8errors.py:33 exception error()', + '* ... exception value: (*RuntimeError*)', + "*sample8errors.py:35 line return 'mwhahaha'", + "*sample8errors.py:35 return return 'mwhahaha'", + "* ... return value: 'mwhahaha'", + '*---------------------- function exit', + '*>>>>>>>>>>>>>>>>>>>>>> tracing silenced4 on (*RuntimeError*)', + "*test_*.py:* line print('Done silenced3')", + '*test_*.py:* line silenced4()', + '*sample8errors.py:38 call def silenced4():', + '*sample8errors.py:39 line try:', + '*sample8errors.py:40 line error()', + '*sample8errors.py:6 call def error():', + '*sample8errors.py:7 line raise RuntimeError()', + '*sample8errors.py:7 exception raise RuntimeError()', + '* ... exception value: (*RuntimeError*)', + '*sample8errors.py:7 return raise RuntimeError()', + '* ... return value: None', + '*sample8errors.py:40 exception error()', + '* ... exception value: (*RuntimeError*)', + '*sample8errors.py:41 line except Exception as exc:', + '*sample8errors.py:42 line logger.info(repr(exc))', + '*__init__.py:* call def info(self, msg, *args, **kwargs):', + '*sample8errors.py:42 return logger.info(repr(exc))', + '* ... return value: None', + '*---------------------- function exit', + ] + ) +@pytest.mark.xfail( + sys.version_info.major == 3 and sys.version_info.minor == 12, + reason='broken on 3.12, fixme', +) def test_errorsnooper_fastmode(LineMatcher): lines = StringIO() snooper = ErrorSnooper(stream=lines, max_backlog=0, max_events=100) - @hunter.wrap(actions=[snooper]) + @wrap(actions=[snooper]) def a(): - from sample8errors import silenced1, silenced2, silenced3, silenced4, notsilenced + from sample8errors import notsilenced + from sample8errors import silenced1 + from sample8errors import silenced2 + from sample8errors import silenced3 + from sample8errors import silenced4 silenced1() - print("Done silenced1") + print('Done silenced1') silenced2() - print("Done silenced2") + print('Done silenced2') silenced3() - print("Done silenced3") + print('Done silenced3') silenced4() - print("Done silenced4") + print('Done silenced4') try: notsilenced() except ValueError: - print("Done not silenced") + print('Done not silenced') a() print(lines.getvalue()) lm = LineMatcher(lines.getvalue().splitlines()) - lm.fnmatch_lines([ - "*>>>>>>>>>>>>>>>>>>>>>> tracing silenced1 on (*RuntimeError*)", - "*sample8errors.py:17 line except Exception:", - "*sample8errors.py:18 line pass", - "*sample8errors.py:18 return pass", - "* ... return value: None", - "*---------------------- function exit", - - "*>>>>>>>>>>>>>>>>>>>>>> tracing silenced2 on (*RuntimeError*)", - "*sample8errors.py:24 line except Exception as exc:", - "*sample8errors.py:25 line log(exc)", - "*sample8errors.py:10 call def log(msg):", - "*sample8errors.py:11 return print(msg)", - "* ... return value: None", - "*sample8errors.py:26 line for i in range(*):", - "*sample8errors.py:27 line log(i)", - "*sample8errors.py:10 call def log(msg):", - "*sample8errors.py:11 return print(msg)", - "* ... return value: None", - "*sample8errors.py:26 line for i in range(*):", - "*sample8errors.py:27 line log(i)", - "*sample8errors.py:10 call def log(msg):", - "*sample8errors.py:11 return print(msg)", - "* ... return value: None", - "*sample8errors.py:26 line for i in range(*):", - "*sample8errors.py:27 line log(i)", - "*sample8errors.py:10 call def log(msg):", - "*sample8errors.py:11 return print(msg)", - "* ... return value: None", - "*sample8errors.py:26 line for i in range(*):", - "*---------------------- too many lines", - - "*>>>>>>>>>>>>>>>>>>>>>> tracing silenced3 on (*RuntimeError*)", - '*sample8errors.py:35 line return "mwhahaha"', - '*sample8errors.py:35 return return "mwhahaha"', - "* ... return value: 'mwhahaha'", - "*---------------------- function exit", - - "*>>>>>>>>>>>>>>>>>>>>>> tracing silenced4 on (*RuntimeError*)", - "*sample8errors.py:41 line except Exception as exc:", - "*sample8errors.py:42 line logger.info(repr(exc))", - "*__init__.py:* call def info(self, msg, *args, **kwargs):", - "*sample8errors.py:42 return logger.info(repr(exc))", - "* ... return value: None", - "*---------------------- function exit", - ]) + lm.fnmatch_lines( + [ + '*>>>>>>>>>>>>>>>>>>>>>> tracing silenced1 on (*RuntimeError*)', + '*sample8errors.py:17 line except Exception:', + '*sample8errors.py:18 line pass', + '*sample8errors.py:18 return pass', + '* ... return value: None', + '*---------------------- function exit', + '*>>>>>>>>>>>>>>>>>>>>>> tracing silenced2 on (*RuntimeError*)', + '*sample8errors.py:24 line except Exception as exc:', + '*sample8errors.py:25 line log(exc)', + '*sample8errors.py:10 call def log(msg):', + '*sample8errors.py:11 return print(msg)', + '* ... return value: None', + '*sample8errors.py:26 line for i in range(*):', + '*sample8errors.py:27 line log(i)', + '*---------------------- too many lines', + '*>>>>>>>>>>>>>>>>>>>>>> tracing silenced3 on (*RuntimeError*)', + "*sample8errors.py:35 line return 'mwhahaha'", + "*sample8errors.py:35 return return 'mwhahaha'", + "* ... return value: 'mwhahaha'", + '*---------------------- function exit', + '*>>>>>>>>>>>>>>>>>>>>>> tracing silenced4 on (*RuntimeError*)', + '*sample8errors.py:41 line except Exception as exc:', + '*sample8errors.py:42 line logger.info(repr(exc))', + '*__init__.py:* call def info(self, msg, *args, **kwargs):', + '*sample8errors.py:42 return logger.info(repr(exc))', + '* ... return value: None', + '*---------------------- function exit', + ] + ) def test_stack_printer_1(LineMatcher): buff = StringIO() - with hunter.trace(Q(function="five", action=StackPrinter(limit=1, stream=buff))): + with trace(Q(function='five', action=StackPrinter(limit=1, stream=buff))): from sample7 import one + one() output = buff.getvalue() lm = LineMatcher(output.splitlines()) - lm.fnmatch_lines([ - "*sample7.py:??:five <= sample7.py:??:four <= sample7.py:??:three <= sample7.py:??:two <= sample7.py:?:one <= test_integration.py:???:test_stack_printer*", - ]) + lm.fnmatch_lines( + [ + '*sample7.py:??:five <= sample7.py:??:four <= sample7.py:??:three <= sample7.py:??:two <= sample7.py:?:one <= test_integration.py:???:test_stack_printer*', + ] + ) def test_stack_printer_2(LineMatcher): buff = StringIO() - with hunter.trace(Q(function="five", action=StackPrinter(limit=2, stream=buff))): + with trace(Q(function='five', action=StackPrinter(limit=2, stream=buff))): from sample7 import one + one() output = buff.getvalue() lm = LineMatcher(output.splitlines()) - lm.fnmatch_lines([ - "*sample7.py:??:five <= tests/sample7.py:??:four <= tests/sample7.py:??:three <= tests/sample7.py:??:two <= tests/sample7.py:?:one <= tests/test_integration.py:???:test_stack_printer*", - ]) + lm.fnmatch_lines( + [ + '*sample7.py:??:five <= tests/sample7.py:??:four <= tests/sample7.py:??:three <= tests/sample7.py:??:two <= tests/sample7.py:?:one <= tests/test_integration.py:???:test_stack_printer*', + ] + ) + + +@pytest.mark.parametrize('stack', [5, 6], ids='stack={}'.format) +def test_backlog(LineMatcher, stack): + buff = StringIO() + from sample7args import one + + with trace( + Backlog( + fullsource_has='return i', + size=19, + stack=stack, + vars=False, + action=DebugCallPrinter(' [' + 'backlog' + ']', stream=buff), + ).filter(~Q(function='six')), + action=DebugCallPrinter(stream=buff), + ): + one() + one() # make sure Backlog is reusable (doesn't have storage side-effects) + output = buff.getvalue() + import re + + print(re.sub(r'([\[\]])', r'[\1]', output)) + # print(output) + lm = LineMatcher(output.splitlines()) + lm.fnmatch_lines( + [ + 'depth=0 calls=-1 *sample7args.py:* call => one(a=?, b=?, c=?) [[]backlog[]]', + 'depth=1 calls=?? *sample7args.py:* line two() [[]backlog[]]', + 'depth=1 calls=?? *sample7args.py:* call => two(a=?, b=?, c=?) [[]backlog[]]', + 'depth=2 calls=?? *sample7args.py:* line for i in range(1): # two [[]backlog[]]', + "depth=2 calls=?? *sample7args.py:* line a = b = c[[]'side'[]] = 'effect' [[]backlog[]]", + 'depth=2 calls=?? *sample7args.py:* line three() [[]backlog[]]', + 'depth=2 calls=?? *sample7args.py:* call => three(a=?, b=?, c=?) [[]backlog[]]', + 'depth=3 calls=?? *sample7args.py:* line for i in range(1): # three [[]backlog[]]', + "depth=3 calls=?? *sample7args.py:* line a = b = c[[]'side'[]] = 'effect' [[]backlog[]]", + 'depth=3 calls=?? *sample7args.py:* line four() [[]backlog[]]', + 'depth=3 calls=?? *sample7args.py:* call => four(a=?, b=?, c=?) [[]backlog[]]', + 'depth=4 calls=?? *sample7args.py:* line for i in range(1): # four [[]backlog[]]', + "depth=4 calls=?? *sample7args.py:* line a = b = c[[]'side'[]] = 'effect' [[]backlog[]]", + 'depth=4 calls=?? *sample7args.py:* line five() [[]backlog[]]', + 'depth=4 calls=?? *sample7args.py:* call => five(a=?, b=?, c=?) [[]backlog[]]', + 'depth=5 calls=?? *sample7args.py:* line six() [[]backlog[]]', + 'depth=5 calls=?? *sample7args.py:* line six() [[]backlog[]]', + 'depth=5 calls=?? *sample7args.py:* line six() [[]backlog[]]', + "depth=5 calls=?? *sample7args.py:* line a = b = c[[]'side'[]] = in_five = 'effect' [[]backlog[]]", + 'depth=5 calls=?? *sample7args.py:* line for i in range(1): # five [[]backlog[]]', + 'depth=5 calls=?? *sample7args.py:* line return i # five', + 'depth=4 calls=?? *sample7args.py:* return <= five: 0', + 'depth=0 calls=-1 *sample7args.py:* call => one(a=?, b=?, c=?) [[]backlog[]]', + 'depth=1 calls=?? *sample7args.py:* line two() [[]backlog[]]', + 'depth=1 calls=?? *sample7args.py:* call => two(a=?, b=?, c=?) [[]backlog[]]', + 'depth=2 calls=?? *sample7args.py:* line for i in range(1): # two [[]backlog[]]', + "depth=2 calls=?? *sample7args.py:* line a = b = c[[]'side'[]] = 'effect' [[]backlog[]]", + 'depth=2 calls=?? *sample7args.py:* line three() [[]backlog[]]', + 'depth=2 calls=?? *sample7args.py:* call => three(a=?, b=?, c=?) [[]backlog[]]', + 'depth=3 calls=?? *sample7args.py:* line for i in range(1): # three [[]backlog[]]', + "depth=3 calls=?? *sample7args.py:* line a = b = c[[]'side'[]] = 'effect' [[]backlog[]]", + 'depth=3 calls=?? *sample7args.py:* line four() [[]backlog[]]', + 'depth=3 calls=?? *sample7args.py:* call => four(a=?, b=?, c=?) [[]backlog[]]', + 'depth=4 calls=?? *sample7args.py:* line for i in range(1): # four [[]backlog[]]', + "depth=4 calls=?? *sample7args.py:* line a = b = c[[]'side'[]] = 'effect' [[]backlog[]]", + 'depth=4 calls=?? *sample7args.py:* line five() [[]backlog[]]', + 'depth=4 calls=?? *sample7args.py:* call => five(a=?, b=?, c=?) [[]backlog[]]', + 'depth=5 calls=?? *sample7args.py:* line six() [[]backlog[]]', + 'depth=5 calls=?? *sample7args.py:* line six() [[]backlog[]]', + 'depth=5 calls=?? *sample7args.py:* line six() [[]backlog[]]', + "depth=5 calls=?? *sample7args.py:* line a = b = c[[]'side'[]] = in_five = 'effect' [[]backlog[]]", + 'depth=5 calls=?? *sample7args.py:* line for i in range(1): # five [[]backlog[]]', + 'depth=5 calls=?? *sample7args.py:* line return i # five', + 'depth=4 calls=?? *sample7args.py:* return <= five: 0', + ] + ) + + +def test_backlog_subprocess(LineMatcher): + output = subprocess.check_output( + [ + sys.executable, + os.path.join(os.path.dirname(__file__), 'sample7args.py'), + ], + stderr=subprocess.STDOUT, + universal_newlines=True, + ) + import re + + print(re.sub(r'([\[\]])', r'[\1]', output)) + print(output) + lm = LineMatcher(output.splitlines()) + lm.fnmatch_lines( + [ + "depth=0 calls=0 *sample7args.py:4 call => one(a=123, b='234', c={'3': [[]4, '5'[]]}) [[]backlog[]]", + 'depth=1 calls=1 *sample7args.py:5 line for i in range(1): # one [[]backlog[]]', + "depth=1 calls=1 *sample7args.py:6 line a = b = c[[]'side'[]] = 'effect' [[]backlog[]]", + 'depth=1 calls=1 *sample7args.py:7 line two() [[]backlog[]]', + "depth=1 calls=1 *sample7args.py:10 call => two(a=123, b='234', c={'3': [[]4, '5'[]]}) [[]backlog[]]", + 'depth=2 calls=2 *sample7args.py:11 line for i in range(1): # two [[]backlog[]]', + "depth=2 calls=2 *sample7args.py:12 line a = b = c[[]'side'[]] = 'effect' [[]backlog[]]", + 'depth=2 calls=2 *sample7args.py:13 line three() [[]backlog[]]', + "depth=2 calls=2 *sample7args.py:16 call => three(a=123, b='234', c={'3': [[]4, '5'[]]}) [[]backlog[]]", + 'depth=3 calls=3 *sample7args.py:17 line for i in range(1): # three [[]backlog[]]', + "depth=3 calls=3 *sample7args.py:18 line a = b = c[[]'side'[]] = 'effect' [[]backlog[]]", + 'depth=3 calls=3 *sample7args.py:19 line four() [[]backlog[]]', + "depth=3 calls=3 *sample7args.py:22 call => four(a=123, b='234', c={'3': [[]4, '5'[]]}) [[]backlog[]]", + 'depth=4 calls=4 *sample7args.py:23 line for i in range(1): # four [[]backlog[]]', + "depth=4 calls=4 *sample7args.py:24 line a = b = c[[]'side'[]] = 'effect' [[]backlog[]]", + 'depth=4 calls=4 *sample7args.py:25 line five() [[]backlog[]]', + "depth=4 calls=4 *sample7args.py:28 call => five(a=123, b='234', c={'3': [[]4, '5'[]]})", + 'depth=5 calls=5 *sample7args.py:29 line six()', + 'depth=5 calls=6 *sample7args.py:30 line six()', + 'depth=5 calls=7 *sample7args.py:31 line six()', + "depth=5 calls=8 *sample7args.py:32 line a = b = c[[]'side'[]] = in_five = 'effect'", + 'depth=5 calls=8 *sample7args.py:33 line for i in range(1): # five', + 'depth=5 calls=8 *sample7args.py:34 line return i # five', + 'depth=4 calls=8 *sample7args.py:34 return <= five: 0', + "depth=0 calls=8 *sample7args.py:4 call => one(a=123, b='234', c={*'side': 'effect'*}) [[]backlog[]]", + 'depth=1 calls=9 *sample7args.py:5 line for i in range(1): # one [[]backlog[]]', + "depth=1 calls=9 *sample7args.py:6 line a = b = c[[]'side'[]] = 'effect' [[]backlog[]]", + 'depth=1 calls=9 *sample7args.py:7 line two() [[]backlog[]]', + "depth=1 calls=9 *sample7args.py:10 call => two(a=123, b='234', c={*'side': 'effect'*}) [[]backlog[]]", + 'depth=2 calls=10 *sample7args.py:11 line for i in range(1): # two [[]backlog[]]', + "depth=2 calls=10 *sample7args.py:12 line a = b = c[[]'side'[]] = 'effect' [[]backlog[]]", + 'depth=2 calls=10 *sample7args.py:13 line three() [[]backlog[]]', + "depth=2 calls=10 *sample7args.py:16 call => three(a=123, b='234', c={*'side': 'effect'*}) [[]backlog[]]", + 'depth=3 calls=11 *sample7args.py:17 line for i in range(1): # three [[]backlog[]]', + "depth=3 calls=11 *sample7args.py:18 line a = b = c[[]'side'[]] = 'effect' [[]backlog[]]", + 'depth=3 calls=11 *sample7args.py:19 line four() [[]backlog[]]', + "depth=3 calls=11 *sample7args.py:22 call => four(a=123, b='234', c={*'side': 'effect'*}) [[]backlog[]]", + 'depth=4 calls=12 *sample7args.py:23 line for i in range(1): # four [[]backlog[]]', + "depth=4 calls=12 *sample7args.py:24 line a = b = c[[]'side'[]] = 'effect' [[]backlog[]]", + 'depth=4 calls=12 *sample7args.py:25 line five() [[]backlog[]]', + "depth=4 calls=12 *sample7args.py:28 call => five(a=123, b='234', c={*'side': 'effect'*})", + 'depth=5 calls=13 *sample7args.py:29 line six()', + 'depth=5 calls=14 *sample7args.py:30 line six()', + 'depth=5 calls=15 *sample7args.py:31 line six()', + "depth=5 calls=16 *sample7args.py:32 line a = b = c[[]'side'[]] = in_five = 'effect'", + 'depth=5 calls=16 *sample7args.py:33 line for i in range(1): # five', + 'depth=5 calls=16 *sample7args.py:34 line return i # five', + 'depth=4 calls=16 *sample7args.py:34 return <= five: 0', + ] + ) + + +@pytest.mark.skipif( + sys.platform == 'win32' and sys.version_info[0] == 2, + reason='broken on windows 2.7', +) +@pytest.mark.parametrize( + 'pdb', + [ + 'pdb', + pytest.param('ipdb', marks=pytest.mark.skipif('platform.processor()=="aarch64"')), + ], +) +@pytest.mark.parametrize('mode', ['postmortem', 'settrace', 'debugger']) +def test_pdb(LineMatcher, pdb, mode): + with ( + TestProcess( + sys.executable, + '-msamplepdb', + pdb, + mode, + bufsize=0, + stdin=subprocess.PIPE, + ) as target, + dump_on_error(target.read), + ): + wait_for_strings(target.read, TIMEOUT, '-> ') + target.proc.stdin.write('c\n') + output = target.read() + assert 'TypeError' not in output + assert "'NoneType' object is not callable" not in output + assert 'Disabling tracer because handler' not in output + assert 'Traceback (most recent call last)' not in output diff --git a/tests/test_predicates.py b/tests/test_predicates.py index 68bb4364..c8a7ce76 100644 --- a/tests/test_predicates.py +++ b/tests/test_predicates.py @@ -6,6 +6,7 @@ import hunter from hunter import And +from hunter import Backlog from hunter import CallPrinter from hunter import CodePrinter from hunter import Debugger @@ -16,9 +17,11 @@ from hunter import Q from hunter import Query from hunter import When +from hunter import _Backlog +from hunter.actions import ColorStreamAction -class FakeCallable(object): +class FakeCallable: def __init__(self, value): self.value = value @@ -43,7 +46,14 @@ def __hash__(self): @pytest.fixture def mockevent(): - return hunter.Event(sys._getframe(0), 'line', None, hunter.Tracer()) + return hunter.Event( + sys._getframe(0), + 2 if '_event' in hunter.Event.__module__ else 'line', + None, + 0, + 0, + False, + ) def test_no_inf_recursion(mockevent): @@ -112,58 +122,64 @@ def test_when_allowed(): pytest.raises(TypeError, When, 1) -@pytest.mark.parametrize('expr,expected', [ - ({'module': __name__}, True), - ({'module': __name__ + '.'}, False), - ({'module_startswith': 'test'}, True), - ({'module__startswith': 'test'}, True), - ({'module_contains': 'test'}, True), - ({'module_contains': 'foo'}, False), - ({'module_endswith': 'foo'}, False), - ({'module__endswith': __name__.split('_')[-1]}, True), - ({'module_in': __name__}, True), - ({'module': 'abcd'}, False), - ({'module': ['abcd']}, False), - ({'module_in': ['abcd']}, False), - ({'module_in': ['a', __name__, 'd']}, True), - ({'module': 'abcd'}, False), - ({'module_startswith': ('abc', 'test')}, True), - ({'module_startswith': {'abc', 'test'}}, True), - ({'module_startswith': ['abc', 'test']}, True), - ({'module_startswith': ('abc', 'test')}, True), - ({'module_startswith': ('abc', 'test')}, True), - ({'module_startswith': ('abc', 'xyz')}, False), - ({'module_endswith': ('abc', __name__.split('_')[-1])}, True), - ({'module_endswith': {'abc', __name__.split('_')[-1]}}, True), - ({'module_endswith': ['abc', __name__.split('_')[-1]]}, True), - ({'module_endswith': ('abc', 'xyz')}, False), - ({'module': 'abc'}, False), - ({'module_regex': r'(_|_.*)\b'}, False), - ({'module_regex': r'.+_.+$'}, True), - ({'module_regex': r'(test|test.*)\b'}, True), - ({'calls_gte': 0}, True), - ({'calls_gt': 0}, False), - ({'calls_lte': 0}, True), - ({'calls_lt': 0}, False), - ({'calls_gte': 1}, False), - ({'calls_gt': -1}, True), - ({'calls_lte': -1}, False), - ({'calls_lt': 1}, True), -]) +@pytest.mark.parametrize( + 'expr,expected', + [ + ({'module': __name__}, True), + ({'module': __name__ + '.'}, False), + ({'module_startswith': 'test'}, True), + ({'module__startswith': 'test'}, True), + ({'module_contains': 'test'}, True), + ({'module_contains': 'foo'}, False), + ({'module_endswith': 'foo'}, False), + ({'module__endswith': __name__.split('_')[-1]}, True), + ({'module_in': __name__}, True), + ({'module': 'abcd'}, False), + ({'module': ['abcd']}, False), + ({'module_in': ['abcd']}, False), + ({'module_in': ['a', __name__, 'd']}, True), + ({'module': 'abcd'}, False), + ({'module_startswith': ('abc', 'test')}, True), + ({'module_startswith': {'abc', 'test'}}, True), + ({'module_startswith': ['abc', 'test']}, True), + ({'module_startswith': ('abc', 'test')}, True), + ({'module_startswith': ('abc', 'test')}, True), + ({'module_startswith': ('abc', 'xyz')}, False), + ({'module_endswith': ('abc', __name__.split('_')[-1])}, True), + ({'module_endswith': {'abc', __name__.split('_')[-1]}}, True), + ({'module_endswith': ['abc', __name__.split('_')[-1]]}, True), + ({'module_endswith': ('abc', 'xyz')}, False), + ({'module': 'abc'}, False), + ({'module_regex': r'(_|_.*)\b'}, False), + ({'module_regex': r'.+_.+$'}, True), + ({'module_regex': r'(test|test.*)\b'}, True), + ({'calls_gte': 0}, True), + ({'calls_gt': 0}, False), + ({'calls_lte': 0}, True), + ({'calls_lt': 0}, False), + ({'calls_gte': 1}, False), + ({'calls_gt': -1}, True), + ({'calls_lte': -1}, False), + ({'calls_lt': 1}, True), + ], +) def test_matching(expr, mockevent, expected): assert Query(**expr)(mockevent) == expected -@pytest.mark.parametrize('exc_type,expr', [ - (TypeError, {'module_1': 1}), - (TypeError, {'module1': 1}), - (ValueError, {'module_startswith': 1}), - (ValueError, {'module_startswith': {1: 2}}), - (ValueError, {'module_endswith': 1}), - (ValueError, {'module_endswith': {1: 2}}), - (TypeError, {'module_foo': 1}), - (TypeError, {'module_a_b': 1}), -]) +@pytest.mark.parametrize( + 'exc_type,expr', + [ + (TypeError, {'module_1': 1}), + (TypeError, {'module1': 1}), + (ValueError, {'module_startswith': 1}), + (ValueError, {'module_startswith': {1: 2}}), + (ValueError, {'module_endswith': 1}), + (ValueError, {'module_endswith': {1: 2}}), + (TypeError, {'module_foo': 1}), + (TypeError, {'module_a_b': 1}), + ], +) def test_bad_query(expr, exc_type): pytest.raises(exc_type, Query, **expr) @@ -181,10 +197,7 @@ def test_when(mockevent): assert called == [mockevent] called = [[], []] - predicate = ( - Q(module=__name__, action=lambda ev: called[0].append(ev)) | - Q(module='foo', action=lambda ev: called[1].append(ev)) - ) + predicate = Q(module=__name__, action=lambda ev: called[0].append(ev)) | Q(module='foo', action=lambda ev: called[1].append(ev)) assert predicate(mockevent) is True assert called == [[mockevent], []] @@ -192,10 +205,7 @@ def test_when(mockevent): assert called == [[mockevent, mockevent], []] called = [[], []] - predicate = ( - Q(module=__name__, action=lambda ev: called[0].append(ev)) & - Q(function='mockevent', action=lambda ev: called[1].append(ev)) - ) + predicate = Q(module=__name__, action=lambda ev: called[0].append(ev)) & Q(function='mockevent', action=lambda ev: called[1].append(ev)) assert predicate(mockevent) is True assert called == [[mockevent], [mockevent]] @@ -208,7 +218,13 @@ def test_from(mockevent): assert From(Q(module='foo') | Q(module='bar'), lambda ev: called.append(ev))(mockevent) is False assert called == [] - assert From(Not(Q(module='foo') | Q(module='bar')), lambda ev: called.append(ev))(mockevent) is None + assert ( + From( + Not(Q(module='foo') | Q(module='bar')), + lambda ev: called.append(ev), + )(mockevent) + is None + ) assert called called = [] @@ -216,6 +232,45 @@ def test_from(mockevent): assert called +def test_backlog(mockevent): + assert Backlog(module=__name__)(mockevent) is True + + class Action(ColorStreamAction): + called = [] + + def __call__(self, event): + self.called.append(event) + + assert Backlog(Q(module='foo') | Q(module='bar'), action=Action)(mockevent) is False + assert Action.called == [] + + backlog = Backlog(Not(Q(module='foo') | Q(module='bar')), action=Action) + assert backlog(mockevent) is True + assert backlog(mockevent) is True + assert Action.called == [] + + def predicate(ev, store=[]): + store.append(1) + return len(store) > 2 + + backlog = Backlog(predicate, action=Action, stack=0) + + assert backlog(mockevent) is False + assert backlog(mockevent) is False + assert backlog(mockevent) is True + assert len(Action.called) == 1 + + +def test_backlog_action_setup(): + assert isinstance(Backlog(module=1).action, CallPrinter) + assert isinstance(Backlog(module=1, action=CodePrinter).action, CodePrinter) + + class FakeAction(ColorStreamAction): + pass + + assert isinstance(Backlog(module=1, action=FakeAction).action, FakeAction) + + def test_and_or_kwargs(): assert And(1, function=2) == And(1, Query(function=2)) assert Or(1, function=2) == Or(1, Query(function=2)) @@ -227,6 +282,39 @@ def test_from_typeerror(): pytest.raises(TypeError, From, junk=1) +def test_backlog_typeerror(): + pytest.raises(TypeError, Backlog) + pytest.raises(TypeError, Backlog, junk=1) + pytest.raises(TypeError, Backlog, action=1) + pytest.raises(TypeError, Backlog, module=1, action=1) + pytest.raises(TypeError, Backlog, module=1, action=type) + + +def test_backlog_filter(): + class MyAction(ColorStreamAction): + def __eq__(self, other): + return True + + assert Backlog(Q(), action=MyAction).filter(function=1) == _Backlog(condition=Q(), filter=Query(function=1), action=MyAction) + assert Backlog(Q(), action=MyAction, filter=Q(module=1)).filter(function=2) == _Backlog( + condition=Q(), + filter=And(Query(module=1), Query(function=2)), + action=MyAction, + ) + + def blabla(): + pass + + assert Backlog(Q(), action=MyAction, filter=blabla).filter(function=1) == _Backlog( + condition=Q(), filter=And(blabla, Query(function=1)), action=MyAction + ) + assert Backlog(Q(), action=MyAction, filter=Q(module=1)).filter(blabla, function=2) == _Backlog( + condition=Q(), + filter=And(Query(module=1), blabla, Query(function=2)), + action=MyAction, + ) + + def test_and(mockevent): assert And(C(1), C(2)) == And(C(1), C(2)) assert Q(module=1) & Q(module=2) == And(Q(module=1), Q(module=2)) @@ -255,20 +343,20 @@ def test_str_repr(): assert repr(Q(module='a')).endswith("predicates.Query: query_eq=(('module', 'a'),)>") assert str(Q(module='a')) == "Query(module='a')" - assert "predicates.When: condition=, actions=('foo',)>" in repr(Q(module='a', action=C('foo'))) assert str(Q(module='a', action=C('foo'))) == "When(Query(module='a'), 'foo')" - assert "predicates.Not: predicate=>" in repr(~Q(module='a')) assert str(~Q(module='a')) == "Not(Query(module='a'))" - assert "predicates.Or: predicates=(, " in repr(Q(module='a') | Q(module='b')) assert repr(Q(module='a') | Q(module='b')).endswith("predicates.Query: query_eq=(('module', 'b'),)>)>") assert str(Q(module='a') | Q(module='b')) == "Or(Query(module='a'), Query(module='b'))" - assert "predicates.And: predicates=(," in repr(Q(module='a') & Q(module='b')) assert repr(Q(module='a') & Q(module='b')).endswith("predicates.Query: query_eq=(('module', 'b'),)>)>") assert str(Q(module='a') & Q(module='b')) == "And(Query(module='a'), Query(module='b'))" @@ -279,6 +367,15 @@ def test_str_repr(): ) assert str(From(module='a', depth_gte=2)) == "From(Query(module='a'), Query(depth_gte=2), watermark=0)" + assert ( + repr(Backlog(module='a', action=CodePrinter, size=2)) + .replace(', " + 'size=2, stack=10, vars=False, action=CodePrinter' + ) + ) + assert repr(Debugger()) == "Debugger(klass=, kwargs={})" assert str(Debugger()) == "Debugger(klass=, kwargs={})" @@ -286,22 +383,6 @@ def test_str_repr(): assert str(Manhole()) == 'Manhole(options={})' -def test_hashing(): - assert Q(module='a', function='b') in {Q(module='a', function='b')} - assert ~Q(module='a', function='b') in {~Q(module='a', function='b')} - assert (Q(module='a') | Q(function='b')) in {Q(module='a') | Q(function='b')} - assert (Q(module='a') & Q(function='b')) in {Q(module='a') & Q(function='b')} - assert Q(module='a', action=id) in {Q(module='a', action=id)} - assert From(module='a', depth_gte=2) in {From(module='a', depth_gte=2)} - - class Foo(object): - def __call__(self): - pass - - pytest.raises(TypeError, set, Q(module=object(), action=Foo())) - pytest.raises(TypeError, set, From(module=object(), depth_gte=object())) - - def test_q_deduplicate_callprinter(): out = repr(Q(CallPrinter(), action=CallPrinter())) assert out.startswith('CallPrinter(') diff --git a/tests/test_remote.py b/tests/test_remote.py index b110c7a1..76e28695 100644 --- a/tests/test_remote.py +++ b/tests/test_remote.py @@ -1,27 +1,27 @@ -import distutils.spawn -import os import platform import signal import sys +from shutil import which import pytest from process_tests import TestProcess from process_tests import dump_on_error from process_tests import wait_for_strings -TIMEOUT = int(os.getenv('HUNTER_TEST_TIMEOUT', 10)) +from utils import TIMEOUT -platform, distutils.spawn +platform.system() @pytest.mark.skipif('platform.system() == "Windows"') def test_manhole(): - with TestProcess('python', '-mtarget', 'manhole') as target, dump_on_error(target.read): + with TestProcess(sys.executable, '-msamplemanhole') as target, dump_on_error(target.read): wait_for_strings(target.read, TIMEOUT, 'Oneshot activation is done by signal') with TestProcess('hunter-trace', '-p', str(target.proc.pid), 'stdlib=False') as tracer, dump_on_error(tracer.read): wait_for_strings( - tracer.read, TIMEOUT, + tracer.read, + TIMEOUT, 'Output stream active. Starting tracer', 'call => stuff()', 'line time.sleep(1)', @@ -30,37 +30,71 @@ def test_manhole(): wait_for_strings(target.read, TIMEOUT, 'Broken pipe', 'Stopping tracer.') +@pytest.mark.skipif('platform.system() == "Windows"') +def test_manhole_reattach(): + with TestProcess(sys.executable, '-msamplemanhole') as target, dump_on_error(target.read): + wait_for_strings(target.read, TIMEOUT, 'Oneshot activation is done by signal') + + with TestProcess('hunter-trace', '-p', str(target.proc.pid), 'stdlib=False') as tracer, dump_on_error(tracer.read): + wait_for_strings( + tracer.read, + TIMEOUT, + 'Output stream active. Starting tracer', + 'call => stuff()', + 'line time.sleep(1)', + 'return <= stuff: None', + ) + tracer.proc.send_signal(signal.SIGINT) + + with TestProcess('hunter-trace', '-p', str(target.proc.pid), 'stdlib=False') as tracer, dump_on_error(tracer.read): + wait_for_strings( + tracer.read, + TIMEOUT, + 'Output stream active. Starting tracer', + ' => stuff()', + ' time.sleep(1)', + ' <= stuff: None', + ) + + wait_for_strings(target.read, TIMEOUT, 'Broken pipe', 'Stopping tracer.') + + @pytest.mark.skipif('platform.system() == "Windows"') def test_manhole_clean_exit(): - with TestProcess('python', '-mtarget', 'manhole') as target, dump_on_error(target.read): + with TestProcess(sys.executable, '-msamplemanhole') as target, dump_on_error(target.read): wait_for_strings(target.read, TIMEOUT, 'Oneshot activation is done by signal') with TestProcess('hunter-trace', '-p', str(target.proc.pid), 'stdlib=False') as tracer, dump_on_error(tracer.read): wait_for_strings( - tracer.read, TIMEOUT, + tracer.read, + TIMEOUT, 'Output stream active. Starting tracer', 'call => stuff()', 'line time.sleep(1)', 'return <= stuff: None', ) - target.reset() + target.buff.reset() tracer.proc.send_signal(signal.SIGINT) - wait_for_strings(target.read, TIMEOUT, - 'remote.deactivate()', - 'Doing stuff', - 'Doing stuff', - 'Doing stuff') + wait_for_strings( + target.read, + TIMEOUT, + 'remote.deactivate()', + 'Doing stuff', + 'Doing stuff', + 'Doing stuff', + ) @pytest.mark.skipif('platform.system() == "Windows"') +@pytest.mark.skipif('platform.machine() == "aarch64"') @pytest.mark.skipif('platform.python_implementation() == "PyPy"') -@pytest.mark.skipif('not distutils.spawn.find_executable("gdb")') +@pytest.mark.skipif('not which("gdb")') def test_gdb(): - with TestProcess('python', '-mtarget', 'manhole') as target, dump_on_error(target.read): - with TestProcess('hunter-trace', '-p', str(target.proc.pid), - '--gdb', 'stdlib=False') as tracer, dump_on_error(tracer.read): + with TestProcess(sys.executable, '-msamplemanhole') as target, dump_on_error(target.read): + with TestProcess('hunter-trace', '-p', str(target.proc.pid), '--gdb', 'stdlib=False') as tracer, dump_on_error(tracer.read): wait_for_strings( - tracer.read, TIMEOUT, + tracer.read, + TIMEOUT, 'WARNING: Using GDB may deadlock the process or create unpredictable results!', 'Output stream active. Starting tracer', 'call => stuff()', @@ -71,23 +105,21 @@ def test_gdb(): @pytest.mark.skipif('platform.system() == "Windows"') +@pytest.mark.skipif('platform.machine() == "aarch64"') @pytest.mark.skipif('platform.python_implementation() == "PyPy"') -@pytest.mark.skipif('not distutils.spawn.find_executable("gdb")') +@pytest.mark.skipif('not which("gdb")') def test_gdb_clean_exit(): - with TestProcess(sys.executable, '-mtarget', 'manhole') as target, dump_on_error(target.read): - with TestProcess('hunter-trace', '-p', str(target.proc.pid), - 'stdlib=False', '--gdb') as tracer, dump_on_error(tracer.read): + with TestProcess(sys.executable, '-msamplemanhole') as target, dump_on_error(target.read): + with TestProcess('hunter-trace', '-p', str(target.proc.pid), 'stdlib=False', '--gdb') as tracer, dump_on_error(tracer.read): wait_for_strings( - tracer.read, TIMEOUT, + tracer.read, + TIMEOUT, 'WARNING: Using GDB may deadlock the process or create unpredictable results!', 'Output stream active. Starting tracer', 'call => stuff()', 'line time.sleep(1)', 'return <= stuff: None', ) - target.reset() + target.buff.reset() tracer.proc.send_signal(signal.SIGINT) - wait_for_strings(target.read, TIMEOUT, - 'Doing stuff', - 'Doing stuff', - 'Doing stuff') + wait_for_strings(target.read, TIMEOUT, 'Doing stuff', 'Doing stuff', 'Doing stuff') diff --git a/tests/test_tracer.py b/tests/test_tracer.py index b3fe3dee..fe120a2c 100644 --- a/tests/test_tracer.py +++ b/tests/test_tracer.py @@ -1,16 +1,22 @@ from __future__ import print_function +import asyncio +import faulthandler import functools import os +import pickle import platform import sys import threading +from io import StringIO from pprint import pprint +from urllib.parse import urlencode import pytest import hunter from hunter import And +from hunter import Backlog from hunter import CallPrinter from hunter import CodePrinter from hunter import Debugger @@ -22,50 +28,63 @@ from hunter import When from hunter.actions import StackPrinter -try: - from cStringIO import StringIO -except ImportError: - from io import StringIO - -pytest_plugins = 'pytester', - -PY3 = sys.version_info[0] == 3 - - -class EvilFrame(object): - f_back = None - - def __init__(self, **kwargs): - self.__dict__.update(kwargs) - - -class EvilTracer(object): - def __init__(self, *args, **kwargs): - self._calls = [] - threading_support = kwargs.pop('threading_support', False) - clear_env_var = kwargs.pop('clear_env_var', False) - self.handler = hunter._prepare_predicate(*args, **kwargs) - self.is_pure = hunter.Tracer.__module__ == 'hunter.tracer' - self._tracer = hunter.trace(self._append, threading_support=threading_support, clear_env_var=clear_env_var) - - def _append(self, event): - detached_event = event.detach(lambda obj: obj) - if self.is_pure: - detached_event.frame = EvilFrame(f_lasti=event.frame.f_lasti, f_code=event.code) - self._calls.append(detached_event) - - def __enter__(self): - return self - - def __exit__(self, exc_type, exc_val, exc_tb): - self._tracer.stop() - predicate = self.handler - for call in self._calls: - predicate(call) - +from utils import DebugCallPrinter + +faulthandler.enable() + +if hunter.Tracer.__module__ == 'hunter.tracer': + + class EvilFrame: + f_back = None + f_globals = {} + f_locals = {} + f_lineno = 0 + + def __init__(self, **kwargs): + self.__dict__.update(kwargs) + + class EvilTracer: + is_pure = True + + def __init__(self, *args, **kwargs): + self._calls = [] + threading_support = kwargs.pop('threading_support', False) + clear_env_var = kwargs.pop('clear_env_var', False) + self.handler = hunter._prepare_predicate(*args, **kwargs) + self._tracer = hunter.trace( + self._append, + threading_support=threading_support, + clear_env_var=clear_env_var, + ) + + def _append(self, event): + detached_event = event.detach(lambda obj: obj) + detached_event.detached = False + detached_event.frame = EvilFrame( + f_globals=event.frame.f_globals, + f_locals=event.frame.f_locals, + f_back=event.frame.f_back, + f_lasti=event.frame.f_lasti, + f_code=event.code, + ) + self._calls.append(detached_event) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_val, exc_tb): + self._tracer.stop() + predicate = self.handler + for call in self._calls: + predicate(call) + +else: + from eviltracer import EvilTracer trace = EvilTracer +pytest_plugins = ('pytester',) + def test_mix_predicates_with_callables(): hunter._prepare_predicate(Q(module=1) | Q(lambda: 2)) @@ -80,7 +99,7 @@ def test_mix_predicates_with_callables(): def test_predicate_reverse_and_or(): - class Foobar(object): + class Foobar: def __str__(self): return 'Foobar' @@ -107,6 +126,14 @@ def __call__(self, *args, **kwargs): assert str(foobar | From(module=1, depth=2)) == 'Or(Foobar, From(Query(module=1), Query(depth=2), watermark=0))' assert str(foobar & ~From(module=1, depth=2)) == 'And(Foobar, Not(From(Query(module=1), Query(depth=2), watermark=0)))' assert str(foobar | ~From(module=1, depth=2)) == 'Or(Foobar, Not(From(Query(module=1), Query(depth=2), watermark=0)))' + assert str(From(module=1, depth=2) & foobar) == 'And(From(Query(module=1), Query(depth=2), watermark=0), Foobar)' + assert str(From(module=1, depth=2) | foobar) == 'Or(From(Query(module=1), Query(depth=2), watermark=0), Foobar)' + assert str(foobar & Backlog(module=1)).startswith('And(Foobar, Backlog(Query(module=1), ') + assert str(foobar | Backlog(module=1)).startswith('Or(Foobar, Backlog(Query(module=1), ') + assert str(foobar & ~Backlog(module=1)).startswith('And(Foobar, Backlog(Not(Query(module=1)), ') + assert str(foobar | ~Backlog(module=1)).startswith('Or(Foobar, Backlog(Not(Query(module=1)), ') + assert str(Backlog(module=1) & foobar).startswith('And(Backlog(Query(module=1), ') + assert str(Backlog(module=1) | foobar).startswith('Or(Backlog(Query(module=1), ') assert str(Q(module=1) & foobar) == 'And(Query(module=1), Foobar)' assert str(Q(module=1) | foobar) == 'Or(Query(module=1), Foobar)' assert str(~Q(module=1) & foobar) == 'And(Not(Query(module=1)), Foobar)' @@ -115,8 +142,6 @@ def __call__(self, *args, **kwargs): assert str(Q(module=1, action=foobar) | foobar) == 'Or(When(Query(module=1), Foobar), Foobar)' assert str(~Q(module=1, action=foobar) & foobar) == 'And(Not(When(Query(module=1), Foobar)), Foobar)' assert str(~Q(module=1, action=foobar) | foobar) == 'Or(Not(When(Query(module=1), Foobar)), Foobar)' - assert str(From(module=1, depth=2) & foobar) == 'And(From(Query(module=1), Query(depth=2), watermark=0), Foobar)' - assert str(From(module=1, depth=2) | foobar) == 'Or(From(Query(module=1), Query(depth=2), watermark=0), Foobar)' def test_threading_support(LineMatcher): @@ -130,9 +155,16 @@ def record(event): names.add(event.threadname) return True - with hunter.trace(record, - actions=[CodePrinter(stream=lines), VarsPrinter('a', stream=lines), CallPrinter(stream=lines)], - threading_support=True): + with hunter.trace( + record, + actions=[ + CodePrinter(stream=lines), + VarsPrinter('a', stream=lines), + CallPrinter(stream=lines), + ], + threading_support=True, + ): + def foo(a=1): started.set() print(a) @@ -149,16 +181,18 @@ def main(): assert idents - {t.ident} == {None} assert 'MainThread' in names assert any(name.startswith('Thread-') for name in names) - lm.fnmatch_lines_random([ - 'Thread-* *test_tracer.py:* call def foo(a=1):', - 'Thread-* *test_tracer.py:* call [[]a => 1[]]', - 'Thread-* *test_tracer.py:* call => foo(a=1)', - 'Thread-* *test_tracer.py:* call [[]a => 1[]]', - 'MainThread *test_tracer.py:* call def foo(a=1):', - 'MainThread *test_tracer.py:* call [[]a => 1[]]', - 'MainThread *test_tracer.py:* call => foo(a=1)', - 'MainThread *test_tracer.py:* call [[]a => 1[]]', - ]) + lm.fnmatch_lines_random( + [ + 'Thread-* *test_tracer.py:* call def foo(a=1):', + 'Thread-* *test_tracer.py:* call [[]a => 1[]]', + 'Thread-* *test_tracer.py:* call => foo(a=1)', + 'Thread-* *test_tracer.py:* call [[]a => 1[]]', + 'MainThread *test_tracer.py:* call def foo(a=1):', + 'MainThread *test_tracer.py:* call [[]a => 1[]]', + 'MainThread *test_tracer.py:* call => foo(a=1)', + 'MainThread *test_tracer.py:* call [[]a => 1[]]', + ] + ) @pytest.mark.parametrize('query', [{'threadid': None}, {'threadname': 'MainThread'}]) @@ -173,9 +207,17 @@ def record(event): names.add(event.threadname) return True - with hunter.trace(~Q(**query), record, - actions=[CodePrinter(stream=lines), VarsPrinter('a', stream=lines), CallPrinter(stream=lines)], - threading_support=True): + with hunter.trace( + ~Q(**query), + record, + actions=[ + CodePrinter(stream=lines), + VarsPrinter('a', stream=lines), + CallPrinter(stream=lines), + ], + threading_support=True, + ): + def foo(a=1): started.set() print(a) @@ -193,18 +235,26 @@ def main(): assert None not in idents assert 'MainThread' not in names pprint(lm.lines) - lm.fnmatch_lines_random([ - 'Thread-* *test_tracer.py:* call def foo(a=1):', - 'Thread-* *test_tracer.py:* call [[]a => 1[]]', - 'Thread-* *test_tracer.py:* call => foo(a=1)', - 'Thread-* *test_tracer.py:* call [[]a => 1[]]', - ]) + lm.fnmatch_lines_random( + [ + 'Thread-* *test_tracer.py:* call def foo(a=1):', + 'Thread-* *test_tracer.py:* call [[]a => 1[]]', + 'Thread-* *test_tracer.py:* call => foo(a=1)', + 'Thread-* *test_tracer.py:* call [[]a => 1[]]', + ] + ) def test_tracing_printing_failures(LineMatcher): lines = StringIO() - with trace(actions=[CodePrinter(stream=lines, repr_func=repr), VarsPrinter('x', stream=lines, repr_func=repr)]): - class Bad(object): + with trace( + actions=[ + CodePrinter(stream=lines, repr_func=repr), + VarsPrinter('x', stream=lines, repr_func=repr), + ] + ): + + class Bad: __slots__ = [] def __repr__(self): @@ -225,32 +275,35 @@ def b(): pass lm = LineMatcher(lines.getvalue().splitlines()) print(lines.getvalue()) - lm.fnmatch_lines([ - """*tests*test_*.py:* call class Bad(object):""", - """*tests*test_*.py:* line class Bad(object):""", - """*tests*test_*.py:* line def __repr__(self):""", - """*tests*test_*.py:* return def __repr__(self):""", - """* ... return value: *""", - """*tests*test_*.py:* call def a():""", - """*tests*test_*.py:* line x = Bad()""", - """*tests*test_*.py:* line return x""", - """*tests*test_*.py:* line [[]x => !!! FAILED REPR: RuntimeError("I'm a bad class!"*)[]]""", - """*tests*test_*.py:* return return x""", - """* ... return value: !!! FAILED REPR: RuntimeError("I'm a bad class!"*)""", - """*tests*test_*.py:* call def b():""", - """*tests*test_*.py:* line x = Bad()""", - """*tests*test_*.py:* line raise Exception(x)""", - """*tests*test_*.py:* line [[]x => !!! FAILED REPR: RuntimeError("I'm a bad class!"*)[]]""", - """*tests*test_*.py:* exception raise Exception(x)""", - """* ... exception value: !!! FAILED REPR: RuntimeError("I'm a bad class!"*)""", - """*tests*test_*.py:* return raise Exception(x)""", - """* ... return value: None""", - ]) + lm.fnmatch_lines( + [ + """*tests*test_*.py:* call class Bad:""", + """*tests*test_*.py:* line class Bad:""", + """*tests*test_*.py:* line def __repr__(self):""", + """*tests*test_*.py:* return def __repr__(self):""", + """* ... return value: *""", + """*tests*test_*.py:* call def a():""", + """*tests*test_*.py:* line x = Bad()""", + """*tests*test_*.py:* line return x""", + """*tests*test_*.py:* line [[]x => !!! FAILED REPR: RuntimeError("I'm a bad class!"*)[]]""", + """*tests*test_*.py:* return return x""", + """* ... return value: !!! FAILED REPR: RuntimeError("I'm a bad class!"*)""", + """*tests*test_*.py:* call def b():""", + """*tests*test_*.py:* line x = Bad()""", + """*tests*test_*.py:* line raise Exception(x)""", + """*tests*test_*.py:* line [[]x => !!! FAILED REPR: RuntimeError("I'm a bad class!"*)[]]""", + """*tests*test_*.py:* exception raise Exception(x)""", + """* ... exception value: !!! FAILED REPR: RuntimeError("I'm a bad class!"*)""", + """*tests*test_*.py:* return raise Exception(x)""", + """* ... return value: None""", + ] + ) def test_tracing_vars(LineMatcher): lines = StringIO() with hunter.trace(actions=[VarsPrinter('b', stream=lines), CodePrinter(stream=lines)]): + def a(): b = 1 b = 2 @@ -264,35 +317,50 @@ def a(): pass print(lines.getvalue()) lm = LineMatcher(lines.getvalue().splitlines()) - lm.fnmatch_lines([ - "*test_tracer.py* call def a():", - "*test_tracer.py* line b = 1", - "*test_tracer.py* line [[]b => 1[]]", - "*test_tracer.py* line b = 2", - "*test_tracer.py* line [[]b => 2[]]", - "*test_tracer.py* line return 1", - "*test_tracer.py* return [[]b => 2[]]", - "*test_tracer.py* return return 1", - "* ... return value: 1", - ]) + lm.fnmatch_lines( + [ + '*test_tracer.py* call def a():', + '*test_tracer.py* line b = 1', + '*test_tracer.py* line [[]b => 1[]]', + '*test_tracer.py* line b = 2', + '*test_tracer.py* line [[]b => 2[]]', + '*test_tracer.py* line return 1', + '*test_tracer.py* return [[]b => 2[]]', + '*test_tracer.py* return return 1', + '* ... return value: 1', + ] + ) def test_tracing_vars_expressions(LineMatcher): lines = StringIO() - with hunter.trace(actions=[VarsPrinter('Foo.bar', 'vars(Foo)', 'len(range(2))', 'Foo.__dict__["bar"]', stream=lines)]): + with hunter.trace( + actions=[ + VarsPrinter( + 'Foo.bar', + 'vars(Foo)', + 'len(range(2))', + 'Foo.__dict__["bar"]', + stream=lines, + ) + ] + ): + def main(): - class Foo(object): + class Foo: bar = 1 main() print(lines.getvalue()) lm = LineMatcher(lines.getvalue().splitlines()) - lm.fnmatch_lines_random([ - '* [[]Foo.bar => 1[]]', - '* [[]vars(Foo) => *[]]', - '* [[]len(range(2)) => 2[]]', - '* [[]Foo.__dict__[[]"bar"[]] => 1[]]', - ]) + lm.fnmatch_lines_random( + [ + '* [[]Foo.bar => 1[]]', + '* [[]vars(Foo) => *[]]', + '* [[]len(range(2)) => 2[]]', + '* [[]Foo.__dict__[[]"bar"[]] => 1[]]', + ] + ) def test_trace_merge(): @@ -323,30 +391,56 @@ def test_trace_api_expansion(): # pdb.set_trace when function is foobar, otherwise just print when module is foo with trace(Q(function='foobar', action=Debugger), module='foo') as t: - assert str(t.handler) == str(When(And( - When(Q(function='foobar'), Debugger), - Q(module='foo') - ), CallPrinter)) + assert str(t.handler) == str( + When( + And(When(Q(function='foobar'), Debugger), Q(module='foo')), + CallPrinter, + ) + ) # dumping variables from stack with trace(Q(function='foobar', action=VarsPrinter('foobar')), module='foo') as t: - assert str(t.handler) == str(When(And( - When(Q(function='foobar'), VarsPrinter('foobar')), - Q(module='foo'), - ), CallPrinter)) + assert str(t.handler) == str( + When( + And( + When(Q(function='foobar'), VarsPrinter('foobar')), + Q(module='foo'), + ), + CallPrinter, + ) + ) - with trace(Q(function='foobar', action=VarsPrinter('foobar', 'mumbojumbo')), module='foo') as t: - assert str(t.handler) == str(When(And( - When(Q(function='foobar'), VarsPrinter('foobar', 'mumbojumbo')), - Q(module='foo'), - ), CallPrinter)) + with trace( + Q(function='foobar', action=VarsPrinter('foobar', 'mumbojumbo')), + module='foo', + ) as t: + assert str(t.handler) == str( + When( + And( + When( + Q(function='foobar'), + VarsPrinter('foobar', 'mumbojumbo'), + ), + Q(module='foo'), + ), + CallPrinter, + ) + ) # multiple actions - with trace(Q(function='foobar', actions=[VarsPrinter('foobar'), Debugger]), module='foo') as t: - assert str(t.handler) == str(When(And( - When(Q(function='foobar'), VarsPrinter('foobar'), Debugger), - Q(module='foo'), - ), CallPrinter)) + with trace( + Q(function='foobar', actions=[VarsPrinter('foobar'), Debugger]), + module='foo', + ) as t: + assert str(t.handler) == str( + When( + And( + When(Q(function='foobar'), VarsPrinter('foobar'), Debugger), + Q(module='foo'), + ), + CallPrinter, + ) + ) def test_locals(): @@ -355,8 +449,9 @@ def test_locals(): lambda event: event.locals.get('node') == 'Foobar', module=__name__, function='foo', - action=CodePrinter(stream=out) + action=CodePrinter(stream=out), ): + def foo(): a = 1 node = 'Foobar' @@ -381,11 +476,13 @@ def foo(): foo() lm = LineMatcher(out.getvalue().splitlines()) - lm.fnmatch_lines([ - '* call @foo', - '* | @bar', - '* * def foo():', - ]) + lm.fnmatch_lines( + [ + '* call @foo', + '* | @bar', + '* * def foo():', + ] + ) def test_callprinter(LineMatcher): @@ -401,52 +498,56 @@ def foo(): foo() lm = LineMatcher(out.getvalue().splitlines()) - lm.fnmatch_lines([ - '* call => (x=)', - '* line foo = bar = lambda x: x', - '* return <= : ', - '* call => (x=)', - '* line foo = bar = lambda x: x', - '* return <= : ', - '* call => foo()', - '* line return 1', - '* return <= foo: 1', - ]) + lm.fnmatch_lines( + [ + '* call => (x=)', + '* line foo = bar = lambda x: x', + '* return <= : ', + '* call => (x=)', + '* line foo = bar = lambda x: x', + '* return <= : ', + '* call => foo()', + '* line return 1', + '* return <= foo: 1', + ] + ) def test_callprinter_indent(LineMatcher): from sample6 import bar + out = StringIO() with trace(action=CallPrinter(stream=out)): bar() lm = LineMatcher(out.getvalue().splitlines()) - lm.fnmatch_lines([ - "*sample6.py:1 call => bar()", - "*sample6.py:2 line foo()", - "*sample6.py:5 call => foo()", - "*sample6.py:6 line try:", - "*sample6.py:7 line asdf()", - "*sample6.py:16 call => asdf()", - "*sample6.py:17 line raise Exception()", - "*sample6.py:17 exception ! asdf: (<*Exception'>, Exception(), )", - "*sample6.py:17 return <= asdf: None", - "*sample6.py:7 exception ! foo: (<*Exception'>, Exception(), )", - "*sample6.py:8 line except:", - "*sample6.py:9 line pass", - "*sample6.py:10 line try:", - "*sample6.py:11 line asdf()", - "*sample6.py:16 call => asdf()", - "*sample6.py:17 line raise Exception()", - "*sample6.py:17 exception ! asdf: (<*Exception'>, Exception(), )", - "*sample6.py:17 return <= asdf: None", - "*sample6.py:11 exception ! foo: (<*Exception'>, Exception(), )", - "*sample6.py:12 line except:", - "*sample6.py:13 line pass", - "*sample6.py:13 return <= foo: None", - "*sample6.py:2 return <= bar: None", - - ]) + lm.fnmatch_lines( + [ + '*sample6.py:1 call => bar()', + '*sample6.py:2 line foo()', + '*sample6.py:5 call => foo()', + '*sample6.py:6 line try:', + '*sample6.py:7 line asdf()', + '*sample6.py:16 call => asdf()', + '*sample6.py:17 line raise Exception()', + "*sample6.py:17 exception ! asdf: (<*Exception'>, Exception(), )", + '*sample6.py:17 return <= asdf: None', + "*sample6.py:7 exception ! foo: (<*Exception'>, Exception(), )", + '*sample6.py:8 line except:', + '*sample6.py:9 line pass', + '*sample6.py:10 line try:', + '*sample6.py:11 line asdf()', + '*sample6.py:16 call => asdf()', + '*sample6.py:17 line raise Exception()', + "*sample6.py:17 exception ! asdf: (<*Exception'>, Exception(), )", + '*sample6.py:17 return <= asdf: None', + "*sample6.py:11 exception ! foo: (<*Exception'>, Exception(), )", + '*sample6.py:12 line except:', + '*sample6.py:13 line pass', + '*sample6.py:13 return <= foo: None', + '*sample6.py:2 return <= bar: None', + ] + ) def test_source(LineMatcher): @@ -462,11 +563,13 @@ def foo(): foo() lm = LineMatcher(calls) - lm.fnmatch_lines([ - ' foo = bar = lambda x: x\n', - ' @foo\n', - ' return 1\n', - ]) + lm.fnmatch_lines( + [ + ' foo = bar = lambda x: x\n', + ' @foo\n', + ' return 1\n', + ] + ) def test_wraps(LineMatcher): @@ -480,11 +583,96 @@ def foo(): lm = LineMatcher(calls) for line in calls: print(repr(line)) - lm.fnmatch_lines([ - "'call' calls=0 depth=0 @hunter.wrap*", - "'line' calls=1 depth=1 return 1\n", - "'return' calls=1 depth=0 return 1\n", - ]) + lm.fnmatch_lines( + [ + "'call' calls=0 depth=0 @hunter.wrap*", + "'line' calls=1 depth=1 return 1\n", + "'return' calls=1 depth=0 return 1\n", + ] + ) + for call in calls: + assert 'tracer.stop()' not in call + + +def test_wraps_generator(LineMatcher): + calls = [] + + @hunter.wrap(action=lambda event: calls.append('%6r calls=%r depth=%r %s' % (event.kind, event.calls, event.depth, event.fullsource))) + def foo(): + yield 1 + + assert list(foo()) == [1] + lm = LineMatcher(calls) + for line in calls: + print(repr(line)) + lm.fnmatch_lines( + [ + "'call' calls=0 depth=0 @hunter.wrap*", + "'line' calls=1 depth=1 yield 1\n", + "'return' calls=1 depth=0 yield 1\n", + ] + ) + for call in calls: + assert 'tracer.stop()' not in call + + +def test_wraps_async_generator(LineMatcher): + calls = [] + + @hunter.wrap( + action=lambda event: calls.append( + '%s %6r calls=%r depth=%r %s' % (event.module, event.kind, event.calls, event.depth, event.fullsource) + ) + ) + async def foo(): + yield 1 + await asyncio.sleep(0.01) + + async def runner(): + result = [] + async for item in foo(): + result.append(item) + return result + + assert asyncio.run(runner()) == [1] + lm = LineMatcher(calls) + for line in calls: + print(repr(line)) + lm.fnmatch_lines( + [ + "test_tracer 'call' calls=* depth=0 @hunter.wrap*", + "test_tracer 'line' calls=* depth=1 yield 1\n", + "test_tracer 'return' calls=* depth=0 yield 1\n", + ] + ) + for call in calls: + assert 'tracer.stop()' not in call + + +def test_wraps_coroutine(LineMatcher): + calls = [] + + @hunter.wrap( + action=lambda event: calls.append( + '%s %6r calls=%r depth=%r %s' % (event.module, event.kind, event.calls, event.depth, event.fullsource) + ) + ) + async def foo(): + await asyncio.sleep(0.01) + print(1) + return 1 + + assert asyncio.run(foo()) == 1 + lm = LineMatcher(calls) + for line in calls: + print(repr(line)) + lm.fnmatch_lines( + [ + "test_tracer 'call' calls=0 depth=0 @hunter.wrap*", + "test_tracer 'line' calls=1 depth=1 await asyncio.sleep(0.01)\n", + "test_tracer 'return' calls=* depth=0 await asyncio.sleep(0.01)\n", + ] + ) for call in calls: assert 'tracer.stop()' not in call @@ -496,8 +684,10 @@ def bar(): for i in range(2): return 'A' - @hunter.wrap(local=True, action=lambda event: calls.append( - '%06s calls=%s depth=%s %s' % (event.kind, event.calls, event.depth, event.fullsource))) + @hunter.wrap( + local=True, + action=lambda event: calls.append('%06s calls=%s depth=%s %s' % (event.kind, event.calls, event.depth, event.fullsource)), + ) def foo(): bar() return 1 @@ -506,21 +696,129 @@ def foo(): lm = LineMatcher(calls) for line in calls: print(repr(line)) - lm.fnmatch_lines([ - ' call calls=0 depth=0 @hunter.wrap*', - ' line calls=? depth=1 return 1\n', - 'return calls=? depth=0 return 1\n', - ]) + lm.fnmatch_lines( + [ + ' call calls=0 depth=0 @hunter.wrap*', + ' line calls=? depth=1 return 1\n', + 'return calls=? depth=0 return 1\n', + ] + ) + for call in calls: + assert 'for i in range(2)' not in call + assert 'tracer.stop()' not in call + + +def test_wraps_generator_local(LineMatcher): + calls = [] + + def bar(): + for i in range(2): + return 'A' + + @hunter.wrap( + local=True, action=lambda event: calls.append('%6r calls=%r depth=%r %s' % (event.kind, event.calls, event.depth, event.fullsource)) + ) + def foo(): + bar() + yield 1 + + assert list(foo()) == [1] + lm = LineMatcher(calls) + for line in calls: + print(repr(line)) + lm.fnmatch_lines( + [ + "'call' calls=0 depth=0 @hunter.wrap*", + "'line' calls=* depth=1 yield 1\n", + "'return' calls=* depth=0 yield 1\n", + ] + ) + for call in calls: + assert 'for i in range(2)' not in call + assert 'tracer.stop()' not in call + + +def test_wraps_async_generator_local(LineMatcher): + calls = [] + + def bar(): + for i in range(2): + return 'A' + + @hunter.wrap( + local=True, + action=lambda event: calls.append( + '%s %6r calls=%r depth=%r %s' % (event.module, event.kind, event.calls, event.depth, event.fullsource) + ), + ) + async def foo(): + bar() + yield 1 + await asyncio.sleep(0.01) + + async def runner(): + result = [] + async for item in foo(): + result.append(item) + return result + + assert asyncio.run(runner()) == [1] + lm = LineMatcher(calls) + for line in calls: + print(repr(line)) + lm.fnmatch_lines( + [ + "test_tracer 'call' calls=* depth=0 @hunter.wrap*", + "test_tracer 'line' calls=* depth=1 yield 1\n", + "test_tracer 'return' calls=* depth=0 yield 1\n", + ] + ) for call in calls: assert 'for i in range(2)' not in call assert 'tracer.stop()' not in call -@pytest.mark.skipif('os.environ.get("SETUPPY_CFLAGS") == "-DCYTHON_TRACE=1"') +def test_wraps_coroutine_local(LineMatcher): + calls = [] + + def bar(): + for i in range(2): + return 'A' + + @hunter.wrap( + local=True, + action=lambda event: calls.append( + '%s %6r calls=%r depth=%r %s' % (event.module, event.kind, event.calls, event.depth, event.fullsource) + ), + ) + async def foo(): + bar() + await asyncio.sleep(0.01) + print(1) + return 1 + + assert asyncio.run(foo()) == 1 + lm = LineMatcher(calls) + for line in calls: + print(repr(line)) + lm.fnmatch_lines( + [ + "test_tracer 'call' calls=0 depth=0 @hunter.wrap*", + "test_tracer 'line' calls=* depth=1 await asyncio.sleep(0.01)\n", + "test_tracer 'return' calls=* depth=0 await asyncio.sleep(0.01)\n", + ] + ) + for call in calls: + assert 'for i in range(2)' not in call + assert 'tracer.stop()' not in call + + +@pytest.mark.skipif('os.environ.get("SETUPPY_EXT_COVERAGE") == "yes"') def test_depth(): calls = [] tracer = hunter.trace(action=lambda event: calls.append((event.kind, event.module, event.function, event.depth))) try: + def bar(): for i in range(2): yield i @@ -544,23 +842,30 @@ def foo(): assert ('return', __name__, 'foo', 0) in calls +@pytest.mark.xfail( + sys.version_info.major == 3 and sys.version_info.minor == 12, + reason='broken on 3.12, see https://github.com/cython/cython/issues/5470', +) def test_source_cython(LineMatcher): pytest.importorskip('sample5') calls = [] - from sample5 import foo - with trace(action=lambda event: calls.append(event.source)): - foo() + from sample5 import bar + + with trace(action=lambda event: calls.extend(event.source.splitlines())): + bar() lm = LineMatcher(calls) - lm.fnmatch_lines([ - 'def foo():\n', - ' return 1\n', - ]) + lm.fnmatch_lines( + [ + 'def bar():', + ' return 1', + ] + ) def test_fullsource(LineMatcher): calls = [] - with trace(action=lambda event: calls.append(event.fullsource)): + with trace(action=lambda event: calls.extend(event.fullsource.splitlines())): foo = bar = lambda x: x @foo @@ -571,31 +876,43 @@ def foo(): foo() lm = LineMatcher(calls) - lm.fnmatch_lines([ - ' foo = bar = lambda x: x\n', - ' @foo\n @bar\n def foo():\n', - ' return 1\n', - ]) + lm.fnmatch_lines( + [ + ' foo = bar = lambda x: x', + ' @foo', + ' @bar', + ' def foo():', + ' return 1', + ] + ) +@pytest.mark.xfail( + sys.version_info.major == 3 and sys.version_info.minor == 12, + reason='broken on 3.12, see https://github.com/cython/cython/issues/5470', +) def test_fullsource_cython(LineMatcher): pytest.importorskip('sample5') calls = [] from sample5 import foo - with trace(action=lambda event: calls.append(event.fullsource)): + + with trace(action=lambda event: calls.extend(event.fullsource.splitlines())): foo() lm = LineMatcher(calls) - lm.fnmatch_lines([ - 'def foo():\n', - ' return 1\n', - ]) + lm.fnmatch_lines( + [ + 'def foo():', + ' return 1', + ] + ) def test_custom_action(): calls = [] with trace(action=lambda event: calls.append(event.function), kind='return'): + def foo(): return 1 @@ -605,6 +922,7 @@ def foo(): def test_trace_with_class_actions(): with trace(CodePrinter): + def a(): pass @@ -628,13 +946,14 @@ def tracer_impl(request): Tracer = pytest.importorskip('hunter._tracer').Tracer if Tracer is not hunter.Tracer: - pytest.skip("%s is not %s in this environment" % (Tracer, hunter.Tracer)) + pytest.skip('%s is not %s in this environment' % (Tracer, hunter.Tracer)) return Tracer def _bulky_func_that_use_stdlib(): import difflib + a = list(map(str, range(500))) b = list(map(str, range(0, 500, 2))) list(difflib.unified_diff(a, b, 'a', 'b')) @@ -643,7 +962,7 @@ def _bulky_func_that_use_stdlib(): def test_perf_filter(tracer_impl, benchmark): impl = tracer_impl() - class Counter(object): + class Counter: calls = 0 def inc(_): @@ -651,7 +970,7 @@ def inc(_): handler = Q( Q(module='does-not-exist') | Q(module='does not exist'.split()), - action=inc + action=inc, ) @benchmark @@ -668,14 +987,16 @@ def test_perf_stdlib(tracer_impl, benchmark): @benchmark def run(): output = StringIO() - with t.trace(Q( - ~Q(module_contains='pytest'), - ~Q(module_in=(__name__, 'hunter.tracer', 'hunter._tracer')), - ~Q(filename=''), - ~Q(filename=''), - stdlib=False, - action=CodePrinter(stream=output) - )): + with t.trace( + Q( + ~Q(module_contains='pytest'), + ~Q(module_in=(__name__, 'hunter.tracer', 'hunter._tracer')), + ~Q(filename=''), + ~Q(filename=''), + stdlib=False, + action=CodePrinter(stream=output), + ) + ): _bulky_func_that_use_stdlib() return output @@ -688,18 +1009,15 @@ def test_perf_actions(tracer_impl, benchmark): @benchmark def run(): output = StringIO() - with t.trace(Q( - ~Q(module_in=['re', 'sre', 'sre_parse']) & ~Q(module_startswith='namedtuple') & Q(kind='call'), - actions=[ - CodePrinter( - stream=output - ), - VarsPrinter( - 'line', - stream=output - ) - ] - )): + with t.trace( + Q( + ~Q(module_in=['re', 'sre', 'sre_parse']) & ~Q(module_startswith='namedtuple') & Q(kind='call'), + actions=[ + CodePrinter(stream=output), + VarsPrinter('line', stream=output), + ], + ) + ): _bulky_func_that_use_stdlib() @@ -717,16 +1035,19 @@ def test_clear_env_var(monkeypatch): def test_from_predicate(LineMatcher): buff = StringIO() from sample7 import one + with trace(From(Q(function='five'), CallPrinter(stream=buff))): one() output = buff.getvalue() lm = LineMatcher(output.splitlines()) - lm.fnmatch_lines([ - "* call => five()", - "* line for i in range(1): # five", - "* line return i", - "* return <= five: 0", - ]) + lm.fnmatch_lines( + [ + '* call => five()', + '* line for i in range(1): # five', + '* line return i', + '* return <= five: 0', + ] + ) assert '<= four' not in output assert 'three' not in output assert 'two' not in output @@ -736,35 +1057,47 @@ def test_from_predicate(LineMatcher): def test_from_predicate_with_subpredicate(LineMatcher): buff = StringIO() from sample7 import one - with trace(From(Q(source_has='# two'), Q(depth_lt=1)), action=CallPrinter(stream=buff)): + + with trace( + From(Q(source_has='# two'), Q(depth_lt=1)), + action=CallPrinter(stream=buff), + ): one() output = buff.getvalue() lm = LineMatcher(output.splitlines()) - lm.fnmatch_lines([ - '* line for i in range(1): # two', - '* line three()', - '* call => three()', - '* return <= three: None', - '* line for i in range(1): # two', - ]) + lm.fnmatch_lines( + [ + '* line for i in range(1): # two', + '* line three()', + '* call => three()', + '* return <= three: None', + '* line for i in range(1): # two', + ] + ) assert 'five' not in output assert 'four' not in output assert 'one()' not in output assert '# one' not in output - assert len(lm.lines) == 5 + if 'with trace' in output: + assert len(lm.lines) == 6, lm.lines + else: + assert len(lm.lines) == 5, lm.lines def test_from_predicate_line(LineMatcher): buff = StringIO() from sample7 import one + with trace(From(Q(fullsource_has='in_five'), CallPrinter(stream=buff))): one() output = buff.getvalue() lm = LineMatcher(output.splitlines()) - lm.fnmatch_lines([ - "* line * for i in range(1): # five", - "* line * return i", - ]) + lm.fnmatch_lines( + [ + '* line * for i in range(1): # five', + '* line * return i', + ] + ) assert 'four' not in output assert 'three' not in output assert 'two' not in output @@ -774,16 +1107,19 @@ def test_from_predicate_line(LineMatcher): def test_from_predicate_no_predicate(LineMatcher): buff = StringIO() from sample7 import one + with trace(From(Q(function='five')), action=CallPrinter(stream=buff)): one() output = buff.getvalue() lm = LineMatcher(output.splitlines()) - lm.fnmatch_lines([ - "* call => five()", - "* line for i in range(1): # five", - "* line return i", - "* return <= five: 0", - ]) + lm.fnmatch_lines( + [ + '* call => five()', + '* line for i in range(1): # five', + '* line return i', + '* return <= five: 0', + ] + ) assert '<= four' not in output assert 'three' not in output assert 'two' not in output @@ -793,20 +1129,138 @@ def test_from_predicate_no_predicate(LineMatcher): def test_from_predicate_line_no_predicate(LineMatcher): buff = StringIO() from sample7 import one + with trace(From(Q(fullsource_has='in_five')), action=CallPrinter(stream=buff)): one() output = buff.getvalue() lm = LineMatcher(output.splitlines()) - lm.fnmatch_lines([ - "* line * for i in range(1): # five", - "* line * return i", - ]) + lm.fnmatch_lines( + [ + '* line * for i in range(1): # five', + '* line * return i', + ] + ) assert 'four' not in output assert 'three' not in output assert 'two' not in output assert 'one' not in output +# def test_backlog_size_call(LineMatcher): +# backlog_buff = StringIO() +# tracer_buff = StringIO() +# from sample7 import one +# with trace( +# Backlog(function='five', size=5, action=CallPrinter(stream=backlog_buff)), +# action=CallPrinter(stream=tracer_buff) +# ): +# one() +# backlog_output = backlog_buff.getvalue() +# lm = LineMatcher(backlog_output.splitlines()) +# lm.fnmatch_lines([ +# "* line for i in range(1): # three", +# "* line four()", +# "* call => four()", +# "* line for i in range(1): # four", +# "* line five()", +# ]) +# assert '=> three' not in backlog_output +# assert '=> five()' not in backlog_output +# assert 'two' not in backlog_output +# assert 'one' not in backlog_output +# +# tracer_output = tracer_buff.getvalue() +# assert len(tracer_output.splitlines()) == 1 +# assert " call => five()" in tracer_output +# +# +# def test_backlog_size_line(LineMatcher): +# buff = StringIO() +# tracer_buff = StringIO() +# from sample7 import one +# with trace( +# Backlog(fullsource_has='return i', size=5, action=CallPrinter(stream=buff)), +# action=CallPrinter(stream=tracer_buff) +# ): +# one() +# output = buff.getvalue() +# lm = LineMatcher(output.splitlines()) +# lm.fnmatch_lines([ +# "* line for i in range(1): # four", +# "* line five()", +# "* call => five()", +# "* line in_five = 1", +# "* line for i in range(1): # five", +# ]) +# +# assert 'four' not in output +# +# tracer_output = tracer_buff.getvalue() +# assert len(tracer_output.splitlines()) == 1 +# assert " line return i" in tracer_output +# +# +# def test_backlog_size_call_filter(LineMatcher): +# buff = StringIO() +# tracer_buff = StringIO() +# from sample7 import one +# with trace( +# Backlog(function='five', size=5, action=CallPrinter(stream=buff)).filter(~Q(fullsource_has='four')), +# action=CallPrinter(stream=tracer_buff) +# ): +# one() +# output = buff.getvalue() +# lm = LineMatcher(output.splitlines()) +# lm.fnmatch_lines([ +# "* line for i in range(1): # two", +# "* line three()", +# "* call => three()", +# "* line for i in range(1): # three", +# "* line five()", +# ]) +# assert "four" not in output +# +# tracer_output = tracer_buff.getvalue() +# assert len(tracer_output.splitlines()) == 1 +# assert " call => five()" in tracer_buff.getvalue() +# +# +# def test_backlog_size_predicate_line_filter(LineMatcher): +# buff = StringIO() +# tracer_buff = StringIO() +# from sample7 import one +# with trace( +# Backlog(fullsource_has='return i', size=5, action=CallPrinter(stream=buff)).filter(~Q(fullsource_has="five")), +# action=CallPrinter(stream=tracer_buff) +# ): +# one() +# output = buff.getvalue() +# lm = LineMatcher(output.splitlines()) +# lm.fnmatch_lines([ +# "* call => three()", +# "* line for i in range(1): # three", +# "* line four()", +# "* call => four()", +# "* line for i in range(1): # four", +# ]) +# +# assert "five" not in output +# +# tracer_output = tracer_buff.getvalue() +# assert len(tracer_output.splitlines()) == 1 +# assert " line return i" in tracer_output +# +# +# def test_backlog_size_first_line_match(LineMatcher): +# buff = StringIO() +# tracer_buff = StringIO() +# from sample7 import one +# with trace(Backlog(fullsource_has='one', module_rx='sample7', size=100, action=CallPrinter(stream=buff)).filter(fullsource_has='one'), action=CallPrinter(stream=tracer_buff)): +# one() +# output = buff.getvalue() +# assert not output + + def decorator(func): @functools.wraps(func) def wrapper(*a, **k): @@ -837,7 +1291,7 @@ def old_m(self, _): pass -class Desc(object): +class Desc: def __init__(self, func): self.func = func @@ -845,7 +1299,7 @@ def __get__(self, instance, owner): return self.func -class New(object): +class New: @staticmethod def new_sm(_): pass @@ -869,7 +1323,7 @@ def lf(_): def dlf(_): pass - class Local(object): + class Local: @staticmethod def local_sm(_): pass @@ -887,14 +1341,18 @@ def local_m(self, _): global_ddm = Desc(dgf) buff = StringIO() - with trace(actions=[ - hunter.CallPrinter(stream=buff), - lambda event: buff.write( - "{0.function}({1})|{2}|{0.kind}\n".format( - event, - event.locals.get('_'), - getattr(event.function_object, '__name__', 'missing'))) - ]): + with trace( + actions=[ + hunter.CallPrinter(stream=buff), + lambda event: buff.write( + '{0.function}({1})|{2}|{0.kind}\n'.format( + event, + event.locals.get('_'), + getattr(event.function_object, '__name__', 'missing'), + ) + ), + ] + ): gf(1) dgf(2) lf(3) @@ -924,38 +1382,41 @@ def local_m(self, _): output = buff.getvalue() print(output) lm = LineMatcher(output.splitlines()) - lm.fnmatch_lines([ - "gf(1)|gf|call", - "dgf(2)|{}|call".format('dgf' if PY3 else 'missing'), - "lf(3)|missing|call", - "dlf(4)|missing|call", - "old_sm(5)|{}|call".format('old_sm' if PY3 else 'missing'), - "old_cm(6)|old_cm|call", - "old_sm(7)|{}|call".format('old_sm' if PY3 else 'missing'), - "old_cm(8)|old_cm|call", - "old_m(9)|old_m|call", - "new_sm(10)|new_sm|call", - "new_cm(11)|new_cm|call", - "new_sm(12)|new_sm|call", - "new_cm(13)|new_cm|call", - "new_m(14)|new_m|call", - "gf(15)|gf|call", - "dgf(16)|{}|call".format('dgf' if PY3 else 'missing'), - "local_sm(17)|missing|call", - "local_cm(18)|local_cm|call", - "local_sm(19)|missing|call", - "local_cm(20)|local_cm|call", - "local_m(21)|local_m|call", - "lf(22)|missing|call", - "dlf(23)|missing|call", - "gf(24)|gf|call", - "dgf(25)|{}|call".format('dgf' if PY3 else 'missing'), - ]) + lm.fnmatch_lines( + [ + 'gf(1)|gf|call', + 'dgf(2)|dgf|call', + 'lf(3)|missing|call', + 'dlf(4)|missing|call', + 'old_sm(5)|old_sm|call', + 'old_cm(6)|old_cm|call', + 'old_sm(7)|old_sm|call', + 'old_cm(8)|old_cm|call', + 'old_m(9)|old_m|call', + 'new_sm(10)|new_sm|call', + 'new_cm(11)|new_cm|call', + 'new_sm(12)|new_sm|call', + 'new_cm(13)|new_cm|call', + 'new_m(14)|new_m|call', + 'gf(15)|gf|call', + 'dgf(16)|dgf|call', + 'local_sm(17)|missing|call', + 'local_cm(18)|local_cm|call', + 'local_sm(19)|missing|call', + 'local_cm(20)|local_cm|call', + 'local_m(21)|local_m|call', + 'lf(22)|missing|call', + 'dlf(23)|missing|call', + 'gf(24)|gf|call', + 'dgf(25)|{}|call'.format('dgf'), + ] + ) def test_tracing_bare(LineMatcher): lines = StringIO() with trace(CodePrinter(stream=lines)): + def a(): return 1 @@ -967,15 +1428,37 @@ def a(): pass print(lines.getvalue()) lm = LineMatcher(lines.getvalue().splitlines()) - lm.fnmatch_lines([ - "*test_*.py* call def a():", - "*test_*.py* line return 1", - "*test_*.py* return return 1", - "* ... return value: 1", - ]) + lm.fnmatch_lines( + [ + '*test_*.py* call def a():', + '*test_*.py* line return 1', + '*test_*.py* return return 1', + '* ... return value: 1', + ] + ) + + +def test_pickle(): + out = [] + + def pickler(event): + out.append(event) + + with trace( + pickler, + module=__name__, + function='foo', + ): + + def foo(): + pass + + foo() + + with pytest.raises(TypeError, match="can.+t pickle '?hunter._?event.Event'? objects?") as exc: + pickle.dumps(out) -@pytest.mark.skipif("not os.environ.get('PUREPYTHONHUNTER')") def test_debugger(LineMatcher): out = StringIO() calls = [] @@ -985,16 +1468,19 @@ def __init__(self, foobar=1): calls.append(foobar) def set_trace(self, frame): - calls.append(frame.f_code.co_name) + calls.append(frame and frame.f_code.co_name) with trace( lambda event: event.locals.get('node') == 'Foobar', module=__name__, function='foo', - actions=[CodePrinter, - VarsPrinter('a', 'node', 'foo', 'test_debugger', stream=out), - Debugger(klass=FakePDB, foobar=2)] + actions=[ + CodePrinter, + VarsPrinter('a', 'node', 'foo', 'test_debugger', stream=out), + Debugger(klass=FakePDB, foobar=2), + ], ): + def foo(): a = 1 node = 'Foobar' @@ -1007,11 +1493,13 @@ def foo(): assert calls == [2, 'foo'] lm = LineMatcher(out.getvalue().splitlines()) pprint(lm.lines) - lm.fnmatch_lines_random([ - "* [[]test_debugger => *Foobar*[]]", - "* [[]a => 1[]]", - ]) + lm.fnmatch_lines_random( + [ + '* [[]test_debugger => *Foobar*[]]', + '* [[]a => 1[]]', + ] + ) def test_varssnooper(LineMatcher): @@ -1030,233 +1518,285 @@ def a(): print(lines.getvalue()) lm = LineMatcher(lines.getvalue().splitlines()) - lm.fnmatch_lines([ - "*test_*.py* line foo = bar = b = 1", - "*test_*.py* line [[]b := 1[]]", - "* * ... [[]bar := 1[]]", - "* * ... [[]foo := 1[]]", - "*test_*.py* line b = 2", - "*test_*.py* line [[]b : 1 => 2[]]", - "*test_*.py* line foo = 3", - "*test_*.py* line [[]foo : 1 => 3[]]", - "*test_*.py* line foo = bar = 4", - "*test_*.py* line [[]bar : 1 => 4[]]", - "* * ... [[]foo : 3 => 4[]]", - "*test_*.py* line return b", - "*test_*.py* return return b", - "* * ... return value: 2", - ]) + lm.fnmatch_lines( + [ + '*test_*.py* line foo = bar = b = 1', + '*test_*.py* line [[]b := 1[]]', + '* * ... [[]bar := 1[]]', + '* * ... [[]foo := 1[]]', + '*test_*.py* line b = 2', + '*test_*.py* line [[]b : 1 => 2[]]', + '*test_*.py* line foo = 3', + '*test_*.py* line [[]foo : 1 => 3[]]', + '*test_*.py* line foo = bar = 4', + '*test_*.py* line [[]bar : 1 => 4[]]', + '* * ... [[]foo : 3 => 4[]]', + '*test_*.py* line return b', + '*test_*.py* return return b', + '* * ... return value: 2', + ] + ) assert snooper.stored_reprs == {} -@pytest.mark.skipif("not os.environ.get('PUREPYTHONHUNTER')") +@pytest.mark.xfail( + sys.version_info.major == 3 and sys.version_info.minor == 12, + reason='broken on 3.12, fixme', +) def test_errorsnooper(LineMatcher): lines = StringIO() snooper = ErrorSnooper(stream=lines, max_backlog=50, max_events=100) def a(): - from sample8errors import silenced1, silenced2, silenced3, silenced4, notsilenced + from sample8errors import notsilenced + from sample8errors import silenced1 + from sample8errors import silenced2 + from sample8errors import silenced3 + from sample8errors import silenced4 silenced1() - print("Done silenced1") + print('Done silenced1') silenced2() - print("Done silenced2") + print('Done silenced2') silenced3() - print("Done silenced3") + print('Done silenced3') silenced4() - print("Done silenced4") + print('Done silenced4') try: notsilenced() except ValueError: - print("Done not silenced") + print('Done not silenced') with trace(actions=[snooper]): a() lm = LineMatcher(lines.getvalue().splitlines()) - lm.fnmatch_lines([ - "*>>>>>>>>>>>>>>>>>>>>>> tracing silenced1 on (*RuntimeError*)", - "*test_*.py:* line silenced1()", - "*sample8errors.py:14 call def silenced1():", - "*sample8errors.py:15 line try:", - "*sample8errors.py:16 line error()", - "*sample8errors.py:6 call def error():", - "*sample8errors.py:7 line raise RuntimeError()", - "*sample8errors.py:7 exception raise RuntimeError()", - "* ... exception value: (*RuntimeError*)", - "*sample8errors.py:7 return raise RuntimeError()", - "* ... return value: None", - "*sample8errors.py:16 exception error()", - "* ... exception value: (*RuntimeError*)", - "*sample8errors.py:17 line except Exception:", - "*sample8errors.py:18 line pass", - "*sample8errors.py:18 return pass", - "* ... return value: None", - "*---------------------- function exit", - - "*>>>>>>>>>>>>>>>>>>>>>> tracing silenced2 on (*RuntimeError*)", - '*test_*.py:* line print("Done silenced1")', - "*test_*.py:* line silenced2()", - "*sample8errors.py:21 call def silenced2():", - "*sample8errors.py:22 line try:", - "*sample8errors.py:23 line error()", - "*sample8errors.py:6 call def error():", - "*sample8errors.py:7 line raise RuntimeError()", - "*sample8errors.py:7 exception raise RuntimeError()", - "* ... exception value: (*RuntimeError*)", - "*sample8errors.py:7 return raise RuntimeError()", - "* ... return value: None", - "*sample8errors.py:23 exception error()", - "* ... exception value: (*RuntimeError*)", - "*sample8errors.py:24 line except Exception as exc:", - "*sample8errors.py:25 line log(exc)", - "*sample8errors.py:10 call def log(msg):", - "*sample8errors.py:11 return print(msg)", - "* ... return value: None", - "*sample8errors.py:26 line for i in range(*):", - "*sample8errors.py:27 line log(i)", - "*sample8errors.py:10 call def log(msg):", - "*sample8errors.py:11 return print(msg)", - "* ... return value: None", - "*sample8errors.py:26 line for i in range(*):", - "*sample8errors.py:27 line log(i)", - "*sample8errors.py:10 call def log(msg):", - "*sample8errors.py:11 return print(msg)", - "* ... return value: None", - "*sample8errors.py:26 line for i in range(*):", - "*sample8errors.py:27 line log(i)", - "*sample8errors.py:10 call def log(msg):", - "*sample8errors.py:11 return print(msg)", - "* ... return value: None", - "*sample8errors.py:26 line for i in range(*):", - "*---------------------- too many lines", - - "*>>>>>>>>>>>>>>>>>>>>>> tracing silenced3 on (*RuntimeError*)", - '*test_*.py:* line print("Done silenced2")', - "*test_*.py:* line silenced3()", - "*sample8errors.py:31 call def silenced3():", - "*sample8errors.py:32 line try:", - "*sample8errors.py:33 line error()", - "*sample8errors.py:6 call def error():", - "*sample8errors.py:7 line raise RuntimeError()", - "*sample8errors.py:7 exception raise RuntimeError()", - "* ... exception value: (*RuntimeError*)", - "*sample8errors.py:7 return raise RuntimeError()", - "* ... return value: None", - "*sample8errors.py:33 exception error()", - "* ... exception value: (*RuntimeError*)", - '*sample8errors.py:35 line return "mwhahaha"', - '*sample8errors.py:35 return return "mwhahaha"', - "* ... return value: 'mwhahaha'", - "*---------------------- function exit", - - "*>>>>>>>>>>>>>>>>>>>>>> tracing silenced4 on (*RuntimeError*)", - '*test_*.py:* line print("Done silenced3")', - "*test_*.py:* line silenced4()", - "*sample8errors.py:38 call def silenced4():", - "*sample8errors.py:39 line try:", - "*sample8errors.py:40 line error()", - "*sample8errors.py:6 call def error():", - "*sample8errors.py:7 line raise RuntimeError()", - "*sample8errors.py:7 exception raise RuntimeError()", - "* ... exception value: (*RuntimeError*)", - "*sample8errors.py:7 return raise RuntimeError()", - "* ... return value: None", - "*sample8errors.py:40 exception error()", - "* ... exception value: (*RuntimeError*)", - "*sample8errors.py:41 line except Exception as exc:", - "*sample8errors.py:42 line logger.info(repr(exc))", - "*__init__.py:* call def info(self, msg, *args, **kwargs):", - "*sample8errors.py:42 return logger.info(repr(exc))", - "* ... return value: None", - "*---------------------- function exit", - ]) - - -@pytest.mark.skipif("not os.environ.get('PUREPYTHONHUNTER')") + lm.fnmatch_lines( + [ + '*>>>>>>>>>>>>>>>>>>>>>> tracing silenced1 on (*RuntimeError*)', + '*test_*.py:* line silenced1()', + '*sample8errors.py:14 call def silenced1():', + '*sample8errors.py:15 line try:', + '*sample8errors.py:16 line error()', + '*sample8errors.py:6 call def error():', + '*sample8errors.py:7 line raise RuntimeError()', + '*sample8errors.py:7 exception raise RuntimeError()', + '* ... exception value: (*RuntimeError*)', + '*sample8errors.py:7 return raise RuntimeError()', + '* ... return value: None', + '*sample8errors.py:16 exception error()', + '* ... exception value: (*RuntimeError*)', + '*sample8errors.py:17 line except Exception:', + '*sample8errors.py:18 line pass', + '*sample8errors.py:18 return pass', + '* ... return value: None', + '*---------------------- function exit', + '*>>>>>>>>>>>>>>>>>>>>>> tracing silenced2 on (*RuntimeError*)', + "*test_*.py:* line print('Done silenced1')", + '*test_*.py:* line silenced2()', + '*sample8errors.py:21 call def silenced2():', + '*sample8errors.py:22 line try:', + '*sample8errors.py:23 line error()', + '*sample8errors.py:6 call def error():', + '*sample8errors.py:7 line raise RuntimeError()', + '*sample8errors.py:7 exception raise RuntimeError()', + '* ... exception value: (*RuntimeError*)', + '*sample8errors.py:7 return raise RuntimeError()', + '* ... return value: None', + '*sample8errors.py:23 exception error()', + '* ... exception value: (*RuntimeError*)', + '*sample8errors.py:24 line except Exception as exc:', + '*sample8errors.py:25 line log(exc)', + '*sample8errors.py:10 call def log(msg):', + '*sample8errors.py:11 return print(msg)', + '* ... return value: None', + '*sample8errors.py:26 line for i in range(*):', + '*sample8errors.py:27 line log(i)', + '*---------------------- too many lines', + '*>>>>>>>>>>>>>>>>>>>>>> tracing silenced3 on (*RuntimeError*)', + "*test_*.py:* line print('Done silenced2')", + '*test_*.py:* line silenced3()', + '*sample8errors.py:31 call def silenced3():', + '*sample8errors.py:32 line try:', + '*sample8errors.py:33 line error()', + '*sample8errors.py:6 call def error():', + '*sample8errors.py:7 line raise RuntimeError()', + '*sample8errors.py:7 exception raise RuntimeError()', + '* ... exception value: (*RuntimeError*)', + '*sample8errors.py:7 return raise RuntimeError()', + '* ... return value: None', + '*sample8errors.py:33 exception error()', + '* ... exception value: (*RuntimeError*)', + "*sample8errors.py:35 line return 'mwhahaha'", + "*sample8errors.py:35 return return 'mwhahaha'", + "* ... return value: 'mwhahaha'", + '*---------------------- function exit', + '*>>>>>>>>>>>>>>>>>>>>>> tracing silenced4 on (*RuntimeError*)', + "*test_*.py:* line print('Done silenced3')", + '*test_*.py:* line silenced4()', + '*sample8errors.py:38 call def silenced4():', + '*sample8errors.py:39 line try:', + '*sample8errors.py:40 line error()', + '*sample8errors.py:6 call def error():', + '*sample8errors.py:7 line raise RuntimeError()', + '*sample8errors.py:7 exception raise RuntimeError()', + '* ... exception value: (*RuntimeError*)', + '*sample8errors.py:7 return raise RuntimeError()', + '* ... return value: None', + '*sample8errors.py:40 exception error()', + '* ... exception value: (*RuntimeError*)', + '*sample8errors.py:41 line except Exception as exc:', + '*sample8errors.py:42 line logger.info(repr(exc))', + '*__init__.py:* call def info(self, msg, *args, **kwargs):', + '*sample8errors.py:42 return logger.info(repr(exc))', + '* ... return value: None', + '*---------------------- function exit', + ] + ) + + +@pytest.mark.xfail( + sys.version_info.major == 3 and sys.version_info.minor == 12, + reason='broken on 3.12, fixme', +) def test_errorsnooper_fastmode(LineMatcher): lines = StringIO() snooper = ErrorSnooper(stream=lines, max_backlog=0, max_events=100) def a(): - from sample8errors import silenced1, silenced2, silenced3, silenced4, notsilenced + from sample8errors import notsilenced + from sample8errors import silenced1 + from sample8errors import silenced2 + from sample8errors import silenced3 + from sample8errors import silenced4 silenced1() - print("Done silenced1") + print('Done silenced1') silenced2() - print("Done silenced2") + print('Done silenced2') silenced3() - print("Done silenced3") + print('Done silenced3') silenced4() - print("Done silenced4") + print('Done silenced4') try: notsilenced() except ValueError: - print("Done not silenced") + print('Done not silenced') with trace(actions=[snooper]): a() print(lines.getvalue()) lm = LineMatcher(lines.getvalue().splitlines()) - lm.fnmatch_lines([ - "*>>>>>>>>>>>>>>>>>>>>>> tracing silenced1 on (*RuntimeError*)", - "*sample8errors.py:17 line except Exception:", - "*sample8errors.py:18 line pass", - "*sample8errors.py:18 return pass", - "* ... return value: None", - "*---------------------- function exit", - - "*>>>>>>>>>>>>>>>>>>>>>> tracing silenced2 on (*RuntimeError*)", - "*sample8errors.py:24 line except Exception as exc:", - "*sample8errors.py:25 line log(exc)", - "*sample8errors.py:10 call def log(msg):", - "*sample8errors.py:11 return print(msg)", - "* ... return value: None", - "*sample8errors.py:26 line for i in range(*):", - "*sample8errors.py:27 line log(i)", - "*sample8errors.py:10 call def log(msg):", - "*sample8errors.py:11 return print(msg)", - "* ... return value: None", - "*sample8errors.py:26 line for i in range(*):", - "*sample8errors.py:27 line log(i)", - "*sample8errors.py:10 call def log(msg):", - "*sample8errors.py:11 return print(msg)", - "* ... return value: None", - "*sample8errors.py:26 line for i in range(*):", - "*sample8errors.py:27 line log(i)", - "*sample8errors.py:10 call def log(msg):", - "*sample8errors.py:11 return print(msg)", - "* ... return value: None", - "*sample8errors.py:26 line for i in range(*):", - "*---------------------- too many lines", - - "*>>>>>>>>>>>>>>>>>>>>>> tracing silenced3 on (*RuntimeError*)", - '*sample8errors.py:35 line return "mwhahaha"', - '*sample8errors.py:35 return return "mwhahaha"', - "* ... return value: 'mwhahaha'", - "*---------------------- function exit", - - "*>>>>>>>>>>>>>>>>>>>>>> tracing silenced4 on (*RuntimeError*)", - "*sample8errors.py:41 line except Exception as exc:", - "*sample8errors.py:42 line logger.info(repr(exc))", - "*__init__.py:* call def info(self, msg, *args, **kwargs):", - "*sample8errors.py:42 return logger.info(repr(exc))", - "* ... return value: None", - "*---------------------- function exit", - ]) - - -def test_stack_printer(LineMatcher): + lm.fnmatch_lines( + [ + '*>>>>>>>>>>>>>>>>>>>>>> tracing silenced1 on (*RuntimeError*)', + '*sample8errors.py:17 line except Exception:', + '*sample8errors.py:18 line pass', + '*sample8errors.py:18 return pass', + '* ... return value: None', + '*---------------------- function exit', + '*>>>>>>>>>>>>>>>>>>>>>> tracing silenced2 on (*RuntimeError*)', + '*sample8errors.py:24 line except Exception as exc:', + '*sample8errors.py:25 line log(exc)', + '*sample8errors.py:10 call def log(msg):', + '*sample8errors.py:11 return print(msg)', + '* ... return value: None', + '*sample8errors.py:26 line for i in range(*):', + '*sample8errors.py:27 line log(i)', + '*---------------------- too many lines', + '*>>>>>>>>>>>>>>>>>>>>>> tracing silenced3 on (*RuntimeError*)', + "*sample8errors.py:35 line return 'mwhahaha'", + "*sample8errors.py:35 return return 'mwhahaha'", + "* ... return value: 'mwhahaha'", + '*---------------------- function exit', + '*>>>>>>>>>>>>>>>>>>>>>> tracing silenced4 on (*RuntimeError*)', + '*sample8errors.py:41 line except Exception as exc:', + '*sample8errors.py:42 line logger.info(repr(exc))', + '*__init__.py:* call def info(self, msg, *args, **kwargs):', + '*sample8errors.py:42 return logger.info(repr(exc))', + '* ... return value: None', + '*---------------------- function exit', + ] + ) + + +def test_stack_printer_1(LineMatcher): + buff = StringIO() + with trace(Q(function='five', action=StackPrinter(limit=1, stream=buff))): + from sample7 import one + + one() + + output = buff.getvalue() + lm = LineMatcher(output.splitlines()) + lm.fnmatch_lines( + [ + '*sample7.py:??:five <= sample7.py:??:four <= sample7.py:??:three <= sample7.py:??:two <= sample7.py:?:one <= test_tracer.py:????:test_stack_printer*' + ] + ) + + +def test_stack_printer_2(LineMatcher): buff = StringIO() - with trace(Q(function="five", action=StackPrinter(stream=buff))): + with trace(Q(function='five', action=StackPrinter(limit=2, stream=buff))): from sample7 import one + + one() + + output = buff.getvalue() + lm = LineMatcher(output.splitlines()) + lm.fnmatch_lines( + [ + '*sample7.py:??:five <= tests/sample7.py:??:four <= tests/sample7.py:??:three <= tests/sample7.py:??:two <= tests/sample7.py:?:one <= tests/test_tracer.py:????:test_stack_printer*' + ] + ) + + +@pytest.mark.parametrize('stack', [5, 6, 7], ids='stack={}'.format) +@pytest.mark.parametrize('size', [6, 8, 10, 12, 14, 16] + list(range(17, 35)), ids='size={}'.format) +@pytest.mark.parametrize('vars', [True, False], ids='vars={}'.format) +@pytest.mark.parametrize('filter', [None, ~Q(function='six')], ids='filter={}'.format) +@pytest.mark.parametrize( + 'condition', + [{'fullsource_has': 'return i'}, {'function': 'five'}], + ids=urlencode, +) +def test_backlog_specific(LineMatcher, size, stack, vars, condition, filter): + buff = StringIO() + from sample7args import one + + with trace( + Backlog( + size=size, stack=stack, vars=vars, action=DebugCallPrinter(' [' + 'backlog' + ']', stream=buff), filter=filter, **condition + ), + action=DebugCallPrinter(stream=buff), + ): one() + one() # make sure Backlog is reusable (doesn't have storage side-effects) output = buff.getvalue() + # print(re.sub(r'([\[\]])', r'[\1]', output)) lm = LineMatcher(output.splitlines()) - lm.fnmatch_lines([ - "*sample7.py:30:five <= no frames available (detached=True)", - ]) + lm.fnmatch_lines( + [ + 'depth=0 calls=*sample7args.py:* call => one(a=*, b=*, c=*) [[]backlog[]]', + 'depth=1 calls=*sample7args.py:* call => two(a=*, b=*, c=*) [[]backlog[]]', + 'depth=2 calls=*sample7args.py:* call => three(a=*, b=*, c=*) [[]backlog[]]', + 'depth=3 calls=*sample7args.py:* call => four(a=*, b=*, c=*) [[]backlog[]]', + 'depth=4 calls=*sample7args.py:* call => five(a=*, b=*, c=*)*', + "depth=5 calls=*sample7args.py:* line *a = b = c[[]'side'[]] = in_five = 'effect'*", + 'depth=5 calls=*sample7args.py:* line *for i in range(1): # five*', + 'depth=5 calls=*sample7args.py:* line *return i # five', + 'depth=0 calls=*sample7args.py:* call => one(a=*, b=*, c=*) [[]backlog[]]', + 'depth=1 calls=*sample7args.py:* call => two(a=*, b=*, c=*) [[]backlog[]]', + 'depth=2 calls=*sample7args.py:* call => three(a=*, b=*, c=*) [[]backlog[]]', + 'depth=3 calls=*sample7args.py:* call => four(a=*, b=*, c=*) [[]backlog[]]', + 'depth=4 calls=*sample7args.py:* call => five(a=*, b=*, c=*)*', + "depth=5 calls=*sample7args.py:* line *a = b = c[[]'side'[]] = in_five = 'effect'*", + 'depth=5 calls=*sample7args.py:* line *for i in range(1): # five*', + 'depth=5 calls=*sample7args.py:* line *return i # five', + ] + ) diff --git a/tests/test_util.py b/tests/test_util.py index 349a92ce..b2d74f55 100644 --- a/tests/test_util.py +++ b/tests/test_util.py @@ -1,12 +1,19 @@ +import re from array import array from collections import OrderedDict from collections import deque from collections import namedtuple +from datetime import date +from datetime import datetime +from datetime import time +from datetime import timedelta +from datetime import tzinfo from decimal import Decimal from socket import _socket from socket import socket import py +import pytest import six from hunter.util import safe_repr @@ -16,7 +23,7 @@ except ImportError: from hunter.backports.inspect import getattr_static -MyTuple = namedtuple("MyTuple", "a b") +MyTuple = namedtuple('MyTuple', 'a b') class Dict(dict): @@ -34,50 +41,96 @@ class Set(set): Stuff = namedtuple('Stuff', 'a b') -class Foobar(object): +class Foobar: __slots__ = () - __repr__ = lambda _: "Foo-bar" + __repr__ = lambda _: 'Foo-bar' class Bad1: def __repr__(self): - raise Exception("Bad!") + raise Exception('Bad!') def method(self): pass -class Bad2(object): +class String(str): def __repr__(self): - raise Exception("Bad!") + raise Exception('Bad!') + + __str__ = __repr__ + + +class Int(int): + def __repr__(self): + raise Exception('Bad!') + + __str__ = __repr__ + + +class TzInfo(tzinfo): + def __repr__(self): + raise Exception('Bad!') + + __str__ = __repr__ + + +class Bad2: + def __repr__(self): + raise Exception('Bad!') def method(self): pass def test_safe_repr(): + s1 = _socket.socket() + s2 = socket() data = { 'a': [set('b')], ('c',): deque(['d']), - 'e': _socket.socket(), + 'e': s1, 1: array('d', [1, 2]), - frozenset('f'): socket(), - 'g': Dict({ - 'a': List('123'), - 'b': Set([Decimal('1.0')]), - 'c': Stuff(1, 2), - 'd': Exception(1, 2, { - 'a': safe_repr, - 'b': Foobar, - 'c': Bad2(), - 'ct': Bad2, - }) - }), + frozenset('f'): s2, + 'g': Dict( + { + 'a': List('123'), + 'b': Set([Decimal('1.0')]), + 'c': Stuff(1, 2), + 'd': Exception( + 1, + 2, + { + 'a': safe_repr, + 'b': Foobar, + 'c': Bad2(), + 'ct': Bad2, + }, + ), + } + ), 'od': OrderedDict({'a': 'b'}), 'nt': MyTuple(1, 2), 'bad1': Bad1().method, - 'bad2': Bad2().method + 'bad2': Bad2().method, + 'regex': re.compile('123', 0), + 'badregex': re.compile(String('123')), + 'badregex2': re.compile(String('123'), Int(re.IGNORECASE)), + 'date': date(Int(2000), Int(1), Int(2)), + 'datetime': datetime( + Int(2000), + Int(1), + Int(2), + Int(3), + Int(4), + Int(5), + Int(600), + tzinfo=TzInfo(), + ), + 'time': time(Int(3), Int(4), Int(5), Int(600), tzinfo=TzInfo()), + 'timedelta': timedelta(Int(1), Int(2), Int(3), Int(4), Int(5), Int(6), Int(7)), } + print(re.compile(String('123'), Int(re.IGNORECASE)).match('123')) print(safe_repr(data)) print(safe_repr([data])) print(safe_repr([[data]])) @@ -85,9 +138,23 @@ def test_safe_repr(): print(safe_repr([[[[data]]]])) print(safe_repr([[[[[data]]]]])) + s1.close() + s2.close() assert safe_repr(py.io).startswith('=80 + setuptools_scm>=8 aspectlib + six + py + tzdata + ipdb commands = - {py27,py33,py34,py35,py36,py36,py37,py38}: python tests/setup.py clean --all build_ext --force --inplace + {py38,py39,py310,py311,py312,py313,py313t,py314,py314t}: python tests/setup.py clean --all + {py38,py39,py310,py311,py312,py313,py313t,py314,py314t}: python tests/setup.py build_ext --force --inplace cover: python setup.py clean --all build_ext --force --inplace nocov: {posargs:pytest -vv --ignore=src} - cover: {posargs:pytest --cov --cov-report=term-missing -vv} -install_command = - python -m pip install --no-use-pep517 {opts} {packages} -usedevelop = - nocov: false - cover: true + cover: {posargs:pytest --cov --cov-report=term-missing --cov-report=xml -vv} [testenv:check] deps = docutils - flake8 + pre-commit readme-renderer pygments isort - setuptools-scm + setuptools>=80 + setuptools_scm>=8 skip_install = true commands = - flake8 src tests setup.py - isort --verbose --check-only --diff --recursive src tests setup.py + python setup.py check --strict --metadata --restructuredtext + pre-commit run --all-files --show-diff-on-failure [testenv:cythonize] -basepython = {env:TOXPYTHON:python} +pip_pre = true deps = - cython==0.29.14 + setuptools>=80 + setuptools_scm>=8 + cython skip_install = true commands = {posargs:python setup.py clean --all build_ext --force} -[testenv:spell] -setenv = - SPELLCHECK=1 -commands = - sphinx-build -b spelling docs dist/docs -skip_install = true -deps = - -r{toxinidir}/docs/requirements.txt - sphinxcontrib-spelling - pyenchant - [testenv:docs] usedevelop = true -install_command = - python -m pip install --no-use-pep517 {opts} {packages} deps = -r{toxinidir}/docs/requirements.txt commands = sphinx-build {posargs:-E} -b html docs dist/docs sphinx-build -b linkcheck docs dist/docs -[testenv:codecov] -deps = - codecov - cython==0.29.14 -skip_install = true -setenv = - PYTHONPATH={toxinidir}/src -commands = - codecov [] - [testenv:report] deps = coverage - cython==0.29.14 + cython skip_install = true setenv = PYTHONPATH={toxinidir}/src @@ -125,9 +101,12 @@ commands = coverage html [testenv:clean] -commands = coverage erase +commands = + python setup.py clean + coverage erase skip_install = true deps = + setuptools>=80 + setuptools_scm>=8 coverage - cython==0.29.14 - + cython