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..d9adf568 100644 --- a/.bumpversion.cfg +++ b/.bumpversion.cfg @@ -1,5 +1,5 @@ [bumpversion] -current_version = 3.1.3 +current_version = 3.7.0 commit = True tag = True @@ -7,9 +7,13 @@ tag = True 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..9aa3dbef 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' + pypi_badge: 'yes' + pypi_disable_upload: 'no' + release_date: '2023-04-26' 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.7.0 + version_manager: bump2version website: https://blog.ionelmc.ro year_from: '2015' - year_to: '2019' + year_to: '2024' diff --git a/.coveragerc b/.coveragerc index b74227ab..2d8a895c 100644 --- a/.coveragerc +++ b/.coveragerc @@ -1,6 +1,11 @@ +[paths] +source = src + [run] branch = true -source = src +source = + src + tests parallel = true plugins = Cython.Coverage 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..6d8321fb --- /dev/null +++ b/.github/workflows/github-actions.yml @@ -0,0 +1,1104 @@ +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.11' + toxpython: 'python3.11' + tox_env: 'check' + os: 'ubuntu-latest' + - name: 'docs' + python: '3.11' + toxpython: 'python3.11' + tox_env: 'docs' + os: 'ubuntu-latest' + - name: 'py38-pure-cover (ubuntu/x86_64)' + python: '3.8' + toxpython: 'python3.8' + python_arch: 'x64' + tox_env: 'py38-pure-cover' + cover: true + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'py38-pure-cover (windows/AMD64)' + python: '3.8' + toxpython: 'python3.8' + python_arch: 'x64' + tox_env: 'py38-pure-cover' + cover: true + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'py38-pure-cover (macos/arm64)' + python: '3.8' + toxpython: 'python3.8' + python_arch: 'arm64' + tox_env: 'py38-pure-cover' + cover: true + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'py38-pure-nocov (ubuntu/x86_64)' + python: '3.8' + toxpython: 'python3.8' + python_arch: 'x64' + tox_env: 'py38-pure-nocov' + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'py38-pure-nocov (windows/AMD64)' + python: '3.8' + toxpython: 'python3.8' + python_arch: 'x64' + tox_env: 'py38-pure-nocov' + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'py38-pure-nocov (macos/arm64)' + python: '3.8' + toxpython: 'python3.8' + python_arch: 'arm64' + tox_env: 'py38-pure-nocov' + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'py38-cython-cover (ubuntu/x86_64)' + python: '3.8' + toxpython: 'python3.8' + python_arch: 'x64' + tox_env: 'py38-cython-cover' + cover: true + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'py38-cython-cover (windows/AMD64)' + python: '3.8' + toxpython: 'python3.8' + python_arch: 'x64' + tox_env: 'py38-cython-cover' + cover: true + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'py38-cython-cover (macos/arm64)' + python: '3.8' + toxpython: 'python3.8' + python_arch: 'arm64' + tox_env: 'py38-cython-cover' + cover: true + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'py38-cython-nocov (ubuntu/x86_64/manylinux)' + python: '3.8' + toxpython: 'python3.8' + python_arch: 'x64' + tox_env: 'py38-cython-nocov' + cibw_arch: 'x86_64' + cibw_build: 'cp38-*manylinux*' + artifact: 'ubuntu-cp38-x86_64-manylinux' + os: 'ubuntu-latest' + - name: 'py38-cython-nocov (ubuntu/x86_64/musllinux)' + python: '3.8' + toxpython: 'python3.8' + python_arch: 'x64' + tox_env: 'py38-cython-nocov' + cibw_arch: 'x86_64' + cibw_build: 'cp38-*musllinux*' + artifact: 'ubuntu-cp38-x86_64-musllinux' + os: 'ubuntu-latest' + - name: 'py38-cython-nocov (ubuntu/aarch64/manylinux)' + python: '3.8' + toxpython: 'python3.8' + python_arch: 'x64' + tox_env: 'py38-cython-nocov' + cibw_arch: 'aarch64' + cibw_build: 'cp38-*manylinux*' + artifact: 'ubuntu-cp38-aarch64-manylinux' + os: 'ubuntu-latest' + - name: 'py38-cython-nocov (ubuntu/aarch64/musllinux)' + python: '3.8' + toxpython: 'python3.8' + python_arch: 'x64' + tox_env: 'py38-cython-nocov' + cibw_arch: 'aarch64' + cibw_build: 'cp38-*musllinux*' + artifact: 'ubuntu-cp38-aarch64-musllinux' + os: 'ubuntu-latest' + - name: 'py38-cython-nocov (windows/AMD64)' + python: '3.8' + toxpython: 'python3.8' + python_arch: 'x64' + tox_env: 'py38-cython-nocov' + cibw_arch: 'AMD64' + cibw_build: 'cp38-*' + artifact: 'windows-cp38-AMD64-default' + os: 'windows-latest' + - name: 'py38-cython-nocov (windows/x86)' + python: '3.8' + toxpython: 'python3.8' + python_arch: 'x86' + tox_env: 'py38-cython-nocov' + cibw_arch: 'x86' + cibw_build: 'cp38-*' + artifact: 'windows-cp38-x86-default' + os: 'windows-latest' + - name: 'py38-cython-nocov (macos/arm64)' + python: '3.8' + toxpython: 'python3.8' + python_arch: 'arm64' + tox_env: 'py38-cython-nocov' + cibw_arch: 'arm64' + cibw_build: 'cp38-*' + artifact: 'macos-cp38-arm64-default' + os: 'macos-latest' + - name: 'py39-pure-cover (ubuntu/x86_64)' + python: '3.9' + toxpython: 'python3.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)' + python: '3.9' + toxpython: 'python3.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)' + python: '3.9' + toxpython: 'python3.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)' + python: '3.9' + toxpython: 'python3.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)' + python: '3.9' + toxpython: 'python3.9' + python_arch: 'x64' + tox_env: 'py39-pure-nocov' + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'py39-pure-nocov (macos/arm64)' + python: '3.9' + toxpython: 'python3.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)' + python: '3.9' + toxpython: 'python3.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)' + python: '3.9' + toxpython: 'python3.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)' + python: '3.9' + toxpython: 'python3.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)' + python: '3.9' + toxpython: 'python3.9' + python_arch: 'x64' + tox_env: 'py39-cython-nocov' + cibw_arch: 'x86_64' + cibw_build: 'cp39-*manylinux*' + artifact: 'ubuntu-cp39-x86_64-manylinux' + os: 'ubuntu-latest' + - name: 'py39-cython-nocov (ubuntu/x86_64/musllinux)' + python: '3.9' + toxpython: 'python3.9' + python_arch: 'x64' + tox_env: 'py39-cython-nocov' + cibw_arch: 'x86_64' + cibw_build: 'cp39-*musllinux*' + artifact: 'ubuntu-cp39-x86_64-musllinux' + os: 'ubuntu-latest' + - name: 'py39-cython-nocov (ubuntu/aarch64/manylinux)' + python: '3.9' + toxpython: 'python3.9' + python_arch: 'x64' + tox_env: 'py39-cython-nocov' + cibw_arch: 'aarch64' + cibw_build: 'cp39-*manylinux*' + artifact: 'ubuntu-cp39-aarch64-manylinux' + os: 'ubuntu-latest' + - name: 'py39-cython-nocov (ubuntu/aarch64/musllinux)' + python: '3.9' + toxpython: 'python3.9' + python_arch: 'x64' + tox_env: 'py39-cython-nocov' + cibw_arch: 'aarch64' + cibw_build: 'cp39-*musllinux*' + artifact: 'ubuntu-cp39-aarch64-musllinux' + os: 'ubuntu-latest' + - name: 'py39-cython-nocov (windows/AMD64)' + python: '3.9' + toxpython: 'python3.9' + python_arch: 'x64' + tox_env: 'py39-cython-nocov' + cibw_arch: 'AMD64' + cibw_build: 'cp39-*' + artifact: 'windows-cp39-AMD64-default' + os: 'windows-latest' + - name: 'py39-cython-nocov (windows/x86)' + python: '3.9' + toxpython: 'python3.9' + python_arch: 'x86' + tox_env: 'py39-cython-nocov' + cibw_arch: 'x86' + cibw_build: 'cp39-*' + artifact: 'windows-cp39-x86-default' + os: 'windows-latest' + - name: 'py39-cython-nocov (macos/arm64)' + python: '3.9' + toxpython: 'python3.9' + python_arch: 'arm64' + tox_env: 'py39-cython-nocov' + cibw_arch: 'arm64' + cibw_build: 'cp39-*' + artifact: 'macos-cp39-arm64-default' + os: 'macos-latest' + - name: 'py310-pure-cover (ubuntu/x86_64)' + python: '3.10' + toxpython: 'python3.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)' + python: '3.10' + toxpython: 'python3.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)' + python: '3.10' + toxpython: 'python3.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)' + python: '3.10' + toxpython: 'python3.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)' + python: '3.10' + toxpython: 'python3.10' + python_arch: 'x64' + tox_env: 'py310-pure-nocov' + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'py310-pure-nocov (macos/arm64)' + python: '3.10' + toxpython: 'python3.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)' + python: '3.10' + toxpython: 'python3.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)' + python: '3.10' + toxpython: 'python3.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)' + python: '3.10' + toxpython: 'python3.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)' + python: '3.10' + toxpython: 'python3.10' + python_arch: 'x64' + tox_env: 'py310-cython-nocov' + cibw_arch: 'x86_64' + cibw_build: 'cp310-*manylinux*' + artifact: 'ubuntu-cp310-x86_64-manylinux' + os: 'ubuntu-latest' + - name: 'py310-cython-nocov (ubuntu/x86_64/musllinux)' + python: '3.10' + toxpython: 'python3.10' + python_arch: 'x64' + tox_env: 'py310-cython-nocov' + cibw_arch: 'x86_64' + cibw_build: 'cp310-*musllinux*' + artifact: 'ubuntu-cp310-x86_64-musllinux' + os: 'ubuntu-latest' + - name: 'py310-cython-nocov (ubuntu/aarch64/manylinux)' + python: '3.10' + toxpython: 'python3.10' + python_arch: 'x64' + tox_env: 'py310-cython-nocov' + cibw_arch: 'aarch64' + cibw_build: 'cp310-*manylinux*' + artifact: 'ubuntu-cp310-aarch64-manylinux' + os: 'ubuntu-latest' + - name: 'py310-cython-nocov (ubuntu/aarch64/musllinux)' + python: '3.10' + toxpython: 'python3.10' + python_arch: 'x64' + tox_env: 'py310-cython-nocov' + cibw_arch: 'aarch64' + cibw_build: 'cp310-*musllinux*' + artifact: 'ubuntu-cp310-aarch64-musllinux' + os: 'ubuntu-latest' + - name: 'py310-cython-nocov (windows/AMD64)' + python: '3.10' + toxpython: 'python3.10' + python_arch: 'x64' + tox_env: 'py310-cython-nocov' + cibw_arch: 'AMD64' + cibw_build: 'cp310-*' + artifact: 'windows-cp310-AMD64-default' + os: 'windows-latest' + - name: 'py310-cython-nocov (windows/x86)' + python: '3.10' + toxpython: 'python3.10' + python_arch: 'x86' + tox_env: 'py310-cython-nocov' + cibw_arch: 'x86' + cibw_build: 'cp310-*' + artifact: 'windows-cp310-x86-default' + os: 'windows-latest' + - name: 'py310-cython-nocov (macos/arm64)' + python: '3.10' + toxpython: 'python3.10' + python_arch: 'arm64' + tox_env: 'py310-cython-nocov' + cibw_arch: 'arm64' + cibw_build: 'cp310-*' + artifact: 'macos-cp310-arm64-default' + os: 'macos-latest' + - name: 'py311-pure-cover (ubuntu/x86_64)' + python: '3.11' + toxpython: 'python3.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)' + python: '3.11' + toxpython: 'python3.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)' + python: '3.11' + toxpython: 'python3.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)' + python: '3.11' + toxpython: 'python3.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)' + python: '3.11' + toxpython: 'python3.11' + python_arch: 'x64' + tox_env: 'py311-pure-nocov' + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'py311-pure-nocov (macos/arm64)' + python: '3.11' + toxpython: 'python3.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)' + python: '3.11' + toxpython: 'python3.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)' + python: '3.11' + toxpython: 'python3.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)' + python: '3.11' + toxpython: 'python3.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)' + python: '3.11' + toxpython: 'python3.11' + python_arch: 'x64' + tox_env: 'py311-cython-nocov' + cibw_arch: 'x86_64' + cibw_build: 'cp311-*manylinux*' + artifact: 'ubuntu-cp311-x86_64-manylinux' + os: 'ubuntu-latest' + - name: 'py311-cython-nocov (ubuntu/x86_64/musllinux)' + python: '3.11' + toxpython: 'python3.11' + python_arch: 'x64' + tox_env: 'py311-cython-nocov' + cibw_arch: 'x86_64' + cibw_build: 'cp311-*musllinux*' + artifact: 'ubuntu-cp311-x86_64-musllinux' + os: 'ubuntu-latest' + - name: 'py311-cython-nocov (ubuntu/aarch64/manylinux)' + python: '3.11' + toxpython: 'python3.11' + python_arch: 'x64' + tox_env: 'py311-cython-nocov' + cibw_arch: 'aarch64' + cibw_build: 'cp311-*manylinux*' + artifact: 'ubuntu-cp311-aarch64-manylinux' + os: 'ubuntu-latest' + - name: 'py311-cython-nocov (ubuntu/aarch64/musllinux)' + python: '3.11' + toxpython: 'python3.11' + python_arch: 'x64' + tox_env: 'py311-cython-nocov' + cibw_arch: 'aarch64' + cibw_build: 'cp311-*musllinux*' + artifact: 'ubuntu-cp311-aarch64-musllinux' + os: 'ubuntu-latest' + - name: 'py311-cython-nocov (windows/AMD64)' + python: '3.11' + toxpython: 'python3.11' + python_arch: 'x64' + tox_env: 'py311-cython-nocov' + cibw_arch: 'AMD64' + cibw_build: 'cp311-*' + artifact: 'windows-cp311-AMD64-default' + os: 'windows-latest' + - name: 'py311-cython-nocov (windows/x86)' + python: '3.11' + toxpython: 'python3.11' + python_arch: 'x86' + tox_env: 'py311-cython-nocov' + cibw_arch: 'x86' + cibw_build: 'cp311-*' + artifact: 'windows-cp311-x86-default' + os: 'windows-latest' + - name: 'py311-cython-nocov (macos/arm64)' + python: '3.11' + toxpython: 'python3.11' + python_arch: 'arm64' + tox_env: 'py311-cython-nocov' + cibw_arch: 'arm64' + cibw_build: 'cp311-*' + artifact: 'macos-cp311-arm64-default' + os: 'macos-latest' + - name: 'py312-pure-cover (ubuntu/x86_64)' + python: '3.12' + toxpython: 'python3.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)' + python: '3.12' + toxpython: 'python3.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)' + python: '3.12' + toxpython: 'python3.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)' + python: '3.12' + toxpython: 'python3.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)' + python: '3.12' + toxpython: 'python3.12' + python_arch: 'x64' + tox_env: 'py312-pure-nocov' + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'py312-pure-nocov (macos/arm64)' + python: '3.12' + toxpython: 'python3.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)' + python: '3.12' + toxpython: 'python3.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)' + python: '3.12' + toxpython: 'python3.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)' + python: '3.12' + toxpython: 'python3.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)' + python: '3.12' + toxpython: 'python3.12' + python_arch: 'x64' + tox_env: 'py312-cython-nocov' + cibw_arch: 'x86_64' + cibw_build: 'cp312-*manylinux*' + artifact: 'ubuntu-cp312-x86_64-manylinux' + os: 'ubuntu-latest' + - name: 'py312-cython-nocov (ubuntu/x86_64/musllinux)' + python: '3.12' + toxpython: 'python3.12' + python_arch: 'x64' + tox_env: 'py312-cython-nocov' + cibw_arch: 'x86_64' + cibw_build: 'cp312-*musllinux*' + artifact: 'ubuntu-cp312-x86_64-musllinux' + os: 'ubuntu-latest' + - name: 'py312-cython-nocov (ubuntu/aarch64/manylinux)' + python: '3.12' + toxpython: 'python3.12' + python_arch: 'x64' + tox_env: 'py312-cython-nocov' + cibw_arch: 'aarch64' + cibw_build: 'cp312-*manylinux*' + artifact: 'ubuntu-cp312-aarch64-manylinux' + os: 'ubuntu-latest' + - name: 'py312-cython-nocov (ubuntu/aarch64/musllinux)' + python: '3.12' + toxpython: 'python3.12' + python_arch: 'x64' + tox_env: 'py312-cython-nocov' + cibw_arch: 'aarch64' + cibw_build: 'cp312-*musllinux*' + artifact: 'ubuntu-cp312-aarch64-musllinux' + os: 'ubuntu-latest' + - name: 'py312-cython-nocov (windows/AMD64)' + python: '3.12' + toxpython: 'python3.12' + python_arch: 'x64' + tox_env: 'py312-cython-nocov' + cibw_arch: 'AMD64' + cibw_build: 'cp312-*' + artifact: 'windows-cp312-AMD64-default' + os: 'windows-latest' + - name: 'py312-cython-nocov (windows/x86)' + python: '3.12' + toxpython: 'python3.12' + python_arch: 'x86' + tox_env: 'py312-cython-nocov' + cibw_arch: 'x86' + cibw_build: 'cp312-*' + artifact: 'windows-cp312-x86-default' + os: 'windows-latest' + - name: 'py312-cython-nocov (macos/arm64)' + python: '3.12' + toxpython: 'python3.12' + python_arch: 'arm64' + tox_env: 'py312-cython-nocov' + cibw_arch: 'arm64' + cibw_build: 'cp312-*' + artifact: 'macos-cp312-arm64-default' + os: 'macos-latest' + - name: 'pypy38-pure-cover (ubuntu/x86_64)' + python: 'pypy-3.8' + toxpython: 'pypy3.8' + python_arch: 'x64' + tox_env: 'pypy38-pure-cover' + cover: true + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'pypy38-pure-cover (windows/AMD64)' + python: 'pypy-3.8' + toxpython: 'pypy3.8' + python_arch: 'x64' + tox_env: 'pypy38-pure-cover' + cover: true + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'pypy38-pure-cover (macos/arm64)' + python: 'pypy-3.8' + toxpython: 'pypy3.8' + python_arch: 'arm64' + tox_env: 'pypy38-pure-cover' + cover: true + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'pypy38-pure-nocov (ubuntu/x86_64)' + python: 'pypy-3.8' + toxpython: 'pypy3.8' + python_arch: 'x64' + tox_env: 'pypy38-pure-nocov' + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'pypy38-pure-nocov (windows/AMD64)' + python: 'pypy-3.8' + toxpython: 'pypy3.8' + python_arch: 'x64' + tox_env: 'pypy38-pure-nocov' + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'pypy38-pure-nocov (macos/arm64)' + python: 'pypy-3.8' + toxpython: 'pypy3.8' + python_arch: 'arm64' + tox_env: 'pypy38-pure-nocov' + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'pypy38-cython-cover (ubuntu/x86_64)' + python: 'pypy-3.8' + toxpython: 'pypy3.8' + python_arch: 'x64' + tox_env: 'pypy38-cython-cover' + cover: true + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'pypy38-cython-cover (windows/AMD64)' + python: 'pypy-3.8' + toxpython: 'pypy3.8' + python_arch: 'x64' + tox_env: 'pypy38-cython-cover' + cover: true + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'pypy38-cython-cover (macos/arm64)' + python: 'pypy-3.8' + toxpython: 'pypy3.8' + python_arch: 'arm64' + tox_env: 'pypy38-cython-cover' + cover: true + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'pypy38-cython-nocov (ubuntu/x86_64/manylinux)' + python: 'pypy-3.8' + toxpython: 'pypy3.8' + python_arch: 'x64' + tox_env: 'pypy38-cython-nocov' + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'pypy38-cython-nocov (windows/AMD64)' + python: 'pypy-3.8' + toxpython: 'pypy3.8' + python_arch: 'x64' + tox_env: 'pypy38-cython-nocov' + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'pypy38-cython-nocov (macos/arm64)' + python: 'pypy-3.8' + toxpython: 'pypy3.8' + python_arch: 'arm64' + tox_env: 'pypy38-cython-nocov' + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'pypy39-pure-cover (ubuntu/x86_64)' + python: 'pypy-3.9' + toxpython: 'pypy3.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)' + python: 'pypy-3.9' + toxpython: 'pypy3.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)' + python: 'pypy-3.9' + toxpython: 'pypy3.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)' + python: 'pypy-3.9' + toxpython: 'pypy3.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)' + python: 'pypy-3.9' + toxpython: 'pypy3.9' + python_arch: 'x64' + tox_env: 'pypy39-pure-nocov' + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'pypy39-pure-nocov (macos/arm64)' + python: 'pypy-3.9' + toxpython: 'pypy3.9' + python_arch: 'arm64' + tox_env: 'pypy39-pure-nocov' + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'pypy39-cython-cover (ubuntu/x86_64)' + python: 'pypy-3.9' + toxpython: 'pypy3.9' + python_arch: 'x64' + tox_env: 'pypy39-cython-cover' + cover: true + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'pypy39-cython-cover (windows/AMD64)' + python: 'pypy-3.9' + toxpython: 'pypy3.9' + python_arch: 'x64' + tox_env: 'pypy39-cython-cover' + cover: true + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'pypy39-cython-cover (macos/arm64)' + python: 'pypy-3.9' + toxpython: 'pypy3.9' + python_arch: 'arm64' + tox_env: 'pypy39-cython-cover' + cover: true + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'pypy39-cython-nocov (ubuntu/x86_64/manylinux)' + python: 'pypy-3.9' + toxpython: 'pypy3.9' + python_arch: 'x64' + tox_env: 'pypy39-cython-nocov' + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'pypy39-cython-nocov (windows/AMD64)' + python: 'pypy-3.9' + toxpython: 'pypy3.9' + python_arch: 'x64' + tox_env: 'pypy39-cython-nocov' + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'pypy39-cython-nocov (macos/arm64)' + python: 'pypy-3.9' + toxpython: 'pypy3.9' + python_arch: 'arm64' + tox_env: 'pypy39-cython-nocov' + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'pypy310-pure-cover (ubuntu/x86_64)' + python: 'pypy-3.10' + toxpython: 'pypy3.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)' + python: 'pypy-3.10' + toxpython: 'pypy3.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)' + python: 'pypy-3.10' + toxpython: 'pypy3.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)' + python: 'pypy-3.10' + toxpython: 'pypy3.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)' + python: 'pypy-3.10' + toxpython: 'pypy3.10' + python_arch: 'x64' + tox_env: 'pypy310-pure-nocov' + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'pypy310-pure-nocov (macos/arm64)' + python: 'pypy-3.10' + toxpython: 'pypy3.10' + python_arch: 'arm64' + tox_env: 'pypy310-pure-nocov' + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'pypy310-cython-cover (ubuntu/x86_64)' + python: 'pypy-3.10' + toxpython: 'pypy3.10' + python_arch: 'x64' + tox_env: 'pypy310-cython-cover' + cover: true + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'pypy310-cython-cover (windows/AMD64)' + python: 'pypy-3.10' + toxpython: 'pypy3.10' + python_arch: 'x64' + tox_env: 'pypy310-cython-cover' + cover: true + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'pypy310-cython-cover (macos/arm64)' + python: 'pypy-3.10' + toxpython: 'pypy3.10' + python_arch: 'arm64' + tox_env: 'pypy310-cython-cover' + cover: true + cibw_arch: 'arm64' + cibw_build: false + os: 'macos-latest' + - name: 'pypy310-cython-nocov (ubuntu/x86_64/manylinux)' + python: 'pypy-3.10' + toxpython: 'pypy3.10' + python_arch: 'x64' + tox_env: 'pypy310-cython-nocov' + cibw_arch: 'x86_64' + cibw_build: false + os: 'ubuntu-latest' + - name: 'pypy310-cython-nocov (windows/AMD64)' + python: 'pypy-3.10' + toxpython: 'pypy3.10' + python_arch: 'x64' + tox_env: 'pypy310-cython-nocov' + cibw_arch: 'AMD64' + cibw_build: false + os: 'windows-latest' + - name: 'pypy310-cython-nocov (macos/arm64)' + python: 'pypy-3.10' + toxpython: 'pypy3.10' + python_arch: 'arm64' + tox_env: 'pypy310-cython-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 + - name: cibw build and test + if: matrix.cibw_build + run: cibuildwheel + env: + TOXPYTHON: '${{ matrix.toxpython }}' + CIBW_ARCHS: '${{ matrix.cibw_arch }}' + CIBW_BUILD: '${{ matrix.cibw_build }}' + 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 }} -v + CIBW_TEST_COMMAND_WINDOWS: > + cd /d {project} && + tox --skip-pkg-install --direct-yolo -e ${{ matrix.tox_env }} -v + - name: regular build and test + env: + TOXPYTHON: '${{ matrix.toxpython }}' + if: > + !matrix.cibw_build + run: > + tox -e ${{ matrix.tox_env }} -v + - uses: codecov/codecov-action@v3 + if: matrix.cover + with: + verbose: true + flags: ${{ matrix.tox_env }} + - name: check wheel + if: matrix.cibw_build + run: twine check wheelhouse/*.whl + - name: upload wheel + uses: actions/upload-artifact@v4 + if: matrix.cibw_build + with: + name: '${{ matrix.artifact }}' + if-no-files-found: error + compression-level: 0 + path: wheelhouse/*.whl + finish: + needs: test + if: ${{ always() }} + runs-on: ubuntu-latest + steps: + - uses: codecov/codecov-action@v3 + 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..51775979 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,33 @@ +# 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.4.2 + hooks: + - id: ruff + args: [--fix, --exit-non-zero-on-fix, --show-fixes, --unsafe-fixes] + - repo: https://github.com/psf/black + rev: 24.4.2 + hooks: + - id: black + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v4.6.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.2 + 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/.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..2d46974c 100644 --- a/AUTHORS.rst +++ b/AUTHORS.rst @@ -5,3 +5,5 @@ 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 diff --git a/CHANGELOG.rst b/CHANGELOG.rst index 48ce96e1..61b64d3e 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -2,6 +2,164 @@ Changelog ========= +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 +303,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 +332,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 +341,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 +395,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 +407,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..d50735b1 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-2024, 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..06a11f54 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.7.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.7.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..f3c9a7ea 100755 --- a/ci/bootstrap.py +++ b/ci/bootstrap.py @@ -1,64 +1,57 @@ #!/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): + bin_path = env_path / 'bin' + if not env_path.exists(): import subprocess - print("Making bootstrap env in: {0} ...".format(env_path)) + 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 +62,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..65a1480b 100644 --- a/ci/requirements.txt +++ b/ci/requirements.txt @@ -1,3 +1,6 @@ -virtualenv>=16.6.0 +virtualenv>=20.4.7 pip>=19.1.1 setuptools>=18.0.1 +six>=1.14.0 +tox +twine 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..9a17f061 --- /dev/null +++ b/ci/templates/.github/workflows/github-actions.yml @@ -0,0 +1,136 @@ +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.11' + toxpython: 'python3.11' + tox_env: 'check' + os: 'ubuntu-latest' + - name: 'docs' + python: '3.11' + toxpython: 'python3.11' + tox_env: 'docs' + os: 'ubuntu-latest' +{% for env in tox_environments %} +{% set prefix = env.split('-')[0] -%} +{% if prefix.startswith('pypy') %} +{% set python %}pypy-{{ prefix[4] }}.{{ prefix[5:] }}{% endset %} +{% set cpython %}pp{{ prefix[4:5] }}{% endset %} +{% set toxpython %}pypy{{ prefix[4] }}.{{ prefix[5:] }}{% endset %} +{% else %} +{% set python %}{{ prefix[2] }}.{{ prefix[3:] }}{% endset %} +{% set cpython %}cp{{ prefix[2:] }}{% endset %} +{% set toxpython %}python{{ prefix[2] }}.{{ prefix[3:] }}{% 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 }})' + python: '{{ python }}' + toxpython: '{{ toxpython }}' + python_arch: '{{ python_arch }}' + 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 }}' + artifact: '{{ os }}-{{ cpython }}-{{ cibw_arch }}-{{ wheel_arch.strip("*") or "default" }}' +{% 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 + - name: cibw build and test + if: matrix.cibw_build + run: cibuildwheel + env: + TOXPYTHON: '{{ '${{ matrix.toxpython }}' }}' + CIBW_ARCHS: '{{ '${{ matrix.cibw_arch }}' }}' + CIBW_BUILD: '{{ '${{ matrix.cibw_build }}' }}' + 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 }}' }} -v + CIBW_TEST_COMMAND_WINDOWS: > + cd /d {project} && + tox --skip-pkg-install --direct-yolo -e {{ '${{ matrix.tox_env }}' }} -v + - name: regular build and test + env: + TOXPYTHON: '{{ '${{ matrix.toxpython }}' }}' + if: > + !matrix.cibw_build + run: > + tox -e {{ '${{ matrix.tox_env }}' }} -v + - uses: codecov/codecov-action@v3 + if: matrix.cover + with: + verbose: true + flags: {{ '${{ matrix.tox_env }}' }} + - name: check wheel + if: matrix.cibw_build + run: twine check wheelhouse/*.whl + - name: upload wheel + uses: actions/upload-artifact@v4 + if: matrix.cibw_build + with: + name: '{{ '${{ matrix.artifact }}' }}' + if-no-files-found: error + compression-level: 0 + path: wheelhouse/*.whl + finish: + needs: test + if: {{ '${{ always() }}' }} + runs-on: ubuntu-latest + steps: + - uses: codecov/codecov-action@v3 + with: + CODECOV_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..ffaf4aba 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,44 +14,38 @@ '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-2024' 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 except Exception: + import traceback + traceback.print_exc() - version = release = '3.1.3' + version = release = '3.7.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/' + 'githuburl': 'https://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 diff --git a/docs/configuration.rst b/docs/configuration.rst index 990c3091..20d45a75 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..be73b937 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 ====================== @@ -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,7 +253,7 @@ 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: self.output("{BRIGHT}{fore(BLUE)}{} tracing {} on {}{RESET}\n", @@ -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_VALUE + + 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_VALUE + + 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 == RETURN_VALUE: + # 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_VALUE + + 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 == RETURN_VALUE: + # 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..cf12c4ff 100644 --- a/docs/reference.rst +++ b/docs/reference.rst @@ -1,7 +1,7 @@ Reference ========= -.. autosummary:: +.. _helpers-summary: .. highlights:: :ref:`reference:Helpers` @@ -11,6 +11,7 @@ Reference hunter.stop hunter.wrap hunter.And + hunter.Backlog hunter.From hunter.Not hunter.Or @@ -26,25 +27,26 @@ 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` .. 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` @@ -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..b50de29c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,66 @@ [build-system] requires = [ - "setuptools>=30.3.0", + "setuptools>=64.0.0", "wheel", - "setuptools_scm>=3.3.1", + "setuptools_scm>=3.3.1,!=4.0.0", ] +build-backend = "backend" +backend-path = ["build_backend"] + +[tool.ruff] +extend-exclude = ["static", "ci/templates"] +line-length = 140 +src = ["src", "tests"] +target-version = "py38" +[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 +] +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 + "Q", # flake8-quotes + "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.flake8-quotes] +inline-quotes = "single" + +[tool.ruff.lint.isort] +extra-standard-library = ["opcode"] +forced-separate = ["conftest"] +force-single-line = true + +[tool.black] +line-length = 140 +target-version = ["py38"] +skip-string-normalization = true 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..d1fa8067 --- 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 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 @@ -30,44 +22,35 @@ except ImportError: 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' + LFLAGS = os.environ['LFLAGS'] = '' +else: + CFLAGS = '' + LFLAGS = '' +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 +59,34 @@ 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) + if os.environ.get('SETUPPY_FORCE_PURE'): + raise Exception('C extensions disabled (SETUPPY_FORCE_PURE)!') + 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,25 +94,39 @@ 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', + 'fallback_version': '3.7.0', }, 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'), 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')], zip_safe=False, classifiers=[ # complete classifier list: http://pypi.python.org/pypi?%3Aaction=list_classifiers @@ -137,12 +137,13 @@ def _unavailable(self, e): '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 :: Only', 'Programming Language :: Python :: 3.8', + 'Programming Language :: Python :: 3.9', + 'Programming Language :: Python :: 3.10', + 'Programming Language :: Python :: 3.11', + 'Programming Language :: Python :: 3.12', 'Programming Language :: Python :: Implementation :: CPython', 'Programming Language :: Python :: Implementation :: PyPy', 'Topic :: Utilities', @@ -154,21 +155,29 @@ def _unavailable(self, e): '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', + 'trace', + 'tracer', + 'settrace', + 'debugger', + 'debugging', + 'code', + 'source', ], + python_requires='>=3.8', + install_requires=[], extras_require={ ':platform_system != "Windows"': ['manhole >= 1.5'], }, - setup_requires=[ - 'setuptools_scm>=3.3.1', - 'cython', - ] if Cython else [ - 'setuptools_scm>=3.3.1', - ], + setup_requires=( + [ + 'setuptools_scm>=3.3.1,!=4.0.0', + 'cython', + ] + if Cython + else [ + 'setuptools_scm>=3.3.1,!=4.0.0', + ] + ), entry_points={ 'console_scripts': [ 'hunter-trace = hunter.remote:main', @@ -181,14 +190,19 @@ def _unavailable(self, e): 'develop': DevelopWithPTH, 'build_ext': OptionalBuildExt, }, - 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)] - ) - for root, _, _ in os.walk('src') - for path in glob(join(root, '*.pyx' if Cython else '*.c')) - ], + ext_modules=( + [] + if hasattr(sys, 'pypy_version_info') + else [ + Extension( + 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 path in Path('src').glob('**/*.pyx' if Cython else '**/*.c') + ] + ), + distclass=BinaryDistribution, ) 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..02de712c 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.7.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..83cb6beb 100644 --- a/src/hunter/_event.c +++ b/src/hunter/_event.c @@ -1,20 +1,57 @@ -/* Generated by Cython 0.29.14 */ +/* Generated by Cython 3.0.10 */ +/* BEGIN: Cython Metadata +{ + "distutils": { + "depends": [ + "src/hunter/vendor/_compat.h" + ], + "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 */ +#if defined(CYTHON_LIMITED_API) && 0 + #ifndef Py_LIMITED_API + #if CYTHON_LIMITED_API+0 > 0x03030000 + #define Py_LIMITED_API CYTHON_LIMITED_API + #else + #define Py_LIMITED_API 0x03030000 + #endif + #endif +#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 < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.7+ or Python 3.3+. #else -#define CYTHON_ABI "0_29_14" -#define CYTHON_HEX_VERSION 0x001D0EF0 +#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API +#define __PYX_EXTRA_ABI_MODULE_NAME "limited" +#else +#define __PYX_EXTRA_ABI_MODULE_NAME "" +#endif +#define CYTHON_ABI "3_0_10" __PYX_EXTRA_ABI_MODULE_NAME +#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI +#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." +#define CYTHON_HEX_VERSION 0x03000AF0 #define CYTHON_FUTURE_DIVISION 1 #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 +70,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,12 +78,19 @@ #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_NOGIL 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 @@ -73,27 +115,176 @@ #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 (PY_MAJOR_VERSION >= 3) + #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_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 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) + #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 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_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 (PY_MAJOR_VERSION >= 3) + #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_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00) + #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 +#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_NOGIL 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_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 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 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_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 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 1 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #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 +#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL) #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 1 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif + #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 + #ifndef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #ifndef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS @@ -101,8 +292,6 @@ #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif @@ -114,27 +303,48 @@ #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 1 + #endif #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 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 1 + #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 1 + #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 + #endif #else #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 1 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif - #if PY_VERSION_HEX < 0x02070000 - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #ifndef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 @@ -143,10 +353,7 @@ #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif - #if PY_VERSION_HEX < 0x02070000 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #ifndef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS @@ -155,7 +362,7 @@ #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif - #if PY_VERSION_HEX < 0x030300F0 + #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #elif !defined(CYTHON_USE_UNICODE_WRITER) @@ -173,27 +380,63 @@ #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif + #ifndef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6) + #endif + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1) + #endif #ifndef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 1 #endif - #ifndef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif - #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) + #if PY_VERSION_HEX < 0x03050000 + #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 - #ifndef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 #endif - #ifndef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) + #if PY_VERSION_HEX < 0x030400a1 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #elif !defined(CYTHON_USE_TP_FINALIZE) + #define CYTHON_USE_TP_FINALIZE 1 + #endif + #if PY_VERSION_HEX < 0x030600B1 + #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) + #endif + #if PY_VERSION_HEX < 0x030700A3 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #elif !defined(CYTHON_USE_EXC_INFO_STACK) + #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 1 #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif +#if !defined(CYTHON_VECTORCALL) +#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) +#endif +#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) #if CYTHON_USE_PYLONG_INTERNALS - #include "longintrepr.h" + #if PY_MAJOR_VERSION < 3 + #include "longintrepr.h" + #endif #undef SHIFT #undef BASE #undef MASK @@ -218,6 +461,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,13 +485,16 @@ # 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 # define CYTHON_NCP_UNUSED @@ -245,28 +502,59 @@ # 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,13 +564,26 @@ #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 +#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)) #ifndef CYTHON_INLINE #if defined(__clang__) @@ -298,26 +599,145 @@ #endif #endif -#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) - #define Py_OptimizeFlag 0 -#endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type + #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) #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) + #define __Pyx_DefaultClassType PyType_Type +#if CYTHON_COMPILING_IN_LIMITED_API + static CYTHON_INLINE 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, "iiiiiOOOOOOiOO", 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, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else { + if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); + } + end: + Py_XDECREF(code_type); + Py_XDECREF(exception_table); + Py_XDECREF(types_module); + if (type) { + PyErr_Restore(type, value, traceback); + } + return result; + } + #ifndef CO_OPTIMIZED + #define CO_OPTIMIZED 0x0001 + #endif + #ifndef CO_NEWLOCALS + #define CO_NEWLOCALS 0x0002 + #endif + #ifndef CO_VARARGS + #define CO_VARARGS 0x0004 + #endif + #ifndef CO_VARKEYWORDS + #define CO_VARKEYWORDS 0x0008 + #endif + #ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x0200 + #endif + #ifndef CO_GENERATOR + #define CO_GENERATOR 0x0020 + #endif + #ifndef CO_COROUTINE + #define CO_COROUTINE 0x0080 + #endif +#elif PY_VERSION_HEX >= 0x030B0000 + static CYTHON_INLINE 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; + PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0); + if (!empty_bytes) return NULL; + 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, empty_bytes); + Py_DECREF(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, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + #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 - #define __Pyx_DefaultClassType PyType_Type +#endif +#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 CO_COROUTINE + #define CO_COROUTINE 0x80 +#endif +#ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x200 #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 @@ -331,6 +751,12 @@ #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 @@ -342,34 +768,89 @@ 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_MAJOR_VERSION >= 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) { +#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 < 0x030900B1 + #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_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_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 +#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() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 @@ -377,6 +858,22 @@ #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif +#if CYTHON_COMPILING_IN_LIMITED_API +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; +} +#endif +#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) +#else + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) +#endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 @@ -407,7 +904,29 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { return PyThread_get_key_value(*key); } #endif -#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) +#if PY_MAJOR_VERSION < 3 + #if CYTHON_COMPILING_IN_PYPY + #if PYPY_VERSION_NUM < 0x07030600 + #if defined(__cplusplus) && __cplusplus >= 201402L + [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]] + #elif defined(__GNUC__) || defined(__clang__) + __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))) + #elif defined(_MSC_VER) + __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")) + #endif + static CYTHON_INLINE int PyGILState_Check(void) { + return 0; + } + #else // PYPY_VERSION_NUM < 0x07030600 + #endif // PYPY_VERSION_NUM < 0x07030600 + #else + static CYTHON_INLINE int PyGILState_Check(void) { + PyThreadState * tstate = _PyThreadState_Current; + return tstate && (tstate == PyGILState_GetThisThreadState()); + } + #endif +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() @@ -419,23 +938,92 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS -#define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && 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 PY_MAJOR_VERSION >= 3 && (!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) + #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext) +#else + #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) + #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) + #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v) +#else + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v) +#endif +#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) +#if CYTHON_COMPILING_IN_LIMITED_API + #define CYTHON_PEP393_ENABLED 1 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u) + #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)) +#elif 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))) + #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_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) - #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_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))) + #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 #else #define CYTHON_PEP393_ENABLED 0 #define PyUnicode_1BYTE_KIND 1 @@ -444,11 +1032,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #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_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((int)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_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY @@ -459,14 +1047,20 @@ 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) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500) + #undef 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)) @@ -484,8 +1078,10 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define PyString_Type PyUnicode_Type #define PyString_Check PyUnicode_Check #define PyString_CheckExact PyUnicode_CheckExact +#ifndef PyObject_Unicode #define PyObject_Unicode PyObject_Str #endif +#endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) @@ -493,19 +1089,59 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif -#ifndef PySet_CheckExact - #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) -#endif +#if CYTHON_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_PySequence_ListKeepNew(obj) PySequence_List(obj) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type) +#endif +#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_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_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) + #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) #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_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) + #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) +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 + #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 __Pyx_Py3Int_Check(op) PyLong_Check(op) + #define __Pyx_Py3Int_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong @@ -517,6 +1153,9 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long +#else + #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op)) + #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op)) #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject @@ -529,15 +1168,10 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #if PY_VERSION_HEX < 0x030200A4 typedef long Py_hash_t; #define __Pyx_PyInt_FromHash_t PyInt_FromLong - #define __Pyx_PyInt_AsHash_t PyInt_AsLong + #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t #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) + #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t #endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 @@ -557,8 +1191,10 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { } __Pyx_PyAsyncMethodsStruct; #endif -#if defined(WIN32) || defined(MS_WINDOWS) - #define _USE_MATH_DEFINES +#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) + #if !defined(_USE_MATH_DEFINES) + #define _USE_MATH_DEFINES + #endif #endif #include #ifdef NAN @@ -576,13 +1212,21 @@ static CYTHON_INLINE float __PYX_NAN() { #define __Pyx_truncl truncl #endif - +#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; } #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 + { __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,7 +1239,7 @@ static CYTHON_INLINE float __PYX_NAN() { /* Early includes */ #include #include -#include "frameobject.h" +#include "vendor/_compat.h" #include "pystate.h" #include "pythread.h" #ifdef _OPENMP @@ -609,10 +1253,10 @@ static CYTHON_INLINE float __PYX_NAN() { 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_DEFAULT_STRING_ENCODING "ascii" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #define __Pyx_uchar_cast(c) ((unsigned char)c) @@ -646,9 +1290,10 @@ 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 @@ -666,9 +1311,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_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) @@ -676,13 +1321,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #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) @@ -694,6 +1333,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); (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 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)) #else @@ -705,8 +1345,54 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); #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 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 PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +#include static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; @@ -727,7 +1413,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { - ascii_chars[c] = c; + ascii_chars[c] = (char) c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); @@ -757,6 +1443,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #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 +#include static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; @@ -792,33 +1479,67 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } +#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 * __pyx_cfilenm = __FILE__; static const char *__pyx_filename; +/* #### Code section: filename_table ### */ static const char *__pyx_f[] = { "src/hunter/_event.pyx", "src/hunter/_event.pxd", - "stringsource", - ".tox/cythonize/lib/python3.8/site-packages/Cython/Includes/cpython/type.pxd", + ".tox/cythonize/lib64/python3.11/site-packages/Cython/Includes/cpython/type.pxd", "src/hunter/_tracer.pxd", + "src/hunter/vendor/_cymem/cymem.pxd", }; +/* #### Code section: utility_code_proto_before_types ### */ +/* 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() + +/* ForceInitThreads.proto */ +#ifndef __PYX_FORCE_INIT_THREADS + #define __PYX_FORCE_INIT_THREADS 0 +#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_6vendor_6_cymem_5cymem_PyMalloc; +struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree; +struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool; +struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address; struct __pyx_obj_6hunter_6_event_Event; struct __pyx_obj_6hunter_6_event___pyx_scope_struct__yield_lines; -/* "_tracer.pxd":28 +/* "vendor/_cymem/cymem.pxd":2 + * # cython: language_level=3str + * ctypedef void* (*malloc_t)(size_t n) # <<<<<<<<<<<<<< + * ctypedef void (*free_t)(void *p) + * + */ +typedef void *(*__pyx_t_6hunter_6vendor_6_cymem_5cymem_malloc_t)(size_t); + +/* "vendor/_cymem/cymem.pxd":3 + * # cython: language_level=3str + * ctypedef void* (*malloc_t)(size_t n) + * ctypedef void (*free_t)(void *p) # <<<<<<<<<<<<<< + * + * cdef class PyMalloc: + */ +typedef void (*__pyx_t_6hunter_6vendor_6_cymem_5cymem_free_t)(void *); + +/* "_tracer.pxd":36 * * @cython.final * cdef class Tracer: # <<<<<<<<<<<<<< @@ -830,6 +1551,7 @@ struct __pyx_obj_6hunter_7_tracer_Tracer { PyObject *handler; PyObject *previous; PyObject *threading_support; + int profiling_mode; int depth; int calls; PyObject *__weakref__; @@ -838,7 +1560,68 @@ struct __pyx_obj_6hunter_7_tracer_Tracer { }; -/* "hunter/_event.pxd":11 +/* "vendor/_cymem/cymem.pxd":5 + * ctypedef void (*free_t)(void *p) + * + * cdef class PyMalloc: # <<<<<<<<<<<<<< + * cdef malloc_t malloc + * cdef void _set(self, malloc_t malloc) + */ +struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc { + PyObject_HEAD + struct __pyx_vtabstruct_6hunter_6vendor_6_cymem_5cymem_PyMalloc *__pyx_vtab; + __pyx_t_6hunter_6vendor_6_cymem_5cymem_malloc_t malloc; +}; + + +/* "vendor/_cymem/cymem.pxd":11 + * cdef PyMalloc WrapMalloc(malloc_t malloc) + * + * cdef class PyFree: # <<<<<<<<<<<<<< + * cdef free_t free + * cdef void _set(self, free_t free) + */ +struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree { + PyObject_HEAD + struct __pyx_vtabstruct_6hunter_6vendor_6_cymem_5cymem_PyFree *__pyx_vtab; + __pyx_t_6hunter_6vendor_6_cymem_5cymem_free_t free; +}; + + +/* "vendor/_cymem/cymem.pxd":17 + * cdef PyFree WrapFree(free_t free) + * + * cdef class Pool: # <<<<<<<<<<<<<< + * cdef readonly size_t size + * cdef readonly dict addresses + */ +struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool { + PyObject_HEAD + struct __pyx_vtabstruct_6hunter_6vendor_6_cymem_5cymem_Pool *__pyx_vtab; + size_t size; + PyObject *addresses; + PyObject *refs; + struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *pymalloc; + struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *pyfree; +}; + + +/* "vendor/_cymem/cymem.pxd":29 + * + * + * cdef class Address: # <<<<<<<<<<<<<< + * cdef void* ptr + * cdef readonly PyMalloc pymalloc + */ +struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address { + PyObject_HEAD + void *ptr; + struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *pymalloc; + struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *pyfree; +}; + + +/* "hunter/_event.pxd":13 * * @cython.final * cdef class Event: # <<<<<<<<<<<<<< @@ -855,6 +1638,7 @@ struct __pyx_obj_6hunter_6_event_Event { int calls; int threading_support; int detached; + PyObject *builtin; PyObject *_code; PyObject *_filename; PyObject *_fullsource; @@ -869,10 +1653,11 @@ struct __pyx_obj_6hunter_6_event_Event { PyObject *_thread; PyObject *_threadidn; PyObject *_threadname; + PyObject *_instruction; }; -/* "hunter/_event.pyx":297 +/* "hunter/_event.pyx":363 * * * def yield_lines(filename, module_globals, start, list collector, # <<<<<<<<<<<<<< @@ -896,19 +1681,88 @@ struct __pyx_obj_6hunter_6_event___pyx_scope_struct__yield_lines { -/* "hunter/_event.pyx":29 +/* "vendor/_cymem/cymem.pxd":5 + * ctypedef void (*free_t)(void *p) + * + * cdef class PyMalloc: # <<<<<<<<<<<<<< + * cdef malloc_t malloc + * cdef void _set(self, malloc_t malloc) + */ + +struct __pyx_vtabstruct_6hunter_6vendor_6_cymem_5cymem_PyMalloc { + void (*_set)(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *, __pyx_t_6hunter_6vendor_6_cymem_5cymem_malloc_t); +}; +static struct __pyx_vtabstruct_6hunter_6vendor_6_cymem_5cymem_PyMalloc *__pyx_vtabptr_6hunter_6vendor_6_cymem_5cymem_PyMalloc; + + +/* "vendor/_cymem/cymem.pxd":11 + * cdef PyMalloc WrapMalloc(malloc_t malloc) + * + * cdef class PyFree: # <<<<<<<<<<<<<< + * cdef free_t free + * cdef void _set(self, free_t free) + */ + +struct __pyx_vtabstruct_6hunter_6vendor_6_cymem_5cymem_PyFree { + void (*_set)(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *, __pyx_t_6hunter_6vendor_6_cymem_5cymem_free_t); +}; +static struct __pyx_vtabstruct_6hunter_6vendor_6_cymem_5cymem_PyFree *__pyx_vtabptr_6hunter_6vendor_6_cymem_5cymem_PyFree; + + +/* "vendor/_cymem/cymem.pxd":17 + * cdef PyFree WrapFree(free_t free) * + * cdef class Pool: # <<<<<<<<<<<<<< + * cdef readonly size_t size + * cdef readonly dict addresses + */ + +struct __pyx_vtabstruct_6hunter_6vendor_6_cymem_5cymem_Pool { + void *(*alloc)(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *, size_t, size_t); + void (*free)(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *, void *); + void *(*realloc)(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *, void *, size_t); +}; +static struct __pyx_vtabstruct_6hunter_6vendor_6_cymem_5cymem_Pool *__pyx_vtabptr_6hunter_6vendor_6_cymem_5cymem_Pool; + + +/* "hunter/_event.pyx":47 * + * @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,11 +1771,11 @@ 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; @@ -931,28 +1785,40 @@ static struct __pyx_obj_6hunter_6_event_Event *__pyx_f_6hunter_6_event_5Event_cl #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);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)) + #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext() #endif + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ + } #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 +1829,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 +1844,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 +1879,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,9 +1895,22 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* PyObjectGetAttrStrNoError.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + /* Profile.proto */ #ifndef CYTHON_PROFILE -#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_PYSTON +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY #define CYTHON_PROFILE 0 #else #define CYTHON_PROFILE 1 @@ -1066,6 +1936,12 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #include "compile.h" #include "frameobject.h" #include "traceback.h" +#if PY_VERSION_HEX >= 0x030b00a6 + #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) @@ -1074,11 +1950,51 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #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; + static PyCodeObject *__pyx_frame_code = NULL;\ + CYTHON_FRAME_MODIFIER PyFrameObject *__pyx_frame = NULL;\ + int __Pyx_use_tracing = 0; #define __Pyx_TraceFrameInit(codeobj)\ - if (codeobj) __pyx_frame_code = (PyCodeObject*) codeobj; + if (codeobj) __pyx_frame_code = (PyCodeObject*) codeobj; +#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 #ifdef WITH_THREAD #define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error)\ if (nogil) {\ @@ -1086,8 +2002,7 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject 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))) {\ + if (__Pyx_IsTracing(tstate, 1, 1)) {\ __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ }\ PyGILState_Release(state);\ @@ -1095,8 +2010,7 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject }\ } else {\ PyThreadState* tstate = PyThreadState_GET();\ - if (unlikely(tstate->use_tracing) && !tstate->tracing &&\ - (tstate->c_profilefunc || (CYTHON_TRACE && tstate->c_tracefunc))) {\ + if (__Pyx_IsTracing(tstate, 1, 1)) {\ __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ }\ @@ -1104,8 +2018,7 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #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))) {\ + if (__Pyx_IsTracing(tstate, 1, 1)) {\ __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ }\ @@ -1114,10 +2027,8 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #define __Pyx_TraceException()\ 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;\ + if (__Pyx_IsTracing(tstate, 0, 1)) {\ + __Pyx_EnterTracing(tstate);\ PyObject *exc_info = __Pyx_GetExceptionTuple(tstate);\ if (exc_info) {\ if (CYTHON_TRACE && tstate->c_tracefunc)\ @@ -1127,22 +2038,19 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject tstate->c_profileobj, __pyx_frame, PyTrace_EXCEPTION, exc_info);\ Py_DECREF(exc_info);\ }\ - tstate->use_tracing = 1;\ - tstate->tracing--;\ + __Pyx_LeaveTracing(tstate);\ }\ } static void __Pyx_call_return_trace_func(PyThreadState *tstate, PyFrameObject *frame, PyObject *result) { 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--; + __Pyx_LeaveTracing(tstate); __Pyx_ErrRestoreInState(tstate, type, value, traceback); } #ifdef WITH_THREAD @@ -1153,14 +2061,14 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject PyThreadState *tstate;\ PyGILState_STATE state = PyGILState_Ensure();\ tstate = __Pyx_PyThreadState_Current;\ - if (tstate->use_tracing) {\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ }\ PyGILState_Release(state);\ }\ } else {\ PyThreadState* tstate = __Pyx_PyThreadState_Current;\ - if (tstate->use_tracing) {\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ }\ }\ @@ -1169,7 +2077,7 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #define __Pyx_TraceReturn(result, nogil)\ if (likely(!__Pyx_use_tracing)); else {\ PyThreadState* tstate = __Pyx_PyThreadState_Current;\ - if (tstate->use_tracing) {\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ }\ } @@ -1189,11 +2097,9 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject PyObject *type, *value, *traceback; __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); __Pyx_PyFrame_SetLineNumber(frame, lineno); - tstate->tracing++; - tstate->use_tracing = 0; + __Pyx_EnterTracing(tstate); ret = tstate->c_tracefunc(tstate->c_traceobj, frame, PyTrace_LINE, NULL); - tstate->use_tracing = 1; - tstate->tracing--; + __Pyx_LeaveTracing(tstate); if (likely(!ret)) { __Pyx_ErrRestoreInState(tstate, type, value, traceback); } else { @@ -1210,17 +2116,17 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject if (CYTHON_TRACE_NOGIL) {\ int ret = 0;\ PyThreadState *tstate;\ - PyGILState_STATE state = PyGILState_Ensure();\ + PyGILState_STATE state = __Pyx_PyGILState_Ensure();\ tstate = __Pyx_PyThreadState_Current;\ - if (unlikely(tstate->use_tracing && tstate->c_tracefunc && __pyx_frame->f_trace)) {\ + if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && __pyx_frame->f_trace) {\ ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ }\ - PyGILState_Release(state);\ + __Pyx_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)) {\ + if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && __pyx_frame->f_trace) {\ int ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ if (unlikely(ret)) goto_error;\ }\ @@ -1230,7 +2136,7 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #define __Pyx_TraceLine(lineno, 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)) {\ + if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && __pyx_frame->f_trace) {\ int ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ if (unlikely(ret)) goto_error;\ }\ @@ -1240,102 +2146,104 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #define __Pyx_TraceLine(lineno, nogil, goto_error) if ((1)); else goto_error; #endif -/* IterFinish.proto */ -static CYTHON_INLINE int __Pyx_IterFinish(void); +/* RaiseUnexpectedTypeError.proto */ +static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj); -/* 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); -#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)) -#endif +/* Intern.proto */ +static PyObject* __Pyx_Intern(PyObject* s); -/* PyObjectCall.proto */ +/* TupleAndListFromArray.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) +static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); +static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); #endif -/* PyObjectCallMethO.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); -#endif +/* IncludeStringH.proto */ +#include -/* PyObjectCallNoArg.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); +/* 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_Arg_VARARGS(args, i) PySequence_GetItem(args, i) +#elif CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i) #else -#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) + #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i) #endif - -/* PyCFunctionFastCall.proto */ -#if CYTHON_FAST_PYCCALL -static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg) + #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg) +#else + #define __Pyx_Arg_NewRef_VARARGS(arg) arg + #define __Pyx_Arg_XDECREF_VARARGS(arg) +#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_Arg_FASTCALL(args, i) args[i] + #define __Pyx_NumKwargs_FASTCALL(kwds) 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_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); + #else + #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) + #endif + #define __Pyx_Arg_NewRef_FASTCALL(arg) arg /* no-op, __Pyx_Arg_FASTCALL is direct and this needs + to have the same reference counting */ + #define __Pyx_Arg_XDECREF_FASTCALL(arg) #else -#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) + #define __Pyx_Arg_FASTCALL __Pyx_Arg_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 + #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg) + #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start) +#else +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) #endif -/* PyObjectCallOneArg.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); - -/* 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); - -/* RaiseNeedMoreValuesToUnpack.proto */ -static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); - -/* RaiseTooManyValuesToUnpack.proto */ -static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); - -/* UnpackItemEndCheck.proto */ -static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); +/* 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); -/* RaiseNoneIterError.proto */ -static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); +/* RaiseDoubleKeywords.proto */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); -/* UnpackTupleError.proto */ -static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index); +/* ParseKeywords.proto */ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues, + PyObject **argnames[], + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, + const char* function_name); -/* UnpackTuple2.proto */ -#define __Pyx_unpack_tuple2(tuple, value1, value2, is_tuple, has_known_size, decref_tuple)\ - (likely(is_tuple || PyTuple_Check(tuple)) ?\ - (likely(has_known_size || PyTuple_GET_SIZE(tuple) == 2) ?\ - __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple) :\ - (__Pyx_UnpackTupleError(tuple, 2), -1)) :\ - __Pyx_unpack_tuple2_generic(tuple, value1, value2, has_known_size, decref_tuple)) -static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( - PyObject* tuple, PyObject** value1, PyObject** value2, int decref_tuple); -static int __Pyx_unpack_tuple2_generic( - PyObject* tuple, PyObject** value1, PyObject** value2, int has_known_size, int decref_tuple); +/* 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); -/* dict_iter.proto */ -static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int is_dict, PyObject* method_name, - Py_ssize_t* p_orig_length, int* p_is_dict); -static CYTHON_INLINE int __Pyx_dict_iter_next(PyObject* dict_or_iter, Py_ssize_t orig_length, Py_ssize_t* ppos, - PyObject** pkey, PyObject** pvalue, PyObject** pitem, int is_dict); +/* 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 -/* PyObjectCall2Args.proto */ -static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS @@ -1365,18 +2273,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))) ?\ (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) @@ -1384,6 +2292,9 @@ static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_ve static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); #endif +/* KeywordStringCheck.proto */ +static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed); + /* 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) ?\ @@ -1406,27 +2317,113 @@ 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( +/* 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 **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" +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif + #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 + +/* 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 **args, size_t nargs, PyObject *kwargs); + +/* 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); + +/* 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); + +/* RaiseNeedMoreValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); + +/* RaiseTooManyValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); + +/* UnpackItemEndCheck.proto */ +static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); + +/* RaiseNoneIterError.proto */ +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); + +/* UnpackTupleError.proto */ +static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index); + +/* UnpackTuple2.proto */ +#define __Pyx_unpack_tuple2(tuple, value1, value2, is_tuple, has_known_size, decref_tuple)\ + (likely(is_tuple || PyTuple_Check(tuple)) ?\ + (likely(has_known_size || PyTuple_GET_SIZE(tuple) == 2) ?\ + __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple) :\ + (__Pyx_UnpackTupleError(tuple, 2), -1)) :\ + __Pyx_unpack_tuple2_generic(tuple, value1, value2, has_known_size, decref_tuple)) +static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( + PyObject* tuple, PyObject** value1, PyObject** value2, int decref_tuple); +static int __Pyx_unpack_tuple2_generic( + PyObject* tuple, PyObject** value1, PyObject** value2, int has_known_size, int decref_tuple); + +/* dict_iter.proto */ +static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int is_dict, PyObject* method_name, + Py_ssize_t* p_orig_length, int* p_is_dict); +static CYTHON_INLINE int __Pyx_dict_iter_next(PyObject* dict_or_iter, Py_ssize_t orig_length, Py_ssize_t* ppos, + PyObject** pkey, PyObject** pvalue, PyObject** pitem, int is_dict); + +/* 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); +/* 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)); } -/* 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 @@ -1446,6 +2443,12 @@ static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, long int (inplace ? PyNumber_InPlaceSubtract(op1, op2) : PyNumber_Subtract(op1, op2)) #endif +/* 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); + /* StringJoin.proto */ #if PY_MAJOR_VERSION < 3 #define __Pyx_PyString_Join __Pyx_PyBytes_Join @@ -1454,18 +2457,10 @@ static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, long int #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 /* 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,24 +2478,20 @@ 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)) #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); -#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) @@ -1509,6 +2500,10 @@ static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); #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); + /* SwapException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSwap(type, value, tb) __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb) @@ -1517,12 +2512,35 @@ 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 PY_MAJOR_VERSION < 3 + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + likely(PyString_CheckExact(s)) ? PyUnicode_FromEncodedObject(s, NULL, "strict") :\ + 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 + +/* JoinPyUnicode.proto */ +static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength, + Py_UCS4 max_char); + /* GetAttr.proto */ static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); -/* GetAttr3.proto */ -static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); - /* ListAppend.proto */ #if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { @@ -1530,8 +2548,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,20 +2562,24 @@ 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); +/* IncludeStructmemberH.proto */ +#include -/* RaiseException.proto */ -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); +/* FixUpExtensionType.proto */ +#if CYTHON_USE_TYPE_SPECS +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); +#endif -/* ExtTypeTest.proto */ -static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, 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 -/* HasAttr.proto */ -static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); +/* PyType_Ready.proto */ +CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t); /* PyObject_GenericGetAttrNoDict.proto */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 @@ -1563,22 +2589,181 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj #endif /* 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); + +/* MergeVTables.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_MergeVtables(PyTypeObject *type); +#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_0_10 +#define __PYX_HAVE_RT_ImportType_proto_3_0_10 +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L +#include +#endif +#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L +#define __PYX_GET_STRUCT_ALIGNMENT_3_0_10(s) alignof(s) +#else +#define __PYX_GET_STRUCT_ALIGNMENT_3_0_10(s) sizeof(void*) +#endif +enum __Pyx_ImportType_CheckSize_3_0_10 { + __Pyx_ImportType_CheckSize_Error_3_0_10 = 0, + __Pyx_ImportType_CheckSize_Warn_3_0_10 = 1, + __Pyx_ImportType_CheckSize_Ignore_3_0_10 = 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_0_10(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_10 check_size); +#endif + +/* 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); + +/* FetchCommonType.proto */ +#if !CYTHON_USE_TYPE_SPECS +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); +#else +static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases); +#endif + +/* PyMethodNew.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + PyObject *typesModule=NULL, *methodType=NULL, *result=NULL; + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + typesModule = PyImport_ImportModule("types"); + if (!typesModule) return NULL; + methodType = PyObject_GetAttrString(typesModule, "MethodType"); + Py_DECREF(typesModule); + if (!methodType) return NULL; + result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL); + Py_DECREF(methodType); + return result; +} +#elif PY_MAJOR_VERSION >= 3 +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); +} +#else + #define __Pyx_PyMethod_New PyMethod_New +#endif + +/* PyVectorcallFastCallDict.proto */ +#if CYTHON_METH_FASTCALL +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 + __pyx_vectorcallfunc func_vectorcall; +#endif +#if PY_VERSION_HEX < 0x030500A0 || 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 + void *defaults; + int defaults_pyobjects; + size_t defaults_size; + 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_CyFunctionType) +#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type) +#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_CyFunctionType) +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc); +#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 void *__Pyx_CyFunction_InitDefaults(PyObject *m, + size_t size, + int pyobjects); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, + PyObject *tuple); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, + PyObject *dict); +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, + PyObject *dict); +static int __pyx_CyFunction_init(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 +#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) @@ -1587,6 +2772,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API typedef struct { PyCodeObject* code_object; int code_line; @@ -1600,31 +2786,45 @@ 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); +#endif /* 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_PyInt_As_int(PyObject *); + /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); -/* CIntFromPy.proto */ -static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); +/* FormatTypeName.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%U" +static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp); +#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) +#else +typedef const char *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%.200s" +#define __Pyx_PyType_GetName(tp) ((tp)->tp_name) +#define __Pyx_DECREF_TypeName(obj) +#endif /* CIntFromPy.proto */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); -/* FetchCommonType.proto */ -static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); - -/* PyObjectCallMethod1.proto */ -static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg); - /* 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 +2834,7 @@ typedef struct { PyObject *exc_traceback; } __Pyx_ExcInfoStruct; #endif -typedef struct { +typedef struct __pyx_CoroutineObject { PyObject_HEAD __pyx_coroutine_body_t body; PyObject *closure; @@ -1646,6 +2846,7 @@ typedef struct { PyObject *gi_qualname; PyObject *gi_modulename; PyObject *gi_code; + PyObject *gi_frame; int resume_label; char is_running; } __pyx_CoroutineObject; @@ -1691,67 +2892,92 @@ static int __Pyx_patch_abc(void); /* 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_GeneratorType) #define __Pyx_Generator_New(body, code, closure, name, qualname, module_name)\ __Pyx__Coroutine_New(__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); /* CheckBinaryVersion.proto */ -static int __Pyx_check_binary_version(void); +static unsigned long __Pyx_get_runtime_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); -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*/ +/* #### Code section: module_declarations ### */ +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 "cython" */ -/* Module declarations from 'cython' */ +/* Module declarations from "libc.string" */ -/* Module declarations from 'libc.string' */ +/* Module declarations from "libc.stdio" */ -/* Module declarations from 'libc.stdio' */ +/* Module declarations from "__builtin__" */ -/* Module declarations from '__builtin__' */ +/* Module declarations from "cpython.type" */ -/* Module declarations from 'cpython.type' */ -static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; +/* Module declarations from "cpython" */ -/* Module declarations from 'cpython' */ +/* Module declarations from "cpython.object" */ -/* Module declarations from 'cpython.object' */ +/* Module declarations from "cpython.pystate" */ -/* Module declarations from 'cpython.pystate' */ +/* Module declarations from "cpython.ref" */ -/* Module declarations from 'types' */ +/* Module declarations from "types" */ -/* 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 "hunter._tracer" */ -/* Module declarations from 'cpython.pythread' */ +/* Module declarations from "cpython.pythread" */ -/* 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.vendor._cymem.cymem" */ + +/* 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 struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *__pyx_v_6hunter_6_event_mem = 0; +static PyObject **__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*/ +static CYTHON_INLINE PyObject **__pyx_f_6hunter_6_event_make_kind_names(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[] = "."; +static PyObject *__pyx_builtin_enumerate; +static PyObject *__pyx_builtin_TypeError; +/* #### Code section: string_decls ### */ +static const char __pyx_k__7[] = ""; +static const char __pyx_k__9[] = "?"; +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__14[] = "."; 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_pyc[] = ".pyc"; static const char __pyx_k_pyd[] = ".pyd"; static const char __pyx_k_pyo[] = ".pyo"; @@ -1759,8 +2985,6 @@ 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_code[] = "code"; -static const char __pyx_k_dict[] = "__dict__"; static const char __pyx_k_file[] = "__file__"; static const char __pyx_k_join[] = "join"; static const char __pyx_k_kind[] = "kind"; @@ -1768,14 +2992,18 @@ 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_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_Event[] = "Event"; +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_ident[] = "ident"; static const char __pyx_k_items[] = "items"; @@ -1785,8 +3013,10 @@ static const char __pyx_k_start[] = "start"; static const char __pyx_k_throw[] = "throw"; static const char __pyx_k_amount[] = "amount"; 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_file_2[] = " file"; static const char __pyx_k_import[] = "__import__"; static const char __pyx_k_lambda[] = "lambda"; static const char __pyx_k_lineno[] = "lineno"; @@ -1794,15 +3024,12 @@ static const char __pyx_k_locals[] = "locals"; 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_string[] = ""; static const char __pyx_k_tracer[] = "tracer"; -static const char __pyx_k_update[] = "update"; static const char __pyx_k_values[] = "values"; -static const char __pyx_k_co_name[] = "co_name"; +static const char __pyx_k_MISSING[] = "MISSING"; +static const char __pyx_k_disable[] = "disable"; static const char __pyx_k_findall[] = "findall"; static const char __pyx_k_getline[] = "getline"; static const char __pyx_k_globals[] = "globals"; @@ -1813,174 +3040,57 @@ 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_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_module_2[] = "__module__"; +static const char __pyx_k_module_3[] = ""; 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_NO_SOURCE[] = "\077\077? NO SOURCE: "; +static const char __pyx_k_TypeError[] = "TypeError"; static const char __pyx_k_collector[] = "collector"; +static const char __pyx_k_enumerate[] = "enumerate"; +static const char __pyx_k_exception[] = "exception"; +static const char __pyx_k_f_globals[] = "f_globals"; static const char __pyx_k_functools[] = "functools"; +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_threading[] = "threading"; static const char __pyx_k_TokenError[] = "TokenError"; -static const char __pyx_k_fullsource[] = "fullsource"; static const char __pyx_k_namedtuple[] = "namedtuple_"; -static const char __pyx_k_pyx_result[] = "__pyx_result"; static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; static const char __pyx_k_startswith[] = "startswith"; -static const char __pyx_k_threadname[] = "threadname"; -static const char __pyx_k_NO_SOURCE_r[] = "\077\077? NO SOURCE: {!r}"; -static const char __pyx_k_PickleError[] = "PickleError"; -static const char __pyx_k_co_argcount[] = "co_argcount"; -static const char __pyx_k_co_varnames[] = "co_varnames"; +static const char __pyx_k_Event_clone[] = "Event.clone"; static const char __pyx_k_yield_lines[] = "yield_lines"; +static const char __pyx_k_Event_detach[] = "Event.detach"; static const char __pyx_k_if_same_code[] = "if_same_code"; -static const char __pyx_k_pyx_checksum[] = "__pyx_checksum"; -static const char __pyx_k_stringsource[] = "stringsource"; +static const char __pyx_k_is_coroutine[] = "_is_coroutine"; static const char __pyx_k_value_filter[] = "value_filter"; static const char __pyx_k_hunter__event[] = "hunter._event"; static const char __pyx_k_pkg_resources[] = "pkg_resources"; -static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; static const char __pyx_k_current_thread[] = "current_thread"; static const char __pyx_k_module_globals[] = "module_globals"; static const char __pyx_k_generate_tokens[] = "generate_tokens"; static const char __pyx_k_get_func_in_mro[] = "get_func_in_mro"; static const char __pyx_k_get_main_thread[] = "get_main_thread"; -static const char __pyx_k_pyx_PickleError[] = "__pyx_PickleError"; -static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; static const char __pyx_k_CYTHON_SUFFIX_RE[] = "CYTHON_SUFFIX_RE"; static const char __pyx_k_SYS_PREFIX_PATHS[] = "SYS_PREFIX_PATHS"; +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_pyx_unpickle_Event[] = "__pyx_unpickle_Event"; static const char __pyx_k_SITE_PACKAGES_PATHS[] = "SITE_PACKAGES_PATHS"; static const char __pyx_k_LEADING_WHITESPACE_RE[] = "LEADING_WHITESPACE_RE"; static const char __pyx_k_src_hunter__event_pyx[] = "src/hunter/_event.pyx"; -static const char __pyx_k_NO_SOURCE_not_reading_file[] = "\077\077? NO SOURCE: not reading {} file"; -static const char __pyx_k_Incompatible_checksums_s_vs_0x36[] = "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))"; -static PyObject *__pyx_kp_s_; -static PyObject *__pyx_n_s_CYTHON_SUFFIX_RE; -static PyObject *__pyx_n_s_Event; -static PyObject *__pyx_kp_s_Incompatible_checksums_s_vs_0x36; -static PyObject *__pyx_n_s_LEADING_WHITESPACE_RE; -static PyObject *__pyx_kp_s_NO_SOURCE_not_reading_file; -static PyObject *__pyx_kp_s_NO_SOURCE_r; -static PyObject *__pyx_n_s_PickleError; -static PyObject *__pyx_n_s_SITE_PACKAGES_PATHS; -static PyObject *__pyx_n_s_SYS_PREFIX_PATHS; -static PyObject *__pyx_n_s_TokenError; -static PyObject *__pyx_kp_s__7; -static PyObject *__pyx_n_s_all; -static PyObject *__pyx_n_s_amount; -static PyObject *__pyx_n_s_arg; -static PyObject *__pyx_n_s_args; -static PyObject *__pyx_n_s_basename; -static PyObject *__pyx_n_s_call; -static PyObject *__pyx_n_s_class; -static PyObject *__pyx_n_s_cline_in_traceback; -static PyObject *__pyx_n_s_close; -static PyObject *__pyx_n_s_co_argcount; -static PyObject *__pyx_n_s_co_name; -static PyObject *__pyx_n_s_co_varnames; -static PyObject *__pyx_n_s_code; -static PyObject *__pyx_n_s_collector; -static PyObject *__pyx_n_s_const; -static PyObject *__pyx_n_s_current_thread; -static PyObject *__pyx_n_s_dedent; -static PyObject *__pyx_n_s_def; -static PyObject *__pyx_n_s_dict; -static PyObject *__pyx_n_s_endswith; -static PyObject *__pyx_n_s_exists; -static PyObject *__pyx_n_s_file; -static PyObject *__pyx_n_s_filename; -static PyObject *__pyx_n_s_findall; -static PyObject *__pyx_n_s_format; -static PyObject *__pyx_n_s_frame; -static PyObject *__pyx_n_s_fullsource; -static PyObject *__pyx_n_s_function; -static PyObject *__pyx_n_s_functools; -static PyObject *__pyx_n_s_generate_tokens; -static PyObject *__pyx_n_s_get; -static PyObject *__pyx_n_s_get_func_in_mro; -static PyObject *__pyx_n_s_get_main_thread; -static PyObject *__pyx_n_s_getline; -static PyObject *__pyx_n_s_getlines; -static PyObject *__pyx_n_s_getstate; -static PyObject *__pyx_n_s_globals; -static PyObject *__pyx_n_s_hunter__event; -static PyObject *__pyx_n_s_ident; -static PyObject *__pyx_n_s_if_same_code; -static PyObject *__pyx_n_s_import; -static PyObject *__pyx_n_s_items; -static PyObject *__pyx_n_s_join; -static PyObject *__pyx_n_s_kind; -static PyObject *__pyx_n_s_lambda; -static PyObject *__pyx_n_s_limit; -static PyObject *__pyx_n_s_line; -static PyObject *__pyx_n_s_linecache; -static PyObject *__pyx_n_s_lineno; -static PyObject *__pyx_n_s_locals; -static PyObject *__pyx_n_s_main; -static PyObject *__pyx_n_s_module; -static PyObject *__pyx_kp_s_module_2; -static PyObject *__pyx_n_s_module_globals; -static PyObject *__pyx_n_s_name; -static PyObject *__pyx_n_s_name_2; -static PyObject *__pyx_n_s_namedtuple; -static PyObject *__pyx_n_s_new; -static PyObject *__pyx_n_s_next; -static PyObject *__pyx_n_s_object; -static PyObject *__pyx_n_s_os_path; -static PyObject *__pyx_n_s_partial; -static PyObject *__pyx_n_s_pickle; -static PyObject *__pyx_n_s_pkg_resources; -static PyObject *__pyx_kp_s_py; -static PyObject *__pyx_kp_s_pyc; -static PyObject *__pyx_kp_s_pyd; -static PyObject *__pyx_kp_s_pyo; -static PyObject *__pyx_kp_s_pyx; -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_Event; -static PyObject *__pyx_n_s_pyx_vtable; -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_send; -static PyObject *__pyx_n_s_setstate; -static PyObject *__pyx_n_s_setstate_cython; -static PyObject *__pyx_n_s_site; -static PyObject *__pyx_kp_s_so; -static PyObject *__pyx_n_s_source; -static PyObject *__pyx_n_s_split; -static PyObject *__pyx_n_s_splitext; -static PyObject *__pyx_kp_s_src_hunter__event_pyx; -static PyObject *__pyx_n_s_start; -static PyObject *__pyx_n_s_startswith; -static PyObject *__pyx_n_s_stdlib; -static PyObject *__pyx_kp_s_string; -static PyObject *__pyx_kp_s_stringsource; -static PyObject *__pyx_n_s_sub; -static PyObject *__pyx_n_s_test; -static PyObject *__pyx_n_s_threadid; -static PyObject *__pyx_n_s_threading; -static PyObject *__pyx_n_s_threadname; -static PyObject *__pyx_n_s_throw; -static PyObject *__pyx_n_s_tokenize; -static PyObject *__pyx_n_s_tracer; -static PyObject *__pyx_n_s_update; -static PyObject *__pyx_n_s_util; -static PyObject *__pyx_n_s_value_filter; -static PyObject *__pyx_n_s_values; -static PyObject *__pyx_n_s_yield_lines; -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); /* proto */ -static PyObject *__pyx_pf_6hunter_6_event_5Event_2detach(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self, PyObject *__pyx_v_value_filter); /* proto */ +static const char __pyx_k_NO_SOURCE_not_reading_binary[] = "\077\077? NO SOURCE: not reading binary "; +static const char __pyx_k_Event_kind_r_function_r_module[] = ""; +static const char __pyx_k_Missing_argument_calls_required[] = "Missing argument: calls (required because tracer was not given)."; +static const char __pyx_k_Missing_argument_depth_required[] = "Missing argument: depth (required because tracer was not given)."; +static const char __pyx_k_Missing_argument_threading_suppo[] = "Missing argument: threading_support (required because tracer was not given)."; +/* #### Code section: decls ### */ +static int __pyx_pf_6hunter_6_event_5Event___init__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self, PyFrameObject *__pyx_v_frame, int __pyx_v_kind, PyObject *__pyx_v_arg, struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_tracer, PyObject *__pyx_v_depth, PyObject *__pyx_v_calls, PyObject *__pyx_v_threading_support); /* proto */ +static PyObject *__pyx_pf_6hunter_6_event_5Event_2__repr__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_6_event_5Event_4__eq__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_6hunter_6_event_5Event_6detach(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self, PyObject *__pyx_v_value_filter); /* proto */ +static PyObject *__pyx_pf_6hunter_6_event_5Event_8clone(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_6_event_5Event_11instruction___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_6_event_5Event_8threadid___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_6_event_5Event_10threadname___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_6_event_5Event_6locals___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self); /* proto */ @@ -1994,7 +3104,7 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_4code___get__(struct __pyx_obj_ static PyObject *__pyx_pf_6hunter_6_event_5Event_6stdlib___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_6_event_5Event_10fullsource___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_6_event_5Event_6source___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_6hunter_6_event_5Event_4__getitem__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self, PyObject *__pyx_v_item); /* proto */ +static PyObject *__pyx_pf_6hunter_6_event_5Event_10__getitem__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self, PyObject *__pyx_v_item); /* proto */ static PyObject *__pyx_pf_6hunter_6_event_5Event_5frame___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_6_event_5Event_4kind___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_6_event_5Event_3arg___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self); /* proto */ @@ -2002,1558 +3112,2442 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_5depth___get__(struct __pyx_obj static PyObject *__pyx_pf_6hunter_6_event_5Event_5calls___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_6_event_5Event_17threading_support___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_6_event_5Event_8detached___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_6hunter_6_event_5Event_6__reduce_cython__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self); /* proto */ -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); /* proto */ +static PyObject *__pyx_pf_6hunter_6_event_5Event_7builtin___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_6_event_yield_lines(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_filename, PyObject *__pyx_v_module_globals, PyObject *__pyx_v_start, PyObject *__pyx_v_collector, PyObject *__pyx_v_limit); /* proto */ -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); /* proto */ static PyObject *__pyx_tp_new_6hunter_6_event_Event(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_6hunter_6_event___pyx_scope_struct__yield_lines(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_int_1; -static PyObject *__pyx_int_10; -static PyObject *__pyx_int_57399096; -static PyObject *__pyx_int_neg_1; -static PyObject *__pyx_slice__4; -static PyObject *__pyx_tuple__2; -static PyObject *__pyx_tuple__3; -static PyObject *__pyx_tuple__5; -static PyObject *__pyx_tuple__6; -static PyObject *__pyx_tuple__10; -static PyObject *__pyx_tuple__11; -static PyObject *__pyx_tuple__12; -static PyObject *__pyx_codeobj__8; -static PyObject *__pyx_codeobj__9; -/* Late includes */ - -/* "hunter/_event.pyx":43 - * Needed for the ``calls`` and ``depth`` fields. - * """ - * def __init__(self, FrameType frame, str kind, object arg, Tracer tracer): # <<<<<<<<<<<<<< - * self.arg = arg - * self.frame = frame +/* #### Code section: late_includes ### */ +/* #### Code section: module_state ### */ +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 + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + PyTypeObject *__pyx_ptype_7cpython_4type_type; + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + PyTypeObject *__pyx_ptype_6hunter_7_tracer_FrameType; + PyTypeObject *__pyx_ptype_6hunter_7_tracer_CodeType; + PyTypeObject *__pyx_ptype_6hunter_7_tracer_Tracer; + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + PyTypeObject *__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyMalloc; + PyTypeObject *__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyFree; + PyTypeObject *__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Pool; + PyTypeObject *__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Address; + #if CYTHON_USE_MODULE_STATE + PyObject *__pyx_type_6hunter_6_event_Event; + PyObject *__pyx_type_6hunter_6_event___pyx_scope_struct__yield_lines; + #endif + PyTypeObject *__pyx_ptype_6hunter_6_event_Event; + PyTypeObject *__pyx_ptype_6hunter_6_event___pyx_scope_struct__yield_lines; + PyObject *__pyx_n_s_CYTHON_SUFFIX_RE; + PyObject *__pyx_n_s_Event; + PyObject *__pyx_n_s_Event_clone; + PyObject *__pyx_n_s_Event_detach; + PyObject *__pyx_kp_s_Event_kind_r_function_r_module; + PyObject *__pyx_n_s_LEADING_WHITESPACE_RE; + PyObject *__pyx_n_s_MISSING; + PyObject *__pyx_kp_s_Missing_argument_calls_required; + PyObject *__pyx_kp_s_Missing_argument_depth_required; + PyObject *__pyx_kp_s_Missing_argument_threading_suppo; + PyObject *__pyx_kp_u_NO_SOURCE; + PyObject *__pyx_kp_u_NO_SOURCE_not_reading_binary; + PyObject *__pyx_n_s_SITE_PACKAGES_PATHS; + PyObject *__pyx_n_s_SYS_PREFIX_PATHS; + PyObject *__pyx_n_s_TokenError; + PyObject *__pyx_n_s_TypeError; + PyObject *__pyx_kp_s__14; + PyObject *__pyx_kp_u__14; + PyObject *__pyx_kp_s__7; + PyObject *__pyx_kp_s__9; + PyObject *__pyx_n_s_all; + PyObject *__pyx_n_s_amount; + PyObject *__pyx_n_s_arg; + PyObject *__pyx_n_s_args; + PyObject *__pyx_n_s_asyncio_coroutines; + PyObject *__pyx_n_s_basename; + PyObject *__pyx_n_s_call; + PyObject *__pyx_n_s_calls; + PyObject *__pyx_n_s_class; + PyObject *__pyx_n_s_cline_in_traceback; + PyObject *__pyx_n_s_clone; + PyObject *__pyx_n_s_close; + PyObject *__pyx_n_s_collector; + PyObject *__pyx_n_s_const; + PyObject *__pyx_n_s_current_thread; + PyObject *__pyx_n_s_dedent; + PyObject *__pyx_n_s_def; + PyObject *__pyx_n_s_depth; + PyObject *__pyx_n_s_detach; + PyObject *__pyx_kp_u_disable; + PyObject *__pyx_kp_u_enable; + PyObject *__pyx_n_s_endswith; + PyObject *__pyx_n_s_enumerate; + PyObject *__pyx_n_s_exception; + PyObject *__pyx_n_s_exists; + PyObject *__pyx_n_s_f_globals; + PyObject *__pyx_n_s_file; + PyObject *__pyx_kp_u_file_2; + PyObject *__pyx_n_s_filename; + PyObject *__pyx_n_s_findall; + PyObject *__pyx_n_s_frame; + PyObject *__pyx_n_s_function; + PyObject *__pyx_n_s_functools; + PyObject *__pyx_kp_u_gc; + PyObject *__pyx_n_s_generate_tokens; + PyObject *__pyx_n_s_get; + PyObject *__pyx_n_s_get_func_in_mro; + PyObject *__pyx_n_s_get_main_thread; + PyObject *__pyx_n_s_getline; + PyObject *__pyx_n_s_getlines; + PyObject *__pyx_n_s_globals; + PyObject *__pyx_n_s_hunter__event; + PyObject *__pyx_n_s_ident; + PyObject *__pyx_n_s_if_same_code; + PyObject *__pyx_n_s_import; + PyObject *__pyx_n_s_is_coroutine; + PyObject *__pyx_kp_u_isenabled; + PyObject *__pyx_n_s_items; + PyObject *__pyx_n_s_join; + PyObject *__pyx_n_s_kind; + PyObject *__pyx_n_s_lambda; + PyObject *__pyx_n_s_limit; + PyObject *__pyx_n_s_line; + PyObject *__pyx_n_s_linecache; + PyObject *__pyx_n_s_lineno; + PyObject *__pyx_n_s_locals; + PyObject *__pyx_n_s_main; + PyObject *__pyx_n_s_module; + PyObject *__pyx_n_s_module_2; + PyObject *__pyx_kp_s_module_3; + PyObject *__pyx_n_s_module_globals; + PyObject *__pyx_n_s_name; + PyObject *__pyx_n_s_name_2; + PyObject *__pyx_n_s_namedtuple; + PyObject *__pyx_n_s_next; + PyObject *__pyx_n_s_object; + PyObject *__pyx_n_s_os_path; + PyObject *__pyx_n_s_partial; + PyObject *__pyx_n_s_pkg_resources; + PyObject *__pyx_kp_s_py; + PyObject *__pyx_kp_s_pyc; + PyObject *__pyx_kp_s_pyd; + PyObject *__pyx_kp_s_pyo; + PyObject *__pyx_kp_s_pyx; + PyObject *__pyx_n_s_pyx_vtable; + PyObject *__pyx_n_s_return; + PyObject *__pyx_n_s_self; + PyObject *__pyx_n_s_send; + PyObject *__pyx_n_s_site; + PyObject *__pyx_kp_s_so; + PyObject *__pyx_n_s_split; + PyObject *__pyx_n_s_splitext; + PyObject *__pyx_kp_s_src_hunter__event_pyx; + PyObject *__pyx_n_s_start; + PyObject *__pyx_n_s_startswith; + PyObject *__pyx_kp_s_string; + PyObject *__pyx_n_s_sub; + PyObject *__pyx_n_s_test; + PyObject *__pyx_n_s_threading; + PyObject *__pyx_n_s_threading_support; + PyObject *__pyx_n_s_throw; + PyObject *__pyx_n_s_tokenize; + PyObject *__pyx_n_s_tracer; + PyObject *__pyx_n_s_util; + PyObject *__pyx_n_s_value_filter; + PyObject *__pyx_n_s_values; + PyObject *__pyx_n_s_yield_lines; + PyObject *__pyx_int_1; + PyObject *__pyx_int_10; + PyObject *__pyx_int_neg_1; + PyObject *__pyx_k_; + PyObject *__pyx_tuple__2; + PyObject *__pyx_tuple__3; + PyObject *__pyx_tuple__4; + PyObject *__pyx_tuple__8; + PyObject *__pyx_slice__11; + PyObject *__pyx_tuple__10; + PyObject *__pyx_tuple__12; + PyObject *__pyx_tuple__13; + PyObject *__pyx_tuple__16; + PyObject *__pyx_tuple__17; + PyObject *__pyx_tuple__18; + PyObject *__pyx_tuple__19; + PyObject *__pyx_tuple__20; + PyObject *__pyx_tuple__21; + PyObject *__pyx_codeobj__5; + PyObject *__pyx_codeobj__6; + PyObject *__pyx_codeobj__15; +} __pyx_mstate; + +#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(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o)) + +#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef))) + +#define __pyx_m (PyState_FindModule(&__pyx_moduledef)) +#else +static __pyx_mstate __pyx_mstate_global_static = +#ifdef __cplusplus + {}; +#else + {0}; +#endif +static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static; +#endif +/* #### Code section: module_state_clear ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_clear(PyObject *m) { + __pyx_mstate *clear_module_state = __pyx_mstate(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 + Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_4type_type); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_7_tracer_FrameType); + 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_6vendor_6_cymem_5cymem_PyMalloc); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyFree); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Pool); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Address); + 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); + Py_CLEAR(clear_module_state->__pyx_n_s_CYTHON_SUFFIX_RE); + Py_CLEAR(clear_module_state->__pyx_n_s_Event); + Py_CLEAR(clear_module_state->__pyx_n_s_Event_clone); + Py_CLEAR(clear_module_state->__pyx_n_s_Event_detach); + Py_CLEAR(clear_module_state->__pyx_kp_s_Event_kind_r_function_r_module); + Py_CLEAR(clear_module_state->__pyx_n_s_LEADING_WHITESPACE_RE); + Py_CLEAR(clear_module_state->__pyx_n_s_MISSING); + Py_CLEAR(clear_module_state->__pyx_kp_s_Missing_argument_calls_required); + Py_CLEAR(clear_module_state->__pyx_kp_s_Missing_argument_depth_required); + Py_CLEAR(clear_module_state->__pyx_kp_s_Missing_argument_threading_suppo); + Py_CLEAR(clear_module_state->__pyx_kp_u_NO_SOURCE); + Py_CLEAR(clear_module_state->__pyx_kp_u_NO_SOURCE_not_reading_binary); + Py_CLEAR(clear_module_state->__pyx_n_s_SITE_PACKAGES_PATHS); + Py_CLEAR(clear_module_state->__pyx_n_s_SYS_PREFIX_PATHS); + Py_CLEAR(clear_module_state->__pyx_n_s_TokenError); + Py_CLEAR(clear_module_state->__pyx_n_s_TypeError); + Py_CLEAR(clear_module_state->__pyx_kp_s__14); + Py_CLEAR(clear_module_state->__pyx_kp_u__14); + Py_CLEAR(clear_module_state->__pyx_kp_s__7); + Py_CLEAR(clear_module_state->__pyx_kp_s__9); + Py_CLEAR(clear_module_state->__pyx_n_s_all); + Py_CLEAR(clear_module_state->__pyx_n_s_amount); + Py_CLEAR(clear_module_state->__pyx_n_s_arg); + Py_CLEAR(clear_module_state->__pyx_n_s_args); + Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines); + Py_CLEAR(clear_module_state->__pyx_n_s_basename); + Py_CLEAR(clear_module_state->__pyx_n_s_call); + Py_CLEAR(clear_module_state->__pyx_n_s_calls); + Py_CLEAR(clear_module_state->__pyx_n_s_class); + Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback); + Py_CLEAR(clear_module_state->__pyx_n_s_clone); + Py_CLEAR(clear_module_state->__pyx_n_s_close); + Py_CLEAR(clear_module_state->__pyx_n_s_collector); + Py_CLEAR(clear_module_state->__pyx_n_s_const); + Py_CLEAR(clear_module_state->__pyx_n_s_current_thread); + Py_CLEAR(clear_module_state->__pyx_n_s_dedent); + Py_CLEAR(clear_module_state->__pyx_n_s_def); + Py_CLEAR(clear_module_state->__pyx_n_s_depth); + Py_CLEAR(clear_module_state->__pyx_n_s_detach); + Py_CLEAR(clear_module_state->__pyx_kp_u_disable); + Py_CLEAR(clear_module_state->__pyx_kp_u_enable); + Py_CLEAR(clear_module_state->__pyx_n_s_endswith); + Py_CLEAR(clear_module_state->__pyx_n_s_enumerate); + Py_CLEAR(clear_module_state->__pyx_n_s_exception); + Py_CLEAR(clear_module_state->__pyx_n_s_exists); + Py_CLEAR(clear_module_state->__pyx_n_s_f_globals); + Py_CLEAR(clear_module_state->__pyx_n_s_file); + Py_CLEAR(clear_module_state->__pyx_kp_u_file_2); + Py_CLEAR(clear_module_state->__pyx_n_s_filename); + Py_CLEAR(clear_module_state->__pyx_n_s_findall); + Py_CLEAR(clear_module_state->__pyx_n_s_frame); + Py_CLEAR(clear_module_state->__pyx_n_s_function); + Py_CLEAR(clear_module_state->__pyx_n_s_functools); + Py_CLEAR(clear_module_state->__pyx_kp_u_gc); + Py_CLEAR(clear_module_state->__pyx_n_s_generate_tokens); + Py_CLEAR(clear_module_state->__pyx_n_s_get); + Py_CLEAR(clear_module_state->__pyx_n_s_get_func_in_mro); + Py_CLEAR(clear_module_state->__pyx_n_s_get_main_thread); + Py_CLEAR(clear_module_state->__pyx_n_s_getline); + Py_CLEAR(clear_module_state->__pyx_n_s_getlines); + Py_CLEAR(clear_module_state->__pyx_n_s_globals); + Py_CLEAR(clear_module_state->__pyx_n_s_hunter__event); + Py_CLEAR(clear_module_state->__pyx_n_s_ident); + Py_CLEAR(clear_module_state->__pyx_n_s_if_same_code); + Py_CLEAR(clear_module_state->__pyx_n_s_import); + Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine); + Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled); + Py_CLEAR(clear_module_state->__pyx_n_s_items); + Py_CLEAR(clear_module_state->__pyx_n_s_join); + Py_CLEAR(clear_module_state->__pyx_n_s_kind); + Py_CLEAR(clear_module_state->__pyx_n_s_lambda); + Py_CLEAR(clear_module_state->__pyx_n_s_limit); + Py_CLEAR(clear_module_state->__pyx_n_s_line); + Py_CLEAR(clear_module_state->__pyx_n_s_linecache); + Py_CLEAR(clear_module_state->__pyx_n_s_lineno); + Py_CLEAR(clear_module_state->__pyx_n_s_locals); + Py_CLEAR(clear_module_state->__pyx_n_s_main); + Py_CLEAR(clear_module_state->__pyx_n_s_module); + Py_CLEAR(clear_module_state->__pyx_n_s_module_2); + Py_CLEAR(clear_module_state->__pyx_kp_s_module_3); + Py_CLEAR(clear_module_state->__pyx_n_s_module_globals); + Py_CLEAR(clear_module_state->__pyx_n_s_name); + Py_CLEAR(clear_module_state->__pyx_n_s_name_2); + Py_CLEAR(clear_module_state->__pyx_n_s_namedtuple); + Py_CLEAR(clear_module_state->__pyx_n_s_next); + Py_CLEAR(clear_module_state->__pyx_n_s_object); + Py_CLEAR(clear_module_state->__pyx_n_s_os_path); + Py_CLEAR(clear_module_state->__pyx_n_s_partial); + Py_CLEAR(clear_module_state->__pyx_n_s_pkg_resources); + Py_CLEAR(clear_module_state->__pyx_kp_s_py); + Py_CLEAR(clear_module_state->__pyx_kp_s_pyc); + Py_CLEAR(clear_module_state->__pyx_kp_s_pyd); + Py_CLEAR(clear_module_state->__pyx_kp_s_pyo); + Py_CLEAR(clear_module_state->__pyx_kp_s_pyx); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_vtable); + Py_CLEAR(clear_module_state->__pyx_n_s_return); + Py_CLEAR(clear_module_state->__pyx_n_s_self); + Py_CLEAR(clear_module_state->__pyx_n_s_send); + Py_CLEAR(clear_module_state->__pyx_n_s_site); + Py_CLEAR(clear_module_state->__pyx_kp_s_so); + Py_CLEAR(clear_module_state->__pyx_n_s_split); + Py_CLEAR(clear_module_state->__pyx_n_s_splitext); + Py_CLEAR(clear_module_state->__pyx_kp_s_src_hunter__event_pyx); + Py_CLEAR(clear_module_state->__pyx_n_s_start); + Py_CLEAR(clear_module_state->__pyx_n_s_startswith); + Py_CLEAR(clear_module_state->__pyx_kp_s_string); + Py_CLEAR(clear_module_state->__pyx_n_s_sub); + Py_CLEAR(clear_module_state->__pyx_n_s_test); + Py_CLEAR(clear_module_state->__pyx_n_s_threading); + Py_CLEAR(clear_module_state->__pyx_n_s_threading_support); + Py_CLEAR(clear_module_state->__pyx_n_s_throw); + Py_CLEAR(clear_module_state->__pyx_n_s_tokenize); + Py_CLEAR(clear_module_state->__pyx_n_s_tracer); + Py_CLEAR(clear_module_state->__pyx_n_s_util); + Py_CLEAR(clear_module_state->__pyx_n_s_value_filter); + Py_CLEAR(clear_module_state->__pyx_n_s_values); + Py_CLEAR(clear_module_state->__pyx_n_s_yield_lines); + 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); + Py_CLEAR(clear_module_state->__pyx_k_); + Py_CLEAR(clear_module_state->__pyx_tuple__2); + Py_CLEAR(clear_module_state->__pyx_tuple__3); + Py_CLEAR(clear_module_state->__pyx_tuple__4); + Py_CLEAR(clear_module_state->__pyx_tuple__8); + Py_CLEAR(clear_module_state->__pyx_slice__11); + Py_CLEAR(clear_module_state->__pyx_tuple__10); + Py_CLEAR(clear_module_state->__pyx_tuple__12); + Py_CLEAR(clear_module_state->__pyx_tuple__13); + Py_CLEAR(clear_module_state->__pyx_tuple__16); + Py_CLEAR(clear_module_state->__pyx_tuple__17); + Py_CLEAR(clear_module_state->__pyx_tuple__18); + Py_CLEAR(clear_module_state->__pyx_tuple__19); + Py_CLEAR(clear_module_state->__pyx_tuple__20); + Py_CLEAR(clear_module_state->__pyx_tuple__21); + Py_CLEAR(clear_module_state->__pyx_codeobj__5); + Py_CLEAR(clear_module_state->__pyx_codeobj__6); + Py_CLEAR(clear_module_state->__pyx_codeobj__15); + return 0; +} +#endif +/* #### Code section: module_state_traverse ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { + __pyx_mstate *traverse_module_state = __pyx_mstate(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); + Py_VISIT(traverse_module_state->__pyx_empty_tuple); + Py_VISIT(traverse_module_state->__pyx_empty_bytes); + Py_VISIT(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_7_tracer_FrameType); + 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_6vendor_6_cymem_5cymem_PyMalloc); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyFree); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Pool); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Address); + 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); + Py_VISIT(traverse_module_state->__pyx_n_s_CYTHON_SUFFIX_RE); + Py_VISIT(traverse_module_state->__pyx_n_s_Event); + Py_VISIT(traverse_module_state->__pyx_n_s_Event_clone); + Py_VISIT(traverse_module_state->__pyx_n_s_Event_detach); + Py_VISIT(traverse_module_state->__pyx_kp_s_Event_kind_r_function_r_module); + Py_VISIT(traverse_module_state->__pyx_n_s_LEADING_WHITESPACE_RE); + Py_VISIT(traverse_module_state->__pyx_n_s_MISSING); + Py_VISIT(traverse_module_state->__pyx_kp_s_Missing_argument_calls_required); + Py_VISIT(traverse_module_state->__pyx_kp_s_Missing_argument_depth_required); + Py_VISIT(traverse_module_state->__pyx_kp_s_Missing_argument_threading_suppo); + Py_VISIT(traverse_module_state->__pyx_kp_u_NO_SOURCE); + Py_VISIT(traverse_module_state->__pyx_kp_u_NO_SOURCE_not_reading_binary); + Py_VISIT(traverse_module_state->__pyx_n_s_SITE_PACKAGES_PATHS); + Py_VISIT(traverse_module_state->__pyx_n_s_SYS_PREFIX_PATHS); + Py_VISIT(traverse_module_state->__pyx_n_s_TokenError); + Py_VISIT(traverse_module_state->__pyx_n_s_TypeError); + Py_VISIT(traverse_module_state->__pyx_kp_s__14); + Py_VISIT(traverse_module_state->__pyx_kp_u__14); + Py_VISIT(traverse_module_state->__pyx_kp_s__7); + Py_VISIT(traverse_module_state->__pyx_kp_s__9); + Py_VISIT(traverse_module_state->__pyx_n_s_all); + Py_VISIT(traverse_module_state->__pyx_n_s_amount); + Py_VISIT(traverse_module_state->__pyx_n_s_arg); + Py_VISIT(traverse_module_state->__pyx_n_s_args); + Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines); + Py_VISIT(traverse_module_state->__pyx_n_s_basename); + Py_VISIT(traverse_module_state->__pyx_n_s_call); + Py_VISIT(traverse_module_state->__pyx_n_s_calls); + Py_VISIT(traverse_module_state->__pyx_n_s_class); + Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback); + Py_VISIT(traverse_module_state->__pyx_n_s_clone); + Py_VISIT(traverse_module_state->__pyx_n_s_close); + Py_VISIT(traverse_module_state->__pyx_n_s_collector); + Py_VISIT(traverse_module_state->__pyx_n_s_const); + Py_VISIT(traverse_module_state->__pyx_n_s_current_thread); + Py_VISIT(traverse_module_state->__pyx_n_s_dedent); + Py_VISIT(traverse_module_state->__pyx_n_s_def); + Py_VISIT(traverse_module_state->__pyx_n_s_depth); + Py_VISIT(traverse_module_state->__pyx_n_s_detach); + Py_VISIT(traverse_module_state->__pyx_kp_u_disable); + Py_VISIT(traverse_module_state->__pyx_kp_u_enable); + Py_VISIT(traverse_module_state->__pyx_n_s_endswith); + Py_VISIT(traverse_module_state->__pyx_n_s_enumerate); + Py_VISIT(traverse_module_state->__pyx_n_s_exception); + Py_VISIT(traverse_module_state->__pyx_n_s_exists); + Py_VISIT(traverse_module_state->__pyx_n_s_f_globals); + Py_VISIT(traverse_module_state->__pyx_n_s_file); + Py_VISIT(traverse_module_state->__pyx_kp_u_file_2); + Py_VISIT(traverse_module_state->__pyx_n_s_filename); + Py_VISIT(traverse_module_state->__pyx_n_s_findall); + Py_VISIT(traverse_module_state->__pyx_n_s_frame); + Py_VISIT(traverse_module_state->__pyx_n_s_function); + Py_VISIT(traverse_module_state->__pyx_n_s_functools); + Py_VISIT(traverse_module_state->__pyx_kp_u_gc); + Py_VISIT(traverse_module_state->__pyx_n_s_generate_tokens); + Py_VISIT(traverse_module_state->__pyx_n_s_get); + Py_VISIT(traverse_module_state->__pyx_n_s_get_func_in_mro); + Py_VISIT(traverse_module_state->__pyx_n_s_get_main_thread); + Py_VISIT(traverse_module_state->__pyx_n_s_getline); + Py_VISIT(traverse_module_state->__pyx_n_s_getlines); + Py_VISIT(traverse_module_state->__pyx_n_s_globals); + Py_VISIT(traverse_module_state->__pyx_n_s_hunter__event); + Py_VISIT(traverse_module_state->__pyx_n_s_ident); + Py_VISIT(traverse_module_state->__pyx_n_s_if_same_code); + Py_VISIT(traverse_module_state->__pyx_n_s_import); + Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine); + Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled); + Py_VISIT(traverse_module_state->__pyx_n_s_items); + Py_VISIT(traverse_module_state->__pyx_n_s_join); + Py_VISIT(traverse_module_state->__pyx_n_s_kind); + Py_VISIT(traverse_module_state->__pyx_n_s_lambda); + Py_VISIT(traverse_module_state->__pyx_n_s_limit); + Py_VISIT(traverse_module_state->__pyx_n_s_line); + Py_VISIT(traverse_module_state->__pyx_n_s_linecache); + Py_VISIT(traverse_module_state->__pyx_n_s_lineno); + Py_VISIT(traverse_module_state->__pyx_n_s_locals); + Py_VISIT(traverse_module_state->__pyx_n_s_main); + Py_VISIT(traverse_module_state->__pyx_n_s_module); + Py_VISIT(traverse_module_state->__pyx_n_s_module_2); + Py_VISIT(traverse_module_state->__pyx_kp_s_module_3); + Py_VISIT(traverse_module_state->__pyx_n_s_module_globals); + Py_VISIT(traverse_module_state->__pyx_n_s_name); + Py_VISIT(traverse_module_state->__pyx_n_s_name_2); + Py_VISIT(traverse_module_state->__pyx_n_s_namedtuple); + Py_VISIT(traverse_module_state->__pyx_n_s_next); + Py_VISIT(traverse_module_state->__pyx_n_s_object); + Py_VISIT(traverse_module_state->__pyx_n_s_os_path); + Py_VISIT(traverse_module_state->__pyx_n_s_partial); + Py_VISIT(traverse_module_state->__pyx_n_s_pkg_resources); + Py_VISIT(traverse_module_state->__pyx_kp_s_py); + Py_VISIT(traverse_module_state->__pyx_kp_s_pyc); + Py_VISIT(traverse_module_state->__pyx_kp_s_pyd); + Py_VISIT(traverse_module_state->__pyx_kp_s_pyo); + Py_VISIT(traverse_module_state->__pyx_kp_s_pyx); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_vtable); + Py_VISIT(traverse_module_state->__pyx_n_s_return); + Py_VISIT(traverse_module_state->__pyx_n_s_self); + Py_VISIT(traverse_module_state->__pyx_n_s_send); + Py_VISIT(traverse_module_state->__pyx_n_s_site); + Py_VISIT(traverse_module_state->__pyx_kp_s_so); + Py_VISIT(traverse_module_state->__pyx_n_s_split); + Py_VISIT(traverse_module_state->__pyx_n_s_splitext); + Py_VISIT(traverse_module_state->__pyx_kp_s_src_hunter__event_pyx); + Py_VISIT(traverse_module_state->__pyx_n_s_start); + Py_VISIT(traverse_module_state->__pyx_n_s_startswith); + Py_VISIT(traverse_module_state->__pyx_kp_s_string); + Py_VISIT(traverse_module_state->__pyx_n_s_sub); + Py_VISIT(traverse_module_state->__pyx_n_s_test); + Py_VISIT(traverse_module_state->__pyx_n_s_threading); + Py_VISIT(traverse_module_state->__pyx_n_s_threading_support); + Py_VISIT(traverse_module_state->__pyx_n_s_throw); + Py_VISIT(traverse_module_state->__pyx_n_s_tokenize); + Py_VISIT(traverse_module_state->__pyx_n_s_tracer); + Py_VISIT(traverse_module_state->__pyx_n_s_util); + Py_VISIT(traverse_module_state->__pyx_n_s_value_filter); + Py_VISIT(traverse_module_state->__pyx_n_s_values); + Py_VISIT(traverse_module_state->__pyx_n_s_yield_lines); + Py_VISIT(traverse_module_state->__pyx_int_1); + Py_VISIT(traverse_module_state->__pyx_int_10); + Py_VISIT(traverse_module_state->__pyx_int_neg_1); + Py_VISIT(traverse_module_state->__pyx_k_); + Py_VISIT(traverse_module_state->__pyx_tuple__2); + Py_VISIT(traverse_module_state->__pyx_tuple__3); + Py_VISIT(traverse_module_state->__pyx_tuple__4); + Py_VISIT(traverse_module_state->__pyx_tuple__8); + Py_VISIT(traverse_module_state->__pyx_slice__11); + Py_VISIT(traverse_module_state->__pyx_tuple__10); + Py_VISIT(traverse_module_state->__pyx_tuple__12); + Py_VISIT(traverse_module_state->__pyx_tuple__13); + Py_VISIT(traverse_module_state->__pyx_tuple__16); + Py_VISIT(traverse_module_state->__pyx_tuple__17); + Py_VISIT(traverse_module_state->__pyx_tuple__18); + Py_VISIT(traverse_module_state->__pyx_tuple__19); + Py_VISIT(traverse_module_state->__pyx_tuple__20); + Py_VISIT(traverse_module_state->__pyx_tuple__21); + Py_VISIT(traverse_module_state->__pyx_codeobj__5); + Py_VISIT(traverse_module_state->__pyx_codeobj__6); + Py_VISIT(traverse_module_state->__pyx_codeobj__15); + return 0; +} +#endif +/* #### Code section: module_state_defines ### */ +#define __pyx_d __pyx_mstate_global->__pyx_d +#define __pyx_b __pyx_mstate_global->__pyx_b +#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime +#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple +#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes +#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode +#ifdef __Pyx_CyFunction_USED +#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType +#endif +#ifdef __Pyx_FusedFunction_USED +#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType +#endif +#ifdef __Pyx_Generator_USED +#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType +#endif +#ifdef __Pyx_IterableCoroutine_USED +#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#define __pyx_ptype_7cpython_4type_type __pyx_mstate_global->__pyx_ptype_7cpython_4type_type +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#define __pyx_ptype_6hunter_7_tracer_FrameType __pyx_mstate_global->__pyx_ptype_6hunter_7_tracer_FrameType +#define __pyx_ptype_6hunter_7_tracer_CodeType __pyx_mstate_global->__pyx_ptype_6hunter_7_tracer_CodeType +#define __pyx_ptype_6hunter_7_tracer_Tracer __pyx_mstate_global->__pyx_ptype_6hunter_7_tracer_Tracer +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#define __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyMalloc __pyx_mstate_global->__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyMalloc +#define __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyFree __pyx_mstate_global->__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyFree +#define __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Pool __pyx_mstate_global->__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Pool +#define __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Address __pyx_mstate_global->__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Address +#if CYTHON_USE_MODULE_STATE +#define __pyx_type_6hunter_6_event_Event __pyx_mstate_global->__pyx_type_6hunter_6_event_Event +#define __pyx_type_6hunter_6_event___pyx_scope_struct__yield_lines __pyx_mstate_global->__pyx_type_6hunter_6_event___pyx_scope_struct__yield_lines +#endif +#define __pyx_ptype_6hunter_6_event_Event __pyx_mstate_global->__pyx_ptype_6hunter_6_event_Event +#define __pyx_ptype_6hunter_6_event___pyx_scope_struct__yield_lines __pyx_mstate_global->__pyx_ptype_6hunter_6_event___pyx_scope_struct__yield_lines +#define __pyx_n_s_CYTHON_SUFFIX_RE __pyx_mstate_global->__pyx_n_s_CYTHON_SUFFIX_RE +#define __pyx_n_s_Event __pyx_mstate_global->__pyx_n_s_Event +#define __pyx_n_s_Event_clone __pyx_mstate_global->__pyx_n_s_Event_clone +#define __pyx_n_s_Event_detach __pyx_mstate_global->__pyx_n_s_Event_detach +#define __pyx_kp_s_Event_kind_r_function_r_module __pyx_mstate_global->__pyx_kp_s_Event_kind_r_function_r_module +#define __pyx_n_s_LEADING_WHITESPACE_RE __pyx_mstate_global->__pyx_n_s_LEADING_WHITESPACE_RE +#define __pyx_n_s_MISSING __pyx_mstate_global->__pyx_n_s_MISSING +#define __pyx_kp_s_Missing_argument_calls_required __pyx_mstate_global->__pyx_kp_s_Missing_argument_calls_required +#define __pyx_kp_s_Missing_argument_depth_required __pyx_mstate_global->__pyx_kp_s_Missing_argument_depth_required +#define __pyx_kp_s_Missing_argument_threading_suppo __pyx_mstate_global->__pyx_kp_s_Missing_argument_threading_suppo +#define __pyx_kp_u_NO_SOURCE __pyx_mstate_global->__pyx_kp_u_NO_SOURCE +#define __pyx_kp_u_NO_SOURCE_not_reading_binary __pyx_mstate_global->__pyx_kp_u_NO_SOURCE_not_reading_binary +#define __pyx_n_s_SITE_PACKAGES_PATHS __pyx_mstate_global->__pyx_n_s_SITE_PACKAGES_PATHS +#define __pyx_n_s_SYS_PREFIX_PATHS __pyx_mstate_global->__pyx_n_s_SYS_PREFIX_PATHS +#define __pyx_n_s_TokenError __pyx_mstate_global->__pyx_n_s_TokenError +#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError +#define __pyx_kp_s__14 __pyx_mstate_global->__pyx_kp_s__14 +#define __pyx_kp_u__14 __pyx_mstate_global->__pyx_kp_u__14 +#define __pyx_kp_s__7 __pyx_mstate_global->__pyx_kp_s__7 +#define __pyx_kp_s__9 __pyx_mstate_global->__pyx_kp_s__9 +#define __pyx_n_s_all __pyx_mstate_global->__pyx_n_s_all +#define __pyx_n_s_amount __pyx_mstate_global->__pyx_n_s_amount +#define __pyx_n_s_arg __pyx_mstate_global->__pyx_n_s_arg +#define __pyx_n_s_args __pyx_mstate_global->__pyx_n_s_args +#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines +#define __pyx_n_s_basename __pyx_mstate_global->__pyx_n_s_basename +#define __pyx_n_s_call __pyx_mstate_global->__pyx_n_s_call +#define __pyx_n_s_calls __pyx_mstate_global->__pyx_n_s_calls +#define __pyx_n_s_class __pyx_mstate_global->__pyx_n_s_class +#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback +#define __pyx_n_s_clone __pyx_mstate_global->__pyx_n_s_clone +#define __pyx_n_s_close __pyx_mstate_global->__pyx_n_s_close +#define __pyx_n_s_collector __pyx_mstate_global->__pyx_n_s_collector +#define __pyx_n_s_const __pyx_mstate_global->__pyx_n_s_const +#define __pyx_n_s_current_thread __pyx_mstate_global->__pyx_n_s_current_thread +#define __pyx_n_s_dedent __pyx_mstate_global->__pyx_n_s_dedent +#define __pyx_n_s_def __pyx_mstate_global->__pyx_n_s_def +#define __pyx_n_s_depth __pyx_mstate_global->__pyx_n_s_depth +#define __pyx_n_s_detach __pyx_mstate_global->__pyx_n_s_detach +#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable +#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable +#define __pyx_n_s_endswith __pyx_mstate_global->__pyx_n_s_endswith +#define __pyx_n_s_enumerate __pyx_mstate_global->__pyx_n_s_enumerate +#define __pyx_n_s_exception __pyx_mstate_global->__pyx_n_s_exception +#define __pyx_n_s_exists __pyx_mstate_global->__pyx_n_s_exists +#define __pyx_n_s_f_globals __pyx_mstate_global->__pyx_n_s_f_globals +#define __pyx_n_s_file __pyx_mstate_global->__pyx_n_s_file +#define __pyx_kp_u_file_2 __pyx_mstate_global->__pyx_kp_u_file_2 +#define __pyx_n_s_filename __pyx_mstate_global->__pyx_n_s_filename +#define __pyx_n_s_findall __pyx_mstate_global->__pyx_n_s_findall +#define __pyx_n_s_frame __pyx_mstate_global->__pyx_n_s_frame +#define __pyx_n_s_function __pyx_mstate_global->__pyx_n_s_function +#define __pyx_n_s_functools __pyx_mstate_global->__pyx_n_s_functools +#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc +#define __pyx_n_s_generate_tokens __pyx_mstate_global->__pyx_n_s_generate_tokens +#define __pyx_n_s_get __pyx_mstate_global->__pyx_n_s_get +#define __pyx_n_s_get_func_in_mro __pyx_mstate_global->__pyx_n_s_get_func_in_mro +#define __pyx_n_s_get_main_thread __pyx_mstate_global->__pyx_n_s_get_main_thread +#define __pyx_n_s_getline __pyx_mstate_global->__pyx_n_s_getline +#define __pyx_n_s_getlines __pyx_mstate_global->__pyx_n_s_getlines +#define __pyx_n_s_globals __pyx_mstate_global->__pyx_n_s_globals +#define __pyx_n_s_hunter__event __pyx_mstate_global->__pyx_n_s_hunter__event +#define __pyx_n_s_ident __pyx_mstate_global->__pyx_n_s_ident +#define __pyx_n_s_if_same_code __pyx_mstate_global->__pyx_n_s_if_same_code +#define __pyx_n_s_import __pyx_mstate_global->__pyx_n_s_import +#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine +#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled +#define __pyx_n_s_items __pyx_mstate_global->__pyx_n_s_items +#define __pyx_n_s_join __pyx_mstate_global->__pyx_n_s_join +#define __pyx_n_s_kind __pyx_mstate_global->__pyx_n_s_kind +#define __pyx_n_s_lambda __pyx_mstate_global->__pyx_n_s_lambda +#define __pyx_n_s_limit __pyx_mstate_global->__pyx_n_s_limit +#define __pyx_n_s_line __pyx_mstate_global->__pyx_n_s_line +#define __pyx_n_s_linecache __pyx_mstate_global->__pyx_n_s_linecache +#define __pyx_n_s_lineno __pyx_mstate_global->__pyx_n_s_lineno +#define __pyx_n_s_locals __pyx_mstate_global->__pyx_n_s_locals +#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main +#define __pyx_n_s_module __pyx_mstate_global->__pyx_n_s_module +#define __pyx_n_s_module_2 __pyx_mstate_global->__pyx_n_s_module_2 +#define __pyx_kp_s_module_3 __pyx_mstate_global->__pyx_kp_s_module_3 +#define __pyx_n_s_module_globals __pyx_mstate_global->__pyx_n_s_module_globals +#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name +#define __pyx_n_s_name_2 __pyx_mstate_global->__pyx_n_s_name_2 +#define __pyx_n_s_namedtuple __pyx_mstate_global->__pyx_n_s_namedtuple +#define __pyx_n_s_next __pyx_mstate_global->__pyx_n_s_next +#define __pyx_n_s_object __pyx_mstate_global->__pyx_n_s_object +#define __pyx_n_s_os_path __pyx_mstate_global->__pyx_n_s_os_path +#define __pyx_n_s_partial __pyx_mstate_global->__pyx_n_s_partial +#define __pyx_n_s_pkg_resources __pyx_mstate_global->__pyx_n_s_pkg_resources +#define __pyx_kp_s_py __pyx_mstate_global->__pyx_kp_s_py +#define __pyx_kp_s_pyc __pyx_mstate_global->__pyx_kp_s_pyc +#define __pyx_kp_s_pyd __pyx_mstate_global->__pyx_kp_s_pyd +#define __pyx_kp_s_pyo __pyx_mstate_global->__pyx_kp_s_pyo +#define __pyx_kp_s_pyx __pyx_mstate_global->__pyx_kp_s_pyx +#define __pyx_n_s_pyx_vtable __pyx_mstate_global->__pyx_n_s_pyx_vtable +#define __pyx_n_s_return __pyx_mstate_global->__pyx_n_s_return +#define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self +#define __pyx_n_s_send __pyx_mstate_global->__pyx_n_s_send +#define __pyx_n_s_site __pyx_mstate_global->__pyx_n_s_site +#define __pyx_kp_s_so __pyx_mstate_global->__pyx_kp_s_so +#define __pyx_n_s_split __pyx_mstate_global->__pyx_n_s_split +#define __pyx_n_s_splitext __pyx_mstate_global->__pyx_n_s_splitext +#define __pyx_kp_s_src_hunter__event_pyx __pyx_mstate_global->__pyx_kp_s_src_hunter__event_pyx +#define __pyx_n_s_start __pyx_mstate_global->__pyx_n_s_start +#define __pyx_n_s_startswith __pyx_mstate_global->__pyx_n_s_startswith +#define __pyx_kp_s_string __pyx_mstate_global->__pyx_kp_s_string +#define __pyx_n_s_sub __pyx_mstate_global->__pyx_n_s_sub +#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test +#define __pyx_n_s_threading __pyx_mstate_global->__pyx_n_s_threading +#define __pyx_n_s_threading_support __pyx_mstate_global->__pyx_n_s_threading_support +#define __pyx_n_s_throw __pyx_mstate_global->__pyx_n_s_throw +#define __pyx_n_s_tokenize __pyx_mstate_global->__pyx_n_s_tokenize +#define __pyx_n_s_tracer __pyx_mstate_global->__pyx_n_s_tracer +#define __pyx_n_s_util __pyx_mstate_global->__pyx_n_s_util +#define __pyx_n_s_value_filter __pyx_mstate_global->__pyx_n_s_value_filter +#define __pyx_n_s_values __pyx_mstate_global->__pyx_n_s_values +#define __pyx_n_s_yield_lines __pyx_mstate_global->__pyx_n_s_yield_lines +#define __pyx_int_1 __pyx_mstate_global->__pyx_int_1 +#define __pyx_int_10 __pyx_mstate_global->__pyx_int_10 +#define __pyx_int_neg_1 __pyx_mstate_global->__pyx_int_neg_1 +#define __pyx_k_ __pyx_mstate_global->__pyx_k_ +#define __pyx_tuple__2 __pyx_mstate_global->__pyx_tuple__2 +#define __pyx_tuple__3 __pyx_mstate_global->__pyx_tuple__3 +#define __pyx_tuple__4 __pyx_mstate_global->__pyx_tuple__4 +#define __pyx_tuple__8 __pyx_mstate_global->__pyx_tuple__8 +#define __pyx_slice__11 __pyx_mstate_global->__pyx_slice__11 +#define __pyx_tuple__10 __pyx_mstate_global->__pyx_tuple__10 +#define __pyx_tuple__12 __pyx_mstate_global->__pyx_tuple__12 +#define __pyx_tuple__13 __pyx_mstate_global->__pyx_tuple__13 +#define __pyx_tuple__16 __pyx_mstate_global->__pyx_tuple__16 +#define __pyx_tuple__17 __pyx_mstate_global->__pyx_tuple__17 +#define __pyx_tuple__18 __pyx_mstate_global->__pyx_tuple__18 +#define __pyx_tuple__19 __pyx_mstate_global->__pyx_tuple__19 +#define __pyx_tuple__20 __pyx_mstate_global->__pyx_tuple__20 +#define __pyx_tuple__21 __pyx_mstate_global->__pyx_tuple__21 +#define __pyx_codeobj__5 __pyx_mstate_global->__pyx_codeobj__5 +#define __pyx_codeobj__6 __pyx_mstate_global->__pyx_codeobj__6 +#define __pyx_codeobj__15 __pyx_mstate_global->__pyx_codeobj__15 +/* #### Code section: module_code ### */ + +/* "hunter/_event.pyx":36 + * cdef PyObject** KIND_NAMES = make_kind_names(['call', 'exception', 'line', 'return', 'call', 'exception', 'return']) + * + * cdef inline PyObject** make_kind_names(list strings): # <<<<<<<<<<<<<< + * cdef PyObject** array = mem.alloc(len(strings), sizeof(PyObject*)) + * cdef object name */ -/* 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; - PyObject *__pyx_v_arg = 0; - struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_tracer = 0; - int __pyx_r; +static CYTHON_INLINE PyObject **__pyx_f_6hunter_6_event_make_kind_names(PyObject *__pyx_v_strings) { + PyObject **__pyx_v_array; + PyObject *__pyx_v_name = 0; + Py_ssize_t __pyx_v_i; + PyObject *__pyx_v_string = NULL; + PyObject **__pyx_r; + __Pyx_TraceDeclarations + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + void *__pyx_t_2; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("make_kind_names", 1); + __Pyx_TraceCall("make_kind_names", __pyx_f[0], 36, 0, __PYX_ERR(0, 36, __pyx_L1_error)); + + /* "hunter/_event.pyx":37 + * + * cdef inline PyObject** make_kind_names(list strings): + * cdef PyObject** array = mem.alloc(len(strings), sizeof(PyObject*)) # <<<<<<<<<<<<<< + * cdef object name + * for i, string in enumerate(strings): + */ + __Pyx_TraceLine(37,0,__PYX_ERR(0, 37, __pyx_L1_error)) + if (unlikely(__pyx_v_strings == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(0, 37, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_PyList_GET_SIZE(__pyx_v_strings); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 37, __pyx_L1_error) + __pyx_t_2 = ((struct __pyx_vtabstruct_6hunter_6vendor_6_cymem_5cymem_Pool *)__pyx_v_6hunter_6_event_mem->__pyx_vtab)->alloc(__pyx_v_6hunter_6_event_mem, __pyx_t_1, (sizeof(PyObject *))); if (unlikely(__pyx_t_2 == ((void *)NULL))) __PYX_ERR(0, 37, __pyx_L1_error) + __pyx_v_array = ((PyObject **)__pyx_t_2); + + /* "hunter/_event.pyx":39 + * cdef PyObject** array = mem.alloc(len(strings), sizeof(PyObject*)) + * cdef object name + * for i, string in enumerate(strings): # <<<<<<<<<<<<<< + * name = intern(string) + * Py_XINCREF( name) + */ + __Pyx_TraceLine(39,0,__PYX_ERR(0, 39, __pyx_L1_error)) + __pyx_t_1 = 0; + __pyx_t_3 = __pyx_v_strings; __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 39, __pyx_L1_error) + #endif + if (__pyx_t_4 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_5); __pyx_t_4++; if (unlikely((0 < 0))) __PYX_ERR(0, 39, __pyx_L1_error) + #else + __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + __Pyx_XDECREF_SET(__pyx_v_string, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_v_i = __pyx_t_1; + __pyx_t_1 = (__pyx_t_1 + 1); + + /* "hunter/_event.pyx":40 + * cdef object name + * for i, string in enumerate(strings): + * name = intern(string) # <<<<<<<<<<<<<< + * Py_XINCREF( name) + * array[i] = name + */ + __Pyx_TraceLine(40,0,__PYX_ERR(0, 40, __pyx_L1_error)) + __pyx_t_5 = __Pyx_Intern(__pyx_v_string); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 40, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_5); + __pyx_t_5 = 0; + + /* "hunter/_event.pyx":41 + * for i, string in enumerate(strings): + * name = intern(string) + * Py_XINCREF( name) # <<<<<<<<<<<<<< + * array[i] = name + * return array + */ + __Pyx_TraceLine(41,0,__PYX_ERR(0, 41, __pyx_L1_error)) + Py_XINCREF(((PyObject *)__pyx_v_name)); + + /* "hunter/_event.pyx":42 + * name = intern(string) + * Py_XINCREF( name) + * array[i] = name # <<<<<<<<<<<<<< + * return array + * + */ + __Pyx_TraceLine(42,0,__PYX_ERR(0, 42, __pyx_L1_error)) + (__pyx_v_array[__pyx_v_i]) = ((PyObject *)__pyx_v_name); + + /* "hunter/_event.pyx":39 + * cdef PyObject** array = mem.alloc(len(strings), sizeof(PyObject*)) + * cdef object name + * for i, string in enumerate(strings): # <<<<<<<<<<<<<< + * name = intern(string) + * Py_XINCREF( name) + */ + __Pyx_TraceLine(39,0,__PYX_ERR(0, 39, __pyx_L1_error)) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "hunter/_event.pyx":43 + * Py_XINCREF( name) + * array[i] = name + * return array # <<<<<<<<<<<<<< + * + * + */ + __Pyx_TraceLine(43,0,__PYX_ERR(0, 43, __pyx_L1_error)) + __pyx_r = ((PyObject **)__pyx_v_array); + goto __pyx_L0; + + /* "hunter/_event.pyx":36 + * cdef PyObject** KIND_NAMES = make_kind_names(['call', 'exception', 'line', 'return', 'call', 'exception', 'return']) + * + * cdef inline PyObject** make_kind_names(list strings): # <<<<<<<<<<<<<< + * cdef PyObject** array = mem.alloc(len(strings), sizeof(PyObject*)) + * cdef object name + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("hunter._event.make_kind_names", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_name); + __Pyx_XDECREF(__pyx_v_string); + __Pyx_TraceReturn(Py_None, 0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/_event.pyx":61 + * Needed for the ``calls`` and ``depth`` fields. + * """ + * def __init__(self, FrameType frame, int kind, object arg, Tracer tracer=None, object depth=None, object calls=None, # <<<<<<<<<<<<<< + * object threading_support=MISSING): + * if tracer is None: + */ + +/* 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; + int __pyx_v_kind; + PyObject *__pyx_v_arg = 0; + struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_tracer = 0; + PyObject *__pyx_v_depth = 0; + PyObject *__pyx_v_calls = 0; + PyObject *__pyx_v_threading_support = 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("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __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)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_frame,&__pyx_n_s_kind,&__pyx_n_s_arg,&__pyx_n_s_tracer,&__pyx_n_s_depth,&__pyx_n_s_calls,&__pyx_n_s_threading_support,0}; + values[3] = __Pyx_Arg_NewRef_VARARGS((PyObject *)((struct __pyx_obj_6hunter_7_tracer_Tracer *)Py_None)); + values[4] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)Py_None)); + values[5] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)Py_None)); + values[6] = __Pyx_Arg_NewRef_VARARGS(__pyx_k_); + if (__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); + switch (__pyx_nargs) { + case 7: values[6] = __Pyx_Arg_VARARGS(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_VARARGS(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_VARARGS(__pyx_args, 4); CYTHON_FALLTHROUGH; - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 4: values[3] = __Pyx_Arg_VARARGS(__pyx_args, 3); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_frame)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_frame)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 61, __pyx_L3_error) 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--; + if (likely((values[1] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_kind)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 61, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, 1); __PYX_ERR(0, 43, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__init__", 0, 3, 7, 1); __PYX_ERR(0, 61, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_arg)) != 0)) kw_args--; + if (likely((values[2] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_arg)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 61, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, 2); __PYX_ERR(0, 43, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__init__", 0, 3, 7, 2); __PYX_ERR(0, 61, __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) + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_tracer); + if (value) { values[3] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 61, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_depth); + if (value) { values[4] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 61, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_calls); + if (value) { values[5] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 61, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_threading_support); + if (value) { values[6] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 61, __pyx_L3_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 (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(0, 61, __pyx_L3_error) } - } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { - goto __pyx_L5_argtuple_error; } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - values[2] = PyTuple_GET_ITEM(__pyx_args, 2); - values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + switch (__pyx_nargs) { + case 7: values[6] = __Pyx_Arg_VARARGS(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_VARARGS(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_VARARGS(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_VARARGS(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); + values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); + values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } } __pyx_v_frame = ((PyFrameObject *)values[0]); - __pyx_v_kind = ((PyObject*)values[1]); + __pyx_v_kind = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_kind == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 61, __pyx_L3_error) __pyx_v_arg = values[2]; __pyx_v_tracer = ((struct __pyx_obj_6hunter_7_tracer_Tracer *)values[3]); + __pyx_v_depth = values[4]; + __pyx_v_calls = values[5]; + __pyx_v_threading_support = values[6]; } - 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__", 0, 3, 7, __pyx_nargs); __PYX_ERR(0, 61, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(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); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_frame), __pyx_ptype_6hunter_7_tracer_FrameType, 1, "frame", 0))) __PYX_ERR(0, 61, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_tracer), __pyx_ptype_6hunter_7_tracer_Tracer, 1, "tracer", 0))) __PYX_ERR(0, 61, __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_v_depth, __pyx_v_calls, __pyx_v_threading_support); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = -1; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(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, PyFrameObject *__pyx_v_frame, int __pyx_v_kind, PyObject *__pyx_v_arg, struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_tracer, PyObject *__pyx_v_depth, PyObject *__pyx_v_calls, PyObject *__pyx_v_threading_support) { int __pyx_r; __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations int __pyx_t_1; - int __pyx_t_2; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); - __Pyx_TraceCall("__init__", __pyx_f[0], 43, 0, __PYX_ERR(0, 43, __pyx_L1_error)); + __Pyx_TraceCall("__init__", __pyx_f[0], 61, 0, __PYX_ERR(0, 61, __pyx_L1_error)); + __Pyx_INCREF(__pyx_v_depth); + __Pyx_INCREF(__pyx_v_calls); + __Pyx_INCREF(__pyx_v_threading_support); - /* "hunter/_event.pyx":44 - * """ - * def __init__(self, FrameType frame, str kind, object arg, Tracer tracer): + /* "hunter/_event.pyx":63 + * def __init__(self, FrameType frame, int kind, object arg, Tracer tracer=None, object depth=None, object calls=None, + * object threading_support=MISSING): + * if tracer is None: # <<<<<<<<<<<<<< + * if depth is None: + * raise TypeError('Missing argument: depth (required because tracer was not given).') + */ + __Pyx_TraceLine(63,0,__PYX_ERR(0, 63, __pyx_L1_error)) + __pyx_t_1 = (((PyObject *)__pyx_v_tracer) == Py_None); + if (__pyx_t_1) { + + /* "hunter/_event.pyx":64 + * object threading_support=MISSING): + * if tracer is None: + * if depth is None: # <<<<<<<<<<<<<< + * raise TypeError('Missing argument: depth (required because tracer was not given).') + * if calls is None: + */ + __Pyx_TraceLine(64,0,__PYX_ERR(0, 64, __pyx_L1_error)) + __pyx_t_1 = (__pyx_v_depth == Py_None); + if (unlikely(__pyx_t_1)) { + + /* "hunter/_event.pyx":65 + * if tracer is None: + * if depth is None: + * raise TypeError('Missing argument: depth (required because tracer was not given).') # <<<<<<<<<<<<<< + * if calls is None: + * raise TypeError('Missing argument: calls (required because tracer was not given).') + */ + __Pyx_TraceLine(65,0,__PYX_ERR(0, 65, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 65, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 65, __pyx_L1_error) + + /* "hunter/_event.pyx":64 + * object threading_support=MISSING): + * if tracer is None: + * if depth is None: # <<<<<<<<<<<<<< + * raise TypeError('Missing argument: depth (required because tracer was not given).') + * if calls is None: + */ + } + + /* "hunter/_event.pyx":66 + * if depth is None: + * raise TypeError('Missing argument: depth (required because tracer was not given).') + * if calls is None: # <<<<<<<<<<<<<< + * raise TypeError('Missing argument: calls (required because tracer was not given).') + * if threading_support is MISSING: + */ + __Pyx_TraceLine(66,0,__PYX_ERR(0, 66, __pyx_L1_error)) + __pyx_t_1 = (__pyx_v_calls == Py_None); + if (unlikely(__pyx_t_1)) { + + /* "hunter/_event.pyx":67 + * raise TypeError('Missing argument: depth (required because tracer was not given).') + * if calls is None: + * raise TypeError('Missing argument: calls (required because tracer was not given).') # <<<<<<<<<<<<<< + * if threading_support is MISSING: + * raise TypeError('Missing argument: threading_support (required because tracer was not given).') + */ + __Pyx_TraceLine(67,0,__PYX_ERR(0, 67, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 67, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 67, __pyx_L1_error) + + /* "hunter/_event.pyx":66 + * if depth is None: + * raise TypeError('Missing argument: depth (required because tracer was not given).') + * if calls is None: # <<<<<<<<<<<<<< + * raise TypeError('Missing argument: calls (required because tracer was not given).') + * if threading_support is MISSING: + */ + } + + /* "hunter/_event.pyx":68 + * if calls is None: + * raise TypeError('Missing argument: calls (required because tracer was not given).') + * if threading_support is MISSING: # <<<<<<<<<<<<<< + * raise TypeError('Missing argument: threading_support (required because tracer was not given).') + * else: + */ + __Pyx_TraceLine(68,0,__PYX_ERR(0, 68, __pyx_L1_error)) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_MISSING); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = (__pyx_v_threading_support == __pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(__pyx_t_1)) { + + /* "hunter/_event.pyx":69 + * raise TypeError('Missing argument: calls (required because tracer was not given).') + * if threading_support is MISSING: + * raise TypeError('Missing argument: threading_support (required because tracer was not given).') # <<<<<<<<<<<<<< + * else: + * depth = tracer.depth + */ + __Pyx_TraceLine(69,0,__PYX_ERR(0, 69, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 69, __pyx_L1_error) + + /* "hunter/_event.pyx":68 + * if calls is None: + * raise TypeError('Missing argument: calls (required because tracer was not given).') + * if threading_support is MISSING: # <<<<<<<<<<<<<< + * raise TypeError('Missing argument: threading_support (required because tracer was not given).') + * else: + */ + } + + /* "hunter/_event.pyx":63 + * def __init__(self, FrameType frame, int kind, object arg, Tracer tracer=None, object depth=None, object calls=None, + * object threading_support=MISSING): + * if tracer is None: # <<<<<<<<<<<<<< + * if depth is None: + * raise TypeError('Missing argument: depth (required because tracer was not given).') + */ + goto __pyx_L3; + } + + /* "hunter/_event.pyx":71 + * raise TypeError('Missing argument: threading_support (required because tracer was not given).') + * else: + * depth = tracer.depth # <<<<<<<<<<<<<< + * calls = tracer.calls + * threading_support = tracer.threading_support + */ + __Pyx_TraceLine(71,0,__PYX_ERR(0, 71, __pyx_L1_error)) + /*else*/ { + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_tracer->depth); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 71, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_depth, __pyx_t_2); + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":72 + * else: + * depth = tracer.depth + * calls = tracer.calls # <<<<<<<<<<<<<< + * threading_support = tracer.threading_support + * + */ + __Pyx_TraceLine(72,0,__PYX_ERR(0, 72, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_tracer->calls); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 72, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_calls, __pyx_t_2); + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":73 + * depth = tracer.depth + * calls = tracer.calls + * threading_support = tracer.threading_support # <<<<<<<<<<<<<< + * + * self.arg = arg + */ + __Pyx_TraceLine(73,0,__PYX_ERR(0, 73, __pyx_L1_error)) + __pyx_t_2 = __pyx_v_tracer->threading_support; + __Pyx_INCREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_threading_support, __pyx_t_2); + __pyx_t_2 = 0; + } + __pyx_L3:; + + /* "hunter/_event.pyx":75 + * threading_support = tracer.threading_support + * * self.arg = arg # <<<<<<<<<<<<<< * self.frame = frame - * self.kind = kind + * self.kind = KIND_NAMES[kind] */ - __Pyx_TraceLine(44,0,__PYX_ERR(0, 44, __pyx_L1_error)) + __Pyx_TraceLine(75,0,__PYX_ERR(0, 75, __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":76 + * * 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)); - __Pyx_GOTREF(__pyx_v_self->frame); - __Pyx_DECREF(((PyObject *)__pyx_v_self->frame)); + * self.kind = KIND_NAMES[kind] + * self.depth = depth + */ + __Pyx_TraceLine(76,0,__PYX_ERR(0, 76, __pyx_L1_error)) + __Pyx_INCREF((PyObject *)__pyx_v_frame); + __Pyx_GIVEREF((PyObject *)__pyx_v_frame); + __Pyx_GOTREF((PyObject *)__pyx_v_self->frame); + __Pyx_DECREF((PyObject *)__pyx_v_self->frame); __pyx_v_self->frame = __pyx_v_frame; - /* "hunter/_event.pyx":46 + /* "hunter/_event.pyx":77 * self.arg = arg * self.frame = frame - * self.kind = kind # <<<<<<<<<<<<<< - * self.depth = tracer.depth - * self.calls = tracer.calls + * self.kind = KIND_NAMES[kind] # <<<<<<<<<<<<<< + * self.depth = depth + * self.calls = calls */ - __Pyx_TraceLine(46,0,__PYX_ERR(0, 46, __pyx_L1_error)) - __Pyx_INCREF(__pyx_v_kind); - __Pyx_GIVEREF(__pyx_v_kind); + __Pyx_TraceLine(77,0,__PYX_ERR(0, 77, __pyx_L1_error)) + __pyx_t_2 = ((PyObject *)(__pyx_v_6hunter_6_event_KIND_NAMES[__pyx_v_kind])); + __Pyx_INCREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); __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_2); + __pyx_t_2 = 0; - /* "hunter/_event.pyx":47 + /* "hunter/_event.pyx":78 * 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.kind = KIND_NAMES[kind] + * self.depth = depth # <<<<<<<<<<<<<< + * self.calls = calls + * self.threading_support = threading_support + */ + __Pyx_TraceLine(78,0,__PYX_ERR(0, 78, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_depth); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 78, __pyx_L1_error) + __pyx_v_self->depth = __pyx_t_3; + + /* "hunter/_event.pyx":79 + * self.kind = KIND_NAMES[kind] + * self.depth = depth + * self.calls = calls # <<<<<<<<<<<<<< + * self.threading_support = 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; + __Pyx_TraceLine(79,0,__PYX_ERR(0, 79, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_calls); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 79, __pyx_L1_error) + __pyx_v_self->calls = __pyx_t_3; - /* "hunter/_event.pyx":49 - * self.depth = tracer.depth - * self.calls = tracer.calls - * self.threading_support = tracer.threading_support # <<<<<<<<<<<<<< + /* "hunter/_event.pyx":80 + * self.depth = depth + * self.calls = calls + * self.threading_support = threading_support # <<<<<<<<<<<<<< * self.detached = False - * + * self.builtin = kind > 3 */ - __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(80,0,__PYX_ERR(0, 80, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_threading_support); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 80, __pyx_L1_error) + __pyx_v_self->threading_support = __pyx_t_1; - /* "hunter/_event.pyx":50 - * self.calls = tracer.calls - * self.threading_support = tracer.threading_support + /* "hunter/_event.pyx":81 + * 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(81,0,__PYX_ERR(0, 81, __pyx_L1_error)) __pyx_v_self->detached = 0; - /* "hunter/_event.pyx":52 + /* "hunter/_event.pyx":82 + * self.threading_support = threading_support * self.detached = False + * self.builtin = kind > 3 # <<<<<<<<<<<<<< + * + * self._code = UNSET + */ + __Pyx_TraceLine(82,0,__PYX_ERR(0, 82, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyBool_FromLong((__pyx_v_kind > 3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->builtin); + __Pyx_DECREF(__pyx_v_self->builtin); + __pyx_v_self->builtin = __pyx_t_2; + __pyx_t_2 = 0; + + /* "hunter/_event.pyx":84 + * 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(84,0,__PYX_ERR(0, 84, __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":85 * * 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(85,0,__PYX_ERR(0, 85, __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":86 * 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(86,0,__PYX_ERR(0, 86, __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":87 * 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(87,0,__PYX_ERR(0, 87, __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":88 * 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(88,0,__PYX_ERR(0, 88, __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":89 * 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(89,0,__PYX_ERR(0, 89, __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":90 * 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(90,0,__PYX_ERR(0, 90, __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":91 * 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(91,0,__PYX_ERR(0, 91, __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":92 * 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(92,0,__PYX_ERR(0, 92, __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":93 * 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(93,0,__PYX_ERR(0, 93, __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":94 * 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(94,0,__PYX_ERR(0, 94, __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":95 * 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(95,0,__PYX_ERR(0, 95, __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":96 * self._stdlib = UNSET * self._threadidn = UNSET * self._threadname = UNSET # <<<<<<<<<<<<<< * self._thread = UNSET - * + * self._instruction = UNSET */ - __Pyx_TraceLine(64,0,__PYX_ERR(0, 64, __pyx_L1_error)) + __Pyx_TraceLine(96,0,__PYX_ERR(0, 96, __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":97 * 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(97,0,__PYX_ERR(0, 97, __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 + /* "hunter/_event.pyx":98 + * self._threadname = UNSET + * self._thread = UNSET + * self._instruction = UNSET # <<<<<<<<<<<<<< + * + * def __repr__(self): + */ + __Pyx_TraceLine(98,0,__PYX_ERR(0, 98, __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":61 * Needed for the ``calls`` and ``depth`` fields. * """ - * def __init__(self, FrameType frame, str kind, object arg, Tracer tracer): # <<<<<<<<<<<<<< - * self.arg = arg - * self.frame = frame + * def __init__(self, FrameType frame, int kind, object arg, Tracer tracer=None, object depth=None, object calls=None, # <<<<<<<<<<<<<< + * object threading_support=MISSING): + * if tracer is None: */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("hunter._event.Event.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; + __Pyx_XDECREF(__pyx_v_depth); + __Pyx_XDECREF(__pyx_v_calls); + __Pyx_XDECREF(__pyx_v_threading_support); __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_event.pyx":67 - * self._thread = UNSET - * - * def detach(self, value_filter=None): # <<<<<<<<<<<<<< - * event = Event.__new__(Event) +/* "hunter/_event.pyx":100 + * 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_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) { - PyObject *__pyx_v_value_filter = 0; +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("detach (wrapper)", 0); - { - 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); - 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) - } - } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - } - __pyx_v_value_filter = values[0]; - } - goto __pyx_L4_argument_unpacking_done; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("detach", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 67, __pyx_L3_error) - __pyx_L3_error:; - __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_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_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_2__repr__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_TraceDeclarations __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; - __Pyx_RefNannySetupContext("detach", 0); - __Pyx_TraceCall("detach", __pyx_f[0], 67, 0, __PYX_ERR(0, 67, __pyx_L1_error)); + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__repr__", 1); + __Pyx_TraceCall("__repr__", __pyx_f[0], 100, 0, __PYX_ERR(0, 100, __pyx_L1_error)); - /* "hunter/_event.pyx":68 - * - * def detach(self, value_filter=None): - * event = Event.__new__(Event) # <<<<<<<<<<<<<< + /* "hunter/_event.pyx":101 * - * event._code = self.code + * def __repr__(self): + * return '' % ( # <<<<<<<<<<<<<< + * self.kind, self.function, self.module, self.filename, self.lineno + * ) */ - __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; + __Pyx_TraceLine(101,0,__PYX_ERR(0, 101, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); - /* "hunter/_event.pyx":70 - * event = Event.__new__(Event) + /* "hunter/_event.pyx":102 + * def __repr__(self): + * return '' % ( + * self.kind, self.function, self.module, self.filename, self.lineno # <<<<<<<<<<<<<< + * ) * - * 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_TraceLine(102,0,__PYX_ERR(0, 102, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_function); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_module); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 102, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_filename); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_lineno); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_v_self->kind); + __Pyx_GIVEREF(__pyx_v_self->kind); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_self->kind)) __PYX_ERR(0, 102, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1)) __PYX_ERR(0, 102, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_event->_code); - __Pyx_DECREF(__pyx_v_event->_code); - __pyx_v_event->_code = __pyx_t_2; + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_2)) __PYX_ERR(0, 102, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_3)) __PYX_ERR(0, 102, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 4, __pyx_t_4)) __PYX_ERR(0, 102, __pyx_L1_error); + __pyx_t_1 = 0; __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; - /* "hunter/_event.pyx":71 + /* "hunter/_event.pyx":101 * - * event._code = self.code - * event._filename = self.filename # <<<<<<<<<<<<<< - * event._fullsource = self.fullsource - * event._function_object = self._function_object + * def __repr__(self): + * return '' % ( # <<<<<<<<<<<<<< + * self.kind, self.function, self.module, self.filename, self.lineno + * ) */ - __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; + __Pyx_TraceLine(101,0,__PYX_ERR(0, 101, __pyx_L1_error)) + __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Event_kind_r_function_r_module, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 101, __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/_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 + /* "hunter/_event.pyx":100 + * self._instruction = UNSET + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return '' % ( + * self.kind, self.function, self.module, self.filename, self.lineno */ - __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; - /* "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; + /* 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.__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/_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 +/* "hunter/_event.pyx":105 + * ) + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return self is other + * */ - __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":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_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)); - /* "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 +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_TraceDeclarations + __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_RefNannySetupContext("__eq__", 1); + __Pyx_TraceCall("__eq__", __pyx_f[0], 105, 0, __PYX_ERR(0, 105, __pyx_L1_error)); + + /* "hunter/_event.pyx":106 + * + * def __eq__(self, other): + * return self is other # <<<<<<<<<<<<<< + * + * def detach(self, value_filter=None): */ - __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_TraceLine(106,0,__PYX_ERR(0, 106, __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, 106, __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_r = __pyx_t_2; __pyx_t_2 = 0; + goto __pyx_L0; - /* "hunter/_event.pyx":78 - * event._module = self.module - * event._source = self.source - * event._stdlib = self.stdlib # <<<<<<<<<<<<<< - * event._threadidn = self.threadid - * event._threadname = self.threadname + /* "hunter/_event.pyx":105 + * ) + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return self is other + * */ - __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":79 - * event._source = self.source - * event._stdlib = self.stdlib - * event._threadidn = self.threadid # <<<<<<<<<<<<<< - * event._threadname = self.threadname + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("hunter._event.Event.__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/_event.pyx":108 + * return self is other + * + * def detach(self, value_filter=None): # <<<<<<<<<<<<<< + * 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; - /* "hunter/_event.pyx":80 - * event._stdlib = self.stdlib - * event._threadidn = self.threadid - * event._threadname = self.threadname # <<<<<<<<<<<<<< +/* Python wrapper */ +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*)(__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_MACROS + __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 **__pyx_pyargnames[] = {&__pyx_n_s_value_filter,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_value_filter); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 108, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "detach") < 0)) __PYX_ERR(0, 108, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_value_filter = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("detach", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 108, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(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_6detach(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self), __pyx_v_value_filter); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +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_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__5) + __Pyx_RefNannySetupContext("detach", 1); + __Pyx_TraceCall("detach", __pyx_f[0], 108, 0, __PYX_ERR(0, 108, __pyx_L1_error)); + + /* "hunter/_event.pyx":109 + * + * def detach(self, value_filter=None): + * return fast_detach(self, value_filter) # <<<<<<<<<<<<<< * - * if value_filter: + * def clone(self): */ - __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; + __Pyx_TraceLine(109,0,__PYX_ERR(0, 109, __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, 109, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; - /* "hunter/_event.pyx":82 - * event._threadname = self.threadname + /* "hunter/_event.pyx":108 + * return self is other + * + * def detach(self, value_filter=None): # <<<<<<<<<<<<<< + * return fast_detach(self, value_filter) * - * 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) { - /* "hunter/_event.pyx":83 + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("hunter._event.Event.detach", __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/_event.pyx":111 + * return fast_detach(self, value_filter) + * + * def clone(self): # <<<<<<<<<<<<<< + * return fast_clone(self) * - * 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; - - /* "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":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); - } - } - __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; - - /* "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":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":88 - * else: - * event._globals = {} - * event._locals = {} # <<<<<<<<<<<<<< - * event.arg = None - * - */ - __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; - - /* "hunter/_event.pyx":89 - * event._globals = {} - * event._locals = {} - * event.arg = None # <<<<<<<<<<<<<< - * - * 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; - } - __pyx_L3:; - - /* "hunter/_event.pyx":91 - * event.arg = None - * - * 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; - - /* "hunter/_event.pyx":92 - * - * 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 - * - */ - __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; +/* 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*)(__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_MACROS + __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;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "clone", 0))) return NULL; + __pyx_r = __pyx_pf_6hunter_6_event_5Event_8clone(((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_self)); - /* "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_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_event.pyx":96 - * event.kind = self.kind - * - * event.detached = True # <<<<<<<<<<<<<< - * - * return event - */ - __Pyx_TraceLine(96,0,__PYX_ERR(0, 96, __pyx_L1_error)) - __pyx_v_event->detached = 1; +static PyObject *__pyx_pf_6hunter_6_event_5Event_8clone(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__6) + __Pyx_RefNannySetupContext("clone", 1); + __Pyx_TraceCall("clone", __pyx_f[0], 111, 0, __PYX_ERR(0, 111, __pyx_L1_error)); - /* "hunter/_event.pyx":98 - * event.detached = True + /* "hunter/_event.pyx":112 * - * return event # <<<<<<<<<<<<<< + * def clone(self): + * return fast_clone(self) # <<<<<<<<<<<<<< * - * cdef inline Event clone(self): + * cdef inline instruction_getter(self): */ - __Pyx_TraceLine(98,0,__PYX_ERR(0, 98, __pyx_L1_error)) + __Pyx_TraceLine(112,0,__PYX_ERR(0, 112, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_event)); - __pyx_r = ((PyObject *)__pyx_v_event); + __pyx_t_1 = ((PyObject *)__pyx_f_6hunter_6_event_fast_clone(__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; goto __pyx_L0; - /* "hunter/_event.pyx":67 - * self._thread = UNSET + /* "hunter/_event.pyx":111 + * return fast_detach(self, value_filter) * - * def detach(self, value_filter=None): # <<<<<<<<<<<<<< - * event = Event.__new__(Event) + * def clone(self): # <<<<<<<<<<<<<< + * return fast_clone(self) * */ /* 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_AddTraceback("hunter._event.Event.clone", __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_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_event.pyx":100 - * return event +/* "hunter/_event.pyx":114 + * return fast_clone(self) + * + * cdef inline instruction_getter(self): # <<<<<<<<<<<<<< + * cdef int position * - * cdef inline Event clone(self): # <<<<<<<<<<<<<< - * event = Event.__new__(Event) - * event.arg = self.arg */ -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; +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_TraceDeclarations __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; + int __pyx_t_1; PyObject *__pyx_t_2 = NULL; - int __pyx_t_3; + PyObject *__pyx_t_3 = NULL; int __pyx_t_4; - __Pyx_RefNannySetupContext("clone", 0); - __Pyx_TraceCall("clone", __pyx_f[0], 100, 0, __PYX_ERR(0, 100, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("instruction_getter", 1); + __Pyx_TraceCall("instruction_getter", __pyx_f[0], 114, 0, __PYX_ERR(0, 114, __pyx_L1_error)); - /* "hunter/_event.pyx":101 + /* "hunter/_event.pyx":117 + * cdef int position * - * cdef inline Event clone(self): - * event = Event.__new__(Event) # <<<<<<<<<<<<<< - * event.arg = self.arg - * event.frame = self.frame + * if self._instruction is UNSET: # <<<<<<<<<<<<<< + * position = PyFrame_GetLasti(self.frame) + * co_code = PyCode_GetCode(self.code_getter()) */ - __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; + __Pyx_TraceLine(117,0,__PYX_ERR(0, 117, __pyx_L1_error)) + __pyx_t_1 = (__pyx_v_self->_instruction == __pyx_v_6hunter_6_event_UNSET); + if (__pyx_t_1) { - /* "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; - - /* "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":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":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":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":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":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":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":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 + /* "hunter/_event.pyx":118 + * + * if self._instruction is UNSET: + * position = PyFrame_GetLasti(self.frame) # <<<<<<<<<<<<<< + * co_code = PyCode_GetCode(self.code_getter()) + * if co_code and position >= 0: */ - __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; + __Pyx_TraceLine(118,0,__PYX_ERR(0, 118, __pyx_L1_error)) + __pyx_t_2 = ((PyObject *)__pyx_v_self->frame); + __Pyx_INCREF(__pyx_t_2); + __pyx_v_position = PyFrame_GetLasti(((PyFrameObject *)__pyx_t_2)); + __Pyx_DECREF(__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 + /* "hunter/_event.pyx":119 + * if self._instruction is UNSET: + * position = PyFrame_GetLasti(self.frame) + * co_code = PyCode_GetCode(self.code_getter()) # <<<<<<<<<<<<<< + * if co_code and position >= 0: + * self._instruction = co_code[position] */ - __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; + __Pyx_TraceLine(119,0,__PYX_ERR(0, 119, __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, 119, __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, 119, __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":117 - * event._locals = self._locals - * event._module = self._module - * event._source = self._source # <<<<<<<<<<<<<< - * event._stdlib = self._stdlib - * event._threadidn = self._threadidn + /* "hunter/_event.pyx":120 + * position = PyFrame_GetLasti(self.frame) + * co_code = PyCode_GetCode(self.code_getter()) + * if co_code and position >= 0: # <<<<<<<<<<<<<< + * self._instruction = co_code[position] + * else: */ - __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; + __Pyx_TraceLine(120,0,__PYX_ERR(0, 120, __pyx_L1_error)) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_co_code); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 120, __pyx_L1_error) + if (__pyx_t_4) { + } else { + __pyx_t_1 = __pyx_t_4; + goto __pyx_L5_bool_binop_done; + } + __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":118 - * event._module = self._module - * event._source = self._source - * event._stdlib = self._stdlib # <<<<<<<<<<<<<< - * event._threadidn = self._threadidn - * event._threadname = self._threadname + /* "hunter/_event.pyx":121 + * co_code = PyCode_GetCode(self.code_getter()) + * if co_code and position >= 0: + * self._instruction = co_code[position] # <<<<<<<<<<<<<< + * else: + * self._instruction = None */ - __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; + __Pyx_TraceLine(121,0,__PYX_ERR(0, 121, __pyx_L1_error)) + __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_co_code, __pyx_v_position, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 121, __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":119 - * event._source = self._source - * event._stdlib = self._stdlib - * event._threadidn = self._threadidn # <<<<<<<<<<<<<< - * event._threadname = self._threadname - * event._thread = self._thread + /* "hunter/_event.pyx":120 + * position = PyFrame_GetLasti(self.frame) + * co_code = PyCode_GetCode(self.code_getter()) + * if co_code and position >= 0: # <<<<<<<<<<<<<< + * self._instruction = co_code[position] + * else: */ - __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; + goto __pyx_L4; + } - /* "hunter/_event.pyx":120 - * event._stdlib = self._stdlib - * event._threadidn = self._threadidn - * event._threadname = self._threadname # <<<<<<<<<<<<<< - * event._thread = self._thread - * return event + /* "hunter/_event.pyx":123 + * self._instruction = co_code[position] + * else: + * self._instruction = None # <<<<<<<<<<<<<< + * return self._instruction + * */ - __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; + __Pyx_TraceLine(123,0,__PYX_ERR(0, 123, __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":121 - * event._threadidn = self._threadidn - * event._threadname = self._threadname - * event._thread = self._thread # <<<<<<<<<<<<<< - * return event + /* "hunter/_event.pyx":117 + * cdef int position * + * if self._instruction is UNSET: # <<<<<<<<<<<<<< + * position = PyFrame_GetLasti(self.frame) + * co_code = PyCode_GetCode(self.code_getter()) */ - __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":124 + * else: + * self._instruction = None + * return self._instruction # <<<<<<<<<<<<<< * * @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(124,0,__PYX_ERR(0, 124, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_instruction); + __pyx_r = __pyx_v_self->_instruction; goto __pyx_L0; - /* "hunter/_event.pyx":100 - * return event + /* "hunter/_event.pyx":114 + * return fast_clone(self) + * + * cdef inline instruction_getter(self): # <<<<<<<<<<<<<< + * cdef int position * - * cdef inline Event clone(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_AddTraceback("hunter._event.Event.clone", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("hunter._event.Event.instruction_getter", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_event); - __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_XDECREF(__pyx_v_co_code); + __Pyx_XGIVEREF(__pyx_r); __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_event.pyx":125 - * - * @property - * def threadid(self): # <<<<<<<<<<<<<< - * cdef long current +/* "hunter/_event.pyx":126 + * return self._instruction * + * @property # <<<<<<<<<<<<<< + * def instruction(self): + * return self.instruction_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) { +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_r = __pyx_pf_6hunter_6_event_5Event_8threadid___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_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_8threadid___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { +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_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[0], 126, 0, __PYX_ERR(0, 126, __pyx_L1_error)); + + /* "hunter/_event.pyx":128 + * @property + * def instruction(self): + * return self.instruction_getter() # <<<<<<<<<<<<<< + * + * cdef inline threadid_getter(self): + */ + __Pyx_TraceLine(128,0,__PYX_ERR(0, 128, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6hunter_6_event_5Event_instruction_getter(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "hunter/_event.pyx":126 + * return self._instruction + * + * @property # <<<<<<<<<<<<<< + * def instruction(self): + * return self.instruction_getter() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("hunter._event.Event.instruction.__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/_event.pyx":130 + * return self.instruction_getter() + * + * cdef inline threadid_getter(self): # <<<<<<<<<<<<<< + * cdef long current + * + */ + +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_TraceDeclarations __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; + int __pyx_t_5; int __pyx_t_6; - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[0], 125, 0, __PYX_ERR(0, 125, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("threadid_getter", 1); + __Pyx_TraceCall("threadid_getter", __pyx_f[0], 130, 0, __PYX_ERR(0, 130, __pyx_L1_error)); - /* "hunter/_event.pyx":128 + /* "hunter/_event.pyx":133 * 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_TraceLine(133,0,__PYX_ERR(0, 133, __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) { + if (__pyx_t_1) { - /* "hunter/_event.pyx":129 + /* "hunter/_event.pyx":134 * * 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_TraceLine(134,0,__PYX_ERR(0, 134, __pyx_L1_error)) __pyx_v_current = PyThread_get_thread_ident(); - /* "hunter/_event.pyx":130 + /* "hunter/_event.pyx":135 * 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_TraceLine(135,0,__PYX_ERR(0, 135, __pyx_L1_error)) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_get_main_thread); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(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_4, function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; } } - __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; + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v_main = __pyx_t_2; + __pyx_t_2 = 0; - /* "hunter/_event.pyx":131 + /* "hunter/_event.pyx":136 * 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); + __Pyx_TraceLine(136,0,__PYX_ERR(0, 136, __pyx_L1_error)) + __pyx_t_6 = (__pyx_v_main != Py_None); if (__pyx_t_6) { } else { - __pyx_t_2 = __pyx_t_6; + __pyx_t_1 = __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_t_2 = __Pyx_PyInt_From_long(__pyx_v_current); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_main, __pyx_n_s_ident); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 136, __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_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 136, __pyx_L1_error) __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_t_1 = __pyx_t_6; __pyx_L5_bool_binop_done:; - if (__pyx_t_2) { + if (__pyx_t_1) { - /* "hunter/_event.pyx":132 + /* "hunter/_event.pyx":137 * 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_TraceLine(137,0,__PYX_ERR(0, 137, __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 + /* "hunter/_event.pyx":136 * current = PyThread_get_thread_ident() * main = get_main_thread() * if main is not None and current == main.ident: # <<<<<<<<<<<<<< @@ -3563,26 +5557,26 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_8threadid___get__(struct __pyx_ goto __pyx_L4; } - /* "hunter/_event.pyx":134 + /* "hunter/_event.pyx":139 * self._threadidn = None * else: * self._threadidn = current # <<<<<<<<<<<<<< * return self._threadidn * */ - __Pyx_TraceLine(134,0,__PYX_ERR(0, 134, __pyx_L1_error)) + __Pyx_TraceLine(139,0,__PYX_ERR(0, 139, __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_t_4 = __Pyx_PyInt_From_long(__pyx_v_current); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); __Pyx_GOTREF(__pyx_v_self->_threadidn); __Pyx_DECREF(__pyx_v_self->_threadidn); - __pyx_v_self->_threadidn = __pyx_t_5; - __pyx_t_5 = 0; + __pyx_v_self->_threadidn = __pyx_t_4; + __pyx_t_4 = 0; } __pyx_L4:; - /* "hunter/_event.pyx":128 + /* "hunter/_event.pyx":133 * cdef long current * * if self._threadidn is UNSET: # <<<<<<<<<<<<<< @@ -3591,34 +5585,34 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_8threadid___get__(struct __pyx_ */ } - /* "hunter/_event.pyx":135 + /* "hunter/_event.pyx":140 * else: * self._threadidn = current * return self._threadidn # <<<<<<<<<<<<<< * * @property */ - __Pyx_TraceLine(135,0,__PYX_ERR(0, 135, __pyx_L1_error)) + __Pyx_TraceLine(140,0,__PYX_ERR(0, 140, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->_threadidn); __pyx_r = __pyx_v_self->_threadidn; goto __pyx_L0; - /* "hunter/_event.pyx":125 + /* "hunter/_event.pyx":130 + * return self.instruction_getter() * - * @property - * def threadid(self): # <<<<<<<<<<<<<< + * cdef inline threadid_getter(self): # <<<<<<<<<<<<<< * cdef long current * */ /* 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.threadid.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_AddTraceback("hunter._event.Event.threadid_getter", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_main); __Pyx_XGIVEREF(__pyx_r); @@ -3627,96 +5621,160 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_8threadid___get__(struct __pyx_ return __pyx_r; } -/* "hunter/_event.pyx":138 +/* "hunter/_event.pyx":142 + * return self._threadidn * - * @property - * def threadname(self): # <<<<<<<<<<<<<< - * if self._threadname is UNSET: - * if self._thread is UNSET: + * @property # <<<<<<<<<<<<<< + * def threadid(self): + * return self.threadid_getter() */ /* 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) { +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_r = __pyx_pf_6hunter_6_event_5Event_10threadname___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_8threadid___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_pf_6hunter_6_event_5Event_8threadid___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[0], 142, 0, __PYX_ERR(0, 142, __pyx_L1_error)); + + /* "hunter/_event.pyx":144 + * @property + * def threadid(self): + * return self.threadid_getter() # <<<<<<<<<<<<<< + * + * cdef inline threadname_getter(self): + */ + __Pyx_TraceLine(144,0,__PYX_ERR(0, 144, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6hunter_6_event_5Event_threadid_getter(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "hunter/_event.pyx":142 + * return self._threadidn + * + * @property # <<<<<<<<<<<<<< + * def threadid(self): + * return self.threadid_getter() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("hunter._event.Event.threadid.__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/_event.pyx":146 + * return self.threadid_getter() + * + * cdef inline threadname_getter(self): # <<<<<<<<<<<<<< + * if self._threadname is UNSET: + * if self._thread is UNSET: + */ + +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_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)); + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("threadname_getter", 1); + __Pyx_TraceCall("threadname_getter", __pyx_f[0], 146, 0, __PYX_ERR(0, 146, __pyx_L1_error)); - /* "hunter/_event.pyx":139 - * @property - * def threadname(self): + /* "hunter/_event.pyx":147 + * + * 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(147,0,__PYX_ERR(0, 147, __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":148 + * 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(148,0,__PYX_ERR(0, 148, __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":149 * 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_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_TraceLine(149,0,__PYX_ERR(0, 149, __pyx_L1_error)) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_current_thread); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(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_4, function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; } } - __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_4, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __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":148 + * cdef inline threadname_getter(self): * if self._threadname is UNSET: * if self._thread is UNSET: # <<<<<<<<<<<<<< * self._thread = current_thread() @@ -3724,59 +5782,59 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_10threadname___get__(struct __p */ } - /* "hunter/_event.pyx":142 + /* "hunter/_event.pyx":150 * 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(150,0,__PYX_ERR(0, 150, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_thread, __pyx_n_s_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 150, __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":147 + * + * 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":151 * 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(151,0,__PYX_ERR(0, 151, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->_threadname); __pyx_r = __pyx_v_self->_threadname; goto __pyx_L0; - /* "hunter/_event.pyx":138 + /* "hunter/_event.pyx":146 + * 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_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); @@ -3784,113 +5842,215 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_10threadname___get__(struct __p return __pyx_r; } -/* "hunter/_event.pyx":146 +/* "hunter/_event.pyx":153 + * 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_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[0], 153, 0, __PYX_ERR(0, 153, __pyx_L1_error)); + + /* "hunter/_event.pyx":155 + * @property + * def threadname(self): + * return self.threadname_getter() # <<<<<<<<<<<<<< + * + * cdef inline locals_getter(self): + */ + __Pyx_TraceLine(155,0,__PYX_ERR(0, 155, __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, 155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "hunter/_event.pyx":153 + * return self._threadname + * + * @property # <<<<<<<<<<<<<< + * def threadname(self): + * return self.threadname_getter() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("hunter._event.Event.threadname.__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/_event.pyx":157 + * 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_TraceDeclarations __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], 146, 0, __PYX_ERR(0, 146, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("locals_getter", 1); + __Pyx_TraceCall("locals_getter", __pyx_f[0], 157, 0, __PYX_ERR(0, 157, __pyx_L1_error)); - /* "hunter/_event.pyx":147 - * @property - * def locals(self): + /* "hunter/_event.pyx":158 + * + * 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 = {} */ - __Pyx_TraceLine(147,0,__PYX_ERR(0, 147, __pyx_L1_error)) + __Pyx_TraceLine(158,0,__PYX_ERR(0, 158, __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":159 + * cdef inline locals_getter(self): * if self._locals is UNSET: - * PyFrame_FastToLocals(self.frame) # <<<<<<<<<<<<<< - * self._locals = self.frame.f_locals - * return self._locals + * if self.builtin: # <<<<<<<<<<<<<< + * self._locals = {} + * else: */ - __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; + __Pyx_TraceLine(159,0,__PYX_ERR(0, 159, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->builtin); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 159, __pyx_L1_error) + if (__pyx_t_1) { - /* "hunter/_event.pyx":149 + /* "hunter/_event.pyx":160 + * if self._locals is UNSET: + * if self.builtin: + * self._locals = {} # <<<<<<<<<<<<<< + * else: + * PyFrame_FastToLocals(self.frame) + */ + __Pyx_TraceLine(160,0,__PYX_ERR(0, 160, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 160, __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":159 + * 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":162 + * self._locals = {} + * else: + * PyFrame_FastToLocals(self.frame) # <<<<<<<<<<<<<< + * self._locals = PyFrame_GetLocals(self.frame) + * return self._locals + */ + __Pyx_TraceLine(162,0,__PYX_ERR(0, 162, __pyx_L1_error)) + /*else*/ { + __pyx_t_2 = ((PyObject *)__pyx_v_self->frame); + __Pyx_INCREF(__pyx_t_2); + PyFrame_FastToLocals(((PyFrameObject *)__pyx_t_2)); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "hunter/_event.pyx":163 + * else: + * PyFrame_FastToLocals(self.frame) + * self._locals = 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(163,0,__PYX_ERR(0, 163, __pyx_L1_error)) + __pyx_t_2 = ((PyObject *)__pyx_v_self->frame); + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = PyFrame_GetLocals(((PyFrameObject *)__pyx_t_2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 163, __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":158 + * + * 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":164 + * PyFrame_FastToLocals(self.frame) + * self._locals = PyFrame_GetLocals(self.frame) * return self._locals # <<<<<<<<<<<<<< * * @property */ - __Pyx_TraceLine(150,0,__PYX_ERR(0, 150, __pyx_L1_error)) + __Pyx_TraceLine(164,0,__PYX_ERR(0, 164, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->_locals); __pyx_r = __pyx_v_self->_locals; goto __pyx_L0; - /* "hunter/_event.pyx":146 + /* "hunter/_event.pyx":157 + * 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_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); @@ -3898,100 +6058,202 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_6locals___get__(struct __pyx_ob return __pyx_r; } -/* "hunter/_event.pyx":153 +/* "hunter/_event.pyx":166 + * 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_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[0], 153, 0, __PYX_ERR(0, 153, __pyx_L1_error)); + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[0], 166, 0, __PYX_ERR(0, 166, __pyx_L1_error)); - /* "hunter/_event.pyx":154 + /* "hunter/_event.pyx":168 * @property - * def globals(self): + * def locals(self): + * return self.locals_getter() # <<<<<<<<<<<<<< + * + * cdef inline globals_getter(self): + */ + __Pyx_TraceLine(168,0,__PYX_ERR(0, 168, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6hunter_6_event_5Event_locals_getter(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 168, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "hunter/_event.pyx":166 + * return self._locals + * + * @property # <<<<<<<<<<<<<< + * def locals(self): + * return self.locals_getter() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __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_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/_event.pyx":170 + * return self.locals_getter() + * + * cdef inline globals_getter(self): # <<<<<<<<<<<<<< + * if self._globals is UNSET: + * if self.builtin: + */ + +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_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_RefNannySetupContext("globals_getter", 1); + __Pyx_TraceCall("globals_getter", __pyx_f[0], 170, 0, __PYX_ERR(0, 170, __pyx_L1_error)); + + /* "hunter/_event.pyx":171 + * + * cdef inline globals_getter(self): * if self._globals is UNSET: # <<<<<<<<<<<<<< - * self._globals = self.frame.f_globals - * return self._globals + * if self.builtin: + * self._locals = {} */ - __Pyx_TraceLine(154,0,__PYX_ERR(0, 154, __pyx_L1_error)) + __Pyx_TraceLine(171,0,__PYX_ERR(0, 171, __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) { + if (__pyx_t_1) { - /* "hunter/_event.pyx":155 - * def globals(self): + /* "hunter/_event.pyx":172 + * cdef inline globals_getter(self): + * if self._globals is UNSET: + * if self.builtin: # <<<<<<<<<<<<<< + * self._locals = {} + * else: + */ + __Pyx_TraceLine(172,0,__PYX_ERR(0, 172, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->builtin); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 172, __pyx_L1_error) + if (__pyx_t_1) { + + /* "hunter/_event.pyx":173 + * if self._globals is UNSET: + * if self.builtin: + * self._locals = {} # <<<<<<<<<<<<<< + * else: + * self._globals = PyFrame_GetGlobals(self.frame) + */ + __Pyx_TraceLine(173,0,__PYX_ERR(0, 173, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 173, __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":172 + * cdef inline globals_getter(self): * if self._globals is UNSET: - * self._globals = self.frame.f_globals # <<<<<<<<<<<<<< + * if self.builtin: # <<<<<<<<<<<<<< + * self._locals = {} + * else: + */ + goto __pyx_L4; + } + + /* "hunter/_event.pyx":175 + * self._locals = {} + * else: + * self._globals = PyFrame_GetGlobals(self.frame) # <<<<<<<<<<<<<< * 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_TraceLine(175,0,__PYX_ERR(0, 175, __pyx_L1_error)) + /*else*/ { + __pyx_t_2 = ((PyObject *)__pyx_v_self->frame); + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = PyFrame_GetGlobals(((PyFrameObject *)__pyx_t_2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 175, __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":154 - * @property - * def globals(self): + /* "hunter/_event.pyx":171 + * + * cdef inline globals_getter(self): * if self._globals is UNSET: # <<<<<<<<<<<<<< - * self._globals = self.frame.f_globals - * return self._globals + * if self.builtin: + * self._locals = {} */ } - /* "hunter/_event.pyx":156 - * if self._globals is UNSET: - * self._globals = self.frame.f_globals + /* "hunter/_event.pyx":176 + * else: + * self._globals = PyFrame_GetGlobals(self.frame) * return self._globals # <<<<<<<<<<<<<< * * @property */ - __Pyx_TraceLine(156,0,__PYX_ERR(0, 156, __pyx_L1_error)) + __Pyx_TraceLine(176,0,__PYX_ERR(0, 176, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->_globals); __pyx_r = __pyx_v_self->_globals; goto __pyx_L0; - /* "hunter/_event.pyx":153 + /* "hunter/_event.pyx":170 + * return self.locals_getter() * - * @property - * def globals(self): # <<<<<<<<<<<<<< + * cdef inline globals_getter(self): # <<<<<<<<<<<<<< * if self._globals is UNSET: - * self._globals = self.frame.f_globals + * if self.builtin: */ /* function exit code */ __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("hunter._event.Event.globals.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_AddTraceback("hunter._event.Event.globals_getter", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_TraceReturn(__pyx_r, 0); @@ -3999,98 +6261,269 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_7globals___get__(struct __pyx_o return __pyx_r; } -/* "hunter/_event.pyx":159 +/* "hunter/_event.pyx":178 + * return self._globals * - * @property - * def function(self): # <<<<<<<<<<<<<< - * if self._function is UNSET: - * self._function = self.frame.f_code.co_name + * @property # <<<<<<<<<<<<<< + * def globals(self): + * return self.globals_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) { +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_r = __pyx_pf_6hunter_6_event_5Event_8function___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_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_8function___get__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self) { +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_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[0], 178, 0, __PYX_ERR(0, 178, __pyx_L1_error)); + + /* "hunter/_event.pyx":180 + * @property + * def globals(self): + * return self.globals_getter() # <<<<<<<<<<<<<< + * + * cdef inline function_getter(self): + */ + __Pyx_TraceLine(180,0,__PYX_ERR(0, 180, __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, 180, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "hunter/_event.pyx":178 + * return self._globals + * + * @property # <<<<<<<<<<<<<< + * def globals(self): + * return self.globals_getter() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("hunter._event.Event.globals.__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/_event.pyx":182 + * 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_TraceDeclarations __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_RefNannySetupContext("function_getter", 1); + __Pyx_TraceCall("function_getter", __pyx_f[0], 182, 0, __PYX_ERR(0, 182, __pyx_L1_error)); - /* "hunter/_event.pyx":160 - * @property - * def function(self): + /* "hunter/_event.pyx":183 + * + * 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__ */ - __Pyx_TraceLine(160,0,__PYX_ERR(0, 160, __pyx_L1_error)) + __Pyx_TraceLine(183,0,__PYX_ERR(0, 183, __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":184 + * cdef inline function_getter(self): + * if self._function is UNSET: + * if self.builtin: # <<<<<<<<<<<<<< + * self._function = self.arg.__name__ + * else: + */ + __Pyx_TraceLine(184,0,__PYX_ERR(0, 184, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->builtin); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 184, __pyx_L1_error) + if (__pyx_t_1) { + + /* "hunter/_event.pyx":185 + * if self._function is UNSET: + * if self.builtin: + * self._function = self.arg.__name__ # <<<<<<<<<<<<<< + * else: + * self._function = self.code_getter().co_name + */ + __Pyx_TraceLine(185,0,__PYX_ERR(0, 185, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->arg, __pyx_n_s_name_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 185, __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":184 + * 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":187 + * 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(187,0,__PYX_ERR(0, 187, __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, 187, __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":183 + * + * 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":188 + * 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(188,0,__PYX_ERR(0, 188, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->_function); __pyx_r = __pyx_v_self->_function; goto __pyx_L0; - /* "hunter/_event.pyx":159 + /* "hunter/_event.pyx":182 + * 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_AddTraceback("hunter._event.Event.function_getter", __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; +} + +/* "hunter/_event.pyx":190 + * 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_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[0], 190, 0, __PYX_ERR(0, 190, __pyx_L1_error)); + + /* "hunter/_event.pyx":192 + * @property + * def function(self): + * return self.function_getter() # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_TraceLine(192,0,__PYX_ERR(0, 192, __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, 192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "hunter/_event.pyx":190 + * return self._function + * + * @property # <<<<<<<<<<<<<< + * def function(self): + * return self.function_getter() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("hunter._event.Event.function.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -4100,20 +6533,22 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_8function___get__(struct __pyx_ return __pyx_r; } -/* "hunter/_event.pyx":165 +/* "hunter/_event.pyx":194 + * 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,7 +6557,7 @@ 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; @@ -4131,397 +6566,353 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_15function_object___get__(struc __Pyx_TraceDeclarations __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; - PyObject *__pyx_t_8 = NULL; - int __pyx_t_9; - Py_ssize_t __pyx_t_10; - Py_ssize_t __pyx_t_11; - int __pyx_t_12; - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[0], 165, 0, __PYX_ERR(0, 165, __pyx_L1_error)); + int __pyx_t_5; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + Py_ssize_t __pyx_t_8; + Py_ssize_t __pyx_t_9; + int __pyx_t_10; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[0], 194, 0, __PYX_ERR(0, 194, __pyx_L1_error)); + + /* "hunter/_event.pyx":197 + * def function_object(self): + * cdef CodeType code + * if self.builtin: # <<<<<<<<<<<<<< + * return self.builtin + * elif self._function_object is UNSET: + */ + __Pyx_TraceLine(197,0,__PYX_ERR(0, 197, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->builtin); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 197, __pyx_L1_error) + if (__pyx_t_1) { - /* "hunter/_event.pyx":166 - * @property + /* "hunter/_event.pyx":198 + * cdef CodeType code + * if self.builtin: + * return self.builtin # <<<<<<<<<<<<<< + * elif self._function_object is UNSET: + * code = self.code_getter() + */ + __Pyx_TraceLine(198,0,__PYX_ERR(0, 198, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->builtin); + __pyx_r = __pyx_v_self->builtin; + goto __pyx_L0; + + /* "hunter/_event.pyx":197 * 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":199 + * 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(199,0,__PYX_ERR(0, 199, __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":200 + * 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(200,0,__PYX_ERR(0, 200, __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, 200, __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":201 + * 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(201,0,__PYX_ERR(0, 201, __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":202 + * 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(202,0,__PYX_ERR(0, 202, __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":201 + * 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":204 * 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_TraceLine(204,0,__PYX_ERR(0, 204, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_globals); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 204, __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, 204, __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_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_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (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_5, function); - __pyx_t_7 = 1; + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_5 = 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_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_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 204, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } - __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":205 * # 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_TraceLine(205,0,__PYX_ERR(0, 205, __pyx_L1_error)) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_if_same_code); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 205, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(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_5, function); - __pyx_t_7 = 1; + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_5 = 1; } } - #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); + PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_v_candidate, ((PyObject *)__pyx_v_code)}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 205, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } - __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":210 * # 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(210,0,__PYX_ERR(0, 210, __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":211 * # 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(211,0,__PYX_ERR(0, 211, __pyx_L1_error)) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_locals); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 211, __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_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_get); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 211, __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_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_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyCode_GetVarnames(__pyx_v_code); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 211, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_4, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 211, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (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_4, function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; } } - __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_t_5 = 0; + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_7}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 211, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v_first_arg = __pyx_t_2; + __pyx_t_2 = 0; - /* "hunter/_event.pyx":179 + /* "hunter/_event.pyx":212 * 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_TraceLine(212,0,__PYX_ERR(0, 212, __pyx_L1_error)) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_get_func_in_mro); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - __pyx_t_7 = 1; + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; } } - #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); + PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_v_first_arg, ((PyObject *)__pyx_v_code)}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } - __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":210 * # 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":215 * # 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(215,0,__PYX_ERR(0, 215, __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":216 * # 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(216,0,__PYX_ERR(0, 216, __pyx_L1_error)) + __pyx_t_8 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_globals); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (unlikely(__pyx_t_3 == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "values"); - __PYX_ERR(0, 183, __pyx_L1_error) + __PYX_ERR(0, 216, __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_7 = __Pyx_dict_iterator(__pyx_t_3, 0, __pyx_n_s_values, (&__pyx_t_9), (&__pyx_t_5)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_2); + __pyx_t_2 = __pyx_t_7; + __pyx_t_7 = 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); - 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; + __pyx_t_10 = __Pyx_dict_iter_next(__pyx_t_2, __pyx_t_9, &__pyx_t_8, NULL, &__pyx_t_7, NULL, __pyx_t_5); + if (unlikely(__pyx_t_10 == 0)) break; + if (unlikely(__pyx_t_10 == -1)) __PYX_ERR(0, 216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_7); + __pyx_t_7 = 0; - /* "hunter/_event.pyx":184 + /* "hunter/_event.pyx":217 * 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(217,0,__PYX_ERR(0, 217, __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":218 * 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(218,0,__PYX_ERR(0, 218, __pyx_L1_error)) goto __pyx_L9_continue; - /* "hunter/_event.pyx":184 + /* "hunter/_event.pyx":217 * if func is None: * for v in self.globals.values(): * if not isinstance(v, type): # <<<<<<<<<<<<<< @@ -4530,87 +6921,63 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_15function_object___get__(struc */ } - /* "hunter/_event.pyx":186 + /* "hunter/_event.pyx":219 * 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_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_TraceLine(219,0,__PYX_ERR(0, 219, __pyx_L1_error)) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_get_func_in_mro); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 219, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_10 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(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_4, function); - __pyx_t_12 = 1; + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_10 = 1; } } - #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_4, __pyx_v_v, ((PyObject *)__pyx_v_code)}; + __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_10, 2+__pyx_t_10); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 219, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } - __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_7); + __pyx_t_7 = 0; - /* "hunter/_event.pyx":187 + /* "hunter/_event.pyx":220 * 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(220,0,__PYX_ERR(0, 220, __pyx_L1_error)) + __pyx_t_6 = (__pyx_v_func != Py_None); + if (__pyx_t_6) { - /* "hunter/_event.pyx":188 + /* "hunter/_event.pyx":221 * 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(221,0,__PYX_ERR(0, 221, __pyx_L1_error)) goto __pyx_L10_break; - /* "hunter/_event.pyx":187 + /* "hunter/_event.pyx":220 * continue * func = get_func_in_mro(v, code) * if func is not None: # <<<<<<<<<<<<<< @@ -4621,9 +6988,9 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_15function_object___get__(struc __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":215 * # 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: # <<<<<<<<<<<<<< @@ -4632,61 +6999,60 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_15function_object___get__(struc */ } - /* "hunter/_event.pyx":189 + /* "hunter/_event.pyx":222 * 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(222,0,__PYX_ERR(0, 222, __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":199 + * 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":223 * break * self._function_object = func * return self._function_object # <<<<<<<<<<<<<< * - * @property + * cdef inline module_getter(self): */ - __Pyx_TraceLine(190,0,__PYX_ERR(0, 190, __pyx_L1_error)) + __Pyx_TraceLine(223,0,__PYX_ERR(0, 223, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->_function_object); __pyx_r = __pyx_v_self->_function_object; goto __pyx_L0; - /* "hunter/_event.pyx":165 + /* "hunter/_event.pyx":194 + * 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_8); + __Pyx_XDECREF(__pyx_t_7); __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); @@ -4697,149 +7063,176 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_15function_object___get__(struc return __pyx_r; } -/* "hunter/_event.pyx":193 +/* "hunter/_event.pyx":225 + * 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: */ -/* 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; -} - -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_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_RefNannySetupContext("module_getter", 1); + __Pyx_TraceCall("module_getter", __pyx_f[0], 225, 0, __PYX_ERR(0, 225, __pyx_L1_error)); - /* "hunter/_event.pyx":194 - * @property - * def module(self): + /* "hunter/_event.pyx":226 + * + * 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__ */ - __Pyx_TraceLine(194,0,__PYX_ERR(0, 194, __pyx_L1_error)) + __Pyx_TraceLine(226,0,__PYX_ERR(0, 226, __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":227 + * cdef inline module_getter(self): * if self._module is UNSET: - * module = self.frame.f_globals.get('__name__', '') # <<<<<<<<<<<<<< - * if module is None: - * module = '' + * if self.builtin: # <<<<<<<<<<<<<< + * module = self.arg.__module__ + * else: */ - __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; + __Pyx_TraceLine(227,0,__PYX_ERR(0, 227, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->builtin); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 227, __pyx_L1_error) + if (__pyx_t_1) { + + /* "hunter/_event.pyx":228 + * if self._module is UNSET: + * if self.builtin: + * module = self.arg.__module__ # <<<<<<<<<<<<<< + * else: + * module = self.globals.get('__name__', '') + */ + __Pyx_TraceLine(228,0,__PYX_ERR(0, 228, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->arg, __pyx_n_s_module_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 228, __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":227 + * 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":230 + * module = self.arg.__module__ + * else: + * module = self.globals.get('__name__', '') # <<<<<<<<<<<<<< + * if module is None: + * module = '?' + */ + __Pyx_TraceLine(230,0,__PYX_ERR(0, 230, __pyx_L1_error)) + /*else*/ { + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_globals); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_get); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 230, __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_tuple__8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 230, __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":231 + * else: + * module = self.globals.get('__name__', '') * if module is None: # <<<<<<<<<<<<<< - * module = '' - * + * module = '?' + * self._module = 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); + __Pyx_TraceLine(231,0,__PYX_ERR(0, 231, __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":232 + * module = self.globals.get('__name__', '') * if module is None: - * module = '' # <<<<<<<<<<<<<< - * + * module = '?' # <<<<<<<<<<<<<< * self._module = module + * return self._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_); + __Pyx_TraceLine(232,0,__PYX_ERR(0, 232, __pyx_L1_error)) + __Pyx_INCREF(__pyx_kp_s__9); + __Pyx_DECREF_SET(__pyx_v_module, __pyx_kp_s__9); - /* "hunter/_event.pyx":196 - * if self._module is UNSET: - * module = self.frame.f_globals.get('__name__', '') + /* "hunter/_event.pyx":231 + * else: + * module = self.globals.get('__name__', '') * if module is None: # <<<<<<<<<<<<<< - * module = '' - * + * module = '?' + * self._module = module */ } - /* "hunter/_event.pyx":199 - * module = '' - * + /* "hunter/_event.pyx":233 + * if module is None: + * module = '?' * self._module = module # <<<<<<<<<<<<<< * return self._module * */ - __Pyx_TraceLine(199,0,__PYX_ERR(0, 199, __pyx_L1_error)) + __Pyx_TraceLine(233,0,__PYX_ERR(0, 233, __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":226 + * + * 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":234 + * module = '?' * self._module = module * return self._module # <<<<<<<<<<<<<< * * @property */ - __Pyx_TraceLine(200,0,__PYX_ERR(0, 200, __pyx_L1_error)) + __Pyx_TraceLine(234,0,__PYX_ERR(0, 234, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->_module); __pyx_r = __pyx_v_self->_module; goto __pyx_L0; - /* "hunter/_event.pyx":193 + /* "hunter/_event.pyx":225 + * 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_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); @@ -4848,198 +7241,287 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_6module___get__(struct __pyx_ob return __pyx_r; } -/* "hunter/_event.pyx":203 +/* "hunter/_event.pyx":236 + * 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) { - PyObject *__pyx_v_filename = NULL; - PyObject *__pyx_v_basename = NULL; +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_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[0], 236, 0, __PYX_ERR(0, 236, __pyx_L1_error)); + + /* "hunter/_event.pyx":238 + * @property + * def module(self): + * return self.module_getter() # <<<<<<<<<<<<<< + * + * cdef inline filename_getter(self): + */ + __Pyx_TraceLine(238,0,__PYX_ERR(0, 238, __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, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "hunter/_event.pyx":236 + * return self._module + * + * @property # <<<<<<<<<<<<<< + * def module(self): + * return self.module_getter() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("hunter._event.Event.module.__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/_event.pyx":240 + * 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_cybasename = NULL; PyObject *__pyx_v_ext = NULL; PyObject *__pyx_v_cyfilename = NULL; PyObject *__pyx_r = NULL; __Pyx_TraceDeclarations __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; - 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): + Py_ssize_t __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("filename_getter", 1); + __Pyx_TraceCall("filename_getter", __pyx_f[0], 240, 0, __PYX_ERR(0, 240, __pyx_L1_error)); + + /* "hunter/_event.pyx":242 + * 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 */ - __Pyx_TraceLine(204,0,__PYX_ERR(0, 204, __pyx_L1_error)) + __Pyx_TraceLine(242,0,__PYX_ERR(0, 242, __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":243 + * 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(243,0,__PYX_ERR(0, 243, __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, 243, __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":244 * 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(244,0,__PYX_ERR(0, 244, __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":245 + * 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(245,0,__PYX_ERR(0, 245, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_filename); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 245, __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":246 + * filename = code.co_filename * if not filename: - * filename = self.frame.f_globals.get('__file__') # <<<<<<<<<<<<<< + * filename = self.globals.get('__file__') # <<<<<<<<<<<<<< * if not filename: - * 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_TraceLine(246,0,__PYX_ERR(0, 246, __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, 246, __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_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_get); 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_t_4 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (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_4, function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_6 = 1; } } - __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; + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_n_s_file}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 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":245 + * 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":247 * 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(247,0,__PYX_ERR(0, 247, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_filename); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 247, __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":248 + * 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(248,0,__PYX_ERR(0, 248, __pyx_L1_error)) + __Pyx_INCREF(__pyx_kp_s__9); + __Pyx_DECREF_SET(__pyx_v_filename, __pyx_kp_s__9); - /* "hunter/_event.pyx":208 + /* "hunter/_event.pyx":247 * 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":249 * 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_TraceLine(249,0,__PYX_ERR(0, 249, __pyx_L1_error)) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_filename, __pyx_n_s_endswith); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (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_4, function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_6 = 1; } } - __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) { + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_tuple__10}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 249, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_1) { - /* "hunter/_event.pyx":211 - * filename = '' + /* "hunter/_event.pyx":250 + * 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) */ - __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; + __Pyx_TraceLine(250,0,__PYX_ERR(0, 250, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyObject_GetSlice(__pyx_v_filename, 0, -1L, NULL, NULL, &__pyx_slice__11, 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 250, __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":249 * if not filename: - * filename = '' + * filename = '?' * elif filename.endswith(('.pyc', '.pyo')): # <<<<<<<<<<<<<< * filename = filename[:-1] * elif filename.endswith(('.so', '.pyd')): @@ -5047,265 +7529,262 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_8filename___get__(struct __pyx_ goto __pyx_L5; } - /* "hunter/_event.pyx":212 + /* "hunter/_event.pyx":251 * 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_TraceLine(251,0,__PYX_ERR(0, 251, __pyx_L1_error)) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_filename, __pyx_n_s_endswith); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 251, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (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_4, function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_6 = 1; } } - __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) { + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_tuple__12}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 251, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 251, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_1) { - /* "hunter/_event.pyx":213 + /* "hunter/_event.pyx":252 * 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 */ - __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) - __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_TraceLine(252,0,__PYX_ERR(0, 252, __pyx_L1_error)) + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_CYTHON_SUFFIX_RE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = NULL; + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_sub); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = 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); + #if CYTHON_UNPACK_METHODS + if (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_5, function); + __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_6 = 1; } } - #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); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_kp_s__7, __pyx_v_filename}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } - __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":253 * 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(253,0,__PYX_ERR(0, 253, __pyx_L1_error)) + __pyx_t_2 = __pyx_tuple__13; __Pyx_INCREF(__pyx_t_2); + __pyx_t_7 = 0; for (;;) { - if (__pyx_t_8 >= 2) break; + if (__pyx_t_7 >= 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_4 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_7); __Pyx_INCREF(__pyx_t_4); __pyx_t_7++; if (unlikely((0 < 0))) __PYX_ERR(0, 253, __pyx_L1_error) #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_4 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 253, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); #endif - __Pyx_XDECREF_SET(__pyx_v_ext, __pyx_t_5); - __pyx_t_5 = 0; + __Pyx_XDECREF_SET(__pyx_v_ext, __pyx_t_4); + __pyx_t_4 = 0; - /* "hunter/_event.pyx":215 - * basename = CYTHON_SUFFIX_RE.sub('', filename) + /* "hunter/_event.pyx":254 + * 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(254,0,__PYX_ERR(0, 254, __pyx_L1_error)) + __pyx_t_4 = PyNumber_Add(__pyx_v_cybasename, __pyx_v_ext); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_cyfilename, __pyx_t_4); + __pyx_t_4 = 0; - /* "hunter/_event.pyx":216 + /* "hunter/_event.pyx":255 * 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_TraceLine(255,0,__PYX_ERR(0, 255, __pyx_L1_error)) + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_exists); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (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_7, function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_6 = 1; } } - __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); - __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) { + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_v_cyfilename}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 255, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_1) { - /* "hunter/_event.pyx":217 - * cyfilename = basename + ext + /* "hunter/_event.pyx":256 + * cyfilename = cybasename + ext * if exists(cyfilename): * filename = cyfilename # <<<<<<<<<<<<<< * break * */ - __Pyx_TraceLine(217,0,__PYX_ERR(0, 217, __pyx_L1_error)) + __Pyx_TraceLine(256,0,__PYX_ERR(0, 256, __pyx_L1_error)) __Pyx_INCREF(__pyx_v_cyfilename); __Pyx_DECREF_SET(__pyx_v_filename, __pyx_v_cyfilename); - /* "hunter/_event.pyx":218 + /* "hunter/_event.pyx":257 * if exists(cyfilename): * filename = cyfilename * break # <<<<<<<<<<<<<< * * self._filename = filename */ - __Pyx_TraceLine(218,0,__PYX_ERR(0, 218, __pyx_L1_error)) + __Pyx_TraceLine(257,0,__PYX_ERR(0, 257, __pyx_L1_error)) goto __pyx_L7_break; - /* "hunter/_event.pyx":216 + /* "hunter/_event.pyx":255 * for ext in ('.pyx', '.py'): - * cyfilename = basename + ext + * cyfilename = cybasename + ext * if exists(cyfilename): # <<<<<<<<<<<<<< * filename = cyfilename * break */ } - /* "hunter/_event.pyx":214 + /* "hunter/_event.pyx":253 * 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(253,0,__PYX_ERR(0, 253, __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":251 * 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":259 * break * * self._filename = filename # <<<<<<<<<<<<<< * return self._filename * */ - __Pyx_TraceLine(220,0,__PYX_ERR(0, 220, __pyx_L1_error)) + __Pyx_TraceLine(259,0,__PYX_ERR(0, 259, __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":242 + * 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":260 * * self._filename = filename * return self._filename # <<<<<<<<<<<<<< * * @property */ - __Pyx_TraceLine(221,0,__PYX_ERR(0, 221, __pyx_L1_error)) + __Pyx_TraceLine(260,0,__PYX_ERR(0, 260, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->_filename); __pyx_r = __pyx_v_self->_filename; goto __pyx_L0; - /* "hunter/_event.pyx":203 + /* "hunter/_event.pyx":240 + * 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_XDECREF(__pyx_t_8); + __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); @@ -5314,100 +7793,162 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_8filename___get__(struct __pyx_ return __pyx_r; } -/* "hunter/_event.pyx":224 +/* "hunter/_event.pyx":262 + * 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_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[0], 224, 0, __PYX_ERR(0, 224, __pyx_L1_error)); + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[0], 262, 0, __PYX_ERR(0, 262, __pyx_L1_error)); - /* "hunter/_event.pyx":225 + /* "hunter/_event.pyx":264 * @property - * def lineno(self): - * if self._lineno is UNSET: # <<<<<<<<<<<<<< - * self._lineno = self.frame.f_lineno - * return self._lineno - */ - __Pyx_TraceLine(225,0,__PYX_ERR(0, 225, __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) { - - /* "hunter/_event.pyx":226 - * def lineno(self): - * if self._lineno is UNSET: - * self._lineno = self.frame.f_lineno # <<<<<<<<<<<<<< - * return self._lineno + * def filename(self): + * return self.filename_getter() # <<<<<<<<<<<<<< * + * cdef inline lineno_getter(self): */ - __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(264,0,__PYX_ERR(0, 264, __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, 264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "hunter/_event.pyx":262 + * return self._filename + * + * @property # <<<<<<<<<<<<<< + * def filename(self): + * return self.filename_getter() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("hunter._event.Event.filename.__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/_event.pyx":266 + * return self.filename_getter() + * + * cdef inline lineno_getter(self): # <<<<<<<<<<<<<< + * if self._lineno is UNSET: + * self._lineno = 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_TraceDeclarations + __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_RefNannySetupContext("lineno_getter", 1); + __Pyx_TraceCall("lineno_getter", __pyx_f[0], 266, 0, __PYX_ERR(0, 266, __pyx_L1_error)); + + /* "hunter/_event.pyx":267 + * + * cdef inline lineno_getter(self): + * if self._lineno is UNSET: # <<<<<<<<<<<<<< + * self._lineno = PyFrame_GetLineNumber(self.frame) + * return self._lineno + */ + __Pyx_TraceLine(267,0,__PYX_ERR(0, 267, __pyx_L1_error)) + __pyx_t_1 = (__pyx_v_self->_lineno == __pyx_v_6hunter_6_event_UNSET); + if (__pyx_t_1) { + + /* "hunter/_event.pyx":268 + * cdef inline lineno_getter(self): + * if self._lineno is UNSET: + * self._lineno = PyFrame_GetLineNumber(self.frame) # <<<<<<<<<<<<<< + * return self._lineno + * + */ + __Pyx_TraceLine(268,0,__PYX_ERR(0, 268, __pyx_L1_error)) + __pyx_t_2 = ((PyObject *)__pyx_v_self->frame); + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_int(PyFrame_GetLineNumber(((PyFrameObject *)__pyx_t_2))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 268, __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":267 + * + * cdef inline lineno_getter(self): * if self._lineno is UNSET: # <<<<<<<<<<<<<< - * self._lineno = self.frame.f_lineno + * self._lineno = PyFrame_GetLineNumber(self.frame) * return self._lineno */ } - /* "hunter/_event.pyx":227 + /* "hunter/_event.pyx":269 * if self._lineno is UNSET: - * self._lineno = self.frame.f_lineno + * self._lineno = PyFrame_GetLineNumber(self.frame) * return self._lineno # <<<<<<<<<<<<<< * * @property */ - __Pyx_TraceLine(227,0,__PYX_ERR(0, 227, __pyx_L1_error)) + __Pyx_TraceLine(269,0,__PYX_ERR(0, 269, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->_lineno); __pyx_r = __pyx_v_self->_lineno; goto __pyx_L0; - /* "hunter/_event.pyx":224 + /* "hunter/_event.pyx":266 + * 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 = 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_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); @@ -5415,209 +7956,341 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_6lineno___get__(struct __pyx_ob return __pyx_r; } -/* "hunter/_event.pyx":230 +/* "hunter/_event.pyx":271 + * 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_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[0], 230, 0, __PYX_ERR(0, 230, __pyx_L1_error)); + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[0], 271, 0, __PYX_ERR(0, 271, __pyx_L1_error)); - /* "hunter/_event.pyx":231 + /* "hunter/_event.pyx":273 * @property - * def code(self): + * def lineno(self): + * return self.lineno_getter() # <<<<<<<<<<<<<< + * + * cdef inline CodeType code_getter(self): + */ + __Pyx_TraceLine(273,0,__PYX_ERR(0, 273, __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, 273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "hunter/_event.pyx":271 + * return self._lineno + * + * @property # <<<<<<<<<<<<<< + * def lineno(self): + * return self.lineno_getter() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("hunter._event.Event.lineno.__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/_event.pyx":275 + * return self.lineno_getter() + * + * cdef inline CodeType code_getter(self): # <<<<<<<<<<<<<< + * if self._code is UNSET: + * return 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_TraceDeclarations + __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_RefNannySetupContext("code_getter", 1); + __Pyx_TraceCall("code_getter", __pyx_f[0], 275, 0, __PYX_ERR(0, 275, __pyx_L1_error)); + + /* "hunter/_event.pyx":276 + * + * cdef inline CodeType code_getter(self): * if self._code is UNSET: # <<<<<<<<<<<<<< - * return self.frame.f_code + * return PyFrame_GetCode(self.frame) * else: */ - __Pyx_TraceLine(231,0,__PYX_ERR(0, 231, __pyx_L1_error)) + __Pyx_TraceLine(276,0,__PYX_ERR(0, 276, __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":277 + * cdef inline CodeType code_getter(self): * if self._code is UNSET: - * return self.frame.f_code # <<<<<<<<<<<<<< + * return 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(277,0,__PYX_ERR(0, 277, __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 *)PyFrame_GetCode(((PyFrameObject *)__pyx_t_2))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 277, __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; goto __pyx_L0; - /* "hunter/_event.pyx":231 - * @property - * def code(self): + /* "hunter/_event.pyx":276 + * + * cdef inline CodeType code_getter(self): * if self._code is UNSET: # <<<<<<<<<<<<<< - * return self.frame.f_code + * return PyFrame_GetCode(self.frame) * else: */ } - /* "hunter/_event.pyx":234 - * return self.frame.f_code + /* "hunter/_event.pyx":279 + * return PyFrame_GetCode(self.frame) * else: * return self._code # <<<<<<<<<<<<<< * * @property */ - __Pyx_TraceLine(234,0,__PYX_ERR(0, 234, __pyx_L1_error)) + __Pyx_TraceLine(279,0,__PYX_ERR(0, 279, __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_ptype_6hunter_7_tracer_CodeType))))) __PYX_ERR(0, 279, __pyx_L1_error) __Pyx_INCREF(__pyx_v_self->_code); - __pyx_r = __pyx_v_self->_code; + __pyx_r = ((PyCodeObject *)__pyx_v_self->_code); goto __pyx_L0; } - /* "hunter/_event.pyx":230 + /* "hunter/_event.pyx":275 + * 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 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_AddTraceback("hunter._event.Event.code_getter", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); + __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_event.pyx":237 +/* "hunter/_event.pyx":281 + * 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_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[0], 281, 0, __PYX_ERR(0, 281, __pyx_L1_error)); + + /* "hunter/_event.pyx":283 + * @property + * def code(self): + * return self.code_getter() # <<<<<<<<<<<<<< + * + * cdef inline stdlib_getter(self): + */ + __Pyx_TraceLine(283,0,__PYX_ERR(0, 283, __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, 283, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "hunter/_event.pyx":281 + * return self._code + * + * @property # <<<<<<<<<<<<<< + * def code(self): + * return self.code_getter() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("hunter._event.Event.code.__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/_event.pyx":285 + * 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_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)); + int __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_RefNannySetupContext("stdlib_getter", 1); + __Pyx_TraceCall("stdlib_getter", __pyx_f[0], 285, 0, __PYX_ERR(0, 285, __pyx_L1_error)); - /* "hunter/_event.pyx":238 - * @property - * def stdlib(self): + /* "hunter/_event.pyx":286 + * + * 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(286,0,__PYX_ERR(0, 286, __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":287 + * 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(287,0,__PYX_ERR(0, 287, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_module); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 287, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_split); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 287, __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_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (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_5, function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_5 = 1; } } - __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; + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_kp_s__14}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 287, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_v_module_parts = __pyx_t_2; + __pyx_t_2 = 0; - /* "hunter/_event.pyx":240 + /* "hunter/_event.pyx":288 * 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(288,0,__PYX_ERR(0, 288, __pyx_L1_error)) + __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_n_s_pkg_resources, __pyx_v_module_parts, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 288, __pyx_L1_error) if (__pyx_t_1) { - /* "hunter/_event.pyx":242 + /* "hunter/_event.pyx":290 * 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(290,0,__PYX_ERR(0, 290, __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":288 * if self._stdlib is UNSET: * module_parts = self.module.split('.') * if 'pkg_resources' in module_parts: # <<<<<<<<<<<<<< @@ -5627,73 +8300,80 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_6stdlib___get__(struct __pyx_ob goto __pyx_L4; } - /* "hunter/_event.pyx":243 + /* "hunter/_event.pyx":291 * # 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(291,0,__PYX_ERR(0, 291, __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, 291, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_t_2, __pyx_kp_s_string, Py_EQ)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 291, __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_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_module); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 291, __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_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_startswith); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 291, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (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_4, function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; } } - __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_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) { + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_n_s_namedtuple}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 291, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 291, __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_n_s_module); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 291, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_t_2, __pyx_n_s_site, Py_EQ)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 291, __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":293 * 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 + * # if in site-packages then definitely not stdlib */ - __Pyx_TraceLine(245,0,__PYX_ERR(0, 245, __pyx_L1_error)) + __Pyx_TraceLine(293,0,__PYX_ERR(0, 293, __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":291 * # skip this over-vendored module * self._stdlib = True * elif self.filename == '' and (self.module.startswith('namedtuple_') or self.module == 'site'): # <<<<<<<<<<<<<< @@ -5703,116 +8383,130 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_6stdlib___get__(struct __pyx_ob goto __pyx_L4; } - /* "hunter/_event.pyx":246 + /* "hunter/_event.pyx":294 * # 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_TraceLine(294,0,__PYX_ERR(0, 294, __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, 294, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_startswith); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 294, __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_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_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SITE_PACKAGES_PATHS); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 294, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_5 = 1; } } - __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; + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 294, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 294, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__pyx_t_1) { - /* "hunter/_event.pyx":248 + /* "hunter/_event.pyx":296 * 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(296,0,__PYX_ERR(0, 296, __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":294 * # 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":297 + * # 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_TraceLine(297,0,__PYX_ERR(0, 297, __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, 297, __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_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_startswith); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_SYS_PREFIX_PATHS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; } } - __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_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; + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __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, 297, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__pyx_t_1) { - /* "hunter/_event.pyx":250 + /* "hunter/_event.pyx":298 * 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(298,0,__PYX_ERR(0, 298, __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":297 + * # if in site-packages then definitely not stdlib * self._stdlib = False * elif self.filename.startswith(SYS_PREFIX_PATHS): # <<<<<<<<<<<<<< * self._stdlib = True @@ -5821,14 +8515,14 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_6stdlib___get__(struct __pyx_ob goto __pyx_L4; } - /* "hunter/_event.pyx":252 + /* "hunter/_event.pyx":300 * self._stdlib = True * else: * self._stdlib = False # <<<<<<<<<<<<<< * return self._stdlib * */ - __Pyx_TraceLine(252,0,__PYX_ERR(0, 252, __pyx_L1_error)) + __Pyx_TraceLine(300,0,__PYX_ERR(0, 300, __pyx_L1_error)) /*else*/ { __Pyx_INCREF(Py_False); __Pyx_GIVEREF(Py_False); @@ -5838,44 +8532,44 @@ 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":286 + * + * 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":301 * else: * self._stdlib = False * return self._stdlib # <<<<<<<<<<<<<< * * @property */ - __Pyx_TraceLine(253,0,__PYX_ERR(0, 253, __pyx_L1_error)) + __Pyx_TraceLine(301,0,__PYX_ERR(0, 301, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->_stdlib); __pyx_r = __pyx_v_self->_stdlib; goto __pyx_L0; - /* "hunter/_event.pyx":237 + /* "hunter/_event.pyx":285 + * 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_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); @@ -5884,38 +8578,94 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_6stdlib___get__(struct __pyx_ob return __pyx_r; } -/* "hunter/_event.pyx":256 - * - * @property - * def fullsource(self): # <<<<<<<<<<<<<< - * cdef list lines +/* "hunter/_event.pyx":303 + * 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_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[0], 303, 0, __PYX_ERR(0, 303, __pyx_L1_error)); + + /* "hunter/_event.pyx":305 + * @property + * def stdlib(self): + * return self.stdlib_getter() # <<<<<<<<<<<<<< + * + * cdef inline fullsource_getter(self): + */ + __Pyx_TraceLine(305,0,__PYX_ERR(0, 305, __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, 305, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "hunter/_event.pyx":303 + * return self._stdlib + * + * @property # <<<<<<<<<<<<<< + * def stdlib(self): + * return self.stdlib_getter() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("hunter._event.Event.stdlib.__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/_event.pyx":307 + * 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_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; @@ -5934,486 +8684,513 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_10fullsource___get__(struct __p PyObject *__pyx_t_18 = NULL; PyObject *__pyx_t_19 = NULL; int __pyx_t_20; - PyObject *__pyx_t_21 = NULL; - Py_ssize_t __pyx_t_22; + Py_ssize_t __pyx_t_21; + PyObject *(*__pyx_t_22)(PyObject *); PyObject *(*__pyx_t_23)(PyObject *); - PyObject *(*__pyx_t_24)(PyObject *); - int __pyx_t_25; - char const *__pyx_t_26; + int __pyx_t_24; + char const *__pyx_t_25; + PyObject *__pyx_t_26 = NULL; 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 + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("fullsource_getter", 1); + __Pyx_TraceCall("fullsource_getter", __pyx_f[0], 307, 0, __PYX_ERR(0, 307, __pyx_L1_error)); + + /* "hunter/_event.pyx":311 + * 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(311,0,__PYX_ERR(0, 311, __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":312 * * if self._fullsource is UNSET: * try: # <<<<<<<<<<<<<< * self._fullsource = None - * + * code = self.code_getter() */ - __Pyx_TraceLine(260,0,__PYX_ERR(0, 260, __pyx_L1_error)) + __Pyx_TraceLine(312,0,__PYX_ERR(0, 312, __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":313 * 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 != '': */ - __Pyx_TraceLine(261,0,__PYX_ERR(0, 261, __pyx_L4_error)) + __Pyx_TraceLine(313,0,__PYX_ERR(0, 313, __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":314 + * try: + * self._fullsource = None + * code = self.code_getter() # <<<<<<<<<<<<<< + * if self.kind == 'call' and code.co_name != '': + * lines = [] + */ + __Pyx_TraceLine(314,0,__PYX_ERR(0, 314, __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, 314, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_v_code = ((PyCodeObject *)__pyx_t_5); + __pyx_t_5 = 0; + + /* "hunter/_event.pyx":315 * 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: */ - __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(315,0,__PYX_ERR(0, 315, __pyx_L4_error)) + __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_v_self->kind, __pyx_n_s_call, Py_EQ)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 315, __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_PyString_Equals(__pyx_v_code->co_name, __pyx_kp_s_module_3, Py_NE)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 315, __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":316 + * 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( */ - __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; + __Pyx_TraceLine(316,0,__PYX_ERR(0, 316, __pyx_L4_error)) + __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 316, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_v_lines = ((PyObject*)__pyx_t_5); + __pyx_t_5 = 0; - /* "hunter/_event.pyx":265 - * if self.kind == 'call' and self.frame.f_code.co_name != "": + /* "hunter/_event.pyx":317 + * 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_TraceLine(265,0,__PYX_ERR(0, 265, __pyx_L4_error)) + __Pyx_TraceLine(317,0,__PYX_ERR(0, 317, __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":318 * 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_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); + __Pyx_TraceLine(318,0,__PYX_ERR(0, 318, __pyx_L13_error)) + __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_generate_tokens); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 318, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_10); - /* "hunter/_event.pyx":267 + /* "hunter/_event.pyx":319 * try: - * for _, token, _, _, line in generate_tokens(partial( + * for _, token, _, _, _ in generate_tokens( + * partial( # <<<<<<<<<<<<<< + * next, + * yield_lines( + */ + __Pyx_TraceLine(319,0,__PYX_ERR(0, 319, __pyx_L13_error)) + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_n_s_partial); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 319, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_12); + + /* "hunter/_event.pyx":320 + * for _, token, _, _, _ in generate_tokens( + * partial( * next, # <<<<<<<<<<<<<< - * yield_lines(self.filename, self.frame.f_globals, self.lineno - 1, lines) - * )): + * yield_lines( + * self.filename, + */ + __Pyx_TraceLine(320,0,__PYX_ERR(0, 320, __pyx_L13_error)) + __pyx_t_13 = __Pyx_GetBuiltinName(__pyx_n_s_next); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 320, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_13); + + /* "hunter/_event.pyx":321 + * partial( + * next, + * yield_lines( # <<<<<<<<<<<<<< + * self.filename, + * self.frame.f_globals, */ - __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) - __Pyx_GOTREF(__pyx_t_14); + __Pyx_TraceLine(321,0,__PYX_ERR(0, 321, __pyx_L13_error)) + __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_n_s_yield_lines); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 321, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_15); - /* "hunter/_event.pyx":268 - * for _, token, _, _, line in generate_tokens(partial( + /* "hunter/_event.pyx":322 * 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, */ - __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_TraceLine(322,0,__PYX_ERR(0, 322, __pyx_L13_error)) + __pyx_t_16 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_filename); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 322, __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) + + /* "hunter/_event.pyx":323 + * yield_lines( + * self.filename, + * self.frame.f_globals, # <<<<<<<<<<<<<< + * self.lineno - 1, + * lines, + */ + __Pyx_TraceLine(323,0,__PYX_ERR(0, 323, __pyx_L13_error)) + __pyx_t_17 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->frame), __pyx_n_s_f_globals); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 323, __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) + + /* "hunter/_event.pyx":324 + * self.filename, + * self.frame.f_globals, + * self.lineno - 1, # <<<<<<<<<<<<<< + * lines, + * ), + */ + __Pyx_TraceLine(324,0,__PYX_ERR(0, 324, __pyx_L13_error)) + __pyx_t_18 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_lineno); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 324, __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) + __pyx_t_19 = __Pyx_PyInt_SubtractObjC(__pyx_t_18, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 324, __pyx_L13_error) __Pyx_GOTREF(__pyx_t_19); __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + + /* "hunter/_event.pyx":325 + * self.frame.f_globals, + * self.lineno - 1, + * lines, # <<<<<<<<<<<<<< + * ), + * ) + */ + __Pyx_TraceLine(325,0,__PYX_ERR(0, 325, __pyx_L13_error)) __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 CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_15))) { + __pyx_t_18 = PyMethod_GET_SELF(__pyx_t_15); if (likely(__pyx_t_18)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_16); + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_15); __Pyx_INCREF(__pyx_t_18); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_16, function); + __Pyx_DECREF_SET(__pyx_t_15, function); __pyx_t_20 = 1; } } - #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) + { + PyObject *__pyx_callargs[5] = {__pyx_t_18, __pyx_t_16, __pyx_t_17, __pyx_t_19, __pyx_v_lines}; + __pyx_t_14 = __Pyx_PyObject_FastCall(__pyx_t_15, __pyx_callargs+1-__pyx_t_20, 4+__pyx_t_20); __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; - __Pyx_GOTREF(__pyx_t_15); + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __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; + if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 321, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_14); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; } - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_16 = NULL; + __pyx_t_15 = 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); + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_12))) { + __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_12); + if (likely(__pyx_t_15)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12); + __Pyx_INCREF(__pyx_t_15); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_13, function); + __Pyx_DECREF_SET(__pyx_t_12, function); __pyx_t_20 = 1; } } - #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) - __Pyx_GOTREF(__pyx_t_12); - __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; + PyObject *__pyx_callargs[3] = {__pyx_t_15, __pyx_t_13, __pyx_t_14}; + __pyx_t_11 = __Pyx_PyObject_FastCall(__pyx_t_12, __pyx_callargs+1-__pyx_t_20, 2+__pyx_t_20); + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 319, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 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_t_12 = NULL; + __pyx_t_20 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(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_11, function); + __Pyx_DECREF_SET(__pyx_t_10, function); + __pyx_t_20 = 1; } } - __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 + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_t_11}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+1-__pyx_t_20, 1+__pyx_t_20); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 318, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + + /* "hunter/_event.pyx":318 * 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(318,0,__PYX_ERR(0, 318, __pyx_L13_error)) + if (likely(PyList_CheckExact(__pyx_t_5)) || PyTuple_CheckExact(__pyx_t_5)) { + __pyx_t_10 = __pyx_t_5; __Pyx_INCREF(__pyx_t_10); + __pyx_t_21 = 0; + __pyx_t_22 = 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_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_21 = -1; __pyx_t_10 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 318, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_22 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_10); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 318, __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(PyList_CheckExact(__pyx_t_11))) { - if (__pyx_t_22 >= PyList_GET_SIZE(__pyx_t_11)) break; + if (likely(!__pyx_t_22)) { + if (likely(PyList_CheckExact(__pyx_t_10))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_10); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 318, __pyx_L13_error) + #endif + if (__pyx_t_21 >= __pyx_temp) 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) + __pyx_t_5 = PyList_GET_ITEM(__pyx_t_10, __pyx_t_21); __Pyx_INCREF(__pyx_t_5); __pyx_t_21++; if (unlikely((0 < 0))) __PYX_ERR(0, 318, __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); + __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_10, __pyx_t_21); __pyx_t_21++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 318, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_5); #endif } else { - if (__pyx_t_22 >= PyTuple_GET_SIZE(__pyx_t_11)) break; + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_10); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 318, __pyx_L13_error) + #endif + if (__pyx_t_21 >= __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 = PyTuple_GET_ITEM(__pyx_t_10, __pyx_t_21); __Pyx_INCREF(__pyx_t_5); __pyx_t_21++; if (unlikely((0 < 0))) __PYX_ERR(0, 318, __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); + __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_10, __pyx_t_21); __pyx_t_21++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 318, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_5); #endif } } else { - __pyx_t_7 = __pyx_t_23(__pyx_t_11); - if (unlikely(!__pyx_t_7)) { + __pyx_t_5 = __pyx_t_22(__pyx_t_10); + 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) + else __PYX_ERR(0, 318, __pyx_L13_error) } break; } - __Pyx_GOTREF(__pyx_t_7); + __Pyx_GOTREF(__pyx_t_5); } - if ((likely(PyTuple_CheckExact(__pyx_t_7))) || (PyList_CheckExact(__pyx_t_7))) { - PyObject* sequence = __pyx_t_7; + 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, 318, __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_11 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_12 = PyTuple_GET_ITEM(sequence, 1); + __pyx_t_14 = PyTuple_GET_ITEM(sequence, 2); + __pyx_t_13 = PyTuple_GET_ITEM(sequence, 3); + __pyx_t_15 = PyTuple_GET_ITEM(sequence, 4); } 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_11 = PyList_GET_ITEM(sequence, 0); + __pyx_t_12 = PyList_GET_ITEM(sequence, 1); + __pyx_t_14 = PyList_GET_ITEM(sequence, 2); + __pyx_t_13 = PyList_GET_ITEM(sequence, 3); + __pyx_t_15 = PyList_GET_ITEM(sequence, 4); } + __Pyx_INCREF(__pyx_t_11); __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(__pyx_t_14); __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_11,&__pyx_t_12,&__pyx_t_14,&__pyx_t_13,&__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 = PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 318, __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_11,&__pyx_t_12,&__pyx_t_14,&__pyx_t_13,&__pyx_t_15}; + __pyx_t_19 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 318, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_19); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_23 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_19); 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_23(__pyx_t_19); 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_23(__pyx_t_19), 5) < 0) __PYX_ERR(0, 318, __pyx_L13_error) + __pyx_t_23 = NULL; + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 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_19); __pyx_t_19 = 0; + __pyx_t_23 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 266, __pyx_L13_error) + __PYX_ERR(0, 318, __pyx_L13_error) __pyx_L22_unpacking_done:; } - __Pyx_XDECREF_SET(__pyx_v__, __pyx_t_12); + __Pyx_XDECREF_SET(__pyx_v__, __pyx_t_11); + __pyx_t_11 = 0; + __Pyx_XDECREF_SET(__pyx_v_token, __pyx_t_12); __pyx_t_12 = 0; - __Pyx_XDECREF_SET(__pyx_v_token, __pyx_t_13); + __Pyx_DECREF_SET(__pyx_v__, __pyx_t_14); + __pyx_t_14 = 0; + __Pyx_DECREF_SET(__pyx_v__, __pyx_t_13); __pyx_t_13 = 0; - __Pyx_DECREF_SET(__pyx_v__, __pyx_t_21); - __pyx_t_21 = 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; - /* "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":329 + * ) + * ): + * if token in ('def', 'class', 'lambda'): # <<<<<<<<<<<<<< * self._fullsource = ''.join(lines) * break */ - __Pyx_TraceLine(270,0,__PYX_ERR(0, 270, __pyx_L13_error)) + __Pyx_TraceLine(329,0,__PYX_ERR(0, 329, __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_PyString_Equals(__pyx_t_5, __pyx_n_s_def, Py_EQ)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 329, __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_PyString_Equals(__pyx_t_5, __pyx_n_s_class, Py_EQ)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 329, __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_PyString_Equals(__pyx_t_5, __pyx_n_s_lambda, Py_EQ)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 329, __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":330 + * ): + * 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(330,0,__PYX_ERR(0, 330, __pyx_L13_error)) + __pyx_t_5 = __Pyx_PyString_Join(__pyx_kp_s__7, __pyx_v_lines); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 330, __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":331 + * 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(331,0,__PYX_ERR(0, 331, __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":329 + * ) + * ): + * if token in ('def', 'class', 'lambda'): # <<<<<<<<<<<<<< * self._fullsource = ''.join(lines) * break */ } - /* "hunter/_event.pyx":266 + /* "hunter/_event.pyx":318 * 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(318,0,__PYX_ERR(0, 318, __pyx_L13_error)) } + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + goto __pyx_L27_for_end; __pyx_L20_break:; - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 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":317 + * 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 +9200,140 @@ 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_21); __pyx_t_21 = 0; - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "hunter/_event.pyx":273 + /* "hunter/_event.pyx":332 * 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; + __Pyx_TraceLine(332,0,__PYX_ERR(0, 332, __pyx_L15_except_error)) + __Pyx_ErrFetch(&__pyx_t_10, &__pyx_t_5, &__pyx_t_15); + __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_n_s_TokenError); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 332, __pyx_L15_except_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_20 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_10, __pyx_t_13); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_ErrRestore(__pyx_t_10, __pyx_t_5, __pyx_t_15); + __pyx_t_10 = 0; __pyx_t_5 = 0; __pyx_t_15 = 0; if (__pyx_t_20) { __Pyx_ErrRestore(0,0,0); 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":317 + * 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":315 * 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":334 * 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(334,0,__PYX_ERR(0, 334, __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":335 * 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) - __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; + * self._fullsource = f'??? NO SOURCE: {exc!r}' + */ + __Pyx_TraceLine(335,0,__PYX_ERR(0, 335, __pyx_L4_error)) + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_getline); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 335, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_filename); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 335, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_lineno); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 335, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_14 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_globals); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 335, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_14); + __pyx_t_12 = 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); + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_12)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_7, function); + __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_20 = 1; } } - #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); + PyObject *__pyx_callargs[4] = {__pyx_t_12, __pyx_t_10, __pyx_t_13, __pyx_t_14}; + __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_20, 3+__pyx_t_20); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 335, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_15); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } - __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":334 * 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":312 * * 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,146 +9343,131 @@ 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_21); __pyx_t_21 = 0; - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "hunter/_event.pyx":277 + /* "hunter/_event.pyx":336 * 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_TraceLine(336,0,__PYX_ERR(0, 336, __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_AddTraceback("hunter._event.Event.fullsource_getter", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_15, &__pyx_t_5, &__pyx_t_14) < 0) __PYX_ERR(0, 336, __pyx_L6_except_error) + __Pyx_XGOTREF(__pyx_t_15); + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_14); + __Pyx_INCREF(__pyx_t_5); + __pyx_v_exc = __pyx_t_5; /*try:*/ { - /* "hunter/_event.pyx":278 - * self._fullsource = getline(self.filename, self.lineno, self.frame.f_globals) + /* "hunter/_event.pyx":337 + * 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(337,0,__PYX_ERR(0, 337, __pyx_L34_error)) + __pyx_t_13 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_exc), __pyx_empty_unicode); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 337, __pyx_L34_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_10 = __Pyx_PyUnicode_Concat(__pyx_kp_u_NO_SOURCE, __pyx_t_13); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 337, __pyx_L34_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_GIVEREF(__pyx_t_10); __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_10; + __pyx_t_10 = 0; } - /* "hunter/_event.pyx":277 + /* "hunter/_event.pyx":336 * 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(336,0,__PYX_ERR(0, 336, __pyx_L34_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_L35; } - __pyx_L33_error:; + __pyx_L34_error:; /*exception exit:*/{ __Pyx_PyThreadState_declare __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_t_9 = 0; __pyx_t_8 = 0; __pyx_t_7 = 0; __pyx_t_26 = 0; __pyx_t_27 = 0; __pyx_t_28 = 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_15); __pyx_t_15 = 0; + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 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_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); + if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_26, &__pyx_t_27, &__pyx_t_28); + if ((PY_MAJOR_VERSION < 3) || 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_7); + __Pyx_XGOTREF(__pyx_t_26); __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_t_20 = __pyx_lineno; __pyx_t_24 = __pyx_clineno; __pyx_t_25 = __pyx_filename; { - __Pyx_DECREF(__pyx_v_exc); - __pyx_v_exc = NULL; + __Pyx_DECREF(__pyx_v_exc); __pyx_v_exc = 0; } if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_26); __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_ExceptionReset(__pyx_t_26, __pyx_t_27, __pyx_t_28); } - __Pyx_XGIVEREF(__pyx_t_10); __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_26 = 0; __pyx_t_27 = 0; __pyx_t_28 = 0; + __pyx_lineno = __pyx_t_20; __pyx_clineno = __pyx_t_24; __pyx_filename = __pyx_t_25; goto __pyx_L6_except_error; } - __pyx_L34:; + __pyx_L35:; } + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __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; goto __pyx_L5_exception_handled; } goto __pyx_L6_except_error; - __pyx_L6_except_error:; - /* "hunter/_event.pyx":260 + /* "hunter/_event.pyx":312 * * 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":311 + * cdef CodeType code * * if self._fullsource is UNSET: # <<<<<<<<<<<<<< * try: @@ -6739,30 +9475,31 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_10fullsource___get__(struct __p */ } - /* "hunter/_event.pyx":279 + /* "hunter/_event.pyx":338 * 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(338,0,__PYX_ERR(0, 338, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->_fullsource); __pyx_r = __pyx_v_self->_fullsource; goto __pyx_L0; - /* "hunter/_event.pyx":256 + /* "hunter/_event.pyx":307 + * 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,14 +9509,13 @@ 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_21); - __Pyx_AddTraceback("hunter._event.Event.fullsource.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __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); @@ -6787,46 +9523,102 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_10fullsource___get__(struct __p return __pyx_r; } -/* "hunter/_event.pyx":282 +/* "hunter/_event.pyx":340 + * 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) { - PyObject *__pyx_r = 0; +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_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[0], 340, 0, __PYX_ERR(0, 340, __pyx_L1_error)); + + /* "hunter/_event.pyx":342 + * @property + * def fullsource(self): + * return self.fullsource_getter() # <<<<<<<<<<<<<< + * + * cdef inline source_getter(self): + */ + __Pyx_TraceLine(342,0,__PYX_ERR(0, 342, __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, 342, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "hunter/_event.pyx":340 + * return self._fullsource + * + * @property # <<<<<<<<<<<<<< + * def fullsource(self): + * return self.fullsource_getter() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("hunter._event.Event.fullsource.__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/_event.pyx":344 + * 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_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; - PyObject *__pyx_t_7 = NULL; + int __pyx_t_5; + Py_ssize_t __pyx_t_6; + Py_UCS4 __pyx_t_7; 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_14; + PyObject *__pyx_t_14 = NULL; int __pyx_t_15; char const *__pyx_t_16; PyObject *__pyx_t_17 = NULL; @@ -6835,309 +9627,298 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_6source___get__(struct __pyx_ob 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)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("source_getter", 1); + __Pyx_TraceCall("source_getter", __pyx_f[0], 344, 0, __PYX_ERR(0, 344, __pyx_L1_error)); - /* "hunter/_event.pyx":283 - * @property - * def source(self): + /* "hunter/_event.pyx":345 + * + * 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' */ - __Pyx_TraceLine(283,0,__PYX_ERR(0, 283, __pyx_L1_error)) + __Pyx_TraceLine(345,0,__PYX_ERR(0, 345, __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":346 + * 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(346,0,__PYX_ERR(0, 346, __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, 346, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_endswith); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 346, __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_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (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_5, function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_5 = 1; } } - __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) { + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_tuple__12}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 346, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 346, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_1) { - /* "hunter/_event.pyx":285 + /* "hunter/_event.pyx":347 * 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) */ - __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_TraceLine(347,0,__PYX_ERR(0, 347, __pyx_L1_error)) + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = 0; + __pyx_t_7 = 127; + __Pyx_INCREF(__pyx_kp_u_NO_SOURCE_not_reading_binary); + __pyx_t_6 += 34; + __Pyx_GIVEREF(__pyx_kp_u_NO_SOURCE_not_reading_binary); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_u_NO_SOURCE_not_reading_binary); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_splitext); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_basename); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 347, __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_t_10 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_filename); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_11 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_11); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_8, function); + __Pyx_DECREF_SET(__pyx_t_9, function); + __pyx_t_5 = 1; } } - __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); - } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_11, __pyx_t_10}; + __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } - __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) - __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_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_t_9 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; } } - __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_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 285, __pyx_L1_error) + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_t_8}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_4, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 347, __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_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) > __pyx_t_7) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) : __pyx_t_7; + __pyx_t_6 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4); + __pyx_t_4 = 0; + __Pyx_INCREF(__pyx_kp_u_file_2); + __pyx_t_6 += 5; + __Pyx_GIVEREF(__pyx_kp_u_file_2); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_kp_u_file_2); + __pyx_t_4 = __Pyx_PyUnicode_Join(__pyx_t_2, 3, __pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GIVEREF(__pyx_t_4); __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_4; + __pyx_t_4 = 0; - /* "hunter/_event.pyx":284 - * def source(self): + /* "hunter/_event.pyx":346 + * 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":348 * 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(348,0,__PYX_ERR(0, 348, __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_ExceptionSave(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14); __Pyx_XGOTREF(__pyx_t_12); __Pyx_XGOTREF(__pyx_t_13); + __Pyx_XGOTREF(__pyx_t_14); /*try:*/ { - /* "hunter/_event.pyx":287 - * self._source = "??? NO SOURCE: not reading {} file".format(splitext(basename(self.filename))[1]) + /* "hunter/_event.pyx":349 + * 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}' */ - __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) - __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_TraceLine(349,0,__PYX_ERR(0, 349, __pyx_L5_error)) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_getline); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 349, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_filename); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 349, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_lineno); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 349, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_globals); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 349, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_10); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - __pyx_t_14 = 1; + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; } } - #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); + PyObject *__pyx_callargs[4] = {__pyx_t_10, __pyx_t_3, __pyx_t_8, __pyx_t_9}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 3+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 349, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); __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_4; + __pyx_t_4 = 0; - /* "hunter/_event.pyx":286 + /* "hunter/_event.pyx":348 * 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_14); __pyx_t_14 = 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_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; - /* "hunter/_event.pyx":288 + /* "hunter/_event.pyx":350 * 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(350,0,__PYX_ERR(0, 350, __pyx_L7_except_error)) + __pyx_t_5 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_5) { + __Pyx_AddTraceback("hunter._event.Event.source_getter", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_2, &__pyx_t_9) < 0) __PYX_ERR(0, 350, __pyx_L7_except_error) + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_9); + __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":351 + * 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_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GIVEREF(__pyx_t_4); + __Pyx_TraceLine(351,0,__PYX_ERR(0, 351, __pyx_L16_error)) + __pyx_t_8 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_exc), __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 351, __pyx_L16_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_NO_SOURCE, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 351, __pyx_L16_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GIVEREF(__pyx_t_3); __Pyx_GOTREF(__pyx_v_self->_source); __Pyx_DECREF(__pyx_v_self->_source); - __pyx_v_self->_source = __pyx_t_4; - __pyx_t_4 = 0; + __pyx_v_self->_source = __pyx_t_3; + __pyx_t_3 = 0; } - /* "hunter/_event.pyx":288 + /* "hunter/_event.pyx":350 * 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(350,0,__PYX_ERR(0, 350, __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:; @@ -7146,10 +9927,9 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_6source___get__(struct __pyx_ob __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_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; + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 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_XGOTREF(__pyx_t_17); @@ -7158,10 +9938,9 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_6source___get__(struct __pyx_ob __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_5 = __pyx_lineno; __pyx_t_15 = __pyx_clineno; __pyx_t_16 = __pyx_filename; { - __Pyx_DECREF(__pyx_v_exc); - __pyx_v_exc = NULL; + __Pyx_DECREF(__pyx_v_exc); __pyx_v_exc = 0; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_20); @@ -7174,81 +9953,80 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_6source___get__(struct __pyx_ob __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_lineno = __pyx_t_5; __pyx_clineno = __pyx_t_15; __pyx_filename = __pyx_t_16; 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_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L6_exception_handled; } goto __pyx_L7_except_error; - __pyx_L7_except_error:; - /* "hunter/_event.pyx":286 + /* "hunter/_event.pyx":348 * 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_L7_except_error:; __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_14); + __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14); 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_14); + __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14); __pyx_L10_try_end:; } - /* "hunter/_event.pyx":283 - * @property - * def source(self): + /* "hunter/_event.pyx":345 + * + * 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":353 + * self._source = f'??? NO SOURCE: {exc!r}' * * return self._source # <<<<<<<<<<<<<< * - * def __getitem__(self, item): + * @property */ - __Pyx_TraceLine(291,0,__PYX_ERR(0, 291, __pyx_L1_error)) + __Pyx_TraceLine(353,0,__PYX_ERR(0, 353, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->_source); __pyx_r = __pyx_v_self->_source; goto __pyx_L0; - /* "hunter/_event.pyx":282 + /* "hunter/_event.pyx":344 + * 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_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); @@ -7257,52 +10035,126 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_6source___get__(struct __pyx_ob return __pyx_r; } -/* "hunter/_event.pyx":293 +/* "hunter/_event.pyx":355 + * 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; +} + +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_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[0], 355, 0, __PYX_ERR(0, 355, __pyx_L1_error)); + + /* "hunter/_event.pyx":357 + * @property + * def source(self): + * return self.source_getter() # <<<<<<<<<<<<<< + * + * def __getitem__(self, item): + */ + __Pyx_TraceLine(357,0,__PYX_ERR(0, 357, __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, 357, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "hunter/_event.pyx":355 * return self._source * + * @property # <<<<<<<<<<<<<< + * def source(self): + * return self.source_getter() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("hunter._event.Event.source.__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/_event.pyx":359 + * 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_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__getitem__", 0); - __Pyx_TraceCall("__getitem__", __pyx_f[0], 293, 0, __PYX_ERR(0, 293, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getitem__", 1); + __Pyx_TraceCall("__getitem__", __pyx_f[0], 359, 0, __PYX_ERR(0, 359, __pyx_L1_error)); - /* "hunter/_event.pyx":294 + /* "hunter/_event.pyx":360 * * def __getitem__(self, item): * return getattr(self, item) # <<<<<<<<<<<<<< * * */ - __Pyx_TraceLine(294,0,__PYX_ERR(0, 294, __pyx_L1_error)) + __Pyx_TraceLine(360,0,__PYX_ERR(0, 360, __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, 360, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "hunter/_event.pyx":293 - * return self._source + /* "hunter/_event.pyx":359 + * return self.source_getter() * * def __getitem__(self, item): # <<<<<<<<<<<<<< * return getattr(self, item) @@ -7321,7 +10173,7 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_4__getitem__(struct __pyx_obj_6 return __pyx_r; } -/* "hunter/_event.pxd":13 +/* "hunter/_event.pxd":15 * cdef class Event: * cdef: * readonly FrameType frame # <<<<<<<<<<<<<< @@ -7332,9 +10184,11 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_4__getitem__(struct __pyx_obj_6 /* 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 */ @@ -7346,10 +10200,13 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_5frame___get__(struct __pyx_obj PyObject *__pyx_r = NULL; __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 13, 0, __PYX_ERR(1, 13, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[1], 15, 0, __PYX_ERR(1, 15, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_self->frame)); + __Pyx_INCREF((PyObject *)__pyx_v_self->frame); __pyx_r = ((PyObject *)__pyx_v_self->frame); goto __pyx_L0; @@ -7364,7 +10221,7 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_5frame___get__(struct __pyx_obj return __pyx_r; } -/* "hunter/_event.pxd":14 +/* "hunter/_event.pxd":16 * cdef: * readonly FrameType frame * readonly str kind # <<<<<<<<<<<<<< @@ -7375,9 +10232,11 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_5frame___get__(struct __pyx_obj /* 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 */ @@ -7389,8 +10248,11 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_4kind___get__(struct __pyx_obj_ 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)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[1], 16, 0, __PYX_ERR(1, 16, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->kind); __pyx_r = __pyx_v_self->kind; @@ -7407,7 +10269,7 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_4kind___get__(struct __pyx_obj_ return __pyx_r; } -/* "hunter/_event.pxd":15 +/* "hunter/_event.pxd":17 * readonly FrameType frame * readonly str kind * readonly object arg # <<<<<<<<<<<<<< @@ -7418,9 +10280,11 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_4kind___get__(struct __pyx_obj_ /* 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 */ @@ -7432,8 +10296,11 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_3arg___get__(struct __pyx_obj_6 PyObject *__pyx_r = NULL; __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 15, 0, __PYX_ERR(1, 15, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[1], 17, 0, __PYX_ERR(1, 17, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->arg); __pyx_r = __pyx_v_self->arg; @@ -7450,7 +10317,7 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_3arg___get__(struct __pyx_obj_6 return __pyx_r; } -/* "hunter/_event.pxd":16 +/* "hunter/_event.pxd":18 * readonly str kind * readonly object arg * readonly int depth # <<<<<<<<<<<<<< @@ -7461,9 +10328,11 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_3arg___get__(struct __pyx_obj_6 /* 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 */ @@ -7476,10 +10345,13 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_5depth___get__(struct __pyx_obj __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 16, 0, __PYX_ERR(1, 16, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[1], 18, 0, __PYX_ERR(1, 18, __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_PyInt_From_int(__pyx_v_self->depth); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 18, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -7497,7 +10369,7 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_5depth___get__(struct __pyx_obj return __pyx_r; } -/* "hunter/_event.pxd":17 +/* "hunter/_event.pxd":19 * readonly object arg * readonly int depth * readonly int calls # <<<<<<<<<<<<<< @@ -7508,9 +10380,11 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_5depth___get__(struct __pyx_obj /* 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 */ @@ -7523,10 +10397,13 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_5calls___get__(struct __pyx_obj __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 17, 0, __PYX_ERR(1, 17, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[1], 19, 0, __PYX_ERR(1, 19, __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_PyInt_From_int(__pyx_v_self->calls); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -7544,20 +10421,22 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_5calls___get__(struct __pyx_obj return __pyx_r; } -/* "hunter/_event.pxd":18 +/* "hunter/_event.pxd":20 * 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 */ @@ -7570,10 +10449,13 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_17threading_support___get__(str __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 18, 0, __PYX_ERR(1, 18, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[1], 20, 0, __PYX_ERR(1, 20, __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, 20, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -7591,20 +10473,22 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_17threading_support___get__(str return __pyx_r; } -/* "hunter/_event.pxd":19 +/* "hunter/_event.pxd":21 * 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 */ @@ -7617,10 +10501,13 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_8detached___get__(struct __pyx_ __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 19, 0, __PYX_ERR(1, 19, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[1], 21, 0, __PYX_ERR(1, 21, __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, 21, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -7638,489 +10525,46 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_8detached___get__(struct __pyx_ return __pyx_r; } -/* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict - */ - -/* 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) { - 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)); - - /* 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; - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __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) +/* "hunter/_event.pxd":22 + * readonly bint threading_support + * readonly bint detached + * readonly object builtin # <<<<<<<<<<<<<< + * + * object _code */ /* 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) { +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("__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)); + __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_8__setstate_cython__(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +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_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_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[1], 22, 0, __PYX_ERR(1, 22, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->builtin); + __pyx_r = __pyx_v_self->builtin; + 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_AddTraceback("hunter._event.Event.builtin.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -8130,7 +10574,7 @@ static PyObject *__pyx_pf_6hunter_6_event_5Event_8__setstate_cython__(struct __p } 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":363 * * * def yield_lines(filename, module_globals, start, list collector, # <<<<<<<<<<<<<< @@ -8139,79 +10583,123 @@ static PyObject *__pyx_gb_6hunter_6_event_2generator(__pyx_CoroutineObject *__py */ /* 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*)(__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_MACROS + __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)) { + 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}; + values[4] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)((PyObject *)__pyx_int_10))); + if (__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); + switch (__pyx_nargs) { + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); CYTHON_FALLTHROUGH; - case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); CYTHON_FALLTHROUGH; - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_filename)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_filename)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 363, __pyx_L3_error) 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--; + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_module_globals)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 363, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("yield_lines", 0, 4, 5, 1); __PYX_ERR(0, 297, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("yield_lines", 0, 4, 5, 1); __PYX_ERR(0, 363, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_start)) != 0)) kw_args--; + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_start)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 363, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("yield_lines", 0, 4, 5, 2); __PYX_ERR(0, 297, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("yield_lines", 0, 4, 5, 2); __PYX_ERR(0, 363, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: - if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_collector)) != 0)) kw_args--; + if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_collector)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 363, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("yield_lines", 0, 4, 5, 3); __PYX_ERR(0, 297, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("yield_lines", 0, 4, 5, 3); __PYX_ERR(0, 363, __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--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_limit); + if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 363, __pyx_L3_error) } } 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 (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "yield_lines") < 0)) __PYX_ERR(0, 363, __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_Arg_FASTCALL(__pyx_args, 4); 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_Arg_FASTCALL(__pyx_args, 3); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } @@ -8222,15 +10710,23 @@ 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, 363, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(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, 363, __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 */ @@ -8238,6 +10734,12 @@ static PyObject *__pyx_pw_6hunter_6_event_1yield_lines(PyObject *__pyx_self, PyO __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -8246,14 +10748,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); 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, 363, __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 +10776,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, __pyx_codeobj__15, (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, 363, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; @@ -8281,7 +10786,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; @@ -8296,17 +10801,20 @@ static PyObject *__pyx_gb_6hunter_6_event_2generator(__pyx_CoroutineObject *__py 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; - Py_ssize_t __pyx_t_10; + Py_ssize_t __pyx_t_5; + PyObject *(*__pyx_t_6)(PyObject *); + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + Py_ssize_t __pyx_t_9; + int __pyx_t_10; int __pyx_t_11; + 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)); + __Pyx_TraceFrameInit(__pyx_codeobj__15) + __Pyx_TraceCall("yield_lines", __pyx_f[0], 363, 0, __PYX_ERR(0, 363, __pyx_L1_error)); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L7_resume_from_yield; @@ -8316,43 +10824,44 @@ static PyObject *__pyx_gb_6hunter_6_event_2generator(__pyx_CoroutineObject *__py return NULL; } __pyx_L3_first_run:; - if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 297, __pyx_L1_error) + if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 363, __pyx_L1_error) - /* "hunter/_event.pyx":299 + /* "hunter/_event.pyx":365 * 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(365,0,__PYX_ERR(0, 365, __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":366 * 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(366,0,__PYX_ERR(0, 366, __pyx_L1_error)) __pyx_cur_scope->__pyx_v_amount = 0; - /* "hunter/_event.pyx":301 + /* "hunter/_event.pyx":367 * 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_TraceLine(367,0,__PYX_ERR(0, 367, __pyx_L1_error)) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_getlines); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 367, __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))) { + #if CYTHON_UNPACK_METHODS + if (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); @@ -8362,221 +10871,223 @@ static PyObject *__pyx_gb_6hunter_6_event_2generator(__pyx_CoroutineObject *__py __pyx_t_4 = 1; } } - #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_3, __pyx_cur_scope->__pyx_v_filename, __pyx_cur_scope->__pyx_v_module_globals}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 2+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 367, __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_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_2 = PyNumber_Add(__pyx_cur_scope->__pyx_v_start, __pyx_cur_scope->__pyx_v_limit); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 367, __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_t_3 = __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_3)) __PYX_ERR(0, 367, __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; - 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; + if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { + __pyx_t_2 = __pyx_t_3; __Pyx_INCREF(__pyx_t_2); + __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_t_5 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 367, __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_6 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 367, __pyx_L1_error) } - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; for (;;) { - if (likely(!__pyx_t_7)) { + if (likely(!__pyx_t_6)) { if (likely(PyList_CheckExact(__pyx_t_2))) { - if (__pyx_t_6 >= PyList_GET_SIZE(__pyx_t_2)) break; + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 367, __pyx_L1_error) + #endif + if (__pyx_t_5 >= __pyx_temp) 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) + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely((0 < 0))) __PYX_ERR(0, 367, __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); + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 367, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); #endif } else { - if (__pyx_t_6 >= PyTuple_GET_SIZE(__pyx_t_2)) break; + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 367, __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_3 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely((0 < 0))) __PYX_ERR(0, 367, __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); + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 367, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); #endif } } else { - __pyx_t_5 = __pyx_t_7(__pyx_t_2); - if (unlikely(!__pyx_t_5)) { + __pyx_t_3 = __pyx_t_6(__pyx_t_2); + if (unlikely(!__pyx_t_3)) { 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) + else __PYX_ERR(0, 367, __pyx_L1_error) } break; } - __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_3); } __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_3); + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; - /* "hunter/_event.pyx":302 + /* "hunter/_event.pyx":368 * 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 '' */ - __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) { + __Pyx_TraceLine(368,0,__PYX_ERR(0, 368, __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":369 * 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_TraceLine(369,0,__PYX_ERR(0, 369, __pyx_L1_error)) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_LEADING_WHITESPACE_RE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 369, __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_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_findall); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 369, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_1)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_4 = 1; } } - __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; + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_cur_scope->__pyx_v_line}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 369, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_dedent); + __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_dedent, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; - /* "hunter/_event.pyx":304 + /* "hunter/_event.pyx":370 * 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(370,0,__PYX_ERR(0, 370, __pyx_L1_error)) + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_dedent); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 370, __pyx_L1_error) + if (__pyx_t_7) { + __pyx_t_8 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_dedent, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 370, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_3 = __pyx_t_8; + __pyx_t_8 = 0; } else { - __Pyx_INCREF(__pyx_kp_s_); - __pyx_t_5 = __pyx_kp_s_; + __Pyx_INCREF(__pyx_kp_s__7); + __pyx_t_3 = __pyx_kp_s__7; } __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_3); + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; - /* "hunter/_event.pyx":305 + /* "hunter/_event.pyx":371 * 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_cur_scope->__pyx_v_amount = __pyx_t_10; + __Pyx_TraceLine(371,0,__PYX_ERR(0, 371, __pyx_L1_error)) + __pyx_t_9 = PyObject_Length(__pyx_cur_scope->__pyx_v_dedent); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 371, __pyx_L1_error) + __pyx_cur_scope->__pyx_v_amount = __pyx_t_9; - /* "hunter/_event.pyx":302 + /* "hunter/_event.pyx":368 * 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":372 + * 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_TraceLine(372,0,__PYX_ERR(0, 372, __pyx_L1_error)) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_line, __pyx_n_s_startswith); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 372, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __pyx_t_1 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_1)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_4 = 1; } } - __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); + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_cur_scope->__pyx_v_dedent}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 372, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 372, __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, 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_10 = (!__pyx_t_7); + if (__pyx_t_10) { - /* "hunter/_event.pyx":307 + /* "hunter/_event.pyx":373 * 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(373,0,__PYX_ERR(0, 373, __pyx_L1_error)) goto __pyx_L5_break; - /* "hunter/_event.pyx":306 - * dedent = dedent[0] if dedent else "" + /* "hunter/_event.pyx":372 + * dedent = dedent[0] if dedent else '' * amount = len(dedent) * elif not line.startswith(dedent): # <<<<<<<<<<<<<< * break @@ -8585,33 +11096,36 @@ static PyObject *__pyx_gb_6hunter_6_event_2generator(__pyx_CoroutineObject *__py } __pyx_L6:; - /* "hunter/_event.pyx":308 + /* "hunter/_event.pyx":374 * 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(374,0,__PYX_ERR(0, 374, __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, 374, __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_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, 374, __pyx_L1_error) - /* "hunter/_event.pyx":309 + /* "hunter/_event.pyx":375 * 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_TraceLine(375,0,__PYX_ERR(0, 375, __pyx_L1_error)) + __pyx_t_3 = __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_3)) __PYX_ERR(0, 375, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 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_cur_scope->__pyx_t_1 = __pyx_t_5; + __pyx_cur_scope->__pyx_t_2 = __pyx_t_6; __Pyx_XGIVEREF(__pyx_r); __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); @@ -8623,24 +11137,28 @@ static PyObject *__pyx_gb_6hunter_6_event_2generator(__pyx_CoroutineObject *__py __pyx_t_2 = __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_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, 375, __pyx_L1_error) - /* "hunter/_event.pyx":301 + /* "hunter/_event.pyx":367 * 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(367,0,__PYX_ERR(0, 367, __pyx_L1_error)) } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + goto __pyx_L8_for_end; __pyx_L5_break:; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + goto __pyx_L8_for_end; + __pyx_L8_for_end:; CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); - /* "hunter/_event.pyx":297 + /* "hunter/_event.pyx":363 * * * def yield_lines(filename, module_globals, start, list collector, # <<<<<<<<<<<<<< @@ -8652,10 +11170,11 @@ static PyObject *__pyx_gb_6hunter_6_event_2generator(__pyx_CoroutineObject *__py PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; + __Pyx_Generator_Replace_StopIteration(0); __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("yield_lines", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; @@ -8669,2546 +11188,4368 @@ static PyObject *__pyx_gb_6hunter_6_event_2generator(__pyx_CoroutineObject *__py 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 +/* "hunter/_event.pyx":378 + * + * + * cdef inline Event fast_detach(Event self, object value_filter): # <<<<<<<<<<<<<< + * event = Event.__new__(Event) + * */ -/* 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; -} - -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; +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_TraceDeclarations __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; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("fast_detach", 1); + __Pyx_TraceCall("fast_detach", __pyx_f[0], 378, 0, __PYX_ERR(0, 378, __pyx_L1_error)); - /* "(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) + /* "hunter/_event.pyx":379 + * + * cdef inline Event fast_detach(Event self, object value_filter): + * event = Event.__new__(Event) # <<<<<<<<<<<<<< + * + * event._code = self.code_getter() */ - __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; + __Pyx_TraceLine(379,0,__PYX_ERR(0, 379, __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, 379, __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)":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: + /* "hunter/_event.pyx":381 + * event = Event.__new__(Event) + * + * event._code = self.code_getter() # <<<<<<<<<<<<<< + * event._filename = self.filename_getter() + * event._fullsource = self.fullsource_getter() */ - __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) + __Pyx_TraceLine(381,0,__PYX_ERR(0, 381, __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, 381, __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)":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":382 + * + * event._code = self.code_getter() + * event._filename = self.filename_getter() # <<<<<<<<<<<<<< + * event._fullsource = self.fullsource_getter() + * event._function_object = self._function_object */ - } + __Pyx_TraceLine(382,0,__PYX_ERR(0, 382, __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, 382, __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) + /* "hunter/_event.pyx":383 + * 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(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) + __Pyx_TraceLine(383,0,__PYX_ERR(0, 383, __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, 383, __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; + __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 - */ - __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; + /* "hunter/_event.pyx":384 + * 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(384,0,__PYX_ERR(0, 384, __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)":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":385 + * 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(385,0,__PYX_ERR(0, 385, __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, 385, __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)":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] + /* "hunter/_event.pyx":386 + * 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(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; + __Pyx_TraceLine(386,0,__PYX_ERR(0, 386, __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, 386, __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; - /* "(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":387 + * 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(387,0,__PYX_ERR(0, 387, __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, 387, __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_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":388 + * 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(388,0,__PYX_ERR(0, 388, __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, 388, __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; -/* "(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":389 + * 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(389,0,__PYX_ERR(0, 389, __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, 389, __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; -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":390 + * 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(390,0,__PYX_ERR(0, 390, __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, 390, __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; - /* "(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]) + /* "hunter/_event.pyx":391 + * event._stdlib = self.stdlib_getter() + * event._threadidn = self.threadid_getter() + * event._threadname = self.threadname_getter() # <<<<<<<<<<<<<< + * event._instruction = self.instruction_getter() + * */ - __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:; + __Pyx_TraceLine(391,0,__PYX_ERR(0, 391, __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, 391, __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":392 + * event._threadidn = self.threadid_getter() + * event._threadname = self.threadname_getter() + * event._instruction = self.instruction_getter() # <<<<<<<<<<<<<< + * + * if value_filter: + */ + __Pyx_TraceLine(392,0,__PYX_ERR(0, 392, __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, 392, __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":394 + * 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(394,0,__PYX_ERR(0, 394, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_value_filter); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 394, __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]) # <<<<<<<<<<<<<< + /* "hunter/_event.pyx":395 + * + * 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(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_TraceLine(395,0,__PYX_ERR(0, 395, __pyx_L1_error)) + { /* enter inner scope */ + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 395, __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, 395, __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, 395, __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, 395, __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, 395, __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; + __pyx_t_9 = 0; + #if CYTHON_UNPACK_METHODS + if (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_9 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_7genexpr__pyx_v_value}; + __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+1-__pyx_t_9, 1+__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 395, __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, 395, __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":396 + * 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(396,0,__PYX_ERR(0, 396, __pyx_L1_error)) + { /* enter inner scope */ + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 396, __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, 396, __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, 396, __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, 396, __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, 396, __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; + __pyx_t_9 = 0; + #if CYTHON_UNPACK_METHODS + if (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_9 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_8genexpr1__pyx_v_value}; + __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+1-__pyx_t_9, 1+__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 396, __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, 396, __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":397 + * 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(397,0,__PYX_ERR(0, 397, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_value_filter); + __pyx_t_1 = __pyx_v_value_filter; __pyx_t_7 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (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_8, function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_6 = 1; } } - __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; + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_v_self->arg}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 397, __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; - /* "(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]) + /* "hunter/_event.pyx":394 + * 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":399 + * event.arg = value_filter(self.arg) + * else: + * event._globals = {} # <<<<<<<<<<<<<< + * event._locals = {} + * event.arg = None */ + __Pyx_TraceLine(399,0,__PYX_ERR(0, 399, __pyx_L1_error)) + /*else*/ { + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 399, __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); - 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._event.__pyx_unpickle_Event__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; -} -static struct __pyx_vtabstruct_6hunter_6_event_Event __pyx_vtable_6hunter_6_event_Event; + /* "hunter/_event.pyx":400 + * else: + * event._globals = {} + * event._locals = {} # <<<<<<<<<<<<<< + * event.arg = None + * + */ + __Pyx_TraceLine(400,0,__PYX_ERR(0, 400, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 400, __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; -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); - p->_locals = Py_None; Py_INCREF(Py_None); - p->_module = Py_None; Py_INCREF(Py_None); - p->_source = Py_None; Py_INCREF(Py_None); - p->_stdlib = Py_None; Py_INCREF(Py_None); - p->_thread = Py_None; Py_INCREF(Py_None); - p->_threadidn = Py_None; Py_INCREF(Py_None); - p->_threadname = Py_None; Py_INCREF(Py_None); - return o; -} - -static void __pyx_tp_dealloc_6hunter_6_event_Event(PyObject *o) { - struct __pyx_obj_6hunter_6_event_Event *p = (struct __pyx_obj_6hunter_6_event_Event *)o; - PyObject_GC_UnTrack(o); - Py_CLEAR(p->frame); - Py_CLEAR(p->kind); - Py_CLEAR(p->arg); - Py_CLEAR(p->_code); - Py_CLEAR(p->_filename); - Py_CLEAR(p->_fullsource); - Py_CLEAR(p->_function); - Py_CLEAR(p->_function_object); - Py_CLEAR(p->_globals); - Py_CLEAR(p->_lineno); - Py_CLEAR(p->_locals); - Py_CLEAR(p->_module); - Py_CLEAR(p->_source); - Py_CLEAR(p->_stdlib); - Py_CLEAR(p->_thread); - Py_CLEAR(p->_threadidn); - Py_CLEAR(p->_threadname); - (*Py_TYPE(o)->tp_free)(o); -} - -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; - 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->_code) { - e = (*v)(p->_code, a); if (e) return e; - } - if (p->_filename) { - e = (*v)(p->_filename, a); if (e) return e; - } - if (p->_fullsource) { - e = (*v)(p->_fullsource, a); if (e) return e; - } - if (p->_function) { - e = (*v)(p->_function, a); if (e) return e; - } - if (p->_function_object) { - e = (*v)(p->_function_object, a); if (e) return e; - } - if (p->_globals) { - e = (*v)(p->_globals, a); if (e) return e; - } - if (p->_lineno) { - e = (*v)(p->_lineno, a); if (e) return e; - } - if (p->_locals) { - e = (*v)(p->_locals, a); if (e) return e; - } - if (p->_module) { - e = (*v)(p->_module, a); if (e) return e; - } - if (p->_source) { - e = (*v)(p->_source, a); if (e) return e; - } - if (p->_stdlib) { - e = (*v)(p->_stdlib, a); if (e) return e; - } - if (p->_thread) { - e = (*v)(p->_thread, a); if (e) return e; - } - if (p->_threadidn) { - e = (*v)(p->_threadidn, a); if (e) return e; - } - if (p->_threadname) { - e = (*v)(p->_threadname, a); if (e) return e; + /* "hunter/_event.pyx":401 + * event._globals = {} + * event._locals = {} + * event.arg = None # <<<<<<<<<<<<<< + * + * event.builtin = self.builtin + */ + __Pyx_TraceLine(401,0,__PYX_ERR(0, 401, __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; } - return 0; -} - -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); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->arg); - p->arg = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->_code); - p->_code = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->_filename); - p->_filename = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->_fullsource); - p->_fullsource = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->_function); - p->_function = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->_function_object); - p->_function_object = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->_globals); - p->_globals = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->_lineno); - p->_lineno = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->_locals); - p->_locals = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->_module); - p->_module = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->_source); - p->_source = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->_stdlib); - p->_stdlib = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->_thread); - p->_thread = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->_threadidn); - p->_threadidn = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->_threadname); - p->_threadname = 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; - r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); - Py_DECREF(x); - return r; -} + __pyx_L3:; -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); -} + /* "hunter/_event.pyx":403 + * event.arg = None + * + * event.builtin = self.builtin # <<<<<<<<<<<<<< + * event.calls = self.calls + * event.depth = self.depth + */ + __Pyx_TraceLine(403,0,__PYX_ERR(0, 403, __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; -static PyObject *__pyx_getprop_6hunter_6_event_5Event_threadname(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_6_event_5Event_10threadname_1__get__(o); -} + /* "hunter/_event.pyx":404 + * + * event.builtin = self.builtin + * event.calls = self.calls # <<<<<<<<<<<<<< + * event.depth = self.depth + * event.detached = True + */ + __Pyx_TraceLine(404,0,__PYX_ERR(0, 404, __pyx_L1_error)) + __pyx_t_6 = __pyx_v_self->calls; + __pyx_v_event->calls = __pyx_t_6; -static PyObject *__pyx_getprop_6hunter_6_event_5Event_locals(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_6_event_5Event_6locals_1__get__(o); -} + /* "hunter/_event.pyx":405 + * event.builtin = self.builtin + * event.calls = self.calls + * event.depth = self.depth # <<<<<<<<<<<<<< + * event.detached = True + * event.kind = self.kind + */ + __Pyx_TraceLine(405,0,__PYX_ERR(0, 405, __pyx_L1_error)) + __pyx_t_6 = __pyx_v_self->depth; + __pyx_v_event->depth = __pyx_t_6; -static PyObject *__pyx_getprop_6hunter_6_event_5Event_globals(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_6_event_5Event_7globals_1__get__(o); -} + /* "hunter/_event.pyx":406 + * event.calls = self.calls + * event.depth = self.depth + * event.detached = True # <<<<<<<<<<<<<< + * event.kind = self.kind + * event.threading_support = self.threading_support + */ + __Pyx_TraceLine(406,0,__PYX_ERR(0, 406, __pyx_L1_error)) + __pyx_v_event->detached = 1; -static PyObject *__pyx_getprop_6hunter_6_event_5Event_function(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_6_event_5Event_8function_1__get__(o); -} + /* "hunter/_event.pyx":407 + * event.depth = self.depth + * event.detached = True + * event.kind = self.kind # <<<<<<<<<<<<<< + * event.threading_support = self.threading_support + * + */ + __Pyx_TraceLine(407,0,__PYX_ERR(0, 407, __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; -static PyObject *__pyx_getprop_6hunter_6_event_5Event_function_object(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_6_event_5Event_15function_object_1__get__(o); -} + /* "hunter/_event.pyx":408 + * event.detached = True + * event.kind = self.kind + * event.threading_support = self.threading_support # <<<<<<<<<<<<<< + * + * return event + */ + __Pyx_TraceLine(408,0,__PYX_ERR(0, 408, __pyx_L1_error)) + __pyx_t_3 = __pyx_v_self->threading_support; + __pyx_v_event->threading_support = __pyx_t_3; -static PyObject *__pyx_getprop_6hunter_6_event_5Event_module(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_6_event_5Event_6module_1__get__(o); -} + /* "hunter/_event.pyx":410 + * event.threading_support = self.threading_support + * + * return event # <<<<<<<<<<<<<< + * + * cdef inline Event fast_clone(Event self): + */ + __Pyx_TraceLine(410,0,__PYX_ERR(0, 410, __pyx_L1_error)) + __Pyx_XDECREF((PyObject *)__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_event); + __pyx_r = __pyx_v_event; + goto __pyx_L0; -static PyObject *__pyx_getprop_6hunter_6_event_5Event_filename(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_6_event_5Event_8filename_1__get__(o); -} + /* "hunter/_event.pyx":378 + * + * + * cdef inline Event fast_detach(Event self, object value_filter): # <<<<<<<<<<<<<< + * event = Event.__new__(Event) + * + */ -static PyObject *__pyx_getprop_6hunter_6_event_5Event_lineno(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_6_event_5Event_6lineno_1__get__(o); + /* 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.fast_detach", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __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((PyObject *)__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -static PyObject *__pyx_getprop_6hunter_6_event_5Event_code(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_6_event_5Event_4code_1__get__(o); -} +/* "hunter/_event.pyx":412 + * return event + * + * cdef inline Event fast_clone(Event self): # <<<<<<<<<<<<<< + * event = Event.__new__(Event) + * event.arg = self.arg + */ -static PyObject *__pyx_getprop_6hunter_6_event_5Event_stdlib(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_6_event_5Event_6stdlib_1__get__(o); -} +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_TraceDeclarations + __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_RefNannySetupContext("fast_clone", 1); + __Pyx_TraceCall("fast_clone", __pyx_f[0], 412, 0, __PYX_ERR(0, 412, __pyx_L1_error)); -static PyObject *__pyx_getprop_6hunter_6_event_5Event_fullsource(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_6_event_5Event_10fullsource_1__get__(o); -} + /* "hunter/_event.pyx":413 + * + * cdef inline Event fast_clone(Event self): + * event = Event.__new__(Event) # <<<<<<<<<<<<<< + * event.arg = self.arg + * event.builtin = self.builtin + */ + __Pyx_TraceLine(413,0,__PYX_ERR(0, 413, __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, 413, __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; -static PyObject *__pyx_getprop_6hunter_6_event_5Event_source(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_6_event_5Event_6source_1__get__(o); -} + /* "hunter/_event.pyx":414 + * 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(414,0,__PYX_ERR(0, 414, __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; -static PyObject *__pyx_getprop_6hunter_6_event_5Event_frame(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_6_event_5Event_5frame_1__get__(o); -} + /* "hunter/_event.pyx":415 + * event = Event.__new__(Event) + * event.arg = self.arg + * event.builtin = self.builtin # <<<<<<<<<<<<<< + * event.calls = self.calls + * event.depth = self.depth + */ + __Pyx_TraceLine(415,0,__PYX_ERR(0, 415, __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; -static PyObject *__pyx_getprop_6hunter_6_event_5Event_kind(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_6_event_5Event_4kind_1__get__(o); -} + /* "hunter/_event.pyx":416 + * event.arg = self.arg + * event.builtin = self.builtin + * event.calls = self.calls # <<<<<<<<<<<<<< + * event.depth = self.depth + * event.detached = False + */ + __Pyx_TraceLine(416,0,__PYX_ERR(0, 416, __pyx_L1_error)) + __pyx_t_3 = __pyx_v_self->calls; + __pyx_v_event->calls = __pyx_t_3; -static PyObject *__pyx_getprop_6hunter_6_event_5Event_arg(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_6_event_5Event_3arg_1__get__(o); -} + /* "hunter/_event.pyx":417 + * event.builtin = self.builtin + * event.calls = self.calls + * event.depth = self.depth # <<<<<<<<<<<<<< + * event.detached = False + * event.frame = self.frame + */ + __Pyx_TraceLine(417,0,__PYX_ERR(0, 417, __pyx_L1_error)) + __pyx_t_3 = __pyx_v_self->depth; + __pyx_v_event->depth = __pyx_t_3; -static PyObject *__pyx_getprop_6hunter_6_event_5Event_depth(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_6_event_5Event_5depth_1__get__(o); -} + /* "hunter/_event.pyx":418 + * event.calls = self.calls + * event.depth = self.depth + * event.detached = False # <<<<<<<<<<<<<< + * event.frame = self.frame + * event.kind = self.kind + */ + __Pyx_TraceLine(418,0,__PYX_ERR(0, 418, __pyx_L1_error)) + __pyx_v_event->detached = 0; -static PyObject *__pyx_getprop_6hunter_6_event_5Event_calls(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_6_event_5Event_5calls_1__get__(o); -} + /* "hunter/_event.pyx":419 + * event.depth = self.depth + * event.detached = False + * event.frame = self.frame # <<<<<<<<<<<<<< + * event.kind = self.kind + * event.threading_support = self.threading_support + */ + __Pyx_TraceLine(419,0,__PYX_ERR(0, 419, __pyx_L1_error)) + __pyx_t_2 = ((PyObject *)__pyx_v_self->frame); + __Pyx_INCREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF((PyObject *)__pyx_v_event->frame); + __Pyx_DECREF((PyObject *)__pyx_v_event->frame); + __pyx_v_event->frame = ((PyFrameObject *)__pyx_t_2); + __pyx_t_2 = 0; -static PyObject *__pyx_getprop_6hunter_6_event_5Event_threading_support(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_6_event_5Event_17threading_support_1__get__(o); -} + /* "hunter/_event.pyx":420 + * event.detached = False + * event.frame = self.frame + * event.kind = self.kind # <<<<<<<<<<<<<< + * event.threading_support = self.threading_support + * event._code = self._code + */ + __Pyx_TraceLine(420,0,__PYX_ERR(0, 420, __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; -static PyObject *__pyx_getprop_6hunter_6_event_5Event_detached(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_6_event_5Event_8detached_1__get__(o); -} + /* "hunter/_event.pyx":421 + * event.frame = self.frame + * event.kind = self.kind + * event.threading_support = self.threading_support # <<<<<<<<<<<<<< + * event._code = self._code + * event._filename = self._filename + */ + __Pyx_TraceLine(421,0,__PYX_ERR(0, 421, __pyx_L1_error)) + __pyx_t_4 = __pyx_v_self->threading_support; + __pyx_v_event->threading_support = __pyx_t_4; -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}, - {0, 0, 0, 0} -}; + /* "hunter/_event.pyx":422 + * event.kind = self.kind + * event.threading_support = self.threading_support + * event._code = self._code # <<<<<<<<<<<<<< + * event._filename = self._filename + * event._fullsource = self._fullsource + */ + __Pyx_TraceLine(422,0,__PYX_ERR(0, 422, __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; -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}, - {0, 0, 0, 0, 0} -}; + /* "hunter/_event.pyx":423 + * 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(423,0,__PYX_ERR(0, 423, __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; -static PySequenceMethods __pyx_tp_as_sequence_Event = { - 0, /*sq_length*/ - 0, /*sq_concat*/ - 0, /*sq_repeat*/ - __pyx_sq_item_6hunter_6_event_Event, /*sq_item*/ - 0, /*sq_slice*/ - 0, /*sq_ass_item*/ - 0, /*sq_ass_slice*/ - 0, /*sq_contains*/ - 0, /*sq_inplace_concat*/ - 0, /*sq_inplace_repeat*/ -}; + /* "hunter/_event.pyx":424 + * event._code = self._code + * event._filename = self._filename + * event._fullsource = self._fullsource # <<<<<<<<<<<<<< + * event._function_object = self._function_object + * event._function = self._function + */ + __Pyx_TraceLine(424,0,__PYX_ERR(0, 424, __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; -static PyMappingMethods __pyx_tp_as_mapping_Event = { - 0, /*mp_length*/ - __pyx_pw_6hunter_6_event_5Event_5__getitem__, /*mp_subscript*/ - 0, /*mp_ass_subscript*/ -}; + /* "hunter/_event.pyx":425 + * event._filename = self._filename + * event._fullsource = self._fullsource + * event._function_object = self._function_object # <<<<<<<<<<<<<< + * event._function = self._function + * event._globals = self._globals + */ + __Pyx_TraceLine(425,0,__PYX_ERR(0, 425, __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; -static PyTypeObject __pyx_type_6hunter_6_event_Event = { - PyVarObject_HEAD_INIT(0, 0) - "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*/ - #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*/ - &__pyx_tp_as_sequence_Event, /*tp_as_sequence*/ - &__pyx_tp_as_mapping_Event, /*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*/ - "\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*/ - __pyx_tp_traverse_6hunter_6_event_Event, /*tp_traverse*/ - __pyx_tp_clear_6hunter_6_event_Event, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - __pyx_methods_6hunter_6_event_Event, /*tp_methods*/ - 0, /*tp_members*/ - __pyx_getsets_6hunter_6_event_Event, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - __pyx_pw_6hunter_6_event_5Event_1__init__, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_6hunter_6_event_Event, /*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/_event.pyx":426 + * event._fullsource = self._fullsource + * event._function_object = self._function_object + * event._function = self._function # <<<<<<<<<<<<<< + * event._globals = self._globals + * event._lineno = self._lineno + */ + __Pyx_TraceLine(426,0,__PYX_ERR(0, 426, __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; -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; + /* "hunter/_event.pyx":427 + * event._function_object = self._function_object + * event._function = self._function + * event._globals = self._globals # <<<<<<<<<<<<<< + * event._lineno = self._lineno + * event._locals = self._locals + */ + __Pyx_TraceLine(427,0,__PYX_ERR(0, 427, __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; -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]; - 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 { - o = (*t->tp_alloc)(t, 0); - if (unlikely(!o)) return 0; - } - return o; -} + /* "hunter/_event.pyx":428 + * event._function = self._function + * event._globals = self._globals + * event._lineno = self._lineno # <<<<<<<<<<<<<< + * event._locals = self._locals + * event._module = self._module + */ + __Pyx_TraceLine(428,0,__PYX_ERR(0, 428, __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; -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; - PyObject_GC_UnTrack(o); - Py_CLEAR(p->__pyx_v_collector); - Py_CLEAR(p->__pyx_v_dedent); - Py_CLEAR(p->__pyx_v_filename); - Py_CLEAR(p->__pyx_v_limit); - Py_CLEAR(p->__pyx_v_line); - 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 { - (*Py_TYPE(o)->tp_free)(o); - } -} - -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; - if (p->__pyx_v_collector) { - e = (*v)(p->__pyx_v_collector, a); if (e) return e; - } - if (p->__pyx_v_dedent) { - e = (*v)(p->__pyx_v_dedent, a); if (e) return e; - } - if (p->__pyx_v_filename) { - e = (*v)(p->__pyx_v_filename, a); if (e) return e; - } - if (p->__pyx_v_limit) { - e = (*v)(p->__pyx_v_limit, a); if (e) return e; - } - if (p->__pyx_v_line) { - e = (*v)(p->__pyx_v_line, a); if (e) return e; - } - if (p->__pyx_v_module_globals) { - e = (*v)(p->__pyx_v_module_globals, a); if (e) return e; - } - if (p->__pyx_v_start) { - e = (*v)(p->__pyx_v_start, a); if (e) return e; - } - if (p->__pyx_t_0) { - e = (*v)(p->__pyx_t_0, a); if (e) return e; - } - return 0; -} - -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*/ - 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*/ - #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_6_event___pyx_scope_struct__yield_lines, /*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_6_event___pyx_scope_struct__yield_lines, /*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 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 */ - #endif - __pyx_methods /* m_methods */, - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_moduledef_slots, /* m_slots */ - #else - NULL, /* m_reload */ - #endif - NULL, /* m_traverse */ - NULL, /* m_clear */ - NULL /* m_free */ -}; -#endif -#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 + /* "hunter/_event.pyx":429 + * event._globals = self._globals + * event._lineno = self._lineno + * event._locals = self._locals # <<<<<<<<<<<<<< + * event._module = self._module + * event._source = self._source + */ + __Pyx_TraceLine(429,0,__PYX_ERR(0, 429, __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; -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 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; -} + /* "hunter/_event.pyx":430 + * event._lineno = self._lineno + * event._locals = self._locals + * event._module = self._module # <<<<<<<<<<<<<< + * event._source = self._source + * event._stdlib = self._stdlib + */ + __Pyx_TraceLine(430,0,__PYX_ERR(0, 430, __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; -static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + /* "hunter/_event.pyx":431 + * event._locals = self._locals + * event._module = self._module + * event._source = self._source # <<<<<<<<<<<<<< + * event._stdlib = self._stdlib + * event._threadidn = self._threadidn + */ + __Pyx_TraceLine(431,0,__PYX_ERR(0, 431, __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":195 - * def module(self): - * if self._module is UNSET: - * module = self.frame.f_globals.get('__name__', '') # <<<<<<<<<<<<<< - * if module is None: - * module = '' + /* "hunter/_event.pyx":432 + * event._module = self._module + * event._source = self._source + * event._stdlib = self._stdlib # <<<<<<<<<<<<<< + * event._threadidn = self._threadidn + * event._threadname = self._threadname */ - __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); + __Pyx_TraceLine(432,0,__PYX_ERR(0, 432, __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":210 - * if not filename: - * filename = '' - * elif filename.endswith(('.pyc', '.pyo')): # <<<<<<<<<<<<<< - * filename = filename[:-1] - * elif filename.endswith(('.so', '.pyd')): + /* "hunter/_event.pyx":433 + * event._source = self._source + * event._stdlib = self._stdlib + * event._threadidn = self._threadidn # <<<<<<<<<<<<<< + * event._threadname = self._threadname + * event._thread = self._thread */ - __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); + __Pyx_TraceLine(433,0,__PYX_ERR(0, 433, __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":211 - * filename = '' - * elif filename.endswith(('.pyc', '.pyo')): - * filename = filename[:-1] # <<<<<<<<<<<<<< - * elif filename.endswith(('.so', '.pyd')): - * basename = CYTHON_SUFFIX_RE.sub('', filename) + /* "hunter/_event.pyx":434 + * event._stdlib = self._stdlib + * event._threadidn = self._threadidn + * event._threadname = self._threadname # <<<<<<<<<<<<<< + * event._thread = self._thread + * event._instruction = self._instruction */ - __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); + __Pyx_TraceLine(434,0,__PYX_ERR(0, 434, __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":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'): + /* "hunter/_event.pyx":435 + * event._threadidn = self._threadidn + * event._threadname = self._threadname + * event._thread = self._thread # <<<<<<<<<<<<<< + * event._instruction = self._instruction + * return event */ - __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); + __Pyx_TraceLine(435,0,__PYX_ERR(0, 435, __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":214 - * elif filename.endswith(('.so', '.pyd')): - * basename = CYTHON_SUFFIX_RE.sub('', filename) - * for ext in ('.pyx', '.py'): # <<<<<<<<<<<<<< - * cyfilename = basename + ext - * if exists(cyfilename): + /* "hunter/_event.pyx":436 + * event._threadname = self._threadname + * event._thread = self._thread + * event._instruction = self._instruction # <<<<<<<<<<<<<< + * return event */ - __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); + __Pyx_TraceLine(436,0,__PYX_ERR(0, 436, __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":24 - * from .util import if_same_code - * - * __all__ = 'Event', # <<<<<<<<<<<<<< - * - * cdef object UNSET = object() + /* "hunter/_event.pyx":437 + * event._thread = self._thread + * event._instruction = self._instruction + * return event # <<<<<<<<<<<<<< */ - __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); + __Pyx_TraceLine(437,0,__PYX_ERR(0, 437, __pyx_L1_error)) + __Pyx_XDECREF((PyObject *)__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_event); + __pyx_r = __pyx_v_event; + goto __pyx_L0; - /* "hunter/_event.pyx":297 - * + /* "hunter/_event.pyx":412 + * return event * - * def yield_lines(filename, module_globals, start, list collector, # <<<<<<<<<<<<<< - * limit=10): - * dedent = None + * cdef inline Event fast_clone(Event self): # <<<<<<<<<<<<<< + * event = Event.__new__(Event) + * event.arg = self.arg */ - __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; + /* function exit code */ __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __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_TraceReturn(__pyx_r, 0); __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; + return __pyx_r; } +static struct __pyx_vtabstruct_6hunter_6_event_Event __pyx_vtable_6hunter_6_event_Event; -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 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 = ((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->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); + p->_stdlib = Py_None; Py_INCREF(Py_None); + 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; +} -static int __Pyx_modinit_global_init_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); - /*--- Global init code ---*/ - __pyx_v_6hunter_6_event_UNSET = Py_None; Py_INCREF(Py_None); - __Pyx_RefNannyFinishContext(); - return 0; +static void __pyx_tp_dealloc_6hunter_6_event_Event(PyObject *o) { + struct __pyx_obj_6hunter_6_event_Event *p = (struct __pyx_obj_6hunter_6_event_Event *)o; + PyObject_GC_UnTrack(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); + Py_CLEAR(p->_function); + Py_CLEAR(p->_function_object); + Py_CLEAR(p->_globals); + Py_CLEAR(p->_lineno); + Py_CLEAR(p->_locals); + Py_CLEAR(p->_module); + Py_CLEAR(p->_source); + Py_CLEAR(p->_stdlib); + Py_CLEAR(p->_thread); + Py_CLEAR(p->_threadidn); + Py_CLEAR(p->_threadname); + Py_CLEAR(p->_instruction); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*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_modinit_variable_export_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); - /*--- Variable export code ---*/ - __Pyx_RefNannyFinishContext(); +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; + 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; + } + if (p->_filename) { + e = (*v)(p->_filename, a); if (e) return e; + } + if (p->_fullsource) { + e = (*v)(p->_fullsource, a); if (e) return e; + } + if (p->_function) { + e = (*v)(p->_function, a); if (e) return e; + } + if (p->_function_object) { + e = (*v)(p->_function_object, a); if (e) return e; + } + if (p->_globals) { + e = (*v)(p->_globals, a); if (e) return e; + } + if (p->_lineno) { + e = (*v)(p->_lineno, a); if (e) return e; + } + if (p->_locals) { + e = (*v)(p->_locals, a); if (e) return e; + } + if (p->_module) { + e = (*v)(p->_module, a); if (e) return e; + } + if (p->_source) { + e = (*v)(p->_source, a); if (e) return e; + } + if (p->_stdlib) { + e = (*v)(p->_stdlib, a); if (e) return e; + } + if (p->_thread) { + e = (*v)(p->_thread, a); if (e) return e; + } + if (p->_threadidn) { + e = (*v)(p->_threadidn, a); if (e) return e; + } + 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; } -static int __Pyx_modinit_function_export_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); - /*--- Function export code ---*/ - __Pyx_RefNannyFinishContext(); +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); + 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); + tmp = ((PyObject*)p->_filename); + p->_filename = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_fullsource); + p->_fullsource = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_function); + p->_function = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_function_object); + p->_function_object = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_globals); + p->_globals = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_lineno); + p->_lineno = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_locals); + p->_locals = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_module); + p->_module = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_source); + p->_source = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_stdlib); + p->_stdlib = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_thread); + p->_thread = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_threadidn); + p->_threadidn = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + 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; + r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); + Py_DECREF(x); + return r; +} -static int __Pyx_modinit_type_init_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); - /*--- Type init code ---*/ - __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; +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); + } } - __pyx_ptype_6hunter_6_event___pyx_scope_struct__yield_lines = &__pyx_type_6hunter_6_event___pyx_scope_struct__yield_lines; - __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_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_RefNannyFinishContext(); - return -1; +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 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 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); } -static int __Pyx_modinit_function_import_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); - /*--- Function import code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; +static PyObject *__pyx_getprop_6hunter_6_event_5Event_threadname(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_6_event_5Event_10threadname_1__get__(o); } +static PyObject *__pyx_getprop_6hunter_6_event_5Event_locals(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_6_event_5Event_6locals_1__get__(o); +} -#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 +static PyObject *__pyx_getprop_6hunter_6_event_5Event_globals(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_6_event_5Event_7globals_1__get__(o); +} +static PyObject *__pyx_getprop_6hunter_6_event_5Event_function(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_6_event_5Event_8function_1__get__(o); +} -#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); +static PyObject *__pyx_getprop_6hunter_6_event_5Event_function_object(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_6_event_5Event_15function_object_1__get__(o); } -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 PyObject *__pyx_getprop_6hunter_6_event_5Event_module(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_6_event_5Event_6module_1__get__(o); } -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 PyObject *__pyx_getprop_6hunter_6_event_5Event_filename(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_6_event_5Event_8filename_1__get__(o); } -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 PyObject *__pyx_getprop_6hunter_6_event_5Event_lineno(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_6_event_5Event_6lineno_1__get__(o); } +static PyObject *__pyx_getprop_6hunter_6_event_5Event_code(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_6_event_5Event_4code_1__get__(o); +} -static CYTHON_SMALL_CODE int __pyx_pymod_exec__event(PyObject *__pyx_pyinit_module) -#endif -#endif -{ - __Pyx_TraceDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - __Pyx_RefNannyDeclarations - #if CYTHON_PEP489_MULTI_PHASE_INIT - if (__pyx_m) { - if (__pyx_m == __pyx_pyinit_module) return 0; - PyErr_SetString(PyExc_RuntimeError, "Module '_event' 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"); +static PyObject *__pyx_getprop_6hunter_6_event_5Event_stdlib(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_6_event_5Event_6stdlib_1__get__(o); } -#endif - __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit__event(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("_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 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) - } - } - #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(); - (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(); - /*--- 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)); - /* "hunter/_event.pyx":2 - * # cython: linetrace=True, language_level=3str - * 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_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_DECREF(__pyx_t_2); __pyx_t_2 = 0; +static PyObject *__pyx_getprop_6hunter_6_event_5Event_fullsource(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_6_event_5Event_10fullsource_1__get__(o); +} - /* "hunter/_event.pyx":3 - * # cython: linetrace=True, language_level=3str - * 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_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_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; +static PyObject *__pyx_getprop_6hunter_6_event_5Event_source(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_6_event_5Event_6source_1__get__(o); +} - /* "hunter/_event.pyx":4 - * 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_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_DECREF(__pyx_t_2); __pyx_t_2 = 0; +static PyObject *__pyx_getprop_6hunter_6_event_5Event_frame(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_6_event_5Event_5frame_1__get__(o); +} - /* "hunter/_event.pyx":5 - * 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_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_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; +static PyObject *__pyx_getprop_6hunter_6_event_5Event_kind(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_6_event_5Event_4kind_1__get__(o); +} - /* "hunter/_event.pyx":6 - * 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_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_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "hunter/_event.pyx":7 - * 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_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_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "hunter/_event.pyx":8 - * 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_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_DECREF(__pyx_t_2); __pyx_t_2 = 0; +static PyObject *__pyx_getprop_6hunter_6_event_5Event_arg(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_6_event_5Event_3arg_1__get__(o); +} - /* "hunter/_event.pyx":9 - * 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_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_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; +static PyObject *__pyx_getprop_6hunter_6_event_5Event_depth(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_6_event_5Event_5depth_1__get__(o); +} - /* "hunter/_event.pyx":10 - * 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_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_DECREF(__pyx_t_2); __pyx_t_2 = 0; +static PyObject *__pyx_getprop_6hunter_6_event_5Event_calls(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_6_event_5Event_5calls_1__get__(o); +} - /* "hunter/_event.pyx":16 - * from ._tracer cimport Tracer - * - * 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_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_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; +static PyObject *__pyx_getprop_6hunter_6_event_5Event_threading_support(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_6_event_5Event_17threading_support_1__get__(o); +} - /* "hunter/_event.pyx":17 - * - * 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_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_DECREF(__pyx_t_2); __pyx_t_2 = 0; +static PyObject *__pyx_getprop_6hunter_6_event_5Event_detached(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_6_event_5Event_8detached_1__get__(o); +} - /* "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 - * 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_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_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; +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); +} - /* "hunter/_event.pyx":19 - * 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_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_DECREF(__pyx_t_2); __pyx_t_2 = 0; +static PyObject *__pyx_specialmethod___pyx_pw_6hunter_6_event_5Event_3__repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + return __pyx_pw_6hunter_6_event_5Event_3__repr__(self); +} - /* "hunter/_event.pyx":20 - * 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_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_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; +static PyMethodDef __pyx_methods_6hunter_6_event_Event[] = { + {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_pw_6hunter_6_event_5Event_3__repr__, METH_NOARGS|METH_COEXIST, 0}, + {"detach", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_6_event_5Event_7detach, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"clone", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_6_event_5Event_9clone, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; - /* "hunter/_event.pyx":21 - * 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_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_DECREF(__pyx_t_2); __pyx_t_2 = 0; +static struct PyGetSetDef __pyx_getsets_6hunter_6_event_Event[] = { + {(char *)"instruction", __pyx_getprop_6hunter_6_event_5Event_instruction, 0, (char *)0, 0}, + {(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}, + {(char *)"builtin", __pyx_getprop_6hunter_6_event_5Event_builtin, 0, (char *)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 tracer (:class:`hunter.tracer.Tracer`): The :class:`~hunter.tracer.Tracer` instance that created the event.\n Needed for the ``calls`` and ``depth`` fields.\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 - /* "hunter/_event.pyx":22 - * 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_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_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; +static PySequenceMethods __pyx_tp_as_sequence_Event = { + 0, /*sq_length*/ + 0, /*sq_concat*/ + 0, /*sq_repeat*/ + __pyx_sq_item_6hunter_6_event_Event, /*sq_item*/ + 0, /*sq_slice*/ + 0, /*sq_ass_item*/ + 0, /*sq_ass_slice*/ + 0, /*sq_contains*/ + 0, /*sq_inplace_concat*/ + 0, /*sq_inplace_repeat*/ +}; - /* "hunter/_event.pyx":24 - * 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) - - /* "hunter/_event.pyx":26 - * __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_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; - - /* "hunter/_event.pyx":100 - * return event - * - * cdef inline Event clone(self): # <<<<<<<<<<<<<< - * event = Event.__new__(Event) - * event.arg = self.arg - */ - __Pyx_TraceLine(100,0,__PYX_ERR(0, 100, __pyx_L1_error)) - - - /* "hunter/_event.pyx":297 - * - * - * 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; - - /* "(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; - - /* "(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)) +static PyMappingMethods __pyx_tp_as_mapping_Event = { + 0, /*mp_length*/ + __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*/ + sizeof(struct __pyx_obj_6hunter_6_event_Event), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6hunter_6_event_Event, /*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_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*/ + 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*/ + 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 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*/ + __pyx_tp_traverse_6hunter_6_event_Event, /*tp_traverse*/ + __pyx_tp_clear_6hunter_6_event_Event, /*tp_clear*/ + __pyx_tp_richcompare_6hunter_6_event_Event, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_6hunter_6_event_Event, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_6hunter_6_event_Event, /*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_6_event_5Event_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6hunter_6_event_Event, /*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 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #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 CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif - /* "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); +#if CYTHON_USE_FREELISTS +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 - /*--- Wrapped vars code ---*/ +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_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_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_freelist_6hunter_6_event___pyx_scope_struct__yield_lines[--__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 + #endif + { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + #endif + return o; +} - 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._event", __pyx_clineno, __pyx_lineno, __pyx_filename); +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; } - Py_CLEAR(__pyx_m); - } else if (!PyErr_Occurred()) { - PyErr_SetString(PyExc_ImportError, "init hunter._event"); } - __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 + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_v_collector); + Py_CLEAR(p->__pyx_v_dedent); + Py_CLEAR(p->__pyx_v_filename); + Py_CLEAR(p->__pyx_v_limit); + Py_CLEAR(p->__pyx_v_line); + Py_CLEAR(p->__pyx_v_module_globals); + Py_CLEAR(p->__pyx_v_start); + Py_CLEAR(p->__pyx_t_0); + #if CYTHON_USE_FREELISTS + if (((int)(__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_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 + #endif + { + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*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 + } } -/* --- 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; +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; + if (p->__pyx_v_collector) { + e = (*v)(p->__pyx_v_collector, a); if (e) return e; + } + if (p->__pyx_v_dedent) { + e = (*v)(p->__pyx_v_dedent, a); if (e) return e; + } + if (p->__pyx_v_filename) { + e = (*v)(p->__pyx_v_filename, a); if (e) return e; + } + if (p->__pyx_v_limit) { + e = (*v)(p->__pyx_v_limit, a); if (e) return e; + } + if (p->__pyx_v_line) { + e = (*v)(p->__pyx_v_line, a); if (e) return e; + } + if (p->__pyx_v_module_globals) { + e = (*v)(p->__pyx_v_module_globals, a); if (e) return e; + } + if (p->__pyx_v_start) { + e = (*v)(p->__pyx_v_start, a); if (e) return e; + } + if (p->__pyx_t_0) { + e = (*v)(p->__pyx_t_0, a); if (e) return e; + } + return 0; } -#endif +#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 -/* 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)); +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*/ + 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*/ + #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|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*/ + 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_6_event___pyx_scope_struct__yield_lines, /*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 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #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 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} +}; +#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 +/* #### Code section: pystring_table ### */ + +static int __Pyx_CreateStringTabAndInitStrings(void) { + __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__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_n_s_Event_clone, __pyx_k_Event_clone, sizeof(__pyx_k_Event_clone), 0, 0, 1, 1}, + {&__pyx_n_s_Event_detach, __pyx_k_Event_detach, sizeof(__pyx_k_Event_detach), 0, 0, 1, 1}, + {&__pyx_kp_s_Event_kind_r_function_r_module, __pyx_k_Event_kind_r_function_r_module, sizeof(__pyx_k_Event_kind_r_function_r_module), 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_n_s_MISSING, __pyx_k_MISSING, sizeof(__pyx_k_MISSING), 0, 0, 1, 1}, + {&__pyx_kp_s_Missing_argument_calls_required, __pyx_k_Missing_argument_calls_required, sizeof(__pyx_k_Missing_argument_calls_required), 0, 0, 1, 0}, + {&__pyx_kp_s_Missing_argument_depth_required, __pyx_k_Missing_argument_depth_required, sizeof(__pyx_k_Missing_argument_depth_required), 0, 0, 1, 0}, + {&__pyx_kp_s_Missing_argument_threading_suppo, __pyx_k_Missing_argument_threading_suppo, sizeof(__pyx_k_Missing_argument_threading_suppo), 0, 0, 1, 0}, + {&__pyx_kp_u_NO_SOURCE, __pyx_k_NO_SOURCE, sizeof(__pyx_k_NO_SOURCE), 0, 1, 0, 0}, + {&__pyx_kp_u_NO_SOURCE_not_reading_binary, __pyx_k_NO_SOURCE_not_reading_binary, sizeof(__pyx_k_NO_SOURCE_not_reading_binary), 0, 1, 0, 0}, + {&__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_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, + {&__pyx_kp_s__14, __pyx_k__14, sizeof(__pyx_k__14), 0, 0, 1, 0}, + {&__pyx_kp_u__14, __pyx_k__14, sizeof(__pyx_k__14), 0, 1, 0, 0}, + {&__pyx_kp_s__7, __pyx_k__7, sizeof(__pyx_k__7), 0, 0, 1, 0}, + {&__pyx_kp_s__9, __pyx_k__9, sizeof(__pyx_k__9), 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_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 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_calls, __pyx_k_calls, sizeof(__pyx_k_calls), 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_clone, __pyx_k_clone, sizeof(__pyx_k_clone), 0, 0, 1, 1}, + {&__pyx_n_s_close, __pyx_k_close, sizeof(__pyx_k_close), 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_depth, __pyx_k_depth, sizeof(__pyx_k_depth), 0, 0, 1, 1}, + {&__pyx_n_s_detach, __pyx_k_detach, sizeof(__pyx_k_detach), 0, 0, 1, 1}, + {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0}, + {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0}, + {&__pyx_n_s_endswith, __pyx_k_endswith, sizeof(__pyx_k_endswith), 0, 0, 1, 1}, + {&__pyx_n_s_enumerate, __pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 0, 1, 1}, + {&__pyx_n_s_exception, __pyx_k_exception, sizeof(__pyx_k_exception), 0, 0, 1, 1}, + {&__pyx_n_s_exists, __pyx_k_exists, sizeof(__pyx_k_exists), 0, 0, 1, 1}, + {&__pyx_n_s_f_globals, __pyx_k_f_globals, sizeof(__pyx_k_f_globals), 0, 0, 1, 1}, + {&__pyx_n_s_file, __pyx_k_file, sizeof(__pyx_k_file), 0, 0, 1, 1}, + {&__pyx_kp_u_file_2, __pyx_k_file_2, sizeof(__pyx_k_file_2), 0, 1, 0, 0}, + {&__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_frame, __pyx_k_frame, sizeof(__pyx_k_frame), 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_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0}, + {&__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_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_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1}, + {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0}, + {&__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_n_s_module_2, __pyx_k_module_2, sizeof(__pyx_k_module_2), 0, 0, 1, 1}, + {&__pyx_kp_s_module_3, __pyx_k_module_3, sizeof(__pyx_k_module_3), 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_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_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_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, + {&__pyx_n_s_return, __pyx_k_return, sizeof(__pyx_k_return), 0, 0, 1, 1}, + {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, + {&__pyx_n_s_send, __pyx_k_send, sizeof(__pyx_k_send), 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_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_kp_s_string, __pyx_k_string, sizeof(__pyx_k_string), 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_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_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_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} + }; + return __Pyx_InitStrings(__pyx_string_tab); +} +/* #### Code section: cached_builtins ### */ +static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_object = __Pyx_GetBuiltinName(__pyx_n_s_object); if (!__pyx_builtin_object) __PYX_ERR(0, 31, __pyx_L1_error) + __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(0, 39, __pyx_L1_error) + __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 65, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: cached_constants ### */ + +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "hunter/_event.pyx":65 + * if tracer is None: + * if depth is None: + * raise TypeError('Missing argument: depth (required because tracer was not given).') # <<<<<<<<<<<<<< + * if calls is None: + * raise TypeError('Missing argument: calls (required because tracer was not given).') + */ + __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_Missing_argument_depth_required); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 65, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); + + /* "hunter/_event.pyx":67 + * raise TypeError('Missing argument: depth (required because tracer was not given).') + * if calls is None: + * raise TypeError('Missing argument: calls (required because tracer was not given).') # <<<<<<<<<<<<<< + * if threading_support is MISSING: + * raise TypeError('Missing argument: threading_support (required because tracer was not given).') + */ + __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_s_Missing_argument_calls_required); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 67, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + + /* "hunter/_event.pyx":69 + * raise TypeError('Missing argument: calls (required because tracer was not given).') + * if threading_support is MISSING: + * raise TypeError('Missing argument: threading_support (required because tracer was not given).') # <<<<<<<<<<<<<< + * else: + * depth = tracer.depth + */ + __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_s_Missing_argument_threading_suppo); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + + /* "hunter/_event.pyx":230 + * module = self.arg.__module__ + * else: + * module = self.globals.get('__name__', '') # <<<<<<<<<<<<<< + * if module is None: + * module = '?' + */ + __pyx_tuple__8 = PyTuple_Pack(2, __pyx_n_s_name_2, __pyx_kp_s__7); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); + + /* "hunter/_event.pyx":249 + * if not filename: + * filename = '?' + * elif filename.endswith(('.pyc', '.pyo')): # <<<<<<<<<<<<<< + * filename = filename[:-1] + * elif filename.endswith(('.so', '.pyd')): + */ + __pyx_tuple__10 = PyTuple_Pack(2, __pyx_kp_s_pyc, __pyx_kp_s_pyo); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + + /* "hunter/_event.pyx":250 + * filename = '?' + * elif filename.endswith(('.pyc', '.pyo')): + * filename = filename[:-1] # <<<<<<<<<<<<<< + * elif filename.endswith(('.so', '.pyd')): + * cybasename = CYTHON_SUFFIX_RE.sub('', filename) + */ + __pyx_slice__11 = PySlice_New(Py_None, __pyx_int_neg_1, Py_None); if (unlikely(!__pyx_slice__11)) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_slice__11); + __Pyx_GIVEREF(__pyx_slice__11); + + /* "hunter/_event.pyx":251 + * 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_tuple__12 = PyTuple_Pack(2, __pyx_kp_s_so, __pyx_kp_s_pyd); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(0, 251, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__12); + __Pyx_GIVEREF(__pyx_tuple__12); + + /* "hunter/_event.pyx":253 + * elif filename.endswith(('.so', '.pyd')): + * cybasename = CYTHON_SUFFIX_RE.sub('', filename) + * for ext in ('.pyx', '.py'): # <<<<<<<<<<<<<< + * cyfilename = cybasename + ext + * if exists(cyfilename): + */ + __pyx_tuple__13 = PyTuple_Pack(2, __pyx_kp_s_pyx, __pyx_kp_s_py); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 253, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__13); + __Pyx_GIVEREF(__pyx_tuple__13); + + /* "hunter/_event.pyx":29 + * from .util import if_same_code + * + * __all__ = 'Event', # <<<<<<<<<<<<<< + * + * cdef object UNSET = object() + */ + __pyx_tuple__16 = PyTuple_Pack(1, __pyx_n_s_Event); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__16); + __Pyx_GIVEREF(__pyx_tuple__16); + + /* "hunter/_event.pyx":108 + * return self is other + * + * def detach(self, value_filter=None): # <<<<<<<<<<<<<< + * return fast_detach(self, value_filter) + * + */ + __pyx_tuple__17 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_value_filter); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__17); + __Pyx_GIVEREF(__pyx_tuple__17); + __pyx_codeobj__5 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 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_src_hunter__event_pyx, __pyx_n_s_detach, 108, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__5)) __PYX_ERR(0, 108, __pyx_L1_error) + __pyx_tuple__18 = PyTuple_Pack(1, Py_None); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__18); + __Pyx_GIVEREF(__pyx_tuple__18); + + /* "hunter/_event.pyx":111 + * return fast_detach(self, value_filter) + * + * def clone(self): # <<<<<<<<<<<<<< + * return fast_clone(self) + * + */ + __pyx_tuple__19 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__19); + __Pyx_GIVEREF(__pyx_tuple__19); + __pyx_codeobj__6 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 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_src_hunter__event_pyx, __pyx_n_s_clone, 111, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__6)) __PYX_ERR(0, 111, __pyx_L1_error) + + /* "hunter/_event.pyx":363 + * + * + * def yield_lines(filename, module_globals, start, list collector, # <<<<<<<<<<<<<< + * limit=10): + * dedent = None + */ + __pyx_tuple__20 = 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__20)) __PYX_ERR(0, 363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__20); + __Pyx_GIVEREF(__pyx_tuple__20); + __pyx_codeobj__15 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS|CO_GENERATOR, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__20, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_hunter__event_pyx, __pyx_n_s_yield_lines, 363, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__15)) __PYX_ERR(0, 363, __pyx_L1_error) + __pyx_tuple__21 = PyTuple_Pack(1, ((PyObject *)__pyx_int_10)); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(0, 363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__21); + __Pyx_GIVEREF(__pyx_tuple__21); + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} +/* #### Code section: init_constants ### */ + +static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) { + if (__Pyx_CreateStringTabAndInitStrings() < 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_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; +} +/* #### Code section: init_globals ### */ + +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { + return 0; +} +/* #### Code section: init_module ### */ + +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) { + __Pyx_RefNannyDeclarations + __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_mem = ((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *)Py_None); Py_INCREF(Py_None); + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); + /*--- Variable export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_export_code(void) { + __Pyx_RefNannyDeclarations + 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) { + __Pyx_RefNannyDeclarations + 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_vtabptr_6hunter_6_event_Event = &__pyx_vtable_6hunter_6_event_Event; + __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_ptype_6hunter_6_event_Event = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6hunter_6_event_Event_spec, NULL); if (unlikely(!__pyx_ptype_6hunter_6_event_Event)) __PYX_ERR(0, 47, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_6_event_Event_spec, __pyx_ptype_6hunter_6_event_Event) < 0) __PYX_ERR(0, 47, __pyx_L1_error) + #else + __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_ptype_6hunter_6_event_Event) < 0) __PYX_ERR(0, 47, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_6hunter_6_event_Event->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_6hunter_6_event_Event->tp_dictoffset && __pyx_ptype_6hunter_6_event_Event->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_6hunter_6_event_Event->tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + } + #endif + if (__Pyx_SetVtable(__pyx_ptype_6hunter_6_event_Event, __pyx_vtabptr_6hunter_6_event_Event) < 0) __PYX_ERR(0, 47, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_MergeVtables(__pyx_ptype_6hunter_6_event_Event) < 0) __PYX_ERR(0, 47, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Event, (PyObject *) __pyx_ptype_6hunter_6_event_Event) < 0) __PYX_ERR(0, 47, __pyx_L1_error) + #if CYTHON_USE_TYPE_SPECS + __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_ptype_6hunter_6_event___pyx_scope_struct__yield_lines)) __PYX_ERR(0, 363, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_6_event___pyx_scope_struct__yield_lines_spec, __pyx_ptype_6hunter_6_event___pyx_scope_struct__yield_lines) < 0) __PYX_ERR(0, 363, __pyx_L1_error) + #else + __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_ptype_6hunter_6_event___pyx_scope_struct__yield_lines) < 0) __PYX_ERR(0, 363, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_6hunter_6_event___pyx_scope_struct__yield_lines->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_6hunter_6_event___pyx_scope_struct__yield_lines->tp_dictoffset && __pyx_ptype_6hunter_6_event___pyx_scope_struct__yield_lines->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_6hunter_6_event___pyx_scope_struct__yield_lines->tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + } + #endif + __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; + 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(2, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_7cpython_4type_type = __Pyx_ImportType_3_0_10(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyTypeObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyTypeObject), + #else + sizeof(PyHeapTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyHeapTypeObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(2, 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(3, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_6hunter_7_tracer_FrameType = __Pyx_ImportType_3_0_10(__pyx_t_1, "types", "FrameType", sizeof(PyFrameObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyFrameObject),__Pyx_ImportType_CheckSize_Ignore_3_0_10); if (!__pyx_ptype_6hunter_7_tracer_FrameType) __PYX_ERR(3, 19, __pyx_L1_error) + __pyx_ptype_6hunter_7_tracer_CodeType = __Pyx_ImportType_3_0_10(__pyx_t_1, "types", "CodeType", sizeof(PyCodeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyCodeObject),__Pyx_ImportType_CheckSize_Ignore_3_0_10); if (!__pyx_ptype_6hunter_7_tracer_CodeType) __PYX_ERR(3, 22, __pyx_L1_error) + __pyx_t_2 = PyImport_ImportModule("hunter._tracer"); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_ptype_6hunter_7_tracer_Tracer = __Pyx_ImportType_3_0_10(__pyx_t_2, "hunter._tracer", "Tracer", sizeof(struct __pyx_obj_6hunter_7_tracer_Tracer), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_6hunter_7_tracer_Tracer),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_6hunter_7_tracer_Tracer) __PYX_ERR(3, 36, __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.vendor._cymem.cymem"); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyMalloc = __Pyx_ImportType_3_0_10(__pyx_t_2, "hunter.vendor._cymem.cymem", "PyMalloc", sizeof(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyMalloc) __PYX_ERR(4, 5, __pyx_L1_error) + __pyx_vtabptr_6hunter_6vendor_6_cymem_5cymem_PyMalloc = (struct __pyx_vtabstruct_6hunter_6vendor_6_cymem_5cymem_PyMalloc*)__Pyx_GetVtable(__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyMalloc); if (unlikely(!__pyx_vtabptr_6hunter_6vendor_6_cymem_5cymem_PyMalloc)) __PYX_ERR(4, 5, __pyx_L1_error) + __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyFree = __Pyx_ImportType_3_0_10(__pyx_t_2, "hunter.vendor._cymem.cymem", "PyFree", sizeof(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyFree) __PYX_ERR(4, 11, __pyx_L1_error) + __pyx_vtabptr_6hunter_6vendor_6_cymem_5cymem_PyFree = (struct __pyx_vtabstruct_6hunter_6vendor_6_cymem_5cymem_PyFree*)__Pyx_GetVtable(__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyFree); if (unlikely(!__pyx_vtabptr_6hunter_6vendor_6_cymem_5cymem_PyFree)) __PYX_ERR(4, 11, __pyx_L1_error) + __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Pool = __Pyx_ImportType_3_0_10(__pyx_t_2, "hunter.vendor._cymem.cymem", "Pool", sizeof(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Pool) __PYX_ERR(4, 17, __pyx_L1_error) + __pyx_vtabptr_6hunter_6vendor_6_cymem_5cymem_Pool = (struct __pyx_vtabstruct_6hunter_6vendor_6_cymem_5cymem_Pool*)__Pyx_GetVtable(__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Pool); if (unlikely(!__pyx_vtabptr_6hunter_6vendor_6_cymem_5cymem_Pool)) __PYX_ERR(4, 17, __pyx_L1_error) + __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Address = __Pyx_ImportType_3_0_10(__pyx_t_2, "hunter.vendor._cymem.cymem", "Address", sizeof(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Address) __PYX_ERR(4, 29, __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) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); + /*--- Variable import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); + /*--- Function import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + + +#if PY_MAJOR_VERSION >= 3 +#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 + +#ifdef __cplusplus +namespace { + struct PyModuleDef __pyx_moduledef = + #else + static struct PyModuleDef __pyx_moduledef = + #endif + { + PyModuleDef_HEAD_INIT, + "_event", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #elif CYTHON_USE_MODULE_STATE + sizeof(__pyx_mstate), /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + #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 +#endif + +#ifndef CYTHON_NO_PYINIT_EXPORT +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#elif PY_MAJOR_VERSION < 3 +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" void +#else +#define __Pyx_PyMODINIT_FUNC void +#endif +#else +#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); +} +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; +} +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none) +#else +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 +{ + PyObject *value = PyObject_GetAttrString(spec, from_name); + int result = 0; + if (likely(value)) { + if (allow_none || value != Py_None) { +#if CYTHON_COMPILING_IN_LIMITED_API + result = PyModule_AddObject(module, to_name, value); +#else + result = PyDict_SetItemString(moddict, to_name, value); +#endif + } + 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 (__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; +#if CYTHON_COMPILING_IN_LIMITED_API + moddict = module; +#else + moddict = PyModule_GetDict(module); + if (unlikely(!moddict)) goto bad; +#endif + 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__event(PyObject *__pyx_pyinit_module) +#endif +#endif +{ + int stringtab_initialized = 0; + #if CYTHON_USE_MODULE_STATE + int pystate_addmodule_run = 0; + #endif + __Pyx_TraceDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject **__pyx_t_4; + 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 '_event' 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 + /*--- 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); + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #elif CYTHON_USE_MODULE_STATE + __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + { + int add_module_result = PyState_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 = PyModule_Create(&__pyx_moduledef); + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #endif + CYTHON_UNUSED_VAR(__pyx_t_1); + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #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__event(void)", 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) + #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 + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + PyEval_InitThreads(); + #endif + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + stringtab_initialized = 1; + 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 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) + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Global type/function init code ---*/ + (void)__Pyx_modinit_global_init_code(); + (void)__Pyx_modinit_variable_export_code(); + if (unlikely((__Pyx_modinit_function_export_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_type_init_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_type_import_code() < 0))) __PYX_ERR(0, 1, __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__event(void)", __pyx_f[0], 1, 0, __PYX_ERR(0, 1, __pyx_L1_error)); + + /* "hunter/_event.pyx":2 + * # cython: linetrace=True, language_level=3str, c_string_encoding=ascii + * 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_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_partial); + __Pyx_GIVEREF(__pyx_n_s_partial); + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_partial)) __PYX_ERR(0, 2, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_functools, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2, __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_partial); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_partial, __pyx_t_2) < 0) __PYX_ERR(0, 2, __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, c_string_encoding=ascii + * 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_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_n_s_getline); + __Pyx_GIVEREF(__pyx_n_s_getline); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_getline)) __PYX_ERR(0, 3, __pyx_L1_error); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_linecache, __pyx_t_3, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __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_n_s_getline); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_getline, __pyx_t_3) < 0) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "hunter/_event.pyx":4 + * 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_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_getlines); + __Pyx_GIVEREF(__pyx_n_s_getlines); + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_getlines)) __PYX_ERR(0, 4, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_linecache, __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_n_s_getlines); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_getlines, __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":5 + * 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_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_n_s_basename); + __Pyx_GIVEREF(__pyx_n_s_basename); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_basename)) __PYX_ERR(0, 5, __pyx_L1_error); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_os_path, __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_n_s_basename); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_basename, __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/_event.pyx":6 + * 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_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_exists); + __Pyx_GIVEREF(__pyx_n_s_exists); + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_exists)) __PYX_ERR(0, 6, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_os_path, __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_n_s_exists); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_exists, __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":7 + * 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_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_n_s_splitext); + __Pyx_GIVEREF(__pyx_n_s_splitext); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_splitext)) __PYX_ERR(0, 7, __pyx_L1_error); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_os_path, __pyx_t_3, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 7, __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_n_s_splitext); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_splitext, __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; + + /* "hunter/_event.pyx":8 + * 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_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_current_thread); + __Pyx_GIVEREF(__pyx_n_s_current_thread); + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_current_thread)) __PYX_ERR(0, 8, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_threading, __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_n_s_current_thread); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_current_thread, __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":9 + * 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_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_n_s_TokenError); + __Pyx_GIVEREF(__pyx_n_s_TokenError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_TokenError)) __PYX_ERR(0, 9, __pyx_L1_error); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_tokenize, __pyx_t_3, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 9, __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_n_s_TokenError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TokenError, __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; + + /* "hunter/_event.pyx":10 + * 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_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_generate_tokens); + __Pyx_GIVEREF(__pyx_n_s_generate_tokens); + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_generate_tokens)) __PYX_ERR(0, 10, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_tokenize, __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_n_s_generate_tokens); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_generate_tokens, __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":20 + * from .vendor._cymem.cymem cimport Pool + * + * from .const import SITE_PACKAGES_PATHS # <<<<<<<<<<<<<< + * from .const import SYS_PREFIX_PATHS + * from .util import CYTHON_SUFFIX_RE + */ + __Pyx_TraceLine(20,0,__PYX_ERR(0, 20, __pyx_L1_error)) + __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 20, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_n_s_SITE_PACKAGES_PATHS); + __Pyx_GIVEREF(__pyx_n_s_SITE_PACKAGES_PATHS); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_SITE_PACKAGES_PATHS)) __PYX_ERR(0, 20, __pyx_L1_error); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_const, __pyx_t_3, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 20, __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_n_s_SITE_PACKAGES_PATHS); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 20, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SITE_PACKAGES_PATHS, __pyx_t_3) < 0) __PYX_ERR(0, 20, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "hunter/_event.pyx":21 + * + * 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(21,0,__PYX_ERR(0, 21, __pyx_L1_error)) + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 21, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_SYS_PREFIX_PATHS); + __Pyx_GIVEREF(__pyx_n_s_SYS_PREFIX_PATHS); + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_SYS_PREFIX_PATHS)) __PYX_ERR(0, 21, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_const, __pyx_t_2, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 21, __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_SYS_PREFIX_PATHS); 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_SYS_PREFIX_PATHS, __pyx_t_2) < 0) __PYX_ERR(0, 21, __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 + * 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 MISSING + */ + __Pyx_TraceLine(22,0,__PYX_ERR(0, 22, __pyx_L1_error)) + __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_n_s_CYTHON_SUFFIX_RE); + __Pyx_GIVEREF(__pyx_n_s_CYTHON_SUFFIX_RE); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_CYTHON_SUFFIX_RE)) __PYX_ERR(0, 22, __pyx_L1_error); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_util, __pyx_t_3, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __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_n_s_CYTHON_SUFFIX_RE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_CYTHON_SUFFIX_RE, __pyx_t_3) < 0) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "hunter/_event.pyx":23 + * from .const import SYS_PREFIX_PATHS + * from .util import CYTHON_SUFFIX_RE + * from .util import LEADING_WHITESPACE_RE # <<<<<<<<<<<<<< + * from .util import MISSING + * from .util import get_func_in_mro + */ + __Pyx_TraceLine(23,0,__PYX_ERR(0, 23, __pyx_L1_error)) + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_LEADING_WHITESPACE_RE); + __Pyx_GIVEREF(__pyx_n_s_LEADING_WHITESPACE_RE); + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_LEADING_WHITESPACE_RE)) __PYX_ERR(0, 23, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_util, __pyx_t_2, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 23, __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_LEADING_WHITESPACE_RE); 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_LEADING_WHITESPACE_RE, __pyx_t_2) < 0) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "hunter/_event.pyx":24 + * from .util import CYTHON_SUFFIX_RE + * from .util import LEADING_WHITESPACE_RE + * from .util import MISSING # <<<<<<<<<<<<<< + * from .util import get_func_in_mro + * from .util import get_main_thread + */ + __Pyx_TraceLine(24,0,__PYX_ERR(0, 24, __pyx_L1_error)) + __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 24, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_n_s_MISSING); + __Pyx_GIVEREF(__pyx_n_s_MISSING); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_MISSING)) __PYX_ERR(0, 24, __pyx_L1_error); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_util, __pyx_t_3, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 24, __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_n_s_MISSING); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 24, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_MISSING, __pyx_t_3) < 0) __PYX_ERR(0, 24, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "hunter/_event.pyx":25 + * from .util import LEADING_WHITESPACE_RE + * from .util import MISSING + * from .util import get_func_in_mro # <<<<<<<<<<<<<< + * from .util import get_main_thread + * from .util import if_same_code + */ + __Pyx_TraceLine(25,0,__PYX_ERR(0, 25, __pyx_L1_error)) + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 25, __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); + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_get_func_in_mro)) __PYX_ERR(0, 25, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_util, __pyx_t_2, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 25, __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_get_func_in_mro); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 25, __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, 25, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "hunter/_event.pyx":26 + * from .util import MISSING + * from .util import get_func_in_mro + * from .util import get_main_thread # <<<<<<<<<<<<<< + * from .util import if_same_code + * + */ + __Pyx_TraceLine(26,0,__PYX_ERR(0, 26, __pyx_L1_error)) + __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_n_s_get_main_thread); + __Pyx_GIVEREF(__pyx_n_s_get_main_thread); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_get_main_thread)) __PYX_ERR(0, 26, __pyx_L1_error); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_util, __pyx_t_3, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 26, __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_n_s_get_main_thread); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_main_thread, __pyx_t_3) < 0) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "hunter/_event.pyx":27 + * from .util import get_func_in_mro + * from .util import get_main_thread + * from .util import if_same_code # <<<<<<<<<<<<<< + * + * __all__ = 'Event', + */ + __Pyx_TraceLine(27,0,__PYX_ERR(0, 27, __pyx_L1_error)) + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 27, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_if_same_code); + __Pyx_GIVEREF(__pyx_n_s_if_same_code); + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_if_same_code)) __PYX_ERR(0, 27, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_util, __pyx_t_2, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 27, __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_if_same_code); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 27, __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, 27, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "hunter/_event.pyx":29 + * from .util import if_same_code + * + * __all__ = 'Event', # <<<<<<<<<<<<<< + * + * cdef object UNSET = object() + */ + __Pyx_TraceLine(29,0,__PYX_ERR(0, 29, __pyx_L1_error)) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_all, __pyx_tuple__16) < 0) __PYX_ERR(0, 29, __pyx_L1_error) + + /* "hunter/_event.pyx":31 + * __all__ = 'Event', + * + * cdef object UNSET = object() # <<<<<<<<<<<<<< + * + * cdef Pool mem = Pool() + */ + __Pyx_TraceLine(31,0,__PYX_ERR(0, 31, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_builtin_object); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 31, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_v_6hunter_6_event_UNSET); + __Pyx_DECREF_SET(__pyx_v_6hunter_6_event_UNSET, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; + + /* "hunter/_event.pyx":33 + * cdef object UNSET = object() + * + * cdef Pool mem = Pool() # <<<<<<<<<<<<<< + * cdef PyObject** KIND_NAMES = make_kind_names(['call', 'exception', 'line', 'return', 'call', 'exception', 'return']) + * + */ + __Pyx_TraceLine(33,0,__PYX_ERR(0, 33, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Pool)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XGOTREF((PyObject *)__pyx_v_6hunter_6_event_mem); + __Pyx_DECREF_SET(__pyx_v_6hunter_6_event_mem, ((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *)__pyx_t_3)); + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; + + /* "hunter/_event.pyx":34 + * + * cdef Pool mem = Pool() + * cdef PyObject** KIND_NAMES = make_kind_names(['call', 'exception', 'line', 'return', 'call', 'exception', 'return']) # <<<<<<<<<<<<<< + * + * cdef inline PyObject** make_kind_names(list strings): + */ + __Pyx_TraceLine(34,0,__PYX_ERR(0, 34, __pyx_L1_error)) + __pyx_t_3 = PyList_New(7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_n_s_call); + __Pyx_GIVEREF(__pyx_n_s_call); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_call)) __PYX_ERR(0, 34, __pyx_L1_error); + __Pyx_INCREF(__pyx_n_s_exception); + __Pyx_GIVEREF(__pyx_n_s_exception); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 1, __pyx_n_s_exception)) __PYX_ERR(0, 34, __pyx_L1_error); + __Pyx_INCREF(__pyx_n_s_line); + __Pyx_GIVEREF(__pyx_n_s_line); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 2, __pyx_n_s_line)) __PYX_ERR(0, 34, __pyx_L1_error); + __Pyx_INCREF(__pyx_n_s_return); + __Pyx_GIVEREF(__pyx_n_s_return); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 3, __pyx_n_s_return)) __PYX_ERR(0, 34, __pyx_L1_error); + __Pyx_INCREF(__pyx_n_s_call); + __Pyx_GIVEREF(__pyx_n_s_call); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 4, __pyx_n_s_call)) __PYX_ERR(0, 34, __pyx_L1_error); + __Pyx_INCREF(__pyx_n_s_exception); + __Pyx_GIVEREF(__pyx_n_s_exception); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 5, __pyx_n_s_exception)) __PYX_ERR(0, 34, __pyx_L1_error); + __Pyx_INCREF(__pyx_n_s_return); + __Pyx_GIVEREF(__pyx_n_s_return); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 6, __pyx_n_s_return)) __PYX_ERR(0, 34, __pyx_L1_error); + __pyx_t_4 = __pyx_f_6hunter_6_event_make_kind_names(((PyObject*)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((PyObject **)NULL) && PyErr_Occurred())) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_6hunter_6_event_KIND_NAMES = __pyx_t_4; + + /* "hunter/_event.pyx":36 + * cdef PyObject** KIND_NAMES = make_kind_names(['call', 'exception', 'line', 'return', 'call', 'exception', 'return']) + * + * cdef inline PyObject** make_kind_names(list strings): # <<<<<<<<<<<<<< + * cdef PyObject** array = mem.alloc(len(strings), sizeof(PyObject*)) + * cdef object name + */ + __Pyx_TraceLine(36,0,__PYX_ERR(0, 36, __pyx_L1_error)) + + + /* "hunter/_event.pyx":62 + * """ + * def __init__(self, FrameType frame, int kind, object arg, Tracer tracer=None, object depth=None, object calls=None, + * object threading_support=MISSING): # <<<<<<<<<<<<<< + * if tracer is None: + * if depth is None: + */ + __Pyx_TraceLine(62,0,__PYX_ERR(0, 62, __pyx_L1_error)) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_MISSING); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 62, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_k_ = __pyx_t_3; + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; + + /* "hunter/_event.pyx":108 + * return self is other + * + * def detach(self, value_filter=None): # <<<<<<<<<<<<<< + * return fast_detach(self, value_filter) + * + */ + __Pyx_TraceLine(108,0,__PYX_ERR(0, 108, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_6_event_5Event_7detach, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Event_detach, NULL, __pyx_n_s_hunter__event, __pyx_d, ((PyObject *)__pyx_codeobj__5)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__18); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6hunter_6_event_Event, __pyx_n_s_detach, __pyx_t_3) < 0) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_6hunter_6_event_Event); + + /* "hunter/_event.pyx":111 + * return fast_detach(self, value_filter) + * + * def clone(self): # <<<<<<<<<<<<<< + * return fast_clone(self) + * + */ + __Pyx_TraceLine(111,0,__PYX_ERR(0, 111, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_6_event_5Event_9clone, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Event_clone, NULL, __pyx_n_s_hunter__event, __pyx_d, ((PyObject *)__pyx_codeobj__6)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6hunter_6_event_Event, __pyx_n_s_clone, __pyx_t_3) < 0) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_6hunter_6_event_Event); + + /* "hunter/_event.pyx":114 + * return fast_clone(self) + * + * cdef inline instruction_getter(self): # <<<<<<<<<<<<<< + * cdef int position + * + */ + __Pyx_TraceLine(114,0,__PYX_ERR(0, 114, __pyx_L1_error)) + + + /* "hunter/_event.pyx":130 + * return self.instruction_getter() + * + * cdef inline threadid_getter(self): # <<<<<<<<<<<<<< + * cdef long current + * + */ + __Pyx_TraceLine(130,0,__PYX_ERR(0, 130, __pyx_L1_error)) + + + /* "hunter/_event.pyx":146 + * return self.threadid_getter() + * + * cdef inline threadname_getter(self): # <<<<<<<<<<<<<< + * if self._threadname is UNSET: + * if self._thread is UNSET: + */ + __Pyx_TraceLine(146,0,__PYX_ERR(0, 146, __pyx_L1_error)) + + + /* "hunter/_event.pyx":157 + * return self.threadname_getter() + * + * cdef inline locals_getter(self): # <<<<<<<<<<<<<< + * if self._locals is UNSET: + * if self.builtin: + */ + __Pyx_TraceLine(157,0,__PYX_ERR(0, 157, __pyx_L1_error)) + + + /* "hunter/_event.pyx":170 + * return self.locals_getter() + * + * cdef inline globals_getter(self): # <<<<<<<<<<<<<< + * if self._globals is UNSET: + * if self.builtin: + */ + __Pyx_TraceLine(170,0,__PYX_ERR(0, 170, __pyx_L1_error)) + + + /* "hunter/_event.pyx":182 + * return self.globals_getter() + * + * cdef inline function_getter(self): # <<<<<<<<<<<<<< + * if self._function is UNSET: + * if self.builtin: + */ + __Pyx_TraceLine(182,0,__PYX_ERR(0, 182, __pyx_L1_error)) + + + /* "hunter/_event.pyx":225 + * return self._function_object + * + * cdef inline module_getter(self): # <<<<<<<<<<<<<< + * if self._module is UNSET: + * if self.builtin: + */ + __Pyx_TraceLine(225,0,__PYX_ERR(0, 225, __pyx_L1_error)) + + + /* "hunter/_event.pyx":240 + * return self.module_getter() + * + * cdef inline filename_getter(self): # <<<<<<<<<<<<<< + * cdef CodeType code + * if self._filename is UNSET: + */ + __Pyx_TraceLine(240,0,__PYX_ERR(0, 240, __pyx_L1_error)) + + + /* "hunter/_event.pyx":266 + * return self.filename_getter() + * + * cdef inline lineno_getter(self): # <<<<<<<<<<<<<< + * if self._lineno is UNSET: + * self._lineno = PyFrame_GetLineNumber(self.frame) + */ + __Pyx_TraceLine(266,0,__PYX_ERR(0, 266, __pyx_L1_error)) + + + /* "hunter/_event.pyx":275 + * return self.lineno_getter() + * + * cdef inline CodeType code_getter(self): # <<<<<<<<<<<<<< + * if self._code is UNSET: + * return PyFrame_GetCode(self.frame) + */ + __Pyx_TraceLine(275,0,__PYX_ERR(0, 275, __pyx_L1_error)) + + + /* "hunter/_event.pyx":285 + * return self.code_getter() + * + * cdef inline stdlib_getter(self): # <<<<<<<<<<<<<< + * if self._stdlib is UNSET: + * module_parts = self.module.split('.') + */ + __Pyx_TraceLine(285,0,__PYX_ERR(0, 285, __pyx_L1_error)) + + + /* "hunter/_event.pyx":307 + * return self.stdlib_getter() + * + * cdef inline fullsource_getter(self): # <<<<<<<<<<<<<< + * cdef list lines + * cdef CodeType code + */ + __Pyx_TraceLine(307,0,__PYX_ERR(0, 307, __pyx_L1_error)) + + + /* "hunter/_event.pyx":344 + * return self.fullsource_getter() + * + * cdef inline source_getter(self): # <<<<<<<<<<<<<< + * if self._source is UNSET: + * if self.filename.endswith(('.so', '.pyd')): + */ + __Pyx_TraceLine(344,0,__PYX_ERR(0, 344, __pyx_L1_error)) + + + /* "hunter/_event.pyx":363 + * + * + * def yield_lines(filename, module_globals, start, list collector, # <<<<<<<<<<<<<< + * limit=10): + * dedent = None + */ + __Pyx_TraceLine(363,0,__PYX_ERR(0, 363, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_6_event_1yield_lines, 0, __pyx_n_s_yield_lines, NULL, __pyx_n_s_hunter__event, __pyx_d, ((PyObject *)__pyx_codeobj__15)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__21); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_yield_lines, __pyx_t_3) < 0) __PYX_ERR(0, 363, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "hunter/_event.pyx":378 + * + * + * cdef inline Event fast_detach(Event self, object value_filter): # <<<<<<<<<<<<<< + * event = Event.__new__(Event) + * + */ + __Pyx_TraceLine(378,0,__PYX_ERR(0, 378, __pyx_L1_error)) + + + /* "hunter/_event.pyx":412 + * return event + * + * cdef inline Event fast_clone(Event self): # <<<<<<<<<<<<<< + * event = Event.__new__(Event) + * event.arg = self.arg + */ + __Pyx_TraceLine(412,0,__PYX_ERR(0, 412, __pyx_L1_error)) + + + /* "hunter/_event.pyx":1 + * # cython: linetrace=True, language_level=3str, c_string_encoding=ascii # <<<<<<<<<<<<<< + * from functools import partial + * from linecache import getline + */ + __Pyx_TraceLine(1,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_d, __pyx_n_s_test, __pyx_t_3) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_TraceReturn(Py_None, 0); + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + if (__pyx_m) { + if (__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"); + } + __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 +} +/* #### 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); +#if PY_MAJOR_VERSION >= 3 + 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)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#endif + +/* PyObjectGetAttrStrNoError */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 +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 >= 0x030d00A1 + (void) PyObject_GetOptionalAttr(obj, attr_name, &result); + return result; +#else +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 + 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_b, name); + if (unlikely(!result) && !PyErr_Occurred()) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +/* 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; + } +#if PY_VERSION_HEX < 0x030400B1 + } else { + (*frame)->f_tstate = tstate; +#endif + } + __Pyx_PyFrame_SetLineNumber(*frame, firstlineno); + retval = 1; + __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 (retval) { + __Pyx_ErrRestoreInState(tstate, type, value, traceback); + return __Pyx_IsTracing(tstate, 0, 0) && 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*/ + ); +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); +#endif + return py_code; +} +#endif + +/* RaiseUnexpectedTypeError */ +static int +__Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj) +{ + __Pyx_TypeName obj_type_name = __Pyx_PyType_GetName(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; +} + +/* Intern */ +static PyObject* __Pyx_Intern(PyObject* s) { + if (unlikely(!PyString_CheckExact(s))) { + __Pyx_RaiseUnexpectedTypeError("str", s); + return NULL; + } + Py_INCREF(s); + #if PY_MAJOR_VERSION >= 3 + PyUnicode_InternInPlace(&s); + #else + PyString_InternInPlace(&s); + #endif + return s; +} + +/* TupleAndListFromArray */ +#if 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) { + Py_INCREF(__pyx_empty_tuple); + return __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 + 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 + 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; + 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; + } +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 +} + +/* fastcall */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) +{ + Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames); + for (i = 0; i < n; i++) + { + if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i]; + } + for (i = 0; i < n; i++) + { + int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), 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_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { + Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames); + PyObject *dict; + dict = PyDict_New(); + if (unlikely(!dict)) + return NULL; + for (i=0; i= 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 *const *kwvalues, + 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; + int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds)); + while (1) { + Py_XDECREF(key); key = NULL; + Py_XDECREF(value); value = NULL; + if (kwds_is_tuple) { + Py_ssize_t size; +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(kwds); +#else + size = PyTuple_Size(kwds); + if (size < 0) goto bad; +#endif + if (pos >= size) break; +#if CYTHON_AVOID_BORROWED_REFS + key = __Pyx_PySequence_ITEM(kwds, pos); + if (!key) goto bad; +#elif CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kwds, pos); +#else + key = PyTuple_GetItem(kwds, pos); + if (!key) goto bad; +#endif + value = kwvalues[pos]; + pos++; + } + else + { + if (!PyDict_Next(kwds, &pos, &key, &value)) break; +#if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(key); +#endif + } + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; +#if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(value); + Py_DECREF(key); +#endif + key = NULL; + value = NULL; + continue; + } +#if !CYTHON_AVOID_BORROWED_REFS + Py_INCREF(key); +#endif + Py_INCREF(value); + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (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; +#if CYTHON_AVOID_BORROWED_REFS + value = NULL; +#endif + 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 = ( + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key) + ); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; +#if CYTHON_AVOID_BORROWED_REFS + value = NULL; +#endif + 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 + (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(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; + } + } + Py_XDECREF(key); + Py_XDECREF(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: + #if PY_MAJOR_VERSION < 3 + PyErr_Format(PyExc_TypeError, + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + Py_XDECREF(key); + Py_XDECREF(value); + return -1; +} + +/* ArgTypeTest */ +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +{ + __Pyx_TypeName type_name; + __Pyx_TypeName obj_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; + } + type_name = __Pyx_PyType_GetName(type); + obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME + ", got " __Pyx_FMT_TYPENAME ")", name, type_name, obj_type_name); + __Pyx_DECREF_TypeName(type_name); + __Pyx_DECREF_TypeName(obj_type_name); + return 0; +} + +/* 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 PY_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + #endif + 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 + +/* RaiseException */ +#if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + __Pyx_PyThreadState_declare + CYTHON_UNUSED_VAR(cause); + 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 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 PyObject_GetAttr(obj, attr_name); + } +bad: + Py_XDECREF(owned_instance); + return; } #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); +/* 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 - "name '%.200s' is not defined", PyString_AS_STRING(name)); + dictptr = _PyObject_GetDictPtr(obj); #endif } - return result; + 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 -/* 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) +/* 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 { - 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"; + PyObject *result; +#if !CYTHON_AVOID_BORROWED_REFS +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && PY_VERSION_HEX < 0x030d0000 + 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; } - if (exact) { - more_or_less = "exactly"; +#elif CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(!__pyx_m)) { + return NULL; } - PyErr_Format(PyExc_TypeError, - "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", - func_name, more_or_less, num_expected, - (num_expected == 1) ? "" : "s", num_found); -} - -/* RaiseDoubleKeywords */ -static void __Pyx_RaiseDoubleKeywordsError( - const char* func_name, - PyObject* kw_name) -{ - PyErr_Format(PyExc_TypeError, - #if PY_MAJOR_VERSION >= 3 - "%s() got multiple values for keyword argument '%U'", func_name, kw_name); - #else - "%s() got multiple values for keyword argument '%s'", func_name, - PyString_AsString(kw_name)); - #endif + result = PyObject_GetAttr(__pyx_m, name); + if (likely(result)) { + return result; + } +#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); + } +#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); + } + PyErr_Clear(); +#endif + return __Pyx_GetBuiltinName(name); } -/* ParseKeywords */ -static int __Pyx_ParseOptionalKeywords( - PyObject *kwds, - PyObject **argnames[], - PyObject *kwds2, - PyObject *values[], - Py_ssize_t num_pos_args, - const char* function_name) +/* KeywordStringCheck */ +static int __Pyx_CheckKeywordStrings( + PyObject *kw, + const char* function_name, + int kw_allowed) { - PyObject *key = 0, *value = 0; + PyObject* key = 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 { +#if CYTHON_COMPILING_IN_PYPY + if (!kw_allowed && PyDict_Next(kw, &pos, &key, 0)) + goto invalid_keyword; + return 1; +#else + if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) { + Py_ssize_t kwsize; +#if CYTHON_ASSUME_SAFE_MACROS + kwsize = PyTuple_GET_SIZE(kw); +#else + kwsize = PyTuple_Size(kw); + if (kwsize < 0) return 0; +#endif + if (unlikely(kwsize == 0)) + return 1; + if (!kw_allowed) { +#if CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kw, 0); +#else + key = PyTuple_GetItem(kw, pos); + if (!key) return 0; +#endif goto invalid_keyword; } +#if PY_VERSION_HEX < 0x03090000 + for (pos = 0; pos < kwsize; pos++) { +#if CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kw, pos); +#else + key = PyTuple_GetItem(kw, pos); + if (!key) return 0; +#endif + if (unlikely(!PyUnicode_Check(key))) + goto invalid_keyword_type; + } +#endif + return 1; } - 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; -} - -/* 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 - } - else { - if (likely(__Pyx_TypeCheck(obj, type))) return 1; + while (PyDict_Next(kw, &pos, &key, 0)) { + #if PY_MAJOR_VERSION < 3 + if (unlikely(!PyString_Check(key))) + #endif + if (unlikely(!PyUnicode_Check(key))) + goto invalid_keyword_type; } + 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: + #if PY_MAJOR_VERSION < 3 + PyErr_Format(PyExc_TypeError, + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else PyErr_Format(PyExc_TypeError, - "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", - name, type->tp_name, Py_TYPE(obj)->tp_name); + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif 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 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; +/* 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; } -#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; - } -#if PY_VERSION_HEX < 0x030400B1 - } else { - (*frame)->f_tstate = tstate; -#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); } - __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; + 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 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_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)); #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); + return PySequence_GetItem(o, i); #endif - return py_code; } -#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; +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; } } - return 0; -#else - if (unlikely(PyErr_Occurred())) { - if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { - PyErr_Clear(); - return 0; - } else { - return -1; + 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 = PyInt_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); } } - return 0; +#else + if (is_list || !PyMapping_Check(o)) { + return PySequence_GetItem(o, i); + } #endif + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); } /* PyFunctionFastCall */ -#if CYTHON_FAST_PYCALL +#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, PyObject *globals) { PyFrameObject *f; @@ -11237,7 +15578,6 @@ static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args --tstate->recursion_depth; 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); @@ -11253,9 +15593,15 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, PyObject *result; assert(kwargs == NULL || PyDict_Check(kwargs)); nk = kwargs ? PyDict_Size(kwargs) : 0; - if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { + #if PY_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) { + return NULL; + } + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) { return NULL; } + #endif if ( #if PY_MAJOR_VERSION >= 3 co->co_kwonlyargcount == 0 && @@ -11324,137 +15670,142 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, return result; } #endif -#endif - -/* PyObjectCall */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { - PyObject *result; - ternaryfunc call = func->ob_type->tp_call; - if (unlikely(!call)) - return PyObject_Call(func, arg, kw); - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) - return NULL; - result = (*call)(func, arg, kw); - Py_LeaveRecursiveCall(); - if (unlikely(!result) && unlikely(!PyErr_Occurred())) { - PyErr_SetString( - PyExc_SystemError, - "NULL result without error in PyObject_Call"); - } - return result; -} -#endif /* PyObjectCallMethO */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { PyObject *self, *result; PyCFunction cfunc; - cfunc = PyCFunction_GET_FUNCTION(func); - self = PyCFunction_GET_SELF(func); + cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); + self = __Pyx_CyOrPyCFunction_GET_SELF(func); + #if PY_MAJOR_VERSION < 3 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 - -/* 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); - } + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + #endif + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); } - return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); + return result; } #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); +/* PyObjectFastCall */ +#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API +static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **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 - -/* PyObjectCallOneArg */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) { + Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs); #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); + 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 (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 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 PY_VERSION_HEX >= 0x030700A1 + if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) { + return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL); + } + #endif + #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 + #if PY_VERSION_HEX < 0x03090000 + vectorcallfunc f = _PyVectorcall_Function(func); + #else + vectorcallfunc f = PyVectorcall_Function(func); + #endif + if (f) { + return f(func, args, (size_t)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, (size_t)nargs, NULL); } + #endif + } + if (nargs == 0) { + return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs); } - return __Pyx__PyObject_CallOneArg(func, arg); + #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 } -#else + +/* 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; @@ -11471,11 +15822,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 +#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR + if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)) +#elif PY_MAJOR_VERSION >= 3 #ifdef __Pyx_CyFunction_USED - if (likely(PyFunction_Check(descr) || (Py_TYPE(descr) == &PyMethodDescr_Type) || __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) || (Py_TYPE(descr) == &PyMethodDescr_Type))) + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type))) #endif #else #ifdef __Pyx_CyFunction_USED @@ -11516,18 +15869,20 @@ 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_GetName(tp); PyErr_Format(PyExc_AttributeError, #if PY_MAJOR_VERSION >= 3 - "'%.50s' object has no attribute '%U'", - tp->tp_name, name); + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, name); #else - "'%.50s' object has no attribute '%.400s'", - tp->tp_name, PyString_AS_STRING(name)); + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", + type_name, PyString_AS_STRING(name)); #endif + __Pyx_DECREF_TypeName(type_name); return 0; #else attr = __Pyx_PyObject_GetAttrStr(obj, name); @@ -11582,10 +15937,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 */ @@ -11637,7 +15990,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; @@ -11657,6 +16010,9 @@ static int __Pyx_unpack_tuple2_generic(PyObject* tuple, PyObject** pvalue1, PyOb } /* dict_iter */ +#if CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 +#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)); @@ -11726,231 +16082,55 @@ static CYTHON_INLINE int __Pyx_dict_iter_next( 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; -} - -/* 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 - -/* 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; - } -#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); - } -#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); - } - 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; -} -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); - } - 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)); -#else - return PySequence_GetItem(o, i); -#endif -} -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, - CYTHON_NCP_UNUSED int wraparound, - CYTHON_NCP_UNUSED int boundscheck) { -#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS - if (is_list || PyList_CheckExact(o)) { - Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); - if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { - PyObject *r = PyList_GET_ITEM(o, n); - Py_INCREF(r); - return r; - } - } - else if (PyTuple_CheckExact(o)) { - Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); - if ((!boundscheck) || likely(__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(); - } + if (pkey) { + Py_INCREF(key); + *pkey = key; + } + if (pvalue) { + Py_INCREF(value); + *pvalue = value; } - return m->sq_item(o, i); + } + 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(); } } -#else - if (is_list || PySequence_Check(o)) { - return PySequence_GetItem(o, i); + 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; } -#endif - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); + 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) { + int has_cstart, int has_cstop, int wraparound) { + __Pyx_TypeName obj_type_name; #if CYTHON_USE_TYPE_SLOTS PyMappingMethods* mp; #if PY_MAJOR_VERSION < 3 @@ -11989,9 +16169,13 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj, } return ms->sq_slice(obj, cstart, cstop); } +#else + CYTHON_UNUSED_VAR(wraparound); #endif mp = Py_TYPE(obj)->tp_as_mapping; if (likely(mp && mp->mp_subscript)) +#else + CYTHON_UNUSED_VAR(wraparound); #endif { PyObject* result; @@ -12037,159 +16221,32 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj, } return result; } + obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); PyErr_Format(PyExc_TypeError, - "'%.200s' object is unsliceable", Py_TYPE(obj)->tp_name); + "'" __Pyx_FMT_TYPENAME "' object is unsliceable", obj_type_name); + __Pyx_DECREF_TypeName(obj_type_name); bad: return NULL; } -/* 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); - } - } 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 - 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; - 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; +/* 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; } -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 + if (likely(__Pyx_TypeCheck(obj, type))) + return 1; + obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); + type_name = __Pyx_PyType_GetName(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; } /* IterNext */ @@ -12197,7 +16254,7 @@ static PyObject *__Pyx_PyIter_Next2Default(PyObject* defval) { PyObject* exc_type; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign - exc_type = __Pyx_PyErr_Occurred(); + exc_type = __Pyx_PyErr_CurrentExceptionType(); if (unlikely(exc_type)) { if (!defval || unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) return NULL; @@ -12213,21 +16270,23 @@ static PyObject *__Pyx_PyIter_Next2Default(PyObject* defval) { return NULL; } static void __Pyx_PyIter_Next_ErrorNoIterator(PyObject *iterator) { + __Pyx_TypeName iterator_type_name = __Pyx_PyType_GetName(Py_TYPE(iterator)); PyErr_Format(PyExc_TypeError, - "%.200s object is not an iterator", Py_TYPE(iterator)->tp_name); + __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; iternextfunc iternext = Py_TYPE(iterator)->tp_iternext; if (likely(iternext)) { -#if CYTHON_USE_TYPE_SLOTS +#if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY next = iternext(iterator); if (likely(next)) return next; - #if PY_VERSION_HEX >= 0x02070000 +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 if (unlikely(iternext == &_PyObject_NextNotImplemented)) return NULL; - #endif +#endif #else next = PyIter_Next(iterator); if (likely(next)) @@ -12249,15 +16308,17 @@ static CYTHON_INLINE PyObject *__Pyx_PyIter_Next2(PyObject* iterator, PyObject* /* 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; +static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) { + CYTHON_MAYBE_UNUSED_VAR(intval); + CYTHON_MAYBE_UNUSED_VAR(inplace); + CYTHON_UNUSED_VAR(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); + + x = (long)((unsigned long)a - (unsigned long)b); if (likely((x^a) >= 0 || (x^~b) >= 0)) return PyInt_FromLong(x); return PyLong_Type.tp_as_number->nb_subtract(op1, op2); @@ -12271,77 +16332,79 @@ static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, CYTHON_U 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; + 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 + #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 + #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 + #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 + #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 + #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 + #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 + #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 + #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 + #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 + #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 + #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 + #endif } CYTHON_FALLTHROUGH; default: return PyLong_Type.tp_as_number->nb_subtract(op1, op2); @@ -12360,8 +16423,13 @@ static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, CYTHON_U #endif if (PyFloat_CheckExact(op1)) { const long b = intval; +#if CYTHON_COMPILING_IN_LIMITED_API + double a = __pyx_PyFloat_AsDouble(op1); +#else double a = PyFloat_AS_DOUBLE(op1); +#endif double result; + PyFPE_START_PROTECT("subtract", return NULL) result = ((double)a) - (double)b; PyFPE_END_PROTECT(result) @@ -12371,20 +16439,59 @@ static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, CYTHON_U } #endif +/* 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 >= 0x030C00A2) +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 >= 0x030C00A2 + 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; + } + if (unlikely(!method)) return NULL; + return __Pyx__PyObject_CallMethod1(method, arg); +#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); -} + (void) __Pyx_PyObject_CallMethod1; +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION < 3 + return _PyString_Join(sep, values); +#elif CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 + return _PyBytes_Join(sep, values); +#else + return __Pyx_PyObject_CallMethod1(sep, __pyx_n_s_join, values); #endif +} /* 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; @@ -12396,21 +16503,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; @@ -12431,6 +16563,7 @@ static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); + #endif } #endif @@ -12438,7 +16571,7 @@ static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject #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; } @@ -12459,6 +16592,22 @@ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { } return __Pyx_InBases(a, b); } +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); +} #if PY_MAJOR_VERSION == 2 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { PyObject *exception, *value, *tb; @@ -12483,11 +16632,11 @@ static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc } #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) { @@ -12534,31 +16683,6 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj } #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 - /* GetException */ #if CYTHON_FAST_THREAD_STATE static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) @@ -12566,20 +16690,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 >= 0x030C00A6 + local_value = tstate->current_exception; + tstate->current_exception = 0; + if (likely(local_value)) { + local_type = (PyObject*) Py_TYPE(local_value); + Py_INCREF(local_type); + local_tb = PyException_GetTraceback(local_value); + } + #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 #else PyErr_Fetch(&local_type, &local_value, &local_tb); #endif PyErr_NormalizeException(&local_type, &local_value, &local_tb); -#if CYTHON_FAST_THREAD_STATE +#if CYTHON_FAST_THREAD_STATE && PY_VERSION_HEX >= 0x030C00A6 + if (unlikely(tstate->current_exception)) +#elif CYTHON_FAST_THREAD_STATE if (unlikely(tstate->curexc_type)) #else if (unlikely(PyErr_Occurred())) @@ -12601,12 +16737,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; @@ -12633,11 +16778,51 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) return -1; } +/* PyObjectFormatAndDecref */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f) { + if (unlikely(!s)) return NULL; + if (likely(PyUnicode_CheckExact(s))) return s; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_CheckExact(s))) { + PyObject *result = PyUnicode_FromEncodedObject(s, NULL, "strict"); + Py_DECREF(s); + return result; + } + #endif + 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; +} + /* 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; @@ -12645,14 +16830,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; @@ -12668,69 +16853,599 @@ static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, } #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))) +/* JoinPyUnicode */ +static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, 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; + CYTHON_MAYBE_UNUSED_VAR(max_char); +#if CYTHON_PEP393_ENABLED + 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); +#else + result_uval = PyUnicode_FromUnicode(NULL, result_ulength); + if (unlikely(!result_uval)) return NULL; + result_ukind = sizeof(Py_UNICODE); + kind_shift = (result_ukind == 4) ? 2 : result_ukind - 1; + result_udata = PyUnicode_AS_UNICODE(result_uval); +#endif + assert(kind_shift == 2 || kind_shift == 1 || kind_shift == 0); + char_pos = 0; + for (i=0; i < value_count; i++) { + int ukind; + Py_ssize_t ulength; + void *udata; + PyObject *uval = PyTuple_GET_ITEM(value_tuple, i); + if (unlikely(__Pyx_PyUnicode_READY(uval))) + goto bad; + ulength = __Pyx_PyUnicode_GET_LENGTH(uval); + 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 (!CYTHON_PEP393_ENABLED || 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 && PY_VERSION_HEX >= 0x030300F0 || 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 + CYTHON_UNUSED_VAR(max_char); + CYTHON_UNUSED_VAR(result_ulength); + CYTHON_UNUSED_VAR(value_count); + return PyUnicode_Join(__pyx_empty_unicode, value_tuple); +#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); +} + +/* pep479 */ +static void __Pyx_Generator_Replace_StopIteration(int in_async_gen) { + PyObject *exc, *val, *tb, *cur_exc; + __Pyx_PyThreadState_declare + #ifdef __Pyx_StopAsyncIteration_USED + int is_async_stopiteration = 0; + #endif + CYTHON_MAYBE_UNUSED_VAR(in_async_gen); + cur_exc = PyErr_Occurred(); + if (likely(!__Pyx_PyErr_GivenExceptionMatches(cur_exc, PyExc_StopIteration))) { + #ifdef __Pyx_StopAsyncIteration_USED + if (in_async_gen && unlikely(__Pyx_PyErr_GivenExceptionMatches(cur_exc, __Pyx_PyExc_StopAsyncIteration))) { + is_async_stopiteration = 1; + } else + #endif + return; + } + __Pyx_PyThreadState_assign + __Pyx_GetException(&exc, &val, &tb); + Py_XDECREF(exc); + Py_XDECREF(val); + Py_XDECREF(tb); + PyErr_SetString(PyExc_RuntimeError, + #ifdef __Pyx_StopAsyncIteration_USED + is_async_stopiteration ? "async generator raised StopAsyncIteration" : + in_async_gen ? "async generator raised StopIteration" : + #endif + "generator raised StopIteration"); +} + +/* FixUpExtensionType */ +#if CYTHON_USE_TYPE_SPECS +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) { +#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + CYTHON_UNUSED_VAR(spec); + CYTHON_UNUSED_VAR(type); +#else + const PyType_Slot *slot = spec->slots; + while (slot && slot->slot && slot->slot != Py_tp_members) + slot++; + if (slot && slot->slot == Py_tp_members) { + int changed = 0; +#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON) + const +#endif + PyMemberDef *memb = (PyMemberDef*) slot->pfunc; + while (memb && memb->name) { + if (memb->name[0] == '_' && memb->name[1] == '_') { +#if PY_VERSION_HEX < 0x030900b1 + 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 +#else + if ((0)); +#endif +#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON + 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; + if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) { + Py_DECREF(descr); + return -1; + } + Py_DECREF(descr); + changed = 1; + } +#endif + } + memb++; + } + if (changed) + PyType_Modified(type); + } +#endif + return 0; +} +#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_MACROS + n = PyTuple_GET_SIZE(bases); +#else + n = PyTuple_Size(bases); + if (n < 0) return -1; +#endif + for (i = 1; i < n; i++) + { +#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 + PyTypeObject *b; +#if PY_MAJOR_VERSION < 3 + if (PyClass_Check(b0)) + { + PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class", + PyString_AS_STRING(((PyClassObject*)b0)->cl_name)); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } +#endif + b = (PyTypeObject*) b0; + if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) + { + __Pyx_TypeName b_name = __Pyx_PyType_GetName(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 || CYTHON_COMPILING_IN_PYPY + 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_GetName(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 || CYTHON_COMPILING_IN_PYPY) + 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 */ +static int __Pyx_PyType_Ready(PyTypeObject *t) { +#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || 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; + 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 PY_VERSION_HEX >= 0x03050000 && !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 PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) + gc = PyImport_GetModule(__pyx_kp_u_gc); + #endif + if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc); + if (unlikely(!gc)) return -1; + py_status = __Pyx_PyObject_CallMethod0(gc, __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_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 PY_VERSION_HEX >= 0x03050000 && !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_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 +} + +/* PyObject_GenericGetAttrNoDict */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { + __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp); + PyErr_Format(PyExc_AttributeError, +#if PY_MAJOR_VERSION >= 3 + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, attr_name); +#else + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", + type_name, PyString_AS_STRING(attr_name)); +#endif + __Pyx_DECREF_TypeName(type_name); + 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); + } + 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 descr; +} +#endif + +/* 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_n_s_pyx_vtable, ob) < 0)) +#else + if (unlikely(PyDict_SetItem(type->tp_dict, __pyx_n_s_pyx_vtable, ob) < 0)) +#endif + 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_n_s_pyx_vtable); +#else + PyObject *ob = PyObject_GetItem(type->tp_dict, __pyx_n_s_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; +} + +/* MergeVTables */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_MergeVtables(PyTypeObject *type) { + int i; + void** base_vtables; + __Pyx_TypeName tp_base_name; + __Pyx_TypeName base_name; + void* unknown = (void*)-1; + PyObject* bases = type->tp_bases; + int base_depth = 0; + { + PyTypeObject* base = type->tp_base; + while (base) { + base_depth += 1; + base = base->tp_base; + } + } + base_vtables = (void**) malloc(sizeof(void*) * (size_t)(base_depth + 1)); + base_vtables[0] = unknown; + for (i = 1; i < PyTuple_GET_SIZE(bases); i++) { + void* base_vtable = __Pyx_GetVtable(((PyTypeObject*)PyTuple_GET_ITEM(bases, i))); + if (base_vtable != NULL) { + int j; + PyTypeObject* base = type->tp_base; + 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 = base->tp_base; + } + } + } + PyErr_Clear(); + free(base_vtables); + return 0; +bad: + tp_base_name = __Pyx_PyType_GetName(type->tp_base); + base_name = __Pyx_PyType_GetName((PyTypeObject*)PyTuple_GET_ITEM(bases, i)); + PyErr_Format(PyExc_TypeError, + "multiple bases have vtable conflict: '" __Pyx_FMT_TYPENAME "' and '" __Pyx_FMT_TYPENAME "'", tp_base_name, base_name); + __Pyx_DECREF_TypeName(tp_base_name); + __Pyx_DECREF_TypeName(base_name); + free(base_vtables); + return -1; +} +#endif + +/* TypeImport */ +#ifndef __PYX_HAVE_RT_ImportType_3_0_10 +#define __PYX_HAVE_RT_ImportType_3_0_10 +static PyTypeObject *__Pyx_ImportType_3_0_10(PyObject *module, const char *module_name, const char *class_name, + size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_10 check_size) +{ + PyObject *result = 0; + char warning[200]; + Py_ssize_t basicsize; + Py_ssize_t itemsize; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_basicsize; + PyObject *py_itemsize; #endif - return __Pyx_PyObject_GetAttrStr(o, n); + 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 + 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 - return PyObject_GetAttr(o, n); -} - -/* 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); + 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_0_10 && + ((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_0_10 && (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 (PyTypeObject *)result; +bad: + Py_XDECREF(result); + return NULL; } +#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; + PyObject *empty_list = 0; #if PY_MAJOR_VERSION < 3 PyObject *py_import; py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); - if (!py_import) + if (unlikely(!py_import)) goto bad; - #endif - if (from_list) - list = from_list; - else { + if (!from_list) { empty_list = PyList_New(0); - if (!empty_list) + if (unlikely(!empty_list)) goto bad; - list = empty_list; + from_list = empty_list; } - global_dict = PyModule_GetDict(__pyx_m); - if (!global_dict) - goto bad; + #endif empty_dict = PyDict_New(); - if (!empty_dict) + if (unlikely(!empty_dict)) goto bad; { #if PY_MAJOR_VERSION >= 3 if (level == -1) { - if (strchr(__Pyx_MODULE_NAME, '.')) { + if (strchr(__Pyx_MODULE_NAME, '.') != NULL) { module = PyImport_ImportModuleLevelObject( - name, global_dict, empty_dict, list, 1); - if (!module) { - if (!PyErr_ExceptionMatches(PyExc_ImportError)) + name, __pyx_d, empty_dict, from_list, 1); + if (unlikely(!module)) { + if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError))) goto bad; PyErr_Clear(); } @@ -12741,424 +17456,1245 @@ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { if (!module) { #if PY_MAJOR_VERSION < 3 PyObject *py_level = PyInt_FromLong(level); - if (!py_level) + if (unlikely(!py_level)) goto bad; module = PyObject_CallFunctionObjArgs(py_import, - name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); + name, __pyx_d, empty_dict, from_list, py_level, (PyObject *)NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( - name, global_dict, empty_dict, list, level); + name, __pyx_d, empty_dict, from_list, level); #endif } } -bad: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(py_import); +bad: + Py_XDECREF(empty_dict); + Py_XDECREF(empty_list); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_import); + #endif + 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)) { + 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_kp_u__14); + if (unlikely(!module_dot)) { goto modbad; } + full_name = PyUnicode_Concat(module_dot, name); + if (unlikely(!full_name)) { goto modbad; } + #if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) + { + 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, + #if PY_MAJOR_VERSION < 3 + "cannot import name %.230s", PyString_AS_STRING(name)); + #else + "cannot import name %S", name); + #endif + } + return value; +} + +/* FetchSharedCythonModule */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void) { + return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME); +} + +/* FetchCommonType */ +static int __Pyx_VerifyCachedType(PyObject *cached_type, + const char *name, + Py_ssize_t basicsize, + Py_ssize_t expected_basicsize) { + if (!PyType_Check(cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", name); + return -1; + } + if (basicsize != expected_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + name); + return -1; + } + return 0; +} +#if !CYTHON_USE_TYPE_SPECS +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { + PyObject* abi_module; + const char* object_name; + PyTypeObject *cached_type = NULL; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) return NULL; + object_name = strrchr(type->tp_name, '.'); + object_name = object_name ? object_name+1 : type->tp_name; + cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name); + if (cached_type) { + if (__Pyx_VerifyCachedType( + (PyObject *)cached_type, + object_name, + cached_type->tp_basicsize, + type->tp_basicsize) < 0) { + goto bad; + } + goto done; + } + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + if (PyType_Ready(type) < 0) goto bad; + if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0) + goto bad; + Py_INCREF(type); + cached_type = type; +done: + Py_DECREF(abi_module); + return cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} +#else +static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *abi_module, *cached_type = NULL; + const char* object_name = strrchr(spec->name, '.'); + object_name = object_name ? object_name+1 : spec->name; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) return NULL; + cached_type = PyObject_GetAttrString(abi_module, object_name); + if (cached_type) { + Py_ssize_t basicsize; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_basicsize; + py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); + if (unlikely(!py_basicsize)) goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; +#else + basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1; +#endif + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + basicsize, + spec->basicsize) < 0) { + goto bad; + } + goto done; + } + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + CYTHON_UNUSED_VAR(module); + cached_type = __Pyx_PyType_FromModuleAndSpec(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; + if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad; +done: + Py_DECREF(abi_module); + assert(cached_type == NULL || PyType_Check(cached_type)); + return (PyTypeObject *) cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} +#endif + +/* PyVectorcallFastCallDict */ +#if CYTHON_METH_FASTCALL +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; + Py_ssize_t nkw = PyDict_GET_SIZE(kw); + 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 &= Py_TYPE(key)->tp_flags; + Py_INCREF(key); + Py_INCREF(value); + PyTuple_SET_ITEM(kwnames, i, key); + 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) +{ + if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) { + return vc(func, args, nargs, NULL); + } + return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); +} +#endif + +/* CythonFunctionShared */ +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { + 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; +} +#else +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { + 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(__pyx_CyFunctionObject *op, void *closure) +{ + CYTHON_UNUSED_VAR(closure); + 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) { +#if PY_MAJOR_VERSION >= 3 + op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); +#else + op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); +#endif + 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 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_Py_XDECREF_SET(op->func_doc, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(op->func_name == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_name = PyObject_GetAttrString(op->func, "__name__"); +#elif PY_MAJOR_VERSION >= 3 + op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); +#else + op->func_name = PyString_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 int +__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) +#else + if (unlikely(value == NULL || !PyString_Check(value))) +#endif + { + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_name, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + Py_INCREF(op->func_qualname); + return op->func_qualname; +} +static int +__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) +#else + if (unlikely(value == NULL || !PyString_Check(value))) +#endif + { + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_qualname, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(op->func_dict == NULL)) { + op->func_dict = PyDict_New(); + if (unlikely(op->func_dict == NULL)) + return NULL; + } + Py_INCREF(op->func_dict); + return op->func_dict; +} +static int +__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, 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_Py_XDECREF_SET(op->func_dict, value); + 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_XDECREF(empty_list); - Py_XDECREF(empty_dict); - return module; + Py_DECREF(res); + return result; } - -/* 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 +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 value; + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->defaults_tuple, value); + 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; - } - 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; +static PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->defaults_tuple; + CYTHON_UNUSED_VAR(context); + 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; } } - __Pyx_PyThreadState_assign - __Pyx_ErrRestore(type, value, tb); - return; -raise_error: - Py_XDECREF(value); - Py_XDECREF(type); - Py_XDECREF(tb); - return; + Py_INCREF(result); + 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)) { +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: arg 3 must be a traceback or None"); - goto bad; + "__kwdefaults__ must be set to a dict object"); + return -1; } - 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; - } + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->defaults_kwdict; + CYTHON_UNUSED_VAR(context); + 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; } - } else { + } + Py_INCREF(result); + 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, - "raise: exception class must be a subclass of BaseException"); - goto bad; + "__annotations__ 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); - } else { - PyErr_SetString(PyExc_TypeError, - "exception causes must derive from " - "BaseException"); - goto bad; - } - PyException_SetCause(value, fixed_cause); + Py_XINCREF(value); + __Pyx_Py_XDECREF_SET(op->func_annotations, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->func_annotations; + CYTHON_UNUSED_VAR(context); + if (unlikely(!result)) { + result = PyDict_New(); + if (unlikely(!result)) return NULL; + op->func_annotations = result; } - 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_is_coroutine(__pyx_CyFunctionObject *op, void *context) { + int is_coroutine; + CYTHON_UNUSED_VAR(context); + if (op->func_is_coroutine) { + return __Pyx_NewRef(op->func_is_coroutine); + } + is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; +#if PY_VERSION_HEX >= 0x03050000 + if (is_coroutine) { + PyObject *module, *fromlist, *marker = __pyx_n_s_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_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0); + Py_DECREF(fromlist); + if (unlikely(!module)) goto ignore; + op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker); + Py_DECREF(module); + if (likely(op->func_is_coroutine)) { + return __Pyx_NewRef(op->func_is_coroutine); + } +ignore: + PyErr_Clear(); } -bad: - Py_XDECREF(owned_instance); - return; +#endif + op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine); + return __Pyx_NewRef(op->func_is_coroutine); +} +#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[] = { + {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, + {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {(char *) "_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 + {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, +#endif +#if CYTHON_USE_TYPE_SPECS + {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, +#if CYTHON_METH_FASTCALL +#if CYTHON_BACKPORT_VECTORCALL + {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, +#else +#if !CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, +#endif +#endif +#endif +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, +#else + {(char *) "__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) +{ + CYTHON_UNUSED_VAR(args); +#if PY_MAJOR_VERSION >= 3 + Py_INCREF(m->func_qualname); + return m->func_qualname; +#else + return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name); +#endif +} +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} +}; +#if PY_VERSION_HEX < 0x030500A0 || 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_pyobjects = 0; + op->defaults_size = 0; + 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 + 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); + } #endif - -/* ExtTypeTest */ -static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { - if (unlikely(!type)) { - PyErr_SetString(PyExc_SystemError, "Missing type object"); - return 0; +#endif + Py_CLEAR(m->defaults_tuple); + Py_CLEAR(m->defaults_kwdict); + Py_CLEAR(m->func_annotations); + Py_CLEAR(m->func_is_coroutine); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_XDECREF(pydefaults[i]); + PyObject_Free(m->defaults); + m->defaults = NULL; } - 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; - } - r = __Pyx_GetAttr(o, n); - if (unlikely(!r)) { - PyErr_Clear(); - return 0; - } else { - Py_DECREF(r); - return 1; +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) +{ + 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); + Py_VISIT(m->func_name); + Py_VISIT(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + Py_VISIT(m->func_code); +#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); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_VISIT(pydefaults[i]); } + return 0; } - -/* 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, +static PyObject* +__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) +{ #if PY_MAJOR_VERSION >= 3 - "'%.50s' object has no attribute '%U'", - tp->tp_name, attr_name); + return PyUnicode_FromFormat("", + op->func_qualname, (void *)op); +#else + return PyString_FromFormat("", + PyString_AsString(op->func_qualname), (void *)op); +#endif +} +static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *f = ((__pyx_CyFunctionObject*)func)->func; + PyObject *py_name = NULL; + 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*)meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_MACROS + 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); +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, + "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, size); + Py_DECREF(py_name); #else - "'%.50s' object has no attribute '%.400s'", - tp->tp_name, PyString_AS_STRING(attr_name)); + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); #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); - } - 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 NULL; + } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_MACROS + 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; + } +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, + "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, size); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); +#endif + return NULL; } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + return NULL; } - return descr; -} +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments", + py_name); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", + f->m_ml->ml_name); #endif - -/* SetVTable */ -static int __Pyx_SetVtable(PyObject *dict, void *vtable) { -#if PY_VERSION_HEX >= 0x02070000 - PyObject *ob = PyCapsule_New(vtable, 0, 0); + 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 - PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); + self = ((PyCFunctionObject*)func)->m_self; #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; + result = __Pyx_CyFunction_CallMethod(func, self, arg, kw); + 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_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 PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { + PyObject *result; + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; +#if CYTHON_METH_FASTCALL + __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); + if (vc) { +#if CYTHON_ASSUME_SAFE_MACROS + 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 + } +#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_MACROS + 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); +#if PY_MAJOR_VERSION > 2 + PyErr_Format(PyExc_TypeError, + "unbound method %.200S() needs an argument", + cyfunc->func_qualname); +#else + PyErr_SetString(PyExc_TypeError, + "unbound method needs an argument"); +#endif + return NULL; + } + result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); + Py_DECREF(new_args); + } else { + result = __Pyx_CyFunction_Call(func, args, kw); + } + return result; } -static int __Pyx_setup_reduce(PyObject* type_obj) { +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames) +{ 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); + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + if (unlikely(nargs < 1)) { + PyErr_Format(PyExc_TypeError, "%.200s() needs an argument", + ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); + return -1; + } + ret = 1; + } + if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); + return -1; + } return ret; } - -/* 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_NOARGS(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; -#endif - result = PyObject_GetAttrString(module, class_name); - if (!result) - goto bad; - if (!PyType_Check(result)) { + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + if (unlikely(nargs != 0)) { PyErr_Format(PyExc_TypeError, - "%.200s.%.200s is not a type object", - module_name, class_name); - goto bad; + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + def->ml_name, nargs); + return NULL; } -#ifndef Py_LIMITED_API - basicsize = ((PyTypeObject *)result)->tp_basicsize; + return def->ml_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; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; #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; -#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; + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + 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; + if (unlikely(nargs != 1)) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + def->ml_name, nargs); + return NULL; } - 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 def->ml_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; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_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; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; + 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; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames); +} +#endif +#if CYTHON_USE_TYPE_SPECS +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 (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL) + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + __pyx_CyFunctionType_slots +}; +#else +static PyTypeObject __pyx_CyFunctionType_type = { + PyVarObject_HEAD_INIT(0, 0) + __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, + (destructor) __Pyx_CyFunction_dealloc, +#if !CYTHON_METH_FASTCALL + 0, +#elif CYTHON_BACKPORT_VECTORCALL + (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall), +#else + offsetof(PyCFunctionObject, vectorcall), +#endif + 0, + 0, +#if PY_MAJOR_VERSION < 3 + 0, +#else + 0, +#endif + (reprfunc) __Pyx_CyFunction_repr, + 0, + 0, + 0, + 0, + __Pyx_CyFunction_CallAsMethod, + 0, + 0, + 0, + 0, +#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR + Py_TPFLAGS_METHOD_DESCRIPTOR | +#endif +#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + 0, + (traverseproc) __Pyx_CyFunction_traverse, + (inquiry) __Pyx_CyFunction_clear, + 0, +#if PY_VERSION_HEX < 0x030500A0 + offsetof(__pyx_CyFunctionObject, func_weakreflist), +#else + offsetof(PyCFunctionObject, m_weakreflist), +#endif + 0, + 0, + __pyx_CyFunction_methods, + __pyx_CyFunction_members, + __pyx_CyFunction_getsets, + 0, + 0, + __Pyx_PyMethod_New, + 0, + offsetof(__pyx_CyFunctionObject, func_dict), + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX >= 0x030400a1 + 0, +#endif +#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, +#endif +#if __PYX_NEED_TP_PRINT_SLOT + 0, +#endif +#if PY_VERSION_HEX >= 0x030C0000 + 0, +#endif +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, +#endif +}; +#endif +static int __pyx_CyFunction_init(PyObject *module) { +#if CYTHON_USE_TYPE_SPECS + __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL); +#else + CYTHON_UNUSED_VAR(module); + __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); +#endif + if (unlikely(__pyx_CyFunctionType == NULL)) { + return -1; } - return (PyTypeObject *)result; -bad: - Py_XDECREF(result); - return NULL; + return 0; +} +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults = PyObject_Malloc(size); + if (unlikely(!m->defaults)) + return PyErr_NoMemory(); + memset(m->defaults, 0, size); + m->defaults_pyobjects = pyobjects; + m->defaults_size = size; + 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_CyFunctionType), + ml, flags, qualname, closure, module, globals, code + ); + if (likely(op)) { + PyObject_GC_Track(op); + } + return op; } -#endif /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK @@ -13168,6 +18704,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif + CYTHON_MAYBE_UNUSED_VAR(tstate); if (unlikely(!__pyx_cython_runtime)) { return c_line; } @@ -13181,7 +18718,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { } 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_cython_runtime, __pyx_n_s_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; Py_DECREF(use_cline_obj); @@ -13192,7 +18729,7 @@ 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_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); } else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { c_line = 0; @@ -13203,6 +18740,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { #endif /* CodeObjectCache */ +#if !CYTHON_COMPILING_IN_LIMITED_API static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { @@ -13266,7 +18804,7 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { if (__pyx_code_cache.count == __pyx_code_cache.max_count) { int new_max = __pyx_code_cache.max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( - __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); + __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } @@ -13281,44 +18819,136 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { __pyx_code_cache.count++; Py_INCREF(code_object); } +#endif /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API + #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; + result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict); + Py_DECREF(replace); + return result; + } + PyErr_Clear(); + #if __PYX_LIMITED_VERSION_HEX < 0x030780000 + { + PyObject *compiled = NULL, *result = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL; + compiled = Py_CompileString( + "out = type(code)(\n" + " code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n" + " code.co_flags, code.co_code, code.co_consts, code.co_names,\n" + " code.co_varnames, code.co_filename, co_name, co_firstlineno,\n" + " code.co_lnotab)\n", "", Py_file_input); + if (!compiled) return NULL; + result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict); + Py_DECREF(compiled); + if (!result) PyErr_Print(); + Py_DECREF(result); + result = PyDict_GetItemString(scratch_dict, "out"); + if (result) Py_INCREF(result); + return result; + } + #else + return NULL; + #endif +} +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 = 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; + 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; + PyCodeObject *py_code = NULL; + PyObject *py_funcname = NULL; #if PY_MAJOR_VERSION < 3 + PyObject *py_srcfile = NULL; py_srcfile = PyString_FromString(filename); - #else - py_srcfile = PyUnicode_FromString(filename); - #endif if (!py_srcfile) goto bad; + #endif if (c_line) { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + if (!py_funcname) goto bad; #else py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + if (!py_funcname) goto bad; + funcname = PyUnicode_AsUTF8(py_funcname); + if (!funcname) goto bad; #endif } else { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromString(funcname); - #else - py_funcname = PyUnicode_FromString(funcname); + if (!py_funcname) goto bad; #endif } - if (!py_funcname) goto bad; + #if PY_MAJOR_VERSION < 3 py_code = __Pyx_PyCode_New( 0, 0, 0, 0, 0, + 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ @@ -13331,11 +18961,16 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( __pyx_empty_bytes /*PyObject *lnotab*/ ); Py_DECREF(py_srcfile); - Py_DECREF(py_funcname); + #else + py_code = PyCode_NewEmpty(filename, funcname, py_line); + #endif + Py_XDECREF(py_funcname); return py_code; bad: - Py_XDECREF(py_srcfile); Py_XDECREF(py_funcname); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_srcfile); + #endif return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, @@ -13343,14 +18978,24 @@ 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( @@ -13366,37 +19011,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,44 +19035,20 @@ 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); -#endif - } - } else { - if (sizeof(long) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { - return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif - } - } - { - int one = 1; int little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&value; - return _PyLong_FromByteArray(bytes, sizeof(long), - little, !is_unsigned); - } -} - /* CIntFromPy */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { - const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; +#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(int) < sizeof(long)) { + if ((sizeof(int) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -13471,40 +19062,45 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (int) 0; - case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) - case 2: - if (8 * sizeof(int) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { - return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + 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)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; - case 3: - if (8 * sizeof(int) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { - return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; - case 4: - if (8 * sizeof(int) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { - return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -13517,136 +19113,359 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { goto raise_neg_overflow; } #endif - if (sizeof(int) <= sizeof(unsigned long)) { + 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)) { + } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (int) 0; - case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) - case -2: - if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + 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)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 2: - if (8 * sizeof(int) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case -3: - if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case -3: + if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 3: - if (8 * sizeof(int) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case -4: - if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case -4: + if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 4: - if (8 * sizeof(int) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { - return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; + break; + } } #endif - if (sizeof(int) <= sizeof(long)) { + 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)) { + } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { -#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) - PyErr_SetString(PyExc_RuntimeError, - "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); -#else int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if 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; - int ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (int) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (int) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (int) -1; + } else { + stepval = __Pyx_NewRef(v); + } + 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; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((int) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + 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 CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + 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 Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (int) -1; } - } else { - int val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (int) -1; - val = __Pyx_PyInt_As_int(tmp); - Py_DECREF(tmp); - return val; + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +/* CIntToPy */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_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(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; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = 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; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif + } +} + +/* CIntToPy */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_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); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = 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; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif } -raise_overflow: - PyErr_SetString(PyExc_OverflowError, - "value too large to convert to int"); - return (int) -1; -raise_neg_overflow: - PyErr_SetString(PyExc_OverflowError, - "can't convert negative value to int"); - return (int) -1; } +/* FormatTypeName */ +#if CYTHON_COMPILING_IN_LIMITED_API +static __Pyx_TypeName +__Pyx_PyType_GetName(PyTypeObject* tp) +{ + PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_n_s_name_2); + if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) { + PyErr_Clear(); + Py_XDECREF(name); + name = __Pyx_NewRef(__pyx_kp_s__9); + } + return name; +} +#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; +#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 PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { - if (sizeof(long) < sizeof(long)) { + if ((sizeof(long) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -13660,40 +19479,45 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (long) 0; - case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) - case 2: - if (8 * sizeof(long) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { - return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + 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)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; - case 3: - if (8 * sizeof(long) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { - return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; - case 4: - if (8 * sizeof(long) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { - return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -13706,109 +19530,181 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { goto raise_neg_overflow; } #endif - if (sizeof(long) <= sizeof(unsigned long)) { + 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)) { + } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (long) 0; - case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) - case -2: - if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + 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)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 2: - if (8 * sizeof(long) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case -3: - if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case -3: + if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 3: - if (8 * sizeof(long) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case -4: - if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case -4: + if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 4: - if (8 * sizeof(long) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; + break; + } } #endif - if (sizeof(long) <= sizeof(long)) { + 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)) { + } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { -#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) - PyErr_SetString(PyExc_RuntimeError, - "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); -#else long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if 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; - int ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (long) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (long) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (long) -1; + } else { + stepval = __Pyx_NewRef(v); + } + 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; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((long) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + 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 CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + 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 Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (long) -1; } } else { @@ -13829,70 +19725,19 @@ 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); - 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; -} - -/* PyObjectCallMethod1 */ -static PyObject* __Pyx__PyObject_CallMethod1(PyObject* method, PyObject* arg) { - PyObject *result = __Pyx_PyObject_CallOneArg(method, arg); - Py_DECREF(method); - return result; -} -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; - } - if (unlikely(!method)) return NULL; - return __Pyx__PyObject_CallMethod1(method, arg); -} - /* CoroutineBase */ -#include #include +#if PY_VERSION_HEX >= 0x030b00a6 + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif #define __Pyx_Coroutine_Undelegate(gen) Py_CLEAR((gen)->yieldfrom) -static int __Pyx_PyGen__FetchStopIterationValue(CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject **pvalue) { +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); @@ -13907,7 +19752,7 @@ static int __Pyx_PyGen__FetchStopIterationValue(CYTHON_UNUSED PyThreadState *__p 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))) { value = ((PyStopIterationObject *)ev)->value; Py_INCREF(value); Py_DECREF(ev); @@ -13971,6 +19816,9 @@ static int __Pyx_PyGen__FetchStopIterationValue(CYTHON_UNUSED PyThreadState *__p } 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 +19829,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)) { @@ -14000,8 +19850,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) { +static void __Pyx__Coroutine_NotStartedError(PyObject *gen) { const char *msg; + CYTHON_MAYBE_UNUSED_VAR(gen); if ((0)) { #ifdef __Pyx_Coroutine_USED } else if (__Pyx_Coroutine_Check(gen)) { @@ -14017,7 +19868,9 @@ static void __Pyx__Coroutine_NotStartedError(CYTHON_UNUSED PyObject *gen) { 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"); @@ -14054,15 +19907,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_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 } @@ -14078,7 +19946,7 @@ PyObject *__Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value, i } #endif self->is_running = 1; - retval = self->body((PyObject *) self, tstate, value); + retval = self->body(self, tstate, value); self->is_running = 0; #if CYTHON_USE_EXC_INFO_STACK exc_state = &self->gi_exc_state; @@ -14089,18 +19957,29 @@ PyObject *__Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value, i return retval; } 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_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); -#endif + #if PY_VERSION_HEX >= 0x030B00a4 + Py_DECREF(exc_tb); + #endif } +#endif } static CYTHON_INLINE -PyObject *__Pyx_Coroutine_MethodReturn(CYTHON_UNUSED PyObject* gen, PyObject *retval) { +PyObject *__Pyx_Coroutine_MethodReturn(PyObject* gen, PyObject *retval) { + CYTHON_MAYBE_UNUSED_VAR(gen); if (unlikely(!retval)) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign @@ -14115,6 +19994,43 @@ PyObject *__Pyx_Coroutine_MethodReturn(CYTHON_UNUSED PyObject* gen, PyObject *re } return retval; } +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03030000 && (defined(__linux__) || PY_VERSION_HEX >= 0x030600B3) +static CYTHON_INLINE +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 result; +#endif +} +#endif static CYTHON_INLINE PyObject *__Pyx_Coroutine_FinishDelegation(__pyx_CoroutineObject *gen) { PyObject *ret; @@ -14151,17 +20067,17 @@ static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value) { #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, 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 { if (value == Py_None) - ret = Py_TYPE(yf)->tp_iternext(yf); + ret = __Pyx_PyObject_GetIterNextFunc(yf)(yf); else ret = __Pyx_PyObject_CallMethod1(yf, __pyx_n_s_send, value); } @@ -14208,16 +20124,15 @@ static int __Pyx_Coroutine_CloseIter(__pyx_CoroutineObject *gen, PyObject *yf) { { PyObject *meth; gen->is_running = 1; - meth = __Pyx_PyObject_GetAttrStr(yf, __pyx_n_s_close); + meth = __Pyx_PyObject_GetAttrStrNoError(yf, __pyx_n_s_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) + if (unlikely(!retval)) err = -1; } gen->is_running = 0; @@ -14240,7 +20155,7 @@ static PyObject *__Pyx_Generator_Next(PyObject *self) { #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); + ret = __Pyx_PyGen_Send((PyGenObject*)yf, NULL); } else #endif #ifdef __Pyx_Coroutine_USED @@ -14248,7 +20163,7 @@ static PyObject *__Pyx_Generator_Next(PyObject *self) { ret = __Pyx_Coroutine_Send(yf, Py_None); } else #endif - ret = Py_TYPE(yf)->tp_iternext(yf); + ret = __Pyx_PyObject_GetIterNextFunc(yf)(yf); gen->is_running = 0; if (likely(ret)) { return ret; @@ -14257,7 +20172,8 @@ static PyObject *__Pyx_Generator_Next(PyObject *self) { } return __Pyx_Coroutine_SendEx(gen, Py_None, 0); } -static PyObject *__Pyx_Coroutine_Close_Method(PyObject *self, CYTHON_UNUSED PyObject *arg) { +static PyObject *__Pyx_Coroutine_Close_Method(PyObject *self, PyObject *arg) { + CYTHON_UNUSED_VAR(arg); return __Pyx_Coroutine_Close(self); } static PyObject *__Pyx_Coroutine_Close(PyObject *self) { @@ -14338,22 +20254,22 @@ 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_n_s_throw); if (unlikely(!meth)) { Py_DECREF(yf); - if (!PyErr_ExceptionMatches(PyExc_AttributeError)) { + if (unlikely(PyErr_Occurred())) { gen->is_running = 0; 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); } @@ -14372,14 +20288,18 @@ 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, (char *)"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) { @@ -14400,6 +20320,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); @@ -14413,10 +20334,10 @@ static void __Pyx_Coroutine_dealloc(PyObject *self) { if (gen->resume_label >= 0) { PyObject_GC_Track(self); #if PY_VERSION_HEX >= 0x030400a1 && CYTHON_USE_TP_FINALIZE - if (PyObject_CallFinalizerFromDealloc(self)) + if (unlikely(PyObject_CallFinalizerFromDealloc(self))) #else Py_TYPE(gen)->tp_del(self); - if (self->ob_refcnt > 0) + if (unlikely(Py_REFCNT(self) > 0)) #endif { return; @@ -14432,7 +20353,7 @@ static void __Pyx_Coroutine_dealloc(PyObject *self) { } #endif __Pyx_Coroutine_clear(self); - PyObject_GC_Del(gen); + __Pyx_PyHeapTypeObject_GC_Del(gen); } static void __Pyx_Coroutine_del(PyObject *self) { PyObject *error_type, *error_value, *error_traceback; @@ -14443,7 +20364,7 @@ static void __Pyx_Coroutine_del(PyObject *self) { } #if !CYTHON_USE_TP_FINALIZE assert(self->ob_refcnt == 0); - self->ob_refcnt = 1; + __Pyx_SET_REFCNT(self, 1); #endif __Pyx_PyThreadState_assign __Pyx_ErrFetch(&error_type, &error_value, &error_traceback); @@ -14510,17 +20431,17 @@ static void __Pyx_Coroutine_del(PyObject *self) { } __Pyx_ErrRestore(error_type, error_value, error_traceback); #if !CYTHON_USE_TP_FINALIZE - assert(self->ob_refcnt > 0); - if (--self->ob_refcnt == 0) { + assert(Py_REFCNT(self) > 0); + if (likely(--self->ob_refcnt == 0)) { return; } { - Py_ssize_t refcnt = self->ob_refcnt; + Py_ssize_t refcnt = Py_REFCNT(self); _Py_NewReference(self); - self->ob_refcnt = refcnt; + __Pyx_SET_REFCNT(self, refcnt); } #if CYTHON_COMPILING_IN_CPYTHON - assert(PyType_IS_GC(self->ob_type) && + assert(PyType_IS_GC(Py_TYPE(self)) && _Py_AS_GC(self)->gc.gc_refs != _PyGC_REFS_UNTRACKED); _Py_DEC_REFTOTAL; #endif @@ -14531,17 +20452,18 @@ static void __Pyx_Coroutine_del(PyObject *self) { #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; + CYTHON_UNUSED_VAR(context); #if PY_MAJOR_VERSION >= 3 if (unlikely(value == NULL || !PyUnicode_Check(value))) #else @@ -14552,24 +20474,23 @@ __Pyx_Coroutine_set_name(__pyx_CoroutineObject *self, PyObject *value, CYTHON_UN "__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; + CYTHON_UNUSED_VAR(context); #if PY_MAJOR_VERSION >= 3 if (unlikely(value == NULL || !PyUnicode_Check(value))) #else @@ -14580,12 +20501,32 @@ __Pyx_Coroutine_set_qualname(__pyx_CoroutineObject *self, PyObject *value, CYTHO "__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, void *context) +{ + PyObject *frame = self->gi_frame; + CYTHON_UNUSED_VAR(context); + if (!frame) { + if (unlikely(!self->gi_code)) { + Py_RETURN_NONE; + } + frame = (PyObject *) PyFrame_New( + PyThreadState_Get(), /*PyThreadState *tstate,*/ + (PyCodeObject*) self->gi_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (unlikely(!frame)) + return NULL; + self->gi_frame = frame; + } + Py_INCREF(frame); + return frame; +} 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 +20545,13 @@ static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit( gen->resume_label = 0; gen->classobj = NULL; gen->yieldfrom = NULL; + #if PY_VERSION_HEX >= 0x030B00a4 + 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,6 +20564,7 @@ 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; } @@ -14690,7 +20636,7 @@ static int __Pyx_patch_abc(void) { if (CYTHON_REGISTER_ABCS && !abc_patched) { PyObject *module; module = PyImport_ImportModule((PY_MAJOR_VERSION >= 3) ? "collections.abc" : "collections"); - if (!module) { + if (unlikely(!module)) { PyErr_WriteUnraisable(NULL); if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, ((PY_MAJOR_VERSION >= 3) ? @@ -14735,6 +20681,10 @@ static PyMemberDef __pyx_Generator_memberlist[] = { {(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}, + {(char *) "__module__", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_modulename), 0, 0}, +#if CYTHON_USE_TYPE_SPECS + {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CoroutineObject, gi_weakreflist), READONLY, 0}, +#endif {0, 0, 0, 0, 0} }; static PyGetSetDef __pyx_Generator_getsets[] = { @@ -14742,11 +20692,36 @@ static PyGetSetDef __pyx_Generator_getsets[] = { (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}, + {(char *) "gi_frame", (getter)__Pyx_Coroutine_get_frame, NULL, + (char*) PyDoc_STR("Frame of the generator"), 0}, {0, 0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +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 *) __Pyx_PyObject_GenericGetAttrNoDict}, +#if CYTHON_USE_TP_FINALIZE + {Py_tp_finalize, (void *)__Pyx_Coroutine_del}, +#endif + {0, 0}, +}; +static PyType_Spec __pyx_GeneratorType_spec = { + __PYX_TYPE_MODULE_PREFIX "generator", + sizeof(__pyx_CoroutineObject), + 0, + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE, + __pyx_GeneratorType_slots +}; +#else static PyTypeObject __pyx_GeneratorType_type = { PyVarObject_HEAD_INIT(0, 0) - "generator", + __PYX_TYPE_MODULE_PREFIX "generator", sizeof(__pyx_CoroutineObject), 0, (destructor) __Pyx_Coroutine_dealloc, @@ -14801,17 +20776,29 @@ static PyTypeObject __pyx_GeneratorType_type = { #elif PY_VERSION_HEX >= 0x030400a1 0, #endif -#if PY_VERSION_HEX >= 0x030800b1 +#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, +#endif +#if __PYX_NEED_TP_PRINT_SLOT + 0, +#endif +#if PY_VERSION_HEX >= 0x030C0000 0, #endif -#if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, #endif }; -static int __pyx_Generator_init(void) { +#endif +static int __pyx_Generator_init(PyObject *module) { +#if CYTHON_USE_TYPE_SPECS + __pyx_GeneratorType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_GeneratorType_spec, NULL); +#else + CYTHON_UNUSED_VAR(module); __pyx_GeneratorType_type.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; __pyx_GeneratorType_type.tp_iter = PyObject_SelfIter; __pyx_GeneratorType = __Pyx_FetchCommonType(&__pyx_GeneratorType_type); +#endif if (unlikely(!__pyx_GeneratorType)) { return -1; } @@ -14819,25 +20806,111 @@ static int __pyx_Generator_init(void) { } /* 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 unsigned long __Pyx_get_runtime_version(void) { +#if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4 + return Py_Version & ~0xFFUL; +#else + 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; + } + return version; +#endif +} +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, (char *)"__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) + 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 */ +#if PY_MAJOR_VERSION >= 3 +static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) { + if (t.is_unicode | t.is_str) { + if (t.intern) { + *str = PyUnicode_InternFromString(t.s); + } else if (t.encoding) { + *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL); + } else { + *str = PyUnicode_FromStringAndSize(t.s, t.n - 1); + } + } else { + *str = PyBytes_FromStringAndSize(t.s, t.n - 1); + } + if (!*str) + return -1; + if (PyObject_Hash(*str) == -1) + return -1; + return 0; +} +#endif static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { - #if PY_MAJOR_VERSION < 3 + #if PY_MAJOR_VERSION >= 3 + __Pyx_InitString(*t, t->p); + #else if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { @@ -14845,30 +20918,34 @@ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } - #else - if (t->is_unicode | t->is_str) { - if (t->intern) { - *t->p = PyUnicode_InternFromString(t->s); - } else if (t->encoding) { - *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); - } else { - *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); - } - } else { - *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); - } - #endif if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) return -1; + #endif ++t; } 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; @@ -14923,7 +21000,7 @@ static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif -#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) +#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); @@ -14952,22 +21029,26 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { return retval; } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { + __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result)); #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, - "__int__ returned non-int (type %.200s). " - "The ability to return an instance of a strict subclass of int " - "is deprecated, and may be removed in a future version of Python.", - Py_TYPE(result)->tp_name)) { + "__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); + "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")", + type_name, type_name, result_type_name); + __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } @@ -15033,13 +21114,11 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* 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) { @@ -15082,6 +21161,23 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { 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); +#if PY_MAJOR_VERSION < 3 + } else if (likely(PyInt_CheckExact(o))) { + return PyInt_AS_LONG(o); +#endif + } else { + Py_ssize_t ival; + PyObject *x; + x = PyNumber_Index(o); + if (!x) return -1; + ival = PyInt_AsLong(x); + Py_DECREF(x); + return ival; + } +} static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); } @@ -15090,4 +21186,12 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { } +/* #### 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..08105936 100644 --- a/src/hunter/_event.pxd +++ b/src/hunter/_event.pxd @@ -4,8 +4,10 @@ cimport cython from ._tracer cimport * -cdef extern from "frameobject.h": +cdef extern from *: void PyFrame_FastToLocals(FrameType) + int PyFrame_GetLineNumber(FrameType) + @cython.final cdef class Event: @@ -17,6 +19,7 @@ cdef class Event: readonly int calls readonly bint threading_support readonly bint detached + readonly object builtin object _code object _filename @@ -32,5 +35,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..014cee72 100644 --- a/src/hunter/_event.pyx +++ b/src/hunter/_event.pyx @@ -1,4 +1,4 @@ -# cython: linetrace=True, language_level=3str +# cython: linetrace=True, language_level=3str, c_string_encoding=ascii from functools import partial from linecache import getline from linecache import getlines @@ -10,13 +10,18 @@ from tokenize import TokenError from tokenize import generate_tokens from cpython.pythread cimport PyThread_get_thread_ident +from cpython.ref cimport Py_XINCREF +from cpython.ref cimport PyObject +from cython cimport auto_pickle from ._tracer cimport Tracer +from .vendor._cymem.cymem cimport Pool 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 MISSING from .util import get_func_in_mro from .util import get_main_thread from .util import if_same_code @@ -25,7 +30,20 @@ __all__ = 'Event', cdef object UNSET = object() +cdef Pool mem = Pool() +cdef PyObject** KIND_NAMES = make_kind_names(['call', 'exception', 'line', 'return', 'call', 'exception', 'return']) +cdef inline PyObject** make_kind_names(list strings): + cdef PyObject** array = mem.alloc(len(strings), sizeof(PyObject*)) + cdef object name + for i, string in enumerate(strings): + name = intern(string) + Py_XINCREF( name) + array[i] = name + return array + + +@auto_pickle(False) cdef class Event: """ A wrapper object for Frame objects. Instances of this are passed to your custom functions or predicates. @@ -40,14 +58,28 @@ cdef class Event: 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, Tracer tracer=None, object depth=None, object calls=None, + object threading_support=MISSING): + if tracer is None: + if depth is None: + raise TypeError('Missing argument: depth (required because tracer was not given).') + if calls is None: + raise TypeError('Missing argument: calls (required because tracer was not given).') + if threading_support is MISSING: + raise TypeError('Missing argument: threading_support (required because tracer was not given).') + else: + depth = tracer.depth + calls = tracer.calls + threading_support = tracer.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 +95,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 = PyFrame_GetLasti(self.frame) + co_code = PyCode_GetCode(self.code_getter()) + if co_code and 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 +140,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 +151,53 @@ 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: + PyFrame_FastToLocals(self.frame) + self._locals = 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 = 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 +208,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 +222,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 +260,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 = 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 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 +292,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 +301,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 +367,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..fe50de67 100644 --- a/src/hunter/_predicates.c +++ b/src/hunter/_predicates.c @@ -1,20 +1,57 @@ -/* Generated by Cython 0.29.14 */ +/* Generated by Cython 3.0.10 */ +/* BEGIN: Cython Metadata +{ + "distutils": { + "depends": [ + "src/hunter/vendor/_compat.h" + ], + "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 */ +#if defined(CYTHON_LIMITED_API) && 0 + #ifndef Py_LIMITED_API + #if CYTHON_LIMITED_API+0 > 0x03030000 + #define Py_LIMITED_API CYTHON_LIMITED_API + #else + #define Py_LIMITED_API 0x03030000 + #endif + #endif +#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 < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.7+ or Python 3.3+. #else -#define CYTHON_ABI "0_29_14" -#define CYTHON_HEX_VERSION 0x001D0EF0 +#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API +#define __PYX_EXTRA_ABI_MODULE_NAME "limited" +#else +#define __PYX_EXTRA_ABI_MODULE_NAME "" +#endif +#define CYTHON_ABI "3_0_10" __PYX_EXTRA_ABI_MODULE_NAME +#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI +#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." +#define CYTHON_HEX_VERSION 0x03000AF0 #define CYTHON_FUTURE_DIVISION 1 #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 +70,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,12 +78,19 @@ #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_NOGIL 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 @@ -73,27 +115,176 @@ #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 (PY_MAJOR_VERSION >= 3) + #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_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 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) + #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 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_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 (PY_MAJOR_VERSION >= 3) + #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_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00) + #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 +#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_NOGIL 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_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 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 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_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 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 1 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #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 +#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL) #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 1 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif + #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 + #ifndef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #ifndef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS @@ -101,8 +292,6 @@ #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif @@ -114,27 +303,48 @@ #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 1 + #endif #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 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 1 + #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 1 + #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 + #endif #else #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 1 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif - #if PY_VERSION_HEX < 0x02070000 - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #ifndef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 @@ -143,10 +353,7 @@ #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif - #if PY_VERSION_HEX < 0x02070000 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #ifndef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS @@ -155,7 +362,7 @@ #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif - #if PY_VERSION_HEX < 0x030300F0 + #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #elif !defined(CYTHON_USE_UNICODE_WRITER) @@ -173,27 +380,63 @@ #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif + #ifndef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6) + #endif + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1) + #endif #ifndef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 1 #endif - #ifndef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif - #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) + #if PY_VERSION_HEX < 0x03050000 + #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 - #ifndef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 #endif - #ifndef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) + #if PY_VERSION_HEX < 0x030400a1 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #elif !defined(CYTHON_USE_TP_FINALIZE) + #define CYTHON_USE_TP_FINALIZE 1 + #endif + #if PY_VERSION_HEX < 0x030600B1 + #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) + #endif + #if PY_VERSION_HEX < 0x030700A3 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #elif !defined(CYTHON_USE_EXC_INFO_STACK) + #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 1 #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif +#if !defined(CYTHON_VECTORCALL) +#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) +#endif +#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) #if CYTHON_USE_PYLONG_INTERNALS - #include "longintrepr.h" + #if PY_MAJOR_VERSION < 3 + #include "longintrepr.h" + #endif #undef SHIFT #undef BASE #undef MASK @@ -218,6 +461,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,13 +485,16 @@ # 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 # define CYTHON_NCP_UNUSED @@ -245,28 +502,59 @@ # 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,13 +564,26 @@ #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 +#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)) #ifndef CYTHON_INLINE #if defined(__clang__) @@ -298,26 +599,145 @@ #endif #endif -#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) - #define Py_OptimizeFlag 0 -#endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type + #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) #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) + #define __Pyx_DefaultClassType PyType_Type +#if CYTHON_COMPILING_IN_LIMITED_API + static CYTHON_INLINE 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, "iiiiiOOOOOOiOO", 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, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else { + if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); + } + end: + Py_XDECREF(code_type); + Py_XDECREF(exception_table); + Py_XDECREF(types_module); + if (type) { + PyErr_Restore(type, value, traceback); + } + return result; + } + #ifndef CO_OPTIMIZED + #define CO_OPTIMIZED 0x0001 + #endif + #ifndef CO_NEWLOCALS + #define CO_NEWLOCALS 0x0002 + #endif + #ifndef CO_VARARGS + #define CO_VARARGS 0x0004 + #endif + #ifndef CO_VARKEYWORDS + #define CO_VARKEYWORDS 0x0008 + #endif + #ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x0200 + #endif + #ifndef CO_GENERATOR + #define CO_GENERATOR 0x0020 + #endif + #ifndef CO_COROUTINE + #define CO_COROUTINE 0x0080 + #endif +#elif PY_VERSION_HEX >= 0x030B0000 + static CYTHON_INLINE 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; + PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0); + if (!empty_bytes) return NULL; + 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, empty_bytes); + Py_DECREF(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, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + #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 - #define __Pyx_DefaultClassType PyType_Type +#endif +#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 CO_COROUTINE + #define CO_COROUTINE 0x80 +#endif +#ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x200 #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 @@ -331,6 +751,12 @@ #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 @@ -342,34 +768,89 @@ 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_MAJOR_VERSION >= 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) { +#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 < 0x030900B1 + #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_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_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 +#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() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 @@ -377,6 +858,22 @@ #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif +#if CYTHON_COMPILING_IN_LIMITED_API +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; +} +#endif +#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) +#else + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) +#endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 @@ -407,7 +904,29 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { return PyThread_get_key_value(*key); } #endif -#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) +#if PY_MAJOR_VERSION < 3 + #if CYTHON_COMPILING_IN_PYPY + #if PYPY_VERSION_NUM < 0x07030600 + #if defined(__cplusplus) && __cplusplus >= 201402L + [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]] + #elif defined(__GNUC__) || defined(__clang__) + __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))) + #elif defined(_MSC_VER) + __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")) + #endif + static CYTHON_INLINE int PyGILState_Check(void) { + return 0; + } + #else // PYPY_VERSION_NUM < 0x07030600 + #endif // PYPY_VERSION_NUM < 0x07030600 + #else + static CYTHON_INLINE int PyGILState_Check(void) { + PyThreadState * tstate = _PyThreadState_Current; + return tstate && (tstate == PyGILState_GetThisThreadState()); + } + #endif +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() @@ -419,23 +938,92 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS -#define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && 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 PY_MAJOR_VERSION >= 3 && (!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) + #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext) +#else + #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) + #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) + #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v) #else -#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v) #endif -#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) +#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_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define CYTHON_PEP393_ENABLED 1 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u) + #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)) +#elif 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))) + #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_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) - #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_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))) + #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 #else #define CYTHON_PEP393_ENABLED 0 #define PyUnicode_1BYTE_KIND 1 @@ -444,11 +1032,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #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_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((int)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_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY @@ -459,14 +1047,20 @@ 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) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500) + #undef 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)) @@ -484,8 +1078,10 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define PyString_Type PyUnicode_Type #define PyString_Check PyUnicode_Check #define PyString_CheckExact PyUnicode_CheckExact +#ifndef PyObject_Unicode #define PyObject_Unicode PyObject_Str #endif +#endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) @@ -493,19 +1089,59 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif -#ifndef PySet_CheckExact - #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#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_PySequence_ListKeepNew(obj) PySequence_List(obj) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type) +#endif +#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_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_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) + #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) #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_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) + #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) +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 + #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 __Pyx_Py3Int_Check(op) PyLong_Check(op) + #define __Pyx_Py3Int_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong @@ -517,6 +1153,9 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long +#else + #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op)) + #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op)) #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject @@ -529,15 +1168,10 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #if PY_VERSION_HEX < 0x030200A4 typedef long Py_hash_t; #define __Pyx_PyInt_FromHash_t PyInt_FromLong - #define __Pyx_PyInt_AsHash_t PyInt_AsLong + #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t #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) + #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t #endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 @@ -557,8 +1191,10 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { } __Pyx_PyAsyncMethodsStruct; #endif -#if defined(WIN32) || defined(MS_WINDOWS) - #define _USE_MATH_DEFINES +#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) + #if !defined(_USE_MATH_DEFINES) + #define _USE_MATH_DEFINES + #endif #endif #include #ifdef NAN @@ -576,13 +1212,21 @@ static CYTHON_INLINE float __PYX_NAN() { #define __Pyx_truncl truncl #endif - +#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; } #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 + { __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,7 +1239,7 @@ static CYTHON_INLINE float __PYX_NAN() { /* Early includes */ #include #include -#include "frameobject.h" +#include "vendor/_compat.h" #include "pystate.h" #ifdef _OPENMP #include @@ -645,9 +1289,10 @@ 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 @@ -665,9 +1310,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_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) @@ -675,13 +1320,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #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) @@ -693,6 +1332,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); (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 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)) #else @@ -704,8 +1344,54 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); #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 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 PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +#include static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; @@ -726,7 +1412,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { - ascii_chars[c] = c; + ascii_chars[c] = (char) c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); @@ -756,6 +1442,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #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 +#include static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; @@ -791,27 +1478,40 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } +#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 * __pyx_cfilenm = __FILE__; static const char *__pyx_filename; +/* #### Code section: filename_table ### */ static const char *__pyx_f[] = { + "", "src/hunter/_predicates.pyx", "src/hunter/_predicates.pxd", - "stringsource", - ".tox/cythonize/lib/python3.8/site-packages/Cython/Includes/cpython/type.pxd", + ".tox/cythonize/lib64/python3.11/site-packages/Cython/Includes/cpython/type.pxd", "src/hunter/_tracer.pxd", "src/hunter/_event.pxd", }; +/* #### Code section: utility_code_proto_before_types ### */ +/* 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() + +/* ForceInitThreads.proto */ +#ifndef __PYX_FORCE_INIT_THREADS + #define __PYX_FORCE_INIT_THREADS 0 +#endif + +/* #### Code section: numeric_typedefs ### */ +/* #### Code section: complex_type_declarations ### */ +/* #### Code section: type_declarations ### */ /*--- Type declarations ---*/ struct __pyx_obj_6hunter_7_tracer_Tracer; @@ -822,21 +1522,26 @@ 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; + +/* "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 *); -/* "_tracer.pxd":28 +/* "_tracer.pxd":36 * * @cython.final * cdef class Tracer: # <<<<<<<<<<<<<< @@ -848,6 +1553,7 @@ struct __pyx_obj_6hunter_7_tracer_Tracer { PyObject *handler; PyObject *previous; PyObject *threading_support; + int profiling_mode; int depth; int calls; PyObject *__weakref__; @@ -856,7 +1562,7 @@ struct __pyx_obj_6hunter_7_tracer_Tracer { }; -/* "_event.pxd":11 +/* "_event.pxd":13 * * @cython.final * cdef class Event: # <<<<<<<<<<<<<< @@ -873,6 +1579,7 @@ struct __pyx_obj_6hunter_6_event_Event { int calls; int threading_support; int detached; + PyObject *builtin; PyObject *_code; PyObject *_filename; PyObject *_fullsource; @@ -887,6 +1594,7 @@ struct __pyx_obj_6hunter_6_event_Event { PyObject *_thread; PyObject *_threadidn; PyObject *_threadname; + PyObject *_instruction; }; @@ -912,7 +1620,7 @@ struct __pyx_obj_6hunter_11_predicates_Query { }; -/* "hunter/_predicates.pxd":22 +/* "hunter/_predicates.pxd":23 * * @cython.final * cdef class And: # <<<<<<<<<<<<<< @@ -925,7 +1633,7 @@ struct __pyx_obj_6hunter_11_predicates_And { }; -/* "hunter/_predicates.pxd":27 +/* "hunter/_predicates.pxd":29 * * @cython.final * cdef class Or: # <<<<<<<<<<<<<< @@ -938,7 +1646,7 @@ struct __pyx_obj_6hunter_11_predicates_Or { }; -/* "hunter/_predicates.pxd":32 +/* "hunter/_predicates.pxd":35 * * @cython.final * cdef class Not: # <<<<<<<<<<<<<< @@ -951,7 +1659,7 @@ struct __pyx_obj_6hunter_11_predicates_Not { }; -/* "hunter/_predicates.pxd":37 +/* "hunter/_predicates.pxd":41 * * @cython.final * cdef class When: # <<<<<<<<<<<<<< @@ -965,7 +1673,7 @@ struct __pyx_obj_6hunter_11_predicates_When { }; -/* "hunter/_predicates.pxd":43 +/* "hunter/_predicates.pxd":48 * * @cython.final * cdef class From: # <<<<<<<<<<<<<< @@ -982,39 +1690,66 @@ struct __pyx_obj_6hunter_11_predicates_From { }; -/* "hunter/_predicates.pyx":137 +/* "hunter/_predicates.pxd":58 + * + * @cython.final + * cdef class Backlog: # <<<<<<<<<<<<<< + * cdef: + * readonly object condition + */ +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":78 + * + * @cython.final + * cdef class QueryEntry: # <<<<<<<<<<<<<< + * cdef Event_getter_typedef getter + * cdef int getter_index + */ +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; @@ -1023,154 +1758,85 @@ struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_2_genexpr { }; -/* "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 - * - * 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__ { - PyObject_HEAD - struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self; -}; - - -/* "hunter/_predicates.pyx":402 +/* "hunter/_predicates.pyx":446 * * def __str__(self): * return 'And(%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_4_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 - * - * 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 +/* "hunter/_predicates.pyx":496 * * 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 { +struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5_genexpr { PyObject_HEAD - struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_11___str__ *__pyx_outer_scope; + PyObject *__pyx_genexpr_arg_0; PyObject *__pyx_v_p; PyObject *__pyx_t_0; Py_ssize_t __pyx_t_1; }; +/* "cfunc.to_py":66 + * + * @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')""" + */ +struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event { + PyObject_HEAD + PyObject *(*__pyx_v_f)(struct __pyx_obj_6hunter_6_event_Event *); +}; + + -/* "_event.pxd":11 +/* "_event.pxd":13 * * @cython.final * cdef class Event: # <<<<<<<<<<<<<< @@ -1179,9 +1845,22 @@ struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_12_genexpr { */ 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,11 +1869,11 @@ 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; @@ -1204,28 +1883,40 @@ static struct __pyx_vtabstruct_6hunter_6_event_Event *__pyx_vtabptr_6hunter_6_ev #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);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)) + #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext() #endif + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ + } #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 +1927,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 +1942,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 +1977,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,9 +1993,105 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* 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); +static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); +#endif + +/* 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_Arg_VARARGS(args, i) PySequence_GetItem(args, i) +#elif CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i) +#else + #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i) +#endif +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg) + #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg) +#else + #define __Pyx_Arg_NewRef_VARARGS(arg) arg + #define __Pyx_Arg_XDECREF_VARARGS(arg) +#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_Arg_FASTCALL(args, i) args[i] + #define __Pyx_NumKwargs_FASTCALL(kwds) 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_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); + #else + #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) + #endif + #define __Pyx_Arg_NewRef_FASTCALL(arg) arg /* no-op, __Pyx_Arg_FASTCALL is direct and this needs + to have the same reference counting */ + #define __Pyx_Arg_XDECREF_FASTCALL(arg) +#else + #define __Pyx_Arg_FASTCALL __Pyx_Arg_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 + #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg) + #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start) +#else +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) +#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 int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues, + 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); + +/* 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 */ #ifndef CYTHON_PROFILE -#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_PYSTON +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY #define CYTHON_PROFILE 0 #else #define CYTHON_PROFILE 1 @@ -1328,6 +2117,12 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #include "compile.h" #include "frameobject.h" #include "traceback.h" +#if PY_VERSION_HEX >= 0x030b00a6 + #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) @@ -1336,11 +2131,51 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #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; + static PyCodeObject *__pyx_frame_code = NULL;\ + CYTHON_FRAME_MODIFIER PyFrameObject *__pyx_frame = NULL;\ + int __Pyx_use_tracing = 0; #define __Pyx_TraceFrameInit(codeobj)\ - if (codeobj) __pyx_frame_code = (PyCodeObject*) codeobj; + if (codeobj) __pyx_frame_code = (PyCodeObject*) codeobj; +#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 #ifdef WITH_THREAD #define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error)\ if (nogil) {\ @@ -1348,8 +2183,7 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject 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))) {\ + if (__Pyx_IsTracing(tstate, 1, 1)) {\ __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ }\ PyGILState_Release(state);\ @@ -1357,8 +2191,7 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject }\ } else {\ PyThreadState* tstate = PyThreadState_GET();\ - if (unlikely(tstate->use_tracing) && !tstate->tracing &&\ - (tstate->c_profilefunc || (CYTHON_TRACE && tstate->c_tracefunc))) {\ + if (__Pyx_IsTracing(tstate, 1, 1)) {\ __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ }\ @@ -1366,8 +2199,7 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #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))) {\ + if (__Pyx_IsTracing(tstate, 1, 1)) {\ __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ }\ @@ -1376,10 +2208,8 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #define __Pyx_TraceException()\ 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;\ + if (__Pyx_IsTracing(tstate, 0, 1)) {\ + __Pyx_EnterTracing(tstate);\ PyObject *exc_info = __Pyx_GetExceptionTuple(tstate);\ if (exc_info) {\ if (CYTHON_TRACE && tstate->c_tracefunc)\ @@ -1389,22 +2219,19 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject tstate->c_profileobj, __pyx_frame, PyTrace_EXCEPTION, exc_info);\ Py_DECREF(exc_info);\ }\ - tstate->use_tracing = 1;\ - tstate->tracing--;\ + __Pyx_LeaveTracing(tstate);\ }\ } static void __Pyx_call_return_trace_func(PyThreadState *tstate, PyFrameObject *frame, PyObject *result) { 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--; + __Pyx_LeaveTracing(tstate); __Pyx_ErrRestoreInState(tstate, type, value, traceback); } #ifdef WITH_THREAD @@ -1415,14 +2242,14 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject PyThreadState *tstate;\ PyGILState_STATE state = PyGILState_Ensure();\ tstate = __Pyx_PyThreadState_Current;\ - if (tstate->use_tracing) {\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ }\ PyGILState_Release(state);\ }\ } else {\ PyThreadState* tstate = __Pyx_PyThreadState_Current;\ - if (tstate->use_tracing) {\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ }\ }\ @@ -1431,7 +2258,7 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #define __Pyx_TraceReturn(result, nogil)\ if (likely(!__Pyx_use_tracing)); else {\ PyThreadState* tstate = __Pyx_PyThreadState_Current;\ - if (tstate->use_tracing) {\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ }\ } @@ -1451,11 +2278,9 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject PyObject *type, *value, *traceback; __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); __Pyx_PyFrame_SetLineNumber(frame, lineno); - tstate->tracing++; - tstate->use_tracing = 0; + __Pyx_EnterTracing(tstate); ret = tstate->c_tracefunc(tstate->c_traceobj, frame, PyTrace_LINE, NULL); - tstate->use_tracing = 1; - tstate->tracing--; + __Pyx_LeaveTracing(tstate); if (likely(!ret)) { __Pyx_ErrRestoreInState(tstate, type, value, traceback); } else { @@ -1472,17 +2297,17 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject if (CYTHON_TRACE_NOGIL) {\ int ret = 0;\ PyThreadState *tstate;\ - PyGILState_STATE state = PyGILState_Ensure();\ + PyGILState_STATE state = __Pyx_PyGILState_Ensure();\ tstate = __Pyx_PyThreadState_Current;\ - if (unlikely(tstate->use_tracing && tstate->c_tracefunc && __pyx_frame->f_trace)) {\ + if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && __pyx_frame->f_trace) {\ ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ }\ - PyGILState_Release(state);\ + __Pyx_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)) {\ + if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && __pyx_frame->f_trace) {\ int ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ if (unlikely(ret)) goto_error;\ }\ @@ -1492,7 +2317,7 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #define __Pyx_TraceLine(lineno, 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)) {\ + if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && __pyx_frame->f_trace) {\ int ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ if (unlikely(ret)) goto_error;\ }\ @@ -1502,58 +2327,234 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #define __Pyx_TraceLine(lineno, nogil, goto_error) if ((1)); else goto_error; #endif -/* IterFinish.proto */ -static CYTHON_INLINE int __Pyx_IterFinish(void); +/* IncludeStructmemberH.proto */ +#include -/* 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); -#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)) +/* FixUpExtensionType.proto */ +#if CYTHON_USE_TYPE_SPECS +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); #endif -/* PyObjectCall.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +/* FetchSharedCythonModule.proto */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void); + +/* FetchCommonType.proto */ +#if !CYTHON_USE_TYPE_SPECS +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); #else -#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases); +#endif + +/* PyMethodNew.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + PyObject *typesModule=NULL, *methodType=NULL, *result=NULL; + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + typesModule = PyImport_ImportModule("types"); + if (!typesModule) return NULL; + methodType = PyObject_GetAttrString(typesModule, "MethodType"); + Py_DECREF(typesModule); + if (!methodType) return NULL; + result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL); + Py_DECREF(methodType); + return result; +} +#elif PY_MAJOR_VERSION >= 3 +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); +} +#else + #define __Pyx_PyMethod_New PyMethod_New #endif -/* PyObjectCallMethO.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +/* PyVectorcallFastCallDict.proto */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw); #endif -/* PyObjectCallNoArg.proto */ +/* 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 + __pyx_vectorcallfunc func_vectorcall; +#endif +#if PY_VERSION_HEX < 0x030500A0 || 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 + void *defaults; + int defaults_pyobjects; + size_t defaults_size; + 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_CyFunctionType) +#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type) +#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_CyFunctionType) +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc); +#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 void *__Pyx_CyFunction_InitDefaults(PyObject *m, + size_t size, + int pyobjects); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, + PyObject *tuple); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, + PyObject *dict); +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, + PyObject *dict); +static int __pyx_CyFunction_init(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 +#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); + +/* PyObjectCall.proto */ #if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); +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 + +/* UnpackUnboundCMethod.proto */ +typedef struct { + PyObject *type; + PyObject **method_name; + PyCFunction func; + PyObject *method; + int flag; +} __Pyx_CachedCFunction; + +/* CallUnboundCMethod1.proto */ +static PyObject* __Pyx__CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg); +#if CYTHON_COMPILING_IN_CPYTHON +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); +/* KeywordStringCheck.proto */ +static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed); + +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* IterFinish.proto */ +static CYTHON_INLINE int __Pyx_IterFinish(void); + +/* 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 **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" +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif + #define __Pxy_PyFrame_Initialize_Offsets() + #define __Pyx_PyFrame_GetLocalsplus(frame) ((frame)->f_localsplus) #else -#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) + 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 + +/* 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 **args, size_t nargs, PyObject *kwargs); + +/* PyObjectCallNoArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); + /* PyObjectCallOneArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); @@ -1596,9 +2597,6 @@ 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); - /* ListCompAppend.proto */ #if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { @@ -1606,8 +2604,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,17 +2618,35 @@ 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 +/* PyObjectFormatAndDecref.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f); +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f); -/* BytesEquals.proto */ -static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int 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 PY_MAJOR_VERSION < 3 + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + likely(PyString_CheckExact(s)) ? PyUnicode_FromEncodedObject(s, NULL, "strict") :\ + 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 -/* UnicodeEquals.proto */ -static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); +/* JoinPyUnicode.proto */ +static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength, + Py_UCS4 max_char); /* StrEquals.proto */ #if PY_MAJOR_VERSION >= 3 @@ -1663,18 +2683,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))) ?\ (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,15 +2711,6 @@ 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 */ static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self); #if CYTHON_COMPILING_IN_CPYTHON @@ -1720,9 +2731,29 @@ static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObje #define __Pyx_CallUnboundCMethod0(cfunc, self) __Pyx__CallUnboundCMethod0(cfunc, self) #endif -/* None.proto */ +/* RaiseUnboundLocalError.proto */ +static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname); + +/* RaiseClosureNameError.proto */ static CYTHON_INLINE void __Pyx_RaiseClosureNameError(const char *varname); +/* GetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#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 +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); +#endif + +/* pep479.proto */ +static void __Pyx_Generator_Replace_StopIteration(int in_async_gen); + +/* 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); + /* StringJoin.proto */ #if PY_MAJOR_VERSION < 3 #define __Pyx_PyString_Join __Pyx_PyBytes_Join @@ -1731,76 +2762,35 @@ static CYTHON_INLINE void __Pyx_RaiseClosureNameError(const char *varname); #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); - -/* 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); +/* GetAttr3.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); -/* 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 +/* RaiseUnexpectedTypeError.proto */ +static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj); -/* GetAttr.proto */ -static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); +/* bytes_tailmatch.proto */ +static int __Pyx_PyBytes_SingleTailmatch(PyObject* self, PyObject* arg, + Py_ssize_t start, Py_ssize_t end, int direction); +static int __Pyx_PyBytes_Tailmatch(PyObject* self, PyObject* substr, + Py_ssize_t start, Py_ssize_t end, int direction); -/* GetAttr3.proto */ -static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); +/* unicode_tailmatch.proto */ +static int __Pyx_PyUnicode_Tailmatch( + PyObject* s, PyObject* substr, Py_ssize_t start, Py_ssize_t end, int direction); -/* 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); +/* str_tailmatch.proto */ +static CYTHON_INLINE int __Pyx_PyStr_Tailmatch(PyObject* self, PyObject* arg, Py_ssize_t start, + Py_ssize_t end, int direction); -/* 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) -#endif +/* PyObject_Str.proto */ +#define __Pyx_PyObject_Str(obj)\ + (likely(PyString_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_CPYTHON && PY_VERSION_HEX < 0x030d0000 PyObject* none = _PyList_Extend((PyListObject*)L, v); if (unlikely(!none)) return -1; @@ -1818,8 +2808,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,14 +2822,57 @@ static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { #define __Pyx_PyList_Append(L,x) PyList_Append(L,x) #endif +/* ExtTypeTest.proto */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + /* 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)\ + (__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); + +/* append.proto */ +static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x); + +/* GetAttr.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); + /* HasAttr.proto */ +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 +#define __Pyx_HasAttr(o, n) PyObject_HasAttrWithError(o, n) +#else static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); +#endif + +/* 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); /* PyObject_GenericGetAttrNoDict.proto */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 @@ -1845,21 +2882,31 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj #endif /* SetupReduce.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API static int __Pyx_setup_reduce(PyObject* type_obj); +#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_0_10 +#define __PYX_HAVE_RT_ImportType_proto_3_0_10 +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L +#include +#endif +#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L +#define __PYX_GET_STRUCT_ALIGNMENT_3_0_10(s) alignof(s) +#else +#define __PYX_GET_STRUCT_ALIGNMENT_3_0_10(s) sizeof(void*) +#endif +enum __Pyx_ImportType_CheckSize_3_0_10 { + __Pyx_ImportType_CheckSize_Error_3_0_10 = 0, + __Pyx_ImportType_CheckSize_Warn_3_0_10 = 1, + __Pyx_ImportType_CheckSize_Ignore_3_0_10 = 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_0_10(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_10 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); @@ -1875,6 +2922,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API typedef struct { PyCodeObject* code_object; int code_line; @@ -1888,16 +2936,19 @@ 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); +#endif /* 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); +/* 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_long(long value); +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); @@ -1905,24 +2956,41 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +/* FormatTypeName.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%U" +static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp); +#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) +#else +typedef const char *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%.200s" +#define __Pyx_PyType_GetName(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)) #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); - /* 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 +3013,9 @@ 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); - /* 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 +3025,7 @@ typedef struct { PyObject *exc_traceback; } __Pyx_ExcInfoStruct; #endif -typedef struct { +typedef struct __pyx_CoroutineObject { PyObject_HEAD __pyx_coroutine_body_t body; PyObject *closure; @@ -1971,6 +3037,7 @@ typedef struct { PyObject *gi_qualname; PyObject *gi_modulename; PyObject *gi_code; + PyObject *gi_frame; int resume_label; char is_running; } __pyx_CoroutineObject; @@ -2013,98 +3080,109 @@ static int __Pyx_patch_abc(void); /* 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_GeneratorType) #define __Pyx_Generator_New(body, code, closure, name, qualname, module_name)\ __Pyx__Coroutine_New(__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); /* CheckBinaryVersion.proto */ -static int __Pyx_check_binary_version(void); +static unsigned long __Pyx_get_runtime_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); +/* FunctionImport.proto */ +static int __Pyx_ImportFunction_3_0_10(PyObject *module, const char *funcname, void (**f)(void), const char *sig); + /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); +/* #### Code section: module_declarations ### */ + +/* Module declarations from "cython" */ -/* Module declarations from 'cython' */ +/* Module declarations from "libc.string" */ -/* Module declarations from 'libc.string' */ +/* Module declarations from "libc.stdio" */ -/* Module declarations from 'libc.stdio' */ +/* Module declarations from "__builtin__" */ -/* Module declarations from '__builtin__' */ +/* Module declarations from "cpython.type" */ -/* Module declarations from 'cpython.type' */ -static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; +/* Module declarations from "cpython" */ -/* Module declarations from 'cpython' */ +/* Module declarations from "cpython.object" */ -/* Module declarations from 'cpython.object' */ +/* Module declarations from "cpython.pystate" */ -/* Module declarations from 'cpython.pystate' */ +/* Module declarations from "cpython.ref" */ -/* Module declarations from 'types' */ +/* Module declarations from "types" */ -/* 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 "hunter._tracer" */ -/* Module declarations from 'hunter._event' */ -static PyTypeObject *__pyx_ptype_6hunter_6_event_Event = 0; +/* 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 '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._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; -static const char __pyx_k_[] = "_"; +/* #### Code section: string_decls ### */ 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__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_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"; @@ -2113,8 +3191,11 @@ static const char __pyx_k_rx[] = "rx"; static const char __pyx_k_sw[] = "sw"; static const char __pyx_k_And[] = "And"; static const char __pyx_k_Not[] = "Not"; +static const char __pyx_k__10[] = " "; +static const char __pyx_k__48[] = "?"; static const char __pyx_k_all[] = "__all__"; static const char __pyx_k_arg[] = "arg"; +static const char __pyx_k_for[] = " for "; static const char __pyx_k_gte[] = "gte"; static const char __pyx_k_has[] = "has"; static const char __pyx_k_lte[] = "lte"; @@ -2123,7 +3204,7 @@ static const char __pyx_k_From[] = "From"; 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_call[] = "call"; static const char __pyx_k_dict[] = "__dict__"; static const char __pyx_k_gt_2[] = "_gt"; static const char __pyx_k_in_2[] = "_in"; @@ -2131,39 +3212,64 @@ static const char __pyx_k_join[] = "join"; 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_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_And_s[] = "And(%s)"; 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_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_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_Action[] = "Action"; +static const char __pyx_k_action[] = "action"; +static const char __pyx_k_append[] = "append"; +static const char __pyx_k_dict_2[] = "_dict"; +static const char __pyx_k_enable[] = "enable"; +static const char __pyx_k_f_back[] = "f_back"; +static const char __pyx_k_filter[] = "filter"; +static const char __pyx_k_hunter[] = "hunter"; static const char __pyx_k_import[] = "__import__"; +static const char __pyx_k_kwargs[] = "kwargs"; static const char __pyx_k_lineno[] = "lineno"; static const char __pyx_k_locals[] = "locals"; +static const char __pyx_k_maxlen[] = "maxlen"; static const char __pyx_k_module[] = "module"; +static const char __pyx_k_name_2[] = "__name__"; 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_update[] = "update"; +static const char __pyx_k_Backlog[] = "Backlog"; static const char __pyx_k_Query_s[] = "Query(%s)"; static const char __pyx_k_actions[] = "actions"; +static const char __pyx_k_builtin[] = "builtin"; +static const char __pyx_k_cleanup[] = "cleanup"; static const char __pyx_k_compile[] = "compile"; +static const char __pyx_k_disable[] = "disable"; static const char __pyx_k_genexpr[] = "genexpr"; static const char __pyx_k_globals[] = "globals"; static const char __pyx_k_inspect[] = "inspect"; @@ -2178,33 +3284,45 @@ static const char __pyx_k_getstate[] = "__getstate__"; static const char __pyx_k_pyx_type[] = "__pyx_type"; static const char __pyx_k_setstate[] = "__setstate__"; static const char __pyx_k_threadid[] = "threadid"; +static const char __pyx_k_try_repr[] = "try_repr"; static const char __pyx_k_TypeError[] = "TypeError"; static const char __pyx_k_condition[] = "condition"; -static const char __pyx_k_itertools[] = "itertools"; +static const char __pyx_k_isenabled[] = "isenabled"; static const char __pyx_k_predicate[] = "predicate"; static const char __pyx_k_pyx_state[] = "__pyx_state"; static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; static const char __pyx_k_watermark[] = "watermark"; +static const char __pyx_k_QueryEntry[] = "QueryEntry"; static const char __pyx_k_ValueError[] = "ValueError"; +static const char __pyx_k_appendleft[] = "appendleft"; static const char __pyx_k_contains_2[] = "_contains"; static const char __pyx_k_endswith_2[] = "_endswith"; static const char __pyx_k_fullsource[] = "fullsource"; +static const char __pyx_k_predicates[] = "predicates"; static const char __pyx_k_pyx_result[] = "__pyx_result"; static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; static const char __pyx_k_query_eq_r[] = "query_eq=%r"; static const char __pyx_k_query_gt_r[] = "query_gt=%r"; static const char __pyx_k_query_in_r[] = "query_in=%r"; static const char __pyx_k_query_lt_r[] = "query_lt=%r"; +static const char __pyx_k_re_compile[] = "re_compile"; static const char __pyx_k_startswith[] = "startswith"; static const char __pyx_k_threadname[] = "threadname"; static const char __pyx_k_PickleError[] = "PickleError"; +static const char __pyx_k_cfunc_to_py[] = "cfunc.to_py"; +static const char __pyx_k_collections[] = "collections"; +static const char __pyx_k_instruction[] = "instruction"; static const char __pyx_k_query_gte_r[] = "query_gte=%r"; static const char __pyx_k_query_lte_r[] = "query_lte=%r"; +static const char __pyx_k_is_coroutine[] = "_is_coroutine"; static const char __pyx_k_pyx_checksum[] = "__pyx_checksum"; static const char __pyx_k_startswith_2[] = "_startswith"; -static const char __pyx_k_stringsource[] = "stringsource"; +static const char __pyx_k_stringsource[] = ""; +static const char __pyx_k_use_setstate[] = "use_setstate"; static const char __pyx_k_query_regex_r[] = "query_regex=%r"; static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; +static const char __pyx_k_Backlog_filter[] = "Backlog.filter"; +static const char __pyx_k_Must_be_one_of[] = ". Must be one of "; static const char __pyx_k_pyx_PickleError[] = "__pyx_PickleError"; static const char __pyx_k_pyx_unpickle_Or[] = "__pyx_unpickle_Or"; static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; @@ -2212,185 +3330,74 @@ static const char __pyx_k_pyx_unpickle_And[] = "__pyx_unpickle_And"; static const char __pyx_k_pyx_unpickle_Not[] = "__pyx_unpickle_Not"; static const char __pyx_k_query_contains_r[] = "query_contains=%r"; static const char __pyx_k_query_endswith_r[] = "query_endswith=%r"; +static const char __pyx_k_ColorStreamAction[] = "ColorStreamAction"; static const char __pyx_k_pyx_unpickle_From[] = "__pyx_unpickle_From"; static const char __pyx_k_pyx_unpickle_When[] = "__pyx_unpickle_When"; +static const char __pyx_k_threading_support[] = "threading_support"; +static const char __pyx_k_Or___reduce_cython[] = "Or.__reduce_cython__"; +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__predicates[] = "hunter._predicates"; static const char __pyx_k_pyx_unpickle_Query[] = "__pyx_unpickle_Query"; static const char __pyx_k_query_startswith_r[] = "query_startswith=%r"; +static const char __pyx_k_And___reduce_cython[] = "And.__reduce_cython__"; +static const char __pyx_k_Not___reduce_cython[] = "Not.__reduce_cython__"; +static const char __pyx_k_Unexpected_argument[] = "Unexpected argument "; +static const char __pyx_k_Unexpected_operator[] = "Unexpected operator "; +static const char __pyx_k_From___reduce_cython[] = "From.__reduce_cython__"; static const char __pyx_k_From_s_s_watermark_s[] = "From(%s, %s, watermark=%s)"; +static const char __pyx_k_Or___setstate_cython[] = "Or.__setstate_cython__"; +static const char __pyx_k_When___reduce_cython[] = "When.__reduce_cython__"; +static const char __pyx_k_pyx_unpickle_Backlog[] = "__pyx_unpickle_Backlog"; static const char __pyx_k_str___locals_genexpr[] = "__str__..genexpr"; +static const char __pyx_k_And___setstate_cython[] = "And.__setstate_cython__"; +static const char __pyx_k_Not___setstate_cython[] = "Not.__setstate_cython__"; +static const char __pyx_k_Query___reduce_cython[] = "Query.__reduce_cython__"; static const char __pyx_k_init___locals_genexpr[] = "__init__..genexpr"; -static const char __pyx_k_repr___locals_genexpr[] = "__repr__..genexpr"; -static const char __pyx_k_hunter__predicates_Query_s[] = ""; +static const char __pyx_k_From___setstate_cython[] = "From.__setstate_cython__"; +static const char __pyx_k_When___setstate_cython[] = "When.__setstate_cython__"; +static const char __pyx_k_Backlog___reduce_cython[] = "Backlog.__reduce_cython__"; +static const char __pyx_k_Query___setstate_cython[] = "Query.__setstate_cython__"; +static const char __pyx_k_Backlog___setstate_cython[] = "Backlog.__setstate_cython__"; +static const char __pyx_k_hunter_predicates_Query_s[] = ""; +static const char __pyx_k_QueryEntry___reduce_cython[] = "QueryEntry.__reduce_cython__"; +static const char __pyx_k_src_hunter__predicates_pyx[] = "src/hunter/_predicates.pyx"; +static const char __pyx_k_QueryEntry___setstate_cython[] = "QueryEntry.__setstate_cython__"; +static const char __pyx_k_with_optional_operators_like[] = " with optional operators like: "; static const char __pyx_k_Must_give_at_least_one_action[] = "Must give at least one action."; -static const char __pyx_k_str___locals_genexpr_locals_ge[] = "__str__..genexpr..genexpr"; +static const char __pyx_k_Pyx_CFunc_6hunter_11_predicate[] = "__Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event..wrap"; +static const char __pyx_k_Backlog_s_size_s_stack_s_vars_s[] = "Backlog(%s, size=%s, stack=%s, vars=%s, action=%s, filter=%s)"; static const char __pyx_k_hunter__predicates_And_predicat[] = ""; static const char __pyx_k_hunter__predicates_From_conditi[] = ""; static const char __pyx_k_hunter__predicates_Not_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_Backlog_condi[] = ""; +static const char __pyx_k_is_invalid_Must_be_a_string_lis[] = " is invalid. Must be a string, list, tuple or set."; +static const char __pyx_k_self_getter_cannot_be_converted[] = "self.getter cannot be converted to a Python object for pickling"; +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_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,4398 +3408,6069 @@ 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*/ +static __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_items = {0, 0, 0, 0, 0}; +static __Pyx_CachedCFunction __pyx_umethod_PyTuple_Type_index = {0, 0, 0, 0, 0}; +/* #### Code section: late_includes ### */ +/* #### Code section: module_state ### */ +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 + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + PyTypeObject *__pyx_ptype_7cpython_4type_type; + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + PyTypeObject *__pyx_ptype_6hunter_7_tracer_FrameType; + PyTypeObject *__pyx_ptype_6hunter_7_tracer_CodeType; + PyTypeObject *__pyx_ptype_6hunter_7_tracer_Tracer; + #if CYTHON_USE_MODULE_STATE + #endif + PyTypeObject *__pyx_ptype_6hunter_6_event_Event; + #if CYTHON_USE_MODULE_STATE + 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; + #endif + 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; + PyObject *__pyx_n_s_Action; + PyObject *__pyx_kp_s_Action_r_must_be_a_ColorStreamAc; + PyObject *__pyx_n_s_And; + PyObject *__pyx_n_s_And___reduce_cython; + PyObject *__pyx_n_s_And___setstate_cython; + PyObject *__pyx_kp_s_And_s; + PyObject *__pyx_n_s_Backlog; + PyObject *__pyx_n_s_Backlog___reduce_cython; + PyObject *__pyx_n_s_Backlog___setstate_cython; + PyObject *__pyx_n_s_Backlog_filter; + PyObject *__pyx_kp_s_Backlog_s_size_s_stack_s_vars_s; + PyObject *__pyx_n_s_ColorStreamAction; + PyObject *__pyx_n_s_From; + PyObject *__pyx_n_s_From___reduce_cython; + PyObject *__pyx_n_s_From___setstate_cython; + PyObject *__pyx_kp_s_From_s_s_watermark_s; + PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0; + PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_2; + PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_3; + PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_4; + PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_5; + PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_6; + PyObject *__pyx_kp_u_Must_be_one_of; + PyObject *__pyx_kp_s_Must_give_at_least_one_action; + PyObject *__pyx_n_s_Not; + PyObject *__pyx_n_s_Not___reduce_cython; + PyObject *__pyx_n_s_Not___setstate_cython; + PyObject *__pyx_kp_s_Not_s; + PyObject *__pyx_n_s_Or; + PyObject *__pyx_n_s_Or___reduce_cython; + PyObject *__pyx_n_s_Or___setstate_cython; + PyObject *__pyx_kp_s_Or_s; + PyObject *__pyx_n_s_PickleError; + PyObject *__pyx_n_s_Pyx_CFunc_6hunter_11_predicate; + PyObject *__pyx_n_s_Query; + PyObject *__pyx_n_s_QueryEntry; + PyObject *__pyx_n_s_QueryEntry___reduce_cython; + PyObject *__pyx_n_s_QueryEntry___setstate_cython; + PyObject *__pyx_n_s_Query___reduce_cython; + PyObject *__pyx_n_s_Query___setstate_cython; + PyObject *__pyx_kp_s_Query_s; + PyObject *__pyx_n_s_TypeError; + PyObject *__pyx_kp_u_Unexpected_argument; + PyObject *__pyx_kp_u_Unexpected_operator; + PyObject *__pyx_kp_u_Value; + PyObject *__pyx_n_s_ValueError; + PyObject *__pyx_n_s_When; + PyObject *__pyx_n_s_When___reduce_cython; + PyObject *__pyx_n_s_When___setstate_cython; + PyObject *__pyx_kp_s_When_s_s; + PyObject *__pyx_kp_s__10; + PyObject *__pyx_n_s__48; + PyObject *__pyx_n_s__5; + PyObject *__pyx_kp_u__6; + PyObject *__pyx_kp_u__7; + PyObject *__pyx_kp_s__8; + PyObject *__pyx_kp_s__9; + PyObject *__pyx_n_s_action; + PyObject *__pyx_n_s_actions; + PyObject *__pyx_n_s_all; + PyObject *__pyx_n_s_append; + PyObject *__pyx_n_s_appendleft; + PyObject *__pyx_n_s_arg; + PyObject *__pyx_n_s_args; + PyObject *__pyx_n_s_asyncio_coroutines; + PyObject *__pyx_n_s_builtin; + PyObject *__pyx_n_s_call; + PyObject *__pyx_n_s_calls; + PyObject *__pyx_n_s_cfunc_to_py; + PyObject *__pyx_n_s_cleanup; + PyObject *__pyx_n_s_clear; + PyObject *__pyx_n_s_cline_in_traceback; + PyObject *__pyx_n_s_close; + PyObject *__pyx_n_s_collections; + PyObject *__pyx_n_s_compile; + PyObject *__pyx_n_s_condition; + PyObject *__pyx_n_s_contains; + PyObject *__pyx_n_s_contains_2; + PyObject *__pyx_n_s_depth; + PyObject *__pyx_n_s_deque; + PyObject *__pyx_n_s_dict; + PyObject *__pyx_n_s_dict_2; + PyObject *__pyx_kp_u_disable; + PyObject *__pyx_kp_u_enable; + PyObject *__pyx_n_s_endswith; + PyObject *__pyx_n_s_endswith_2; + PyObject *__pyx_n_s_event; + PyObject *__pyx_n_s_ew; + PyObject *__pyx_n_s_f_back; + PyObject *__pyx_n_s_filename; + PyObject *__pyx_n_s_filter; + PyObject *__pyx_kp_u_for; + PyObject *__pyx_n_s_frame; + PyObject *__pyx_n_s_fullsource; + PyObject *__pyx_n_s_function; + PyObject *__pyx_kp_u_gc; + PyObject *__pyx_n_s_genexpr; + PyObject *__pyx_n_s_getstate; + PyObject *__pyx_n_s_globals; + PyObject *__pyx_n_s_gt; + PyObject *__pyx_n_s_gt_2; + PyObject *__pyx_n_s_gte; + PyObject *__pyx_n_s_gte_2; + PyObject *__pyx_n_s_has; + PyObject *__pyx_n_s_hunter; + PyObject *__pyx_n_s_hunter__predicates; + PyObject *__pyx_kp_s_hunter__predicates_And_predicat; + PyObject *__pyx_kp_s_hunter__predicates_From_conditi; + PyObject *__pyx_kp_s_hunter__predicates_Not_predicat; + PyObject *__pyx_kp_s_hunter__predicates_Or_predicate; + PyObject *__pyx_kp_s_hunter__predicates_When_conditi; + PyObject *__pyx_kp_s_hunter_predicates_Backlog_condi; + PyObject *__pyx_kp_s_hunter_predicates_Query_s; + PyObject *__pyx_n_s_import; + PyObject *__pyx_n_s_in; + PyObject *__pyx_n_s_in_2; + PyObject *__pyx_n_s_index; + PyObject *__pyx_n_s_init___locals_genexpr; + PyObject *__pyx_n_s_inspect; + PyObject *__pyx_n_s_instruction; + PyObject *__pyx_n_s_is_coroutine; + PyObject *__pyx_kp_u_is_invalid_Must_be_a_string_lis; + PyObject *__pyx_n_s_isclass; + PyObject *__pyx_kp_u_isenabled; + PyObject *__pyx_n_s_items; + PyObject *__pyx_n_s_join; + PyObject *__pyx_n_s_kind; + PyObject *__pyx_n_s_kwargs; + PyObject *__pyx_n_s_lineno; + PyObject *__pyx_n_s_locals; + PyObject *__pyx_n_s_lt; + PyObject *__pyx_n_s_lt_2; + PyObject *__pyx_n_s_lte; + PyObject *__pyx_n_s_lte_2; + PyObject *__pyx_n_s_main; + PyObject *__pyx_n_s_match; + PyObject *__pyx_n_s_maxlen; + PyObject *__pyx_n_s_merge; + PyObject *__pyx_n_s_module; + PyObject *__pyx_n_s_name; + PyObject *__pyx_n_s_name_2; + PyObject *__pyx_n_s_new; + PyObject *__pyx_n_s_pickle; + PyObject *__pyx_n_s_predicate; + PyObject *__pyx_n_s_predicates; + PyObject *__pyx_n_s_pyx_PickleError; + PyObject *__pyx_n_s_pyx_checksum; + PyObject *__pyx_n_s_pyx_result; + PyObject *__pyx_n_s_pyx_state; + PyObject *__pyx_n_s_pyx_type; + PyObject *__pyx_n_s_pyx_unpickle_And; + PyObject *__pyx_n_s_pyx_unpickle_Backlog; + PyObject *__pyx_n_s_pyx_unpickle_From; + PyObject *__pyx_n_s_pyx_unpickle_Not; + PyObject *__pyx_n_s_pyx_unpickle_Or; + PyObject *__pyx_n_s_pyx_unpickle_Query; + PyObject *__pyx_n_s_pyx_unpickle_When; + PyObject *__pyx_n_s_pyx_vtable; + PyObject *__pyx_kp_s_query_contains_r; + PyObject *__pyx_kp_s_query_endswith_r; + PyObject *__pyx_kp_s_query_eq_r; + PyObject *__pyx_kp_s_query_gt_r; + PyObject *__pyx_kp_s_query_gte_r; + PyObject *__pyx_kp_s_query_in_r; + PyObject *__pyx_kp_s_query_lt_r; + PyObject *__pyx_kp_s_query_lte_r; + PyObject *__pyx_kp_s_query_regex_r; + PyObject *__pyx_kp_s_query_startswith_r; + PyObject *__pyx_n_s_re; + PyObject *__pyx_n_s_re_compile; + PyObject *__pyx_n_s_reduce; + PyObject *__pyx_n_s_reduce_cython; + PyObject *__pyx_n_s_reduce_ex; + PyObject *__pyx_n_s_regex; + PyObject *__pyx_n_s_regex_2; + PyObject *__pyx_n_s_rx; + PyObject *__pyx_n_s_self; + PyObject *__pyx_kp_s_self_getter_cannot_be_converted; + PyObject *__pyx_n_s_send; + PyObject *__pyx_n_s_setstate; + PyObject *__pyx_n_s_setstate_cython; + PyObject *__pyx_n_s_size; + PyObject *__pyx_n_s_source; + PyObject *__pyx_n_s_split; + PyObject *__pyx_kp_s_src_hunter__predicates_pyx; + PyObject *__pyx_n_s_stack; + PyObject *__pyx_n_s_startswith; + PyObject *__pyx_n_s_startswith_2; + PyObject *__pyx_n_s_state; + PyObject *__pyx_n_s_stdlib; + PyObject *__pyx_n_s_str___locals_genexpr; + PyObject *__pyx_kp_s_stringsource; + PyObject *__pyx_n_s_strip; + PyObject *__pyx_n_s_sw; + PyObject *__pyx_n_s_test; + PyObject *__pyx_n_s_threadid; + PyObject *__pyx_n_s_threading_support; + PyObject *__pyx_n_s_threadname; + PyObject *__pyx_n_s_throw; + PyObject *__pyx_n_s_try_repr; + PyObject *__pyx_n_s_update; + PyObject *__pyx_n_s_use_setstate; + PyObject *__pyx_n_s_value; + PyObject *__pyx_n_s_vars; + PyObject *__pyx_n_s_watermark; + PyObject *__pyx_kp_u_with_optional_operators_like; + PyObject *__pyx_n_s_wrap; + 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; + PyObject *__pyx_tuple_; + PyObject *__pyx_tuple__13; + PyObject *__pyx_tuple__28; + PyObject *__pyx_tuple__30; + PyObject *__pyx_tuple__32; + PyObject *__pyx_tuple__34; + PyObject *__pyx_tuple__37; + PyObject *__pyx_tuple__39; + PyObject *__pyx_tuple__40; + PyObject *__pyx_tuple__41; + PyObject *__pyx_tuple__42; + PyObject *__pyx_tuple__43; + PyObject *__pyx_tuple__44; + PyObject *__pyx_tuple__45; + PyObject *__pyx_tuple__46; + PyObject *__pyx_tuple__47; + PyObject *__pyx_codeobj__2; + PyObject *__pyx_codeobj__3; + PyObject *__pyx_codeobj__4; + PyObject *__pyx_codeobj__11; + PyObject *__pyx_codeobj__12; + PyObject *__pyx_codeobj__14; + PyObject *__pyx_codeobj__15; + PyObject *__pyx_codeobj__16; + PyObject *__pyx_codeobj__17; + PyObject *__pyx_codeobj__18; + PyObject *__pyx_codeobj__19; + PyObject *__pyx_codeobj__20; + PyObject *__pyx_codeobj__21; + PyObject *__pyx_codeobj__22; + PyObject *__pyx_codeobj__23; + PyObject *__pyx_codeobj__24; + PyObject *__pyx_codeobj__25; + PyObject *__pyx_codeobj__26; + PyObject *__pyx_codeobj__27; + PyObject *__pyx_codeobj__29; + PyObject *__pyx_codeobj__31; + PyObject *__pyx_codeobj__33; + PyObject *__pyx_codeobj__35; + PyObject *__pyx_codeobj__36; + PyObject *__pyx_codeobj__38; +} __pyx_mstate; + +#if CYTHON_USE_MODULE_STATE +#ifdef __cplusplus +namespace { + extern struct PyModuleDef __pyx_moduledef; +} /* anonymous namespace */ +#else +static struct PyModuleDef __pyx_moduledef; #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; - __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); - /* function exit code */ - __Pyx_XDECREF(__pyx_v_query); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} +#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o)) -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; +#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef))) + +#define __pyx_m (PyState_FindModule(&__pyx_moduledef)) +#else +static __pyx_mstate __pyx_mstate_global_static = +#ifdef __cplusplus + {}; +#else + {0}; +#endif +static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static; +#endif +/* #### Code section: module_state_clear ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_clear(PyObject *m) { + __pyx_mstate *clear_module_state = __pyx_mstate(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 + Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_4type_type); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_7_tracer_FrameType); + 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_6_event_Event); + 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); + Py_CLEAR(clear_module_state->__pyx_n_s_Action); + Py_CLEAR(clear_module_state->__pyx_kp_s_Action_r_must_be_a_ColorStreamAc); + Py_CLEAR(clear_module_state->__pyx_n_s_And); + Py_CLEAR(clear_module_state->__pyx_n_s_And___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_And___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_kp_s_And_s); + Py_CLEAR(clear_module_state->__pyx_n_s_Backlog); + Py_CLEAR(clear_module_state->__pyx_n_s_Backlog___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Backlog___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Backlog_filter); + Py_CLEAR(clear_module_state->__pyx_kp_s_Backlog_s_size_s_stack_s_vars_s); + Py_CLEAR(clear_module_state->__pyx_n_s_ColorStreamAction); + Py_CLEAR(clear_module_state->__pyx_n_s_From); + Py_CLEAR(clear_module_state->__pyx_n_s_From___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_From___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_kp_s_From_s_s_watermark_s); + Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0); + Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_2); + Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_3); + Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_4); + Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_5); + Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_6); + Py_CLEAR(clear_module_state->__pyx_kp_u_Must_be_one_of); + Py_CLEAR(clear_module_state->__pyx_kp_s_Must_give_at_least_one_action); + Py_CLEAR(clear_module_state->__pyx_n_s_Not); + Py_CLEAR(clear_module_state->__pyx_n_s_Not___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Not___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_kp_s_Not_s); + Py_CLEAR(clear_module_state->__pyx_n_s_Or); + Py_CLEAR(clear_module_state->__pyx_n_s_Or___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Or___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_kp_s_Or_s); + Py_CLEAR(clear_module_state->__pyx_n_s_PickleError); + Py_CLEAR(clear_module_state->__pyx_n_s_Pyx_CFunc_6hunter_11_predicate); + Py_CLEAR(clear_module_state->__pyx_n_s_Query); + Py_CLEAR(clear_module_state->__pyx_n_s_QueryEntry); + Py_CLEAR(clear_module_state->__pyx_n_s_QueryEntry___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_QueryEntry___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Query___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Query___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_kp_s_Query_s); + Py_CLEAR(clear_module_state->__pyx_n_s_TypeError); + Py_CLEAR(clear_module_state->__pyx_kp_u_Unexpected_argument); + Py_CLEAR(clear_module_state->__pyx_kp_u_Unexpected_operator); + Py_CLEAR(clear_module_state->__pyx_kp_u_Value); + Py_CLEAR(clear_module_state->__pyx_n_s_ValueError); + Py_CLEAR(clear_module_state->__pyx_n_s_When); + Py_CLEAR(clear_module_state->__pyx_n_s_When___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_When___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_kp_s_When_s_s); + Py_CLEAR(clear_module_state->__pyx_kp_s__10); + Py_CLEAR(clear_module_state->__pyx_n_s__48); + Py_CLEAR(clear_module_state->__pyx_n_s__5); + Py_CLEAR(clear_module_state->__pyx_kp_u__6); + Py_CLEAR(clear_module_state->__pyx_kp_u__7); + Py_CLEAR(clear_module_state->__pyx_kp_s__8); + Py_CLEAR(clear_module_state->__pyx_kp_s__9); + Py_CLEAR(clear_module_state->__pyx_n_s_action); + Py_CLEAR(clear_module_state->__pyx_n_s_actions); + Py_CLEAR(clear_module_state->__pyx_n_s_all); + Py_CLEAR(clear_module_state->__pyx_n_s_append); + Py_CLEAR(clear_module_state->__pyx_n_s_appendleft); + Py_CLEAR(clear_module_state->__pyx_n_s_arg); + Py_CLEAR(clear_module_state->__pyx_n_s_args); + Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines); + Py_CLEAR(clear_module_state->__pyx_n_s_builtin); + Py_CLEAR(clear_module_state->__pyx_n_s_call); + Py_CLEAR(clear_module_state->__pyx_n_s_calls); + Py_CLEAR(clear_module_state->__pyx_n_s_cfunc_to_py); + Py_CLEAR(clear_module_state->__pyx_n_s_cleanup); + Py_CLEAR(clear_module_state->__pyx_n_s_clear); + Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback); + Py_CLEAR(clear_module_state->__pyx_n_s_close); + Py_CLEAR(clear_module_state->__pyx_n_s_collections); + Py_CLEAR(clear_module_state->__pyx_n_s_compile); + Py_CLEAR(clear_module_state->__pyx_n_s_condition); + Py_CLEAR(clear_module_state->__pyx_n_s_contains); + Py_CLEAR(clear_module_state->__pyx_n_s_contains_2); + Py_CLEAR(clear_module_state->__pyx_n_s_depth); + Py_CLEAR(clear_module_state->__pyx_n_s_deque); + Py_CLEAR(clear_module_state->__pyx_n_s_dict); + Py_CLEAR(clear_module_state->__pyx_n_s_dict_2); + Py_CLEAR(clear_module_state->__pyx_kp_u_disable); + Py_CLEAR(clear_module_state->__pyx_kp_u_enable); + Py_CLEAR(clear_module_state->__pyx_n_s_endswith); + Py_CLEAR(clear_module_state->__pyx_n_s_endswith_2); + Py_CLEAR(clear_module_state->__pyx_n_s_event); + Py_CLEAR(clear_module_state->__pyx_n_s_ew); + Py_CLEAR(clear_module_state->__pyx_n_s_f_back); + Py_CLEAR(clear_module_state->__pyx_n_s_filename); + Py_CLEAR(clear_module_state->__pyx_n_s_filter); + Py_CLEAR(clear_module_state->__pyx_kp_u_for); + Py_CLEAR(clear_module_state->__pyx_n_s_frame); + Py_CLEAR(clear_module_state->__pyx_n_s_fullsource); + Py_CLEAR(clear_module_state->__pyx_n_s_function); + Py_CLEAR(clear_module_state->__pyx_kp_u_gc); + Py_CLEAR(clear_module_state->__pyx_n_s_genexpr); + Py_CLEAR(clear_module_state->__pyx_n_s_getstate); + Py_CLEAR(clear_module_state->__pyx_n_s_globals); + Py_CLEAR(clear_module_state->__pyx_n_s_gt); + Py_CLEAR(clear_module_state->__pyx_n_s_gt_2); + Py_CLEAR(clear_module_state->__pyx_n_s_gte); + Py_CLEAR(clear_module_state->__pyx_n_s_gte_2); + Py_CLEAR(clear_module_state->__pyx_n_s_has); + Py_CLEAR(clear_module_state->__pyx_n_s_hunter); + Py_CLEAR(clear_module_state->__pyx_n_s_hunter__predicates); + Py_CLEAR(clear_module_state->__pyx_kp_s_hunter__predicates_And_predicat); + Py_CLEAR(clear_module_state->__pyx_kp_s_hunter__predicates_From_conditi); + Py_CLEAR(clear_module_state->__pyx_kp_s_hunter__predicates_Not_predicat); + Py_CLEAR(clear_module_state->__pyx_kp_s_hunter__predicates_Or_predicate); + Py_CLEAR(clear_module_state->__pyx_kp_s_hunter__predicates_When_conditi); + Py_CLEAR(clear_module_state->__pyx_kp_s_hunter_predicates_Backlog_condi); + Py_CLEAR(clear_module_state->__pyx_kp_s_hunter_predicates_Query_s); + Py_CLEAR(clear_module_state->__pyx_n_s_import); + Py_CLEAR(clear_module_state->__pyx_n_s_in); + Py_CLEAR(clear_module_state->__pyx_n_s_in_2); + Py_CLEAR(clear_module_state->__pyx_n_s_index); + Py_CLEAR(clear_module_state->__pyx_n_s_init___locals_genexpr); + Py_CLEAR(clear_module_state->__pyx_n_s_inspect); + Py_CLEAR(clear_module_state->__pyx_n_s_instruction); + Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine); + Py_CLEAR(clear_module_state->__pyx_kp_u_is_invalid_Must_be_a_string_lis); + Py_CLEAR(clear_module_state->__pyx_n_s_isclass); + Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled); + Py_CLEAR(clear_module_state->__pyx_n_s_items); + Py_CLEAR(clear_module_state->__pyx_n_s_join); + Py_CLEAR(clear_module_state->__pyx_n_s_kind); + Py_CLEAR(clear_module_state->__pyx_n_s_kwargs); + Py_CLEAR(clear_module_state->__pyx_n_s_lineno); + Py_CLEAR(clear_module_state->__pyx_n_s_locals); + Py_CLEAR(clear_module_state->__pyx_n_s_lt); + Py_CLEAR(clear_module_state->__pyx_n_s_lt_2); + Py_CLEAR(clear_module_state->__pyx_n_s_lte); + Py_CLEAR(clear_module_state->__pyx_n_s_lte_2); + Py_CLEAR(clear_module_state->__pyx_n_s_main); + Py_CLEAR(clear_module_state->__pyx_n_s_match); + Py_CLEAR(clear_module_state->__pyx_n_s_maxlen); + Py_CLEAR(clear_module_state->__pyx_n_s_merge); + Py_CLEAR(clear_module_state->__pyx_n_s_module); + Py_CLEAR(clear_module_state->__pyx_n_s_name); + Py_CLEAR(clear_module_state->__pyx_n_s_name_2); + Py_CLEAR(clear_module_state->__pyx_n_s_new); + Py_CLEAR(clear_module_state->__pyx_n_s_pickle); + Py_CLEAR(clear_module_state->__pyx_n_s_predicate); + Py_CLEAR(clear_module_state->__pyx_n_s_predicates); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_PickleError); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_checksum); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_result); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_type); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_And); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_Backlog); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_From); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_Not); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_Or); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_Query); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_When); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_vtable); + Py_CLEAR(clear_module_state->__pyx_kp_s_query_contains_r); + Py_CLEAR(clear_module_state->__pyx_kp_s_query_endswith_r); + Py_CLEAR(clear_module_state->__pyx_kp_s_query_eq_r); + Py_CLEAR(clear_module_state->__pyx_kp_s_query_gt_r); + Py_CLEAR(clear_module_state->__pyx_kp_s_query_gte_r); + Py_CLEAR(clear_module_state->__pyx_kp_s_query_in_r); + Py_CLEAR(clear_module_state->__pyx_kp_s_query_lt_r); + Py_CLEAR(clear_module_state->__pyx_kp_s_query_lte_r); + Py_CLEAR(clear_module_state->__pyx_kp_s_query_regex_r); + Py_CLEAR(clear_module_state->__pyx_kp_s_query_startswith_r); + Py_CLEAR(clear_module_state->__pyx_n_s_re); + Py_CLEAR(clear_module_state->__pyx_n_s_re_compile); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex); + Py_CLEAR(clear_module_state->__pyx_n_s_regex); + Py_CLEAR(clear_module_state->__pyx_n_s_regex_2); + Py_CLEAR(clear_module_state->__pyx_n_s_rx); + Py_CLEAR(clear_module_state->__pyx_n_s_self); + Py_CLEAR(clear_module_state->__pyx_kp_s_self_getter_cannot_be_converted); + Py_CLEAR(clear_module_state->__pyx_n_s_send); + Py_CLEAR(clear_module_state->__pyx_n_s_setstate); + Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_size); + Py_CLEAR(clear_module_state->__pyx_n_s_source); + Py_CLEAR(clear_module_state->__pyx_n_s_split); + Py_CLEAR(clear_module_state->__pyx_kp_s_src_hunter__predicates_pyx); + Py_CLEAR(clear_module_state->__pyx_n_s_stack); + Py_CLEAR(clear_module_state->__pyx_n_s_startswith); + Py_CLEAR(clear_module_state->__pyx_n_s_startswith_2); + Py_CLEAR(clear_module_state->__pyx_n_s_state); + Py_CLEAR(clear_module_state->__pyx_n_s_stdlib); + Py_CLEAR(clear_module_state->__pyx_n_s_str___locals_genexpr); + Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource); + Py_CLEAR(clear_module_state->__pyx_n_s_strip); + Py_CLEAR(clear_module_state->__pyx_n_s_sw); + Py_CLEAR(clear_module_state->__pyx_n_s_test); + Py_CLEAR(clear_module_state->__pyx_n_s_threadid); + Py_CLEAR(clear_module_state->__pyx_n_s_threading_support); + Py_CLEAR(clear_module_state->__pyx_n_s_threadname); + Py_CLEAR(clear_module_state->__pyx_n_s_throw); + Py_CLEAR(clear_module_state->__pyx_n_s_try_repr); + Py_CLEAR(clear_module_state->__pyx_n_s_update); + Py_CLEAR(clear_module_state->__pyx_n_s_use_setstate); + Py_CLEAR(clear_module_state->__pyx_n_s_value); + Py_CLEAR(clear_module_state->__pyx_n_s_vars); + Py_CLEAR(clear_module_state->__pyx_n_s_watermark); + Py_CLEAR(clear_module_state->__pyx_kp_u_with_optional_operators_like); + Py_CLEAR(clear_module_state->__pyx_n_s_wrap); + 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); + Py_CLEAR(clear_module_state->__pyx_tuple_); + Py_CLEAR(clear_module_state->__pyx_tuple__13); + Py_CLEAR(clear_module_state->__pyx_tuple__28); + Py_CLEAR(clear_module_state->__pyx_tuple__30); + Py_CLEAR(clear_module_state->__pyx_tuple__32); + Py_CLEAR(clear_module_state->__pyx_tuple__34); + Py_CLEAR(clear_module_state->__pyx_tuple__37); + Py_CLEAR(clear_module_state->__pyx_tuple__39); + Py_CLEAR(clear_module_state->__pyx_tuple__40); + Py_CLEAR(clear_module_state->__pyx_tuple__41); + Py_CLEAR(clear_module_state->__pyx_tuple__42); + Py_CLEAR(clear_module_state->__pyx_tuple__43); + Py_CLEAR(clear_module_state->__pyx_tuple__44); + Py_CLEAR(clear_module_state->__pyx_tuple__45); + Py_CLEAR(clear_module_state->__pyx_tuple__46); + Py_CLEAR(clear_module_state->__pyx_tuple__47); + Py_CLEAR(clear_module_state->__pyx_codeobj__2); + Py_CLEAR(clear_module_state->__pyx_codeobj__3); + Py_CLEAR(clear_module_state->__pyx_codeobj__4); + Py_CLEAR(clear_module_state->__pyx_codeobj__11); + Py_CLEAR(clear_module_state->__pyx_codeobj__12); + Py_CLEAR(clear_module_state->__pyx_codeobj__14); + Py_CLEAR(clear_module_state->__pyx_codeobj__15); + Py_CLEAR(clear_module_state->__pyx_codeobj__16); + Py_CLEAR(clear_module_state->__pyx_codeobj__17); + Py_CLEAR(clear_module_state->__pyx_codeobj__18); + Py_CLEAR(clear_module_state->__pyx_codeobj__19); + Py_CLEAR(clear_module_state->__pyx_codeobj__20); + Py_CLEAR(clear_module_state->__pyx_codeobj__21); + Py_CLEAR(clear_module_state->__pyx_codeobj__22); + Py_CLEAR(clear_module_state->__pyx_codeobj__23); + Py_CLEAR(clear_module_state->__pyx_codeobj__24); + Py_CLEAR(clear_module_state->__pyx_codeobj__25); + Py_CLEAR(clear_module_state->__pyx_codeobj__26); + Py_CLEAR(clear_module_state->__pyx_codeobj__27); + Py_CLEAR(clear_module_state->__pyx_codeobj__29); + Py_CLEAR(clear_module_state->__pyx_codeobj__31); + Py_CLEAR(clear_module_state->__pyx_codeobj__33); + Py_CLEAR(clear_module_state->__pyx_codeobj__35); + Py_CLEAR(clear_module_state->__pyx_codeobj__36); + Py_CLEAR(clear_module_state->__pyx_codeobj__38); + return 0; +} +#endif +/* #### Code section: module_state_traverse ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { + __pyx_mstate *traverse_module_state = __pyx_mstate(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); + Py_VISIT(traverse_module_state->__pyx_empty_tuple); + Py_VISIT(traverse_module_state->__pyx_empty_bytes); + Py_VISIT(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_7_tracer_FrameType); + 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_6_event_Event); + 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); + Py_VISIT(traverse_module_state->__pyx_n_s_Action); + Py_VISIT(traverse_module_state->__pyx_kp_s_Action_r_must_be_a_ColorStreamAc); + Py_VISIT(traverse_module_state->__pyx_n_s_And); + Py_VISIT(traverse_module_state->__pyx_n_s_And___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_And___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_kp_s_And_s); + Py_VISIT(traverse_module_state->__pyx_n_s_Backlog); + Py_VISIT(traverse_module_state->__pyx_n_s_Backlog___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Backlog___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Backlog_filter); + Py_VISIT(traverse_module_state->__pyx_kp_s_Backlog_s_size_s_stack_s_vars_s); + Py_VISIT(traverse_module_state->__pyx_n_s_ColorStreamAction); + Py_VISIT(traverse_module_state->__pyx_n_s_From); + Py_VISIT(traverse_module_state->__pyx_n_s_From___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_From___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_kp_s_From_s_s_watermark_s); + Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0); + Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_2); + Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_3); + Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_4); + Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_5); + Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_6); + Py_VISIT(traverse_module_state->__pyx_kp_u_Must_be_one_of); + Py_VISIT(traverse_module_state->__pyx_kp_s_Must_give_at_least_one_action); + Py_VISIT(traverse_module_state->__pyx_n_s_Not); + Py_VISIT(traverse_module_state->__pyx_n_s_Not___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Not___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_kp_s_Not_s); + Py_VISIT(traverse_module_state->__pyx_n_s_Or); + Py_VISIT(traverse_module_state->__pyx_n_s_Or___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Or___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_kp_s_Or_s); + Py_VISIT(traverse_module_state->__pyx_n_s_PickleError); + Py_VISIT(traverse_module_state->__pyx_n_s_Pyx_CFunc_6hunter_11_predicate); + Py_VISIT(traverse_module_state->__pyx_n_s_Query); + Py_VISIT(traverse_module_state->__pyx_n_s_QueryEntry); + Py_VISIT(traverse_module_state->__pyx_n_s_QueryEntry___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_QueryEntry___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Query___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Query___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_kp_s_Query_s); + Py_VISIT(traverse_module_state->__pyx_n_s_TypeError); + Py_VISIT(traverse_module_state->__pyx_kp_u_Unexpected_argument); + Py_VISIT(traverse_module_state->__pyx_kp_u_Unexpected_operator); + Py_VISIT(traverse_module_state->__pyx_kp_u_Value); + Py_VISIT(traverse_module_state->__pyx_n_s_ValueError); + Py_VISIT(traverse_module_state->__pyx_n_s_When); + Py_VISIT(traverse_module_state->__pyx_n_s_When___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_When___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_kp_s_When_s_s); + Py_VISIT(traverse_module_state->__pyx_kp_s__10); + Py_VISIT(traverse_module_state->__pyx_n_s__48); + Py_VISIT(traverse_module_state->__pyx_n_s__5); + Py_VISIT(traverse_module_state->__pyx_kp_u__6); + Py_VISIT(traverse_module_state->__pyx_kp_u__7); + Py_VISIT(traverse_module_state->__pyx_kp_s__8); + Py_VISIT(traverse_module_state->__pyx_kp_s__9); + Py_VISIT(traverse_module_state->__pyx_n_s_action); + Py_VISIT(traverse_module_state->__pyx_n_s_actions); + Py_VISIT(traverse_module_state->__pyx_n_s_all); + Py_VISIT(traverse_module_state->__pyx_n_s_append); + Py_VISIT(traverse_module_state->__pyx_n_s_appendleft); + Py_VISIT(traverse_module_state->__pyx_n_s_arg); + Py_VISIT(traverse_module_state->__pyx_n_s_args); + Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines); + Py_VISIT(traverse_module_state->__pyx_n_s_builtin); + Py_VISIT(traverse_module_state->__pyx_n_s_call); + Py_VISIT(traverse_module_state->__pyx_n_s_calls); + Py_VISIT(traverse_module_state->__pyx_n_s_cfunc_to_py); + Py_VISIT(traverse_module_state->__pyx_n_s_cleanup); + Py_VISIT(traverse_module_state->__pyx_n_s_clear); + Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback); + Py_VISIT(traverse_module_state->__pyx_n_s_close); + Py_VISIT(traverse_module_state->__pyx_n_s_collections); + Py_VISIT(traverse_module_state->__pyx_n_s_compile); + Py_VISIT(traverse_module_state->__pyx_n_s_condition); + Py_VISIT(traverse_module_state->__pyx_n_s_contains); + Py_VISIT(traverse_module_state->__pyx_n_s_contains_2); + Py_VISIT(traverse_module_state->__pyx_n_s_depth); + Py_VISIT(traverse_module_state->__pyx_n_s_deque); + Py_VISIT(traverse_module_state->__pyx_n_s_dict); + Py_VISIT(traverse_module_state->__pyx_n_s_dict_2); + Py_VISIT(traverse_module_state->__pyx_kp_u_disable); + Py_VISIT(traverse_module_state->__pyx_kp_u_enable); + Py_VISIT(traverse_module_state->__pyx_n_s_endswith); + Py_VISIT(traverse_module_state->__pyx_n_s_endswith_2); + Py_VISIT(traverse_module_state->__pyx_n_s_event); + Py_VISIT(traverse_module_state->__pyx_n_s_ew); + Py_VISIT(traverse_module_state->__pyx_n_s_f_back); + Py_VISIT(traverse_module_state->__pyx_n_s_filename); + Py_VISIT(traverse_module_state->__pyx_n_s_filter); + Py_VISIT(traverse_module_state->__pyx_kp_u_for); + Py_VISIT(traverse_module_state->__pyx_n_s_frame); + Py_VISIT(traverse_module_state->__pyx_n_s_fullsource); + Py_VISIT(traverse_module_state->__pyx_n_s_function); + Py_VISIT(traverse_module_state->__pyx_kp_u_gc); + Py_VISIT(traverse_module_state->__pyx_n_s_genexpr); + Py_VISIT(traverse_module_state->__pyx_n_s_getstate); + Py_VISIT(traverse_module_state->__pyx_n_s_globals); + Py_VISIT(traverse_module_state->__pyx_n_s_gt); + Py_VISIT(traverse_module_state->__pyx_n_s_gt_2); + Py_VISIT(traverse_module_state->__pyx_n_s_gte); + Py_VISIT(traverse_module_state->__pyx_n_s_gte_2); + Py_VISIT(traverse_module_state->__pyx_n_s_has); + Py_VISIT(traverse_module_state->__pyx_n_s_hunter); + Py_VISIT(traverse_module_state->__pyx_n_s_hunter__predicates); + Py_VISIT(traverse_module_state->__pyx_kp_s_hunter__predicates_And_predicat); + Py_VISIT(traverse_module_state->__pyx_kp_s_hunter__predicates_From_conditi); + Py_VISIT(traverse_module_state->__pyx_kp_s_hunter__predicates_Not_predicat); + Py_VISIT(traverse_module_state->__pyx_kp_s_hunter__predicates_Or_predicate); + Py_VISIT(traverse_module_state->__pyx_kp_s_hunter__predicates_When_conditi); + Py_VISIT(traverse_module_state->__pyx_kp_s_hunter_predicates_Backlog_condi); + Py_VISIT(traverse_module_state->__pyx_kp_s_hunter_predicates_Query_s); + Py_VISIT(traverse_module_state->__pyx_n_s_import); + Py_VISIT(traverse_module_state->__pyx_n_s_in); + Py_VISIT(traverse_module_state->__pyx_n_s_in_2); + Py_VISIT(traverse_module_state->__pyx_n_s_index); + Py_VISIT(traverse_module_state->__pyx_n_s_init___locals_genexpr); + Py_VISIT(traverse_module_state->__pyx_n_s_inspect); + Py_VISIT(traverse_module_state->__pyx_n_s_instruction); + Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine); + Py_VISIT(traverse_module_state->__pyx_kp_u_is_invalid_Must_be_a_string_lis); + Py_VISIT(traverse_module_state->__pyx_n_s_isclass); + Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled); + Py_VISIT(traverse_module_state->__pyx_n_s_items); + Py_VISIT(traverse_module_state->__pyx_n_s_join); + Py_VISIT(traverse_module_state->__pyx_n_s_kind); + Py_VISIT(traverse_module_state->__pyx_n_s_kwargs); + Py_VISIT(traverse_module_state->__pyx_n_s_lineno); + Py_VISIT(traverse_module_state->__pyx_n_s_locals); + Py_VISIT(traverse_module_state->__pyx_n_s_lt); + Py_VISIT(traverse_module_state->__pyx_n_s_lt_2); + Py_VISIT(traverse_module_state->__pyx_n_s_lte); + Py_VISIT(traverse_module_state->__pyx_n_s_lte_2); + Py_VISIT(traverse_module_state->__pyx_n_s_main); + Py_VISIT(traverse_module_state->__pyx_n_s_match); + Py_VISIT(traverse_module_state->__pyx_n_s_maxlen); + Py_VISIT(traverse_module_state->__pyx_n_s_merge); + Py_VISIT(traverse_module_state->__pyx_n_s_module); + Py_VISIT(traverse_module_state->__pyx_n_s_name); + Py_VISIT(traverse_module_state->__pyx_n_s_name_2); + Py_VISIT(traverse_module_state->__pyx_n_s_new); + Py_VISIT(traverse_module_state->__pyx_n_s_pickle); + Py_VISIT(traverse_module_state->__pyx_n_s_predicate); + Py_VISIT(traverse_module_state->__pyx_n_s_predicates); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_PickleError); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_checksum); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_result); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_type); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_And); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_Backlog); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_From); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_Not); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_Or); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_Query); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_When); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_vtable); + Py_VISIT(traverse_module_state->__pyx_kp_s_query_contains_r); + Py_VISIT(traverse_module_state->__pyx_kp_s_query_endswith_r); + Py_VISIT(traverse_module_state->__pyx_kp_s_query_eq_r); + Py_VISIT(traverse_module_state->__pyx_kp_s_query_gt_r); + Py_VISIT(traverse_module_state->__pyx_kp_s_query_gte_r); + Py_VISIT(traverse_module_state->__pyx_kp_s_query_in_r); + Py_VISIT(traverse_module_state->__pyx_kp_s_query_lt_r); + Py_VISIT(traverse_module_state->__pyx_kp_s_query_lte_r); + Py_VISIT(traverse_module_state->__pyx_kp_s_query_regex_r); + Py_VISIT(traverse_module_state->__pyx_kp_s_query_startswith_r); + Py_VISIT(traverse_module_state->__pyx_n_s_re); + Py_VISIT(traverse_module_state->__pyx_n_s_re_compile); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex); + Py_VISIT(traverse_module_state->__pyx_n_s_regex); + Py_VISIT(traverse_module_state->__pyx_n_s_regex_2); + Py_VISIT(traverse_module_state->__pyx_n_s_rx); + Py_VISIT(traverse_module_state->__pyx_n_s_self); + Py_VISIT(traverse_module_state->__pyx_kp_s_self_getter_cannot_be_converted); + Py_VISIT(traverse_module_state->__pyx_n_s_send); + Py_VISIT(traverse_module_state->__pyx_n_s_setstate); + Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_size); + Py_VISIT(traverse_module_state->__pyx_n_s_source); + Py_VISIT(traverse_module_state->__pyx_n_s_split); + Py_VISIT(traverse_module_state->__pyx_kp_s_src_hunter__predicates_pyx); + Py_VISIT(traverse_module_state->__pyx_n_s_stack); + Py_VISIT(traverse_module_state->__pyx_n_s_startswith); + Py_VISIT(traverse_module_state->__pyx_n_s_startswith_2); + Py_VISIT(traverse_module_state->__pyx_n_s_state); + Py_VISIT(traverse_module_state->__pyx_n_s_stdlib); + Py_VISIT(traverse_module_state->__pyx_n_s_str___locals_genexpr); + Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource); + Py_VISIT(traverse_module_state->__pyx_n_s_strip); + Py_VISIT(traverse_module_state->__pyx_n_s_sw); + Py_VISIT(traverse_module_state->__pyx_n_s_test); + Py_VISIT(traverse_module_state->__pyx_n_s_threadid); + Py_VISIT(traverse_module_state->__pyx_n_s_threading_support); + Py_VISIT(traverse_module_state->__pyx_n_s_threadname); + Py_VISIT(traverse_module_state->__pyx_n_s_throw); + Py_VISIT(traverse_module_state->__pyx_n_s_try_repr); + Py_VISIT(traverse_module_state->__pyx_n_s_update); + Py_VISIT(traverse_module_state->__pyx_n_s_use_setstate); + Py_VISIT(traverse_module_state->__pyx_n_s_value); + Py_VISIT(traverse_module_state->__pyx_n_s_vars); + Py_VISIT(traverse_module_state->__pyx_n_s_watermark); + Py_VISIT(traverse_module_state->__pyx_kp_u_with_optional_operators_like); + Py_VISIT(traverse_module_state->__pyx_n_s_wrap); + Py_VISIT(traverse_module_state->__pyx_int_0); + Py_VISIT(traverse_module_state->__pyx_int_10); + Py_VISIT(traverse_module_state->__pyx_int_100); + Py_VISIT(traverse_module_state->__pyx_int_4473905); + Py_VISIT(traverse_module_state->__pyx_int_21139105); + Py_VISIT(traverse_module_state->__pyx_int_28104183); + Py_VISIT(traverse_module_state->__pyx_int_37183945); + Py_VISIT(traverse_module_state->__pyx_int_79429044); + Py_VISIT(traverse_module_state->__pyx_int_82616482); + Py_VISIT(traverse_module_state->__pyx_int_89143876); + Py_VISIT(traverse_module_state->__pyx_int_124881844); + Py_VISIT(traverse_module_state->__pyx_int_149034610); + Py_VISIT(traverse_module_state->__pyx_int_166332997); + Py_VISIT(traverse_module_state->__pyx_int_178834394); + Py_VISIT(traverse_module_state->__pyx_int_190166812); + Py_VISIT(traverse_module_state->__pyx_int_198256870); + Py_VISIT(traverse_module_state->__pyx_int_210676054); + Py_VISIT(traverse_module_state->__pyx_int_217908684); + Py_VISIT(traverse_module_state->__pyx_int_223119700); + Py_VISIT(traverse_module_state->__pyx_int_242287462); + Py_VISIT(traverse_module_state->__pyx_int_258412278); + Py_VISIT(traverse_module_state->__pyx_int_neg_1); + Py_VISIT(traverse_module_state->__pyx_tuple_); + Py_VISIT(traverse_module_state->__pyx_tuple__13); + Py_VISIT(traverse_module_state->__pyx_tuple__28); + Py_VISIT(traverse_module_state->__pyx_tuple__30); + Py_VISIT(traverse_module_state->__pyx_tuple__32); + Py_VISIT(traverse_module_state->__pyx_tuple__34); + Py_VISIT(traverse_module_state->__pyx_tuple__37); + Py_VISIT(traverse_module_state->__pyx_tuple__39); + Py_VISIT(traverse_module_state->__pyx_tuple__40); + Py_VISIT(traverse_module_state->__pyx_tuple__41); + Py_VISIT(traverse_module_state->__pyx_tuple__42); + Py_VISIT(traverse_module_state->__pyx_tuple__43); + Py_VISIT(traverse_module_state->__pyx_tuple__44); + Py_VISIT(traverse_module_state->__pyx_tuple__45); + Py_VISIT(traverse_module_state->__pyx_tuple__46); + Py_VISIT(traverse_module_state->__pyx_tuple__47); + Py_VISIT(traverse_module_state->__pyx_codeobj__2); + Py_VISIT(traverse_module_state->__pyx_codeobj__3); + Py_VISIT(traverse_module_state->__pyx_codeobj__4); + Py_VISIT(traverse_module_state->__pyx_codeobj__11); + Py_VISIT(traverse_module_state->__pyx_codeobj__12); + Py_VISIT(traverse_module_state->__pyx_codeobj__14); + Py_VISIT(traverse_module_state->__pyx_codeobj__15); + Py_VISIT(traverse_module_state->__pyx_codeobj__16); + Py_VISIT(traverse_module_state->__pyx_codeobj__17); + Py_VISIT(traverse_module_state->__pyx_codeobj__18); + Py_VISIT(traverse_module_state->__pyx_codeobj__19); + Py_VISIT(traverse_module_state->__pyx_codeobj__20); + Py_VISIT(traverse_module_state->__pyx_codeobj__21); + Py_VISIT(traverse_module_state->__pyx_codeobj__22); + Py_VISIT(traverse_module_state->__pyx_codeobj__23); + Py_VISIT(traverse_module_state->__pyx_codeobj__24); + Py_VISIT(traverse_module_state->__pyx_codeobj__25); + Py_VISIT(traverse_module_state->__pyx_codeobj__26); + Py_VISIT(traverse_module_state->__pyx_codeobj__27); + Py_VISIT(traverse_module_state->__pyx_codeobj__29); + Py_VISIT(traverse_module_state->__pyx_codeobj__31); + Py_VISIT(traverse_module_state->__pyx_codeobj__33); + Py_VISIT(traverse_module_state->__pyx_codeobj__35); + Py_VISIT(traverse_module_state->__pyx_codeobj__36); + Py_VISIT(traverse_module_state->__pyx_codeobj__38); + return 0; +} +#endif +/* #### Code section: module_state_defines ### */ +#define __pyx_d __pyx_mstate_global->__pyx_d +#define __pyx_b __pyx_mstate_global->__pyx_b +#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime +#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple +#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes +#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode +#ifdef __Pyx_CyFunction_USED +#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType +#endif +#ifdef __Pyx_FusedFunction_USED +#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType +#endif +#ifdef __Pyx_Generator_USED +#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType +#endif +#ifdef __Pyx_IterableCoroutine_USED +#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#define __pyx_ptype_7cpython_4type_type __pyx_mstate_global->__pyx_ptype_7cpython_4type_type +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#define __pyx_ptype_6hunter_7_tracer_FrameType __pyx_mstate_global->__pyx_ptype_6hunter_7_tracer_FrameType +#define __pyx_ptype_6hunter_7_tracer_CodeType __pyx_mstate_global->__pyx_ptype_6hunter_7_tracer_CodeType +#define __pyx_ptype_6hunter_7_tracer_Tracer __pyx_mstate_global->__pyx_ptype_6hunter_7_tracer_Tracer +#if CYTHON_USE_MODULE_STATE +#endif +#define __pyx_ptype_6hunter_6_event_Event __pyx_mstate_global->__pyx_ptype_6hunter_6_event_Event +#if CYTHON_USE_MODULE_STATE +#define __pyx_type_6hunter_11_predicates_Query __pyx_mstate_global->__pyx_type_6hunter_11_predicates_Query +#define __pyx_type_6hunter_11_predicates_And __pyx_mstate_global->__pyx_type_6hunter_11_predicates_And +#define __pyx_type_6hunter_11_predicates_Or __pyx_mstate_global->__pyx_type_6hunter_11_predicates_Or +#define __pyx_type_6hunter_11_predicates_Not __pyx_mstate_global->__pyx_type_6hunter_11_predicates_Not +#define __pyx_type_6hunter_11_predicates_When __pyx_mstate_global->__pyx_type_6hunter_11_predicates_When +#define __pyx_type_6hunter_11_predicates_From __pyx_mstate_global->__pyx_type_6hunter_11_predicates_From +#define __pyx_type_6hunter_11_predicates_Backlog __pyx_mstate_global->__pyx_type_6hunter_11_predicates_Backlog +#define __pyx_type_6hunter_11_predicates_QueryEntry __pyx_mstate_global->__pyx_type_6hunter_11_predicates_QueryEntry +#define __pyx_type_6hunter_11_predicates___pyx_scope_struct____str__ __pyx_mstate_global->__pyx_type_6hunter_11_predicates___pyx_scope_struct____str__ +#define __pyx_type_6hunter_11_predicates___pyx_scope_struct_1_genexpr __pyx_mstate_global->__pyx_type_6hunter_11_predicates___pyx_scope_struct_1_genexpr +#define __pyx_type_6hunter_11_predicates___pyx_scope_struct_2_genexpr __pyx_mstate_global->__pyx_type_6hunter_11_predicates___pyx_scope_struct_2_genexpr +#define __pyx_type_6hunter_11_predicates___pyx_scope_struct_3_genexpr __pyx_mstate_global->__pyx_type_6hunter_11_predicates___pyx_scope_struct_3_genexpr +#define __pyx_type_6hunter_11_predicates___pyx_scope_struct_4_genexpr __pyx_mstate_global->__pyx_type_6hunter_11_predicates___pyx_scope_struct_4_genexpr +#define __pyx_type_6hunter_11_predicates___pyx_scope_struct_5_genexpr __pyx_mstate_global->__pyx_type_6hunter_11_predicates___pyx_scope_struct_5_genexpr +#define __pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event __pyx_mstate_global->__pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event +#endif +#define __pyx_ptype_6hunter_11_predicates_Query __pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Query +#define __pyx_ptype_6hunter_11_predicates_And __pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_And +#define __pyx_ptype_6hunter_11_predicates_Or __pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Or +#define __pyx_ptype_6hunter_11_predicates_Not __pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Not +#define __pyx_ptype_6hunter_11_predicates_When __pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_When +#define __pyx_ptype_6hunter_11_predicates_From __pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_From +#define __pyx_ptype_6hunter_11_predicates_Backlog __pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Backlog +#define __pyx_ptype_6hunter_11_predicates_QueryEntry __pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_QueryEntry +#define __pyx_ptype_6hunter_11_predicates___pyx_scope_struct____str__ __pyx_mstate_global->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct____str__ +#define __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_1_genexpr __pyx_mstate_global->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_1_genexpr +#define __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_2_genexpr __pyx_mstate_global->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_2_genexpr +#define __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_3_genexpr __pyx_mstate_global->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_3_genexpr +#define __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_4_genexpr __pyx_mstate_global->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_4_genexpr +#define __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_5_genexpr __pyx_mstate_global->__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_5_genexpr +#define __pyx_ptype___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 +#define __pyx_n_s_Action __pyx_mstate_global->__pyx_n_s_Action +#define __pyx_kp_s_Action_r_must_be_a_ColorStreamAc __pyx_mstate_global->__pyx_kp_s_Action_r_must_be_a_ColorStreamAc +#define __pyx_n_s_And __pyx_mstate_global->__pyx_n_s_And +#define __pyx_n_s_And___reduce_cython __pyx_mstate_global->__pyx_n_s_And___reduce_cython +#define __pyx_n_s_And___setstate_cython __pyx_mstate_global->__pyx_n_s_And___setstate_cython +#define __pyx_kp_s_And_s __pyx_mstate_global->__pyx_kp_s_And_s +#define __pyx_n_s_Backlog __pyx_mstate_global->__pyx_n_s_Backlog +#define __pyx_n_s_Backlog___reduce_cython __pyx_mstate_global->__pyx_n_s_Backlog___reduce_cython +#define __pyx_n_s_Backlog___setstate_cython __pyx_mstate_global->__pyx_n_s_Backlog___setstate_cython +#define __pyx_n_s_Backlog_filter __pyx_mstate_global->__pyx_n_s_Backlog_filter +#define __pyx_kp_s_Backlog_s_size_s_stack_s_vars_s __pyx_mstate_global->__pyx_kp_s_Backlog_s_size_s_stack_s_vars_s +#define __pyx_n_s_ColorStreamAction __pyx_mstate_global->__pyx_n_s_ColorStreamAction +#define __pyx_n_s_From __pyx_mstate_global->__pyx_n_s_From +#define __pyx_n_s_From___reduce_cython __pyx_mstate_global->__pyx_n_s_From___reduce_cython +#define __pyx_n_s_From___setstate_cython __pyx_mstate_global->__pyx_n_s_From___setstate_cython +#define __pyx_kp_s_From_s_s_watermark_s __pyx_mstate_global->__pyx_kp_s_From_s_s_watermark_s +#define __pyx_kp_s_Incompatible_checksums_0x_x_vs_0 __pyx_mstate_global->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0 +#define __pyx_kp_s_Incompatible_checksums_0x_x_vs_0_2 __pyx_mstate_global->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_2 +#define __pyx_kp_s_Incompatible_checksums_0x_x_vs_0_3 __pyx_mstate_global->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_3 +#define __pyx_kp_s_Incompatible_checksums_0x_x_vs_0_4 __pyx_mstate_global->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_4 +#define __pyx_kp_s_Incompatible_checksums_0x_x_vs_0_5 __pyx_mstate_global->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_5 +#define __pyx_kp_s_Incompatible_checksums_0x_x_vs_0_6 __pyx_mstate_global->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_6 +#define __pyx_kp_u_Must_be_one_of __pyx_mstate_global->__pyx_kp_u_Must_be_one_of +#define __pyx_kp_s_Must_give_at_least_one_action __pyx_mstate_global->__pyx_kp_s_Must_give_at_least_one_action +#define __pyx_n_s_Not __pyx_mstate_global->__pyx_n_s_Not +#define __pyx_n_s_Not___reduce_cython __pyx_mstate_global->__pyx_n_s_Not___reduce_cython +#define __pyx_n_s_Not___setstate_cython __pyx_mstate_global->__pyx_n_s_Not___setstate_cython +#define __pyx_kp_s_Not_s __pyx_mstate_global->__pyx_kp_s_Not_s +#define __pyx_n_s_Or __pyx_mstate_global->__pyx_n_s_Or +#define __pyx_n_s_Or___reduce_cython __pyx_mstate_global->__pyx_n_s_Or___reduce_cython +#define __pyx_n_s_Or___setstate_cython __pyx_mstate_global->__pyx_n_s_Or___setstate_cython +#define __pyx_kp_s_Or_s __pyx_mstate_global->__pyx_kp_s_Or_s +#define __pyx_n_s_PickleError __pyx_mstate_global->__pyx_n_s_PickleError +#define __pyx_n_s_Pyx_CFunc_6hunter_11_predicate __pyx_mstate_global->__pyx_n_s_Pyx_CFunc_6hunter_11_predicate +#define __pyx_n_s_Query __pyx_mstate_global->__pyx_n_s_Query +#define __pyx_n_s_QueryEntry __pyx_mstate_global->__pyx_n_s_QueryEntry +#define __pyx_n_s_QueryEntry___reduce_cython __pyx_mstate_global->__pyx_n_s_QueryEntry___reduce_cython +#define __pyx_n_s_QueryEntry___setstate_cython __pyx_mstate_global->__pyx_n_s_QueryEntry___setstate_cython +#define __pyx_n_s_Query___reduce_cython __pyx_mstate_global->__pyx_n_s_Query___reduce_cython +#define __pyx_n_s_Query___setstate_cython __pyx_mstate_global->__pyx_n_s_Query___setstate_cython +#define __pyx_kp_s_Query_s __pyx_mstate_global->__pyx_kp_s_Query_s +#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError +#define __pyx_kp_u_Unexpected_argument __pyx_mstate_global->__pyx_kp_u_Unexpected_argument +#define __pyx_kp_u_Unexpected_operator __pyx_mstate_global->__pyx_kp_u_Unexpected_operator +#define __pyx_kp_u_Value __pyx_mstate_global->__pyx_kp_u_Value +#define __pyx_n_s_ValueError __pyx_mstate_global->__pyx_n_s_ValueError +#define __pyx_n_s_When __pyx_mstate_global->__pyx_n_s_When +#define __pyx_n_s_When___reduce_cython __pyx_mstate_global->__pyx_n_s_When___reduce_cython +#define __pyx_n_s_When___setstate_cython __pyx_mstate_global->__pyx_n_s_When___setstate_cython +#define __pyx_kp_s_When_s_s __pyx_mstate_global->__pyx_kp_s_When_s_s +#define __pyx_kp_s__10 __pyx_mstate_global->__pyx_kp_s__10 +#define __pyx_n_s__48 __pyx_mstate_global->__pyx_n_s__48 +#define __pyx_n_s__5 __pyx_mstate_global->__pyx_n_s__5 +#define __pyx_kp_u__6 __pyx_mstate_global->__pyx_kp_u__6 +#define __pyx_kp_u__7 __pyx_mstate_global->__pyx_kp_u__7 +#define __pyx_kp_s__8 __pyx_mstate_global->__pyx_kp_s__8 +#define __pyx_kp_s__9 __pyx_mstate_global->__pyx_kp_s__9 +#define __pyx_n_s_action __pyx_mstate_global->__pyx_n_s_action +#define __pyx_n_s_actions __pyx_mstate_global->__pyx_n_s_actions +#define __pyx_n_s_all __pyx_mstate_global->__pyx_n_s_all +#define __pyx_n_s_append __pyx_mstate_global->__pyx_n_s_append +#define __pyx_n_s_appendleft __pyx_mstate_global->__pyx_n_s_appendleft +#define __pyx_n_s_arg __pyx_mstate_global->__pyx_n_s_arg +#define __pyx_n_s_args __pyx_mstate_global->__pyx_n_s_args +#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines +#define __pyx_n_s_builtin __pyx_mstate_global->__pyx_n_s_builtin +#define __pyx_n_s_call __pyx_mstate_global->__pyx_n_s_call +#define __pyx_n_s_calls __pyx_mstate_global->__pyx_n_s_calls +#define __pyx_n_s_cfunc_to_py __pyx_mstate_global->__pyx_n_s_cfunc_to_py +#define __pyx_n_s_cleanup __pyx_mstate_global->__pyx_n_s_cleanup +#define __pyx_n_s_clear __pyx_mstate_global->__pyx_n_s_clear +#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback +#define __pyx_n_s_close __pyx_mstate_global->__pyx_n_s_close +#define __pyx_n_s_collections __pyx_mstate_global->__pyx_n_s_collections +#define __pyx_n_s_compile __pyx_mstate_global->__pyx_n_s_compile +#define __pyx_n_s_condition __pyx_mstate_global->__pyx_n_s_condition +#define __pyx_n_s_contains __pyx_mstate_global->__pyx_n_s_contains +#define __pyx_n_s_contains_2 __pyx_mstate_global->__pyx_n_s_contains_2 +#define __pyx_n_s_depth __pyx_mstate_global->__pyx_n_s_depth +#define __pyx_n_s_deque __pyx_mstate_global->__pyx_n_s_deque +#define __pyx_n_s_dict __pyx_mstate_global->__pyx_n_s_dict +#define __pyx_n_s_dict_2 __pyx_mstate_global->__pyx_n_s_dict_2 +#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable +#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable +#define __pyx_n_s_endswith __pyx_mstate_global->__pyx_n_s_endswith +#define __pyx_n_s_endswith_2 __pyx_mstate_global->__pyx_n_s_endswith_2 +#define __pyx_n_s_event __pyx_mstate_global->__pyx_n_s_event +#define __pyx_n_s_ew __pyx_mstate_global->__pyx_n_s_ew +#define __pyx_n_s_f_back __pyx_mstate_global->__pyx_n_s_f_back +#define __pyx_n_s_filename __pyx_mstate_global->__pyx_n_s_filename +#define __pyx_n_s_filter __pyx_mstate_global->__pyx_n_s_filter +#define __pyx_kp_u_for __pyx_mstate_global->__pyx_kp_u_for +#define __pyx_n_s_frame __pyx_mstate_global->__pyx_n_s_frame +#define __pyx_n_s_fullsource __pyx_mstate_global->__pyx_n_s_fullsource +#define __pyx_n_s_function __pyx_mstate_global->__pyx_n_s_function +#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc +#define __pyx_n_s_genexpr __pyx_mstate_global->__pyx_n_s_genexpr +#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate +#define __pyx_n_s_globals __pyx_mstate_global->__pyx_n_s_globals +#define __pyx_n_s_gt __pyx_mstate_global->__pyx_n_s_gt +#define __pyx_n_s_gt_2 __pyx_mstate_global->__pyx_n_s_gt_2 +#define __pyx_n_s_gte __pyx_mstate_global->__pyx_n_s_gte +#define __pyx_n_s_gte_2 __pyx_mstate_global->__pyx_n_s_gte_2 +#define __pyx_n_s_has __pyx_mstate_global->__pyx_n_s_has +#define __pyx_n_s_hunter __pyx_mstate_global->__pyx_n_s_hunter +#define __pyx_n_s_hunter__predicates __pyx_mstate_global->__pyx_n_s_hunter__predicates +#define __pyx_kp_s_hunter__predicates_And_predicat __pyx_mstate_global->__pyx_kp_s_hunter__predicates_And_predicat +#define __pyx_kp_s_hunter__predicates_From_conditi __pyx_mstate_global->__pyx_kp_s_hunter__predicates_From_conditi +#define __pyx_kp_s_hunter__predicates_Not_predicat __pyx_mstate_global->__pyx_kp_s_hunter__predicates_Not_predicat +#define __pyx_kp_s_hunter__predicates_Or_predicate __pyx_mstate_global->__pyx_kp_s_hunter__predicates_Or_predicate +#define __pyx_kp_s_hunter__predicates_When_conditi __pyx_mstate_global->__pyx_kp_s_hunter__predicates_When_conditi +#define __pyx_kp_s_hunter_predicates_Backlog_condi __pyx_mstate_global->__pyx_kp_s_hunter_predicates_Backlog_condi +#define __pyx_kp_s_hunter_predicates_Query_s __pyx_mstate_global->__pyx_kp_s_hunter_predicates_Query_s +#define __pyx_n_s_import __pyx_mstate_global->__pyx_n_s_import +#define __pyx_n_s_in __pyx_mstate_global->__pyx_n_s_in +#define __pyx_n_s_in_2 __pyx_mstate_global->__pyx_n_s_in_2 +#define __pyx_n_s_index __pyx_mstate_global->__pyx_n_s_index +#define __pyx_n_s_init___locals_genexpr __pyx_mstate_global->__pyx_n_s_init___locals_genexpr +#define __pyx_n_s_inspect __pyx_mstate_global->__pyx_n_s_inspect +#define __pyx_n_s_instruction __pyx_mstate_global->__pyx_n_s_instruction +#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine +#define __pyx_kp_u_is_invalid_Must_be_a_string_lis __pyx_mstate_global->__pyx_kp_u_is_invalid_Must_be_a_string_lis +#define __pyx_n_s_isclass __pyx_mstate_global->__pyx_n_s_isclass +#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled +#define __pyx_n_s_items __pyx_mstate_global->__pyx_n_s_items +#define __pyx_n_s_join __pyx_mstate_global->__pyx_n_s_join +#define __pyx_n_s_kind __pyx_mstate_global->__pyx_n_s_kind +#define __pyx_n_s_kwargs __pyx_mstate_global->__pyx_n_s_kwargs +#define __pyx_n_s_lineno __pyx_mstate_global->__pyx_n_s_lineno +#define __pyx_n_s_locals __pyx_mstate_global->__pyx_n_s_locals +#define __pyx_n_s_lt __pyx_mstate_global->__pyx_n_s_lt +#define __pyx_n_s_lt_2 __pyx_mstate_global->__pyx_n_s_lt_2 +#define __pyx_n_s_lte __pyx_mstate_global->__pyx_n_s_lte +#define __pyx_n_s_lte_2 __pyx_mstate_global->__pyx_n_s_lte_2 +#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main +#define __pyx_n_s_match __pyx_mstate_global->__pyx_n_s_match +#define __pyx_n_s_maxlen __pyx_mstate_global->__pyx_n_s_maxlen +#define __pyx_n_s_merge __pyx_mstate_global->__pyx_n_s_merge +#define __pyx_n_s_module __pyx_mstate_global->__pyx_n_s_module +#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name +#define __pyx_n_s_name_2 __pyx_mstate_global->__pyx_n_s_name_2 +#define __pyx_n_s_new __pyx_mstate_global->__pyx_n_s_new +#define __pyx_n_s_pickle __pyx_mstate_global->__pyx_n_s_pickle +#define __pyx_n_s_predicate __pyx_mstate_global->__pyx_n_s_predicate +#define __pyx_n_s_predicates __pyx_mstate_global->__pyx_n_s_predicates +#define __pyx_n_s_pyx_PickleError __pyx_mstate_global->__pyx_n_s_pyx_PickleError +#define __pyx_n_s_pyx_checksum __pyx_mstate_global->__pyx_n_s_pyx_checksum +#define __pyx_n_s_pyx_result __pyx_mstate_global->__pyx_n_s_pyx_result +#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state +#define __pyx_n_s_pyx_type __pyx_mstate_global->__pyx_n_s_pyx_type +#define __pyx_n_s_pyx_unpickle_And __pyx_mstate_global->__pyx_n_s_pyx_unpickle_And +#define __pyx_n_s_pyx_unpickle_Backlog __pyx_mstate_global->__pyx_n_s_pyx_unpickle_Backlog +#define __pyx_n_s_pyx_unpickle_From __pyx_mstate_global->__pyx_n_s_pyx_unpickle_From +#define __pyx_n_s_pyx_unpickle_Not __pyx_mstate_global->__pyx_n_s_pyx_unpickle_Not +#define __pyx_n_s_pyx_unpickle_Or __pyx_mstate_global->__pyx_n_s_pyx_unpickle_Or +#define __pyx_n_s_pyx_unpickle_Query __pyx_mstate_global->__pyx_n_s_pyx_unpickle_Query +#define __pyx_n_s_pyx_unpickle_When __pyx_mstate_global->__pyx_n_s_pyx_unpickle_When +#define __pyx_n_s_pyx_vtable __pyx_mstate_global->__pyx_n_s_pyx_vtable +#define __pyx_kp_s_query_contains_r __pyx_mstate_global->__pyx_kp_s_query_contains_r +#define __pyx_kp_s_query_endswith_r __pyx_mstate_global->__pyx_kp_s_query_endswith_r +#define __pyx_kp_s_query_eq_r __pyx_mstate_global->__pyx_kp_s_query_eq_r +#define __pyx_kp_s_query_gt_r __pyx_mstate_global->__pyx_kp_s_query_gt_r +#define __pyx_kp_s_query_gte_r __pyx_mstate_global->__pyx_kp_s_query_gte_r +#define __pyx_kp_s_query_in_r __pyx_mstate_global->__pyx_kp_s_query_in_r +#define __pyx_kp_s_query_lt_r __pyx_mstate_global->__pyx_kp_s_query_lt_r +#define __pyx_kp_s_query_lte_r __pyx_mstate_global->__pyx_kp_s_query_lte_r +#define __pyx_kp_s_query_regex_r __pyx_mstate_global->__pyx_kp_s_query_regex_r +#define __pyx_kp_s_query_startswith_r __pyx_mstate_global->__pyx_kp_s_query_startswith_r +#define __pyx_n_s_re __pyx_mstate_global->__pyx_n_s_re +#define __pyx_n_s_re_compile __pyx_mstate_global->__pyx_n_s_re_compile +#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce +#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython +#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex +#define __pyx_n_s_regex __pyx_mstate_global->__pyx_n_s_regex +#define __pyx_n_s_regex_2 __pyx_mstate_global->__pyx_n_s_regex_2 +#define __pyx_n_s_rx __pyx_mstate_global->__pyx_n_s_rx +#define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self +#define __pyx_kp_s_self_getter_cannot_be_converted __pyx_mstate_global->__pyx_kp_s_self_getter_cannot_be_converted +#define __pyx_n_s_send __pyx_mstate_global->__pyx_n_s_send +#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate +#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython +#define __pyx_n_s_size __pyx_mstate_global->__pyx_n_s_size +#define __pyx_n_s_source __pyx_mstate_global->__pyx_n_s_source +#define __pyx_n_s_split __pyx_mstate_global->__pyx_n_s_split +#define __pyx_kp_s_src_hunter__predicates_pyx __pyx_mstate_global->__pyx_kp_s_src_hunter__predicates_pyx +#define __pyx_n_s_stack __pyx_mstate_global->__pyx_n_s_stack +#define __pyx_n_s_startswith __pyx_mstate_global->__pyx_n_s_startswith +#define __pyx_n_s_startswith_2 __pyx_mstate_global->__pyx_n_s_startswith_2 +#define __pyx_n_s_state __pyx_mstate_global->__pyx_n_s_state +#define __pyx_n_s_stdlib __pyx_mstate_global->__pyx_n_s_stdlib +#define __pyx_n_s_str___locals_genexpr __pyx_mstate_global->__pyx_n_s_str___locals_genexpr +#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource +#define __pyx_n_s_strip __pyx_mstate_global->__pyx_n_s_strip +#define __pyx_n_s_sw __pyx_mstate_global->__pyx_n_s_sw +#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test +#define __pyx_n_s_threadid __pyx_mstate_global->__pyx_n_s_threadid +#define __pyx_n_s_threading_support __pyx_mstate_global->__pyx_n_s_threading_support +#define __pyx_n_s_threadname __pyx_mstate_global->__pyx_n_s_threadname +#define __pyx_n_s_throw __pyx_mstate_global->__pyx_n_s_throw +#define __pyx_n_s_try_repr __pyx_mstate_global->__pyx_n_s_try_repr +#define __pyx_n_s_update __pyx_mstate_global->__pyx_n_s_update +#define __pyx_n_s_use_setstate __pyx_mstate_global->__pyx_n_s_use_setstate +#define __pyx_n_s_value __pyx_mstate_global->__pyx_n_s_value +#define __pyx_n_s_vars __pyx_mstate_global->__pyx_n_s_vars +#define __pyx_n_s_watermark __pyx_mstate_global->__pyx_n_s_watermark +#define __pyx_kp_u_with_optional_operators_like __pyx_mstate_global->__pyx_kp_u_with_optional_operators_like +#define __pyx_n_s_wrap __pyx_mstate_global->__pyx_n_s_wrap +#define __pyx_int_0 __pyx_mstate_global->__pyx_int_0 +#define __pyx_int_10 __pyx_mstate_global->__pyx_int_10 +#define __pyx_int_100 __pyx_mstate_global->__pyx_int_100 +#define __pyx_int_4473905 __pyx_mstate_global->__pyx_int_4473905 +#define __pyx_int_21139105 __pyx_mstate_global->__pyx_int_21139105 +#define __pyx_int_28104183 __pyx_mstate_global->__pyx_int_28104183 +#define __pyx_int_37183945 __pyx_mstate_global->__pyx_int_37183945 +#define __pyx_int_79429044 __pyx_mstate_global->__pyx_int_79429044 +#define __pyx_int_82616482 __pyx_mstate_global->__pyx_int_82616482 +#define __pyx_int_89143876 __pyx_mstate_global->__pyx_int_89143876 +#define __pyx_int_124881844 __pyx_mstate_global->__pyx_int_124881844 +#define __pyx_int_149034610 __pyx_mstate_global->__pyx_int_149034610 +#define __pyx_int_166332997 __pyx_mstate_global->__pyx_int_166332997 +#define __pyx_int_178834394 __pyx_mstate_global->__pyx_int_178834394 +#define __pyx_int_190166812 __pyx_mstate_global->__pyx_int_190166812 +#define __pyx_int_198256870 __pyx_mstate_global->__pyx_int_198256870 +#define __pyx_int_210676054 __pyx_mstate_global->__pyx_int_210676054 +#define __pyx_int_217908684 __pyx_mstate_global->__pyx_int_217908684 +#define __pyx_int_223119700 __pyx_mstate_global->__pyx_int_223119700 +#define __pyx_int_242287462 __pyx_mstate_global->__pyx_int_242287462 +#define __pyx_int_258412278 __pyx_mstate_global->__pyx_int_258412278 +#define __pyx_int_neg_1 __pyx_mstate_global->__pyx_int_neg_1 +#define __pyx_tuple_ __pyx_mstate_global->__pyx_tuple_ +#define __pyx_tuple__13 __pyx_mstate_global->__pyx_tuple__13 +#define __pyx_tuple__28 __pyx_mstate_global->__pyx_tuple__28 +#define __pyx_tuple__30 __pyx_mstate_global->__pyx_tuple__30 +#define __pyx_tuple__32 __pyx_mstate_global->__pyx_tuple__32 +#define __pyx_tuple__34 __pyx_mstate_global->__pyx_tuple__34 +#define __pyx_tuple__37 __pyx_mstate_global->__pyx_tuple__37 +#define __pyx_tuple__39 __pyx_mstate_global->__pyx_tuple__39 +#define __pyx_tuple__40 __pyx_mstate_global->__pyx_tuple__40 +#define __pyx_tuple__41 __pyx_mstate_global->__pyx_tuple__41 +#define __pyx_tuple__42 __pyx_mstate_global->__pyx_tuple__42 +#define __pyx_tuple__43 __pyx_mstate_global->__pyx_tuple__43 +#define __pyx_tuple__44 __pyx_mstate_global->__pyx_tuple__44 +#define __pyx_tuple__45 __pyx_mstate_global->__pyx_tuple__45 +#define __pyx_tuple__46 __pyx_mstate_global->__pyx_tuple__46 +#define __pyx_tuple__47 __pyx_mstate_global->__pyx_tuple__47 +#define __pyx_codeobj__2 __pyx_mstate_global->__pyx_codeobj__2 +#define __pyx_codeobj__3 __pyx_mstate_global->__pyx_codeobj__3 +#define __pyx_codeobj__4 __pyx_mstate_global->__pyx_codeobj__4 +#define __pyx_codeobj__11 __pyx_mstate_global->__pyx_codeobj__11 +#define __pyx_codeobj__12 __pyx_mstate_global->__pyx_codeobj__12 +#define __pyx_codeobj__14 __pyx_mstate_global->__pyx_codeobj__14 +#define __pyx_codeobj__15 __pyx_mstate_global->__pyx_codeobj__15 +#define __pyx_codeobj__16 __pyx_mstate_global->__pyx_codeobj__16 +#define __pyx_codeobj__17 __pyx_mstate_global->__pyx_codeobj__17 +#define __pyx_codeobj__18 __pyx_mstate_global->__pyx_codeobj__18 +#define __pyx_codeobj__19 __pyx_mstate_global->__pyx_codeobj__19 +#define __pyx_codeobj__20 __pyx_mstate_global->__pyx_codeobj__20 +#define __pyx_codeobj__21 __pyx_mstate_global->__pyx_codeobj__21 +#define __pyx_codeobj__22 __pyx_mstate_global->__pyx_codeobj__22 +#define __pyx_codeobj__23 __pyx_mstate_global->__pyx_codeobj__23 +#define __pyx_codeobj__24 __pyx_mstate_global->__pyx_codeobj__24 +#define __pyx_codeobj__25 __pyx_mstate_global->__pyx_codeobj__25 +#define __pyx_codeobj__26 __pyx_mstate_global->__pyx_codeobj__26 +#define __pyx_codeobj__27 __pyx_mstate_global->__pyx_codeobj__27 +#define __pyx_codeobj__29 __pyx_mstate_global->__pyx_codeobj__29 +#define __pyx_codeobj__31 __pyx_mstate_global->__pyx_codeobj__31 +#define __pyx_codeobj__33 __pyx_mstate_global->__pyx_codeobj__33 +#define __pyx_codeobj__35 __pyx_mstate_global->__pyx_codeobj__35 +#define __pyx_codeobj__36 __pyx_mstate_global->__pyx_codeobj__36 +#define __pyx_codeobj__38 __pyx_mstate_global->__pyx_codeobj__38 +/* #### 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*)(__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("wrap (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __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 **__pyx_pyargnames[] = {&__pyx_n_s_event,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_event)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 67, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "wrap") < 0)) __PYX_ERR(0, 67, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __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(0, 67, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(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_ptype_6hunter_6_event_Event, 1, "event", 0))) __PYX_ERR(0, 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 */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +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_TraceDeclarations __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) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v_query_eq = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("wrap", 1); + __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_TraceCall("wrap", __pyx_f[0], 67, 0, __PYX_ERR(0, 67, __pyx_L1_error)); - /* "hunter/_predicates.pyx":69 - * """ - * query_eq = {} - * query_startswith = {} # <<<<<<<<<<<<<< - * query_endswith = {} - * query_in = {} + /* "cfunc.to_py":69 + * def wrap(Event event): + * """wrap(event: 'Event')""" + * return f(event) # <<<<<<<<<<<<<< + * return wrap + * */ __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_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_cur_scope->__pyx_v_f(__pyx_v_event); 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_r = __pyx_t_1; __pyx_t_1 = 0; + goto __pyx_L0; - /* "hunter/_predicates.pyx":70 - * query_eq = {} - * query_startswith = {} - * query_endswith = {} # <<<<<<<<<<<<<< - * query_in = {} - * query_contains = {} + /* "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(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; - /* "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; + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __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_TraceReturn(__pyx_r, 0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "hunter/_predicates.pyx":72 - * query_endswith = {} - * query_in = {} - * query_contains = {} # <<<<<<<<<<<<<< - * query_regex = {} - * query_lt = {} +/* "cfunc.to_py":66 + * + * @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')""" */ - __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) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v_query_contains = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - /* "hunter/_predicates.pyx":73 - * query_in = {} - * query_contains = {} - * query_regex = {} # <<<<<<<<<<<<<< - * query_lt = {} - * query_lte = {} +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_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __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_ptype___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event, __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(0, 66, __pyx_L1_error) + } else { + __Pyx_GOTREF((PyObject *)__pyx_cur_scope); + } + __Pyx_TraceCall("__Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event", __pyx_f[0], 66, 0, __PYX_ERR(0, 66, __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(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_TraceLine(67,0,__PYX_ERR(0, 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_n_s_Pyx_CFunc_6hunter_11_predicate, ((PyObject*)__pyx_cur_scope), __pyx_n_s_cfunc_to_py, __pyx_d, ((PyObject *)__pyx_codeobj__2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 67, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_v_query_regex = ((PyObject*)__pyx_t_1); + __pyx_v_wrap = __pyx_t_1; __pyx_t_1 = 0; - /* "hunter/_predicates.pyx":74 - * query_contains = {} - * query_regex = {} - * query_lt = {} # <<<<<<<<<<<<<< - * query_lte = {} - * query_gt = {} + /* "cfunc.to_py":70 + * """wrap(event: 'Event')""" + * return f(event) + * return wrap # <<<<<<<<<<<<<< + * + * */ - __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; + __Pyx_TraceLine(70,0,__PYX_ERR(0, 70, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_wrap); + __pyx_r = __pyx_v_wrap; + goto __pyx_L0; - /* "hunter/_predicates.pyx":75 - * query_regex = {} - * query_lt = {} - * query_lte = {} # <<<<<<<<<<<<<< - * query_gt = {} - * query_gte = {} + /* "cfunc.to_py":66 + * + * @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')""" */ - __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; - /* "hunter/_predicates.pyx":76 - * query_lt = {} - * query_lte = {} - * query_gt = {} # <<<<<<<<<<<<<< - * query_gte = {} + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __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_TraceReturn(__pyx_r, 0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "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(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) + +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_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("Event_get_function", 1); + __Pyx_TraceCall("Event_get_function", __pyx_f[1], 38, 0, __PYX_ERR(1, 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(1, 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; + goto __pyx_L0; - /* "hunter/_predicates.pyx":77 - * query_lte = {} - * query_gt = {} - * query_gte = {} # <<<<<<<<<<<<<< - * - * for key, value in query.items(): + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("hunter._predicates.Event_get_function", __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; +} + +/* "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(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) + +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_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("Event_get_module", 1); + __Pyx_TraceCall("Event_get_module", __pyx_f[1], 39, 0, __PYX_ERR(1, 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(1, 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; + 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; - - /* "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; + __Pyx_AddTraceback("hunter._predicates.Event_get_module", __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; +} - /* "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' % ( +/* "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(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; - /* "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)) { +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_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("Event_get_lineno", 1); + __Pyx_TraceCall("Event_get_lineno", __pyx_f[1], 40, 0, __PYX_ERR(1, 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(1, 40, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; - /* "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) + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("hunter._predicates.Event_get_lineno", __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; +} - /* "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 +/* "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":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) { +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_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("Event_get_globals", 1); + __Pyx_TraceCall("Event_get_globals", __pyx_f[1], 41, 0, __PYX_ERR(1, 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(1, 41, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; - /* "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; + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("hunter._predicates.Event_get_globals", __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; +} - /* "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)): +/* "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(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) { - /* "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) { +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_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("Event_get_stdlib", 1); + __Pyx_TraceCall("Event_get_stdlib", __pyx_f[1], 42, 0, __PYX_ERR(1, 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(1, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; - /* "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)) { + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("hunter._predicates.Event_get_stdlib", __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; +} - /* "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 +/* "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(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":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_TraceDeclarations + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("Event_get_arg", 1); + __Pyx_TraceCall("Event_get_arg", __pyx_f[1], 43, 0, __PYX_ERR(1, 43, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_event->arg); + __pyx_r = __pyx_v_event->arg; + 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_AddTraceback("hunter._predicates.Event_get_arg", __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; +} - /* "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":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() */ - } - /* "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); +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_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("Event_get_locals", 1); + __Pyx_TraceCall("Event_get_locals", __pyx_f[1], 44, 0, __PYX_ERR(1, 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(1, 44, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + 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_AddTraceback("hunter._predicates.Event_get_locals", __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; +} - /* "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)): +/* "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(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":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_TraceDeclarations + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("Event_get_kind", 1); + __Pyx_TraceCall("Event_get_kind", __pyx_f[1], 45, 0, __PYX_ERR(1, 45, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_event->kind); + __pyx_r = __pyx_v_event->kind; + 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_AddTraceback("hunter._predicates.Event_get_kind", __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; +} - /* "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 +/* "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(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":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_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("Event_get_filename", 1); + __Pyx_TraceCall("Event_get_filename", __pyx_f[1], 46, 0, __PYX_ERR(1, 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(1, 46, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + 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_AddTraceback("hunter._predicates.Event_get_filename", __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; +} - /* "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_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("Event_get_source", 1); + __Pyx_TraceCall("Event_get_source", __pyx_f[1], 47, 0, __PYX_ERR(1, 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(1, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + 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_AddTraceback("hunter._predicates.Event_get_source", __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; +} - /* "hunter/_predicates.pyx":100 - * value = tuple(value) - * mapping = query_endswith - * elif operator == 'in': # <<<<<<<<<<<<<< - * mapping = query_in - * elif operator in ('contains', 'has'): +/* "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(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":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_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("Event_get_fullsource", 1); + __Pyx_TraceCall("Event_get_fullsource", __pyx_f[1], 48, 0, __PYX_ERR(1, 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(1, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + 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_AddTraceback("hunter._predicates.Event_get_fullsource", __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; +} - /* "hunter/_predicates.pyx":102 - * elif operator == 'in': - * mapping = query_in - * elif operator in ('contains', 'has'): # <<<<<<<<<<<<<< - * mapping = query_contains - * elif operator in ('regex', 'rx'): +/* "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(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":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_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("Event_get_threadname", 1); + __Pyx_TraceCall("Event_get_threadname", __pyx_f[1], 49, 0, __PYX_ERR(1, 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(1, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + 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; - } - - /* "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":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; - - /* "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_AddTraceback("hunter._predicates.Event_get_threadname", __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; +} - /* "hunter/_predicates.pyx":104 - * elif operator in ('contains', 'has'): - * mapping = query_contains - * elif operator in ('regex', 'rx'): # <<<<<<<<<<<<<< - * value = re.compile(value) - * mapping = query_regex +/* "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 */ - goto __pyx_L13; - } - /* "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_threadid(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("Event_get_threadid", 1); + __Pyx_TraceCall("Event_get_threadid", __pyx_f[1], 50, 0, __PYX_ERR(1, 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(1, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + 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_AddTraceback("hunter._predicates.Event_get_threadid", __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; +} - /* "hunter/_predicates.pyx":107 - * value = re.compile(value) - * mapping = query_regex - * elif operator == 'lt': # <<<<<<<<<<<<<< - * mapping = query_lt - * elif operator == 'lte': +/* "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 */ - goto __pyx_L13; - } - /* "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_instruction(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("Event_get_instruction", 1); + __Pyx_TraceCall("Event_get_instruction", __pyx_f[1], 51, 0, __PYX_ERR(1, 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(1, 51, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + 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_AddTraceback("hunter._predicates.Event_get_instruction", __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; +} - /* "hunter/_predicates.pyx":109 - * elif operator == 'lt': - * mapping = query_lt - * elif operator == 'lte': # <<<<<<<<<<<<<< - * mapping = query_lte - * elif operator == 'gt': +/* "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 */ - goto __pyx_L13; - } - /* "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_depth(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("Event_get_depth", 1); + __Pyx_TraceCall("Event_get_depth", __pyx_f[1], 52, 0, __PYX_ERR(1, 52, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_event->depth); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + 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_AddTraceback("hunter._predicates.Event_get_depth", __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; +} - /* "hunter/_predicates.pyx":111 - * elif operator == 'lte': - * mapping = query_lte - * elif operator == 'gt': # <<<<<<<<<<<<<< - * mapping = query_gt - * elif operator == 'gte': +/* "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 + * */ - goto __pyx_L13; - } - /* "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_calls(struct __pyx_obj_6hunter_6_event_Event *__pyx_v_event) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("Event_get_calls", 1); + __Pyx_TraceCall("Event_get_calls", __pyx_f[1], 53, 0, __PYX_ERR(1, 53, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_event->calls); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + 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_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("hunter._predicates.Event_get_calls", __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; +} - /* "hunter/_predicates.pyx":113 - * elif operator == 'gt': - * mapping = query_gt - * elif operator == 'gte': # <<<<<<<<<<<<<< - * mapping = query_gte - * else: +/* "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 = [ */ - goto __pyx_L13; - } - /* "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) - } - __pyx_L13:; +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_TraceDeclarations + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("Event_get_builtin", 1); + __Pyx_TraceCall("Event_get_builtin", __pyx_f[1], 54, 0, __PYX_ERR(1, 54, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_event->builtin); + __pyx_r = __pyx_v_event->builtin; + goto __pyx_L0; - /* "hunter/_predicates.pyx":86 - * key, ALLOWED_KEYS, ALLOWED_OPERATORS - * )) - * elif count == 2: # <<<<<<<<<<<<<< - * prefix, operator = parts - * if operator in ('startswith', 'sw'): - */ - goto __pyx_L12; - } + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("hunter._predicates.Event_get_builtin", __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; +} - /* "hunter/_predicates.pyx":118 - * raise TypeError('Unexpected operator %r. Must be one of %s.' % (operator, ALLOWED_OPERATORS)) - * else: - * mapping = query_eq # <<<<<<<<<<<<<< - * prefix = key +/* "hunter/_predicates.pyx":83 + * cdef object value * + * def __init__(self, object value, str name): # <<<<<<<<<<<<<< + * self.value = value + * self.getter_index = ALLOWED_KEYS.index(name) */ - __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); - /* "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); +/* 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_MACROS + __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 **__pyx_pyargnames[] = {&__pyx_n_s_value,&__pyx_n_s_name,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_value)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 83, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 83, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, 1); __PYX_ERR(1, 83, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(1, 83, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); + } + __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(1, 83, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); } - __pyx_L12:; + } + __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), (&PyString_Type), 1, "name", 1))) __PYX_ERR(1, 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":121 - * prefix = key - * - * if prefix not in ALLOWED_KEYS: # <<<<<<<<<<<<<< - * raise TypeError('Unexpected argument %r. Must be one of %s.' % (key, ALLOWED_KEYS)) + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +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_TraceDeclarations + __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_RefNannySetupContext("__init__", 1); + __Pyx_TraceCall("__init__", __pyx_f[1], 83, 0, __PYX_ERR(1, 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,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 85, __pyx_L1_error)) + __pyx_t_1 = __Pyx_CallUnboundCMethod1(&__pyx_umethod_PyTuple_Type_index, __pyx_v_6hunter_11_predicates_ALLOWED_KEYS, __pyx_v_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 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(1, 85, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_self->getter_index = __pyx_t_2; + + /* "hunter/_predicates.pyx":86 + * self.value = value + * self.getter_index = ALLOWED_KEYS.index(name) + * self.getter = Event_getters[self.getter_index] # <<<<<<<<<<<<<< * + * def __repr__(self): */ - __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)) { + __Pyx_TraceLine(86,0,__PYX_ERR(1, 86, __pyx_L1_error)) + __pyx_v_self->getter = (__pyx_v_6hunter_11_predicates_Event_getters[__pyx_v_self->getter_index]); - /* "hunter/_predicates.pyx":122 - * - * if prefix not in ALLOWED_KEYS: - * raise TypeError('Unexpected argument %r. Must be one of %s.' % (key, ALLOWED_KEYS)) # <<<<<<<<<<<<<< + /* "hunter/_predicates.pyx":83 + * cdef object value * - * mapping[prefix] = value + * def __init__(self, object value, str name): # <<<<<<<<<<<<<< + * self.value = value + * self.getter_index = ALLOWED_KEYS.index(name) */ - __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) - /* "hunter/_predicates.pyx":121 - * prefix = key + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("hunter._predicates.QueryEntry.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_TraceReturn(Py_None, 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) * */ - } - /* "hunter/_predicates.pyx":124 - * raise TypeError('Unexpected argument %r. Must be one of %s.' % (key, ALLOWED_KEYS)) +/* 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_TraceDeclarations + __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_RefNannySetupContext("__repr__", 1); + __Pyx_TraceCall("__repr__", __pyx_f[1], 88, 0, __PYX_ERR(1, 88, __pyx_L1_error)); + + /* "hunter/_predicates.pyx":89 * - * mapping[prefix] = value # <<<<<<<<<<<<<< + * def __repr__(self): + * return repr(self.value) # <<<<<<<<<<<<<< * - * self.query_eq = tuple(sorted(query_eq.items())) + * def __eq__(self, other): */ - __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) - } + __Pyx_TraceLine(89,0,__PYX_ERR(1, 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(1, 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; + goto __pyx_L0; - /* "hunter/_predicates.pyx":126 - * mapping[prefix] = value + /* "hunter/_predicates.pyx":88 + * self.getter = Event_getters[self.getter_index] + * + * def __repr__(self): # <<<<<<<<<<<<<< + * 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())) */ - __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; - /* "hunter/_predicates.pyx":127 + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("hunter._predicates.QueryEntry.__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":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())) + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return ( + * isinstance(other, QueryEntry) */ - __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; - /* "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())) +/* 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)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +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_TraceDeclarations + __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_RefNannySetupContext("__eq__", 1); + __Pyx_TraceCall("__eq__", __pyx_f[1], 91, 0, __PYX_ERR(1, 91, __pyx_L1_error)); + + /* "hunter/_predicates.pyx":92 + * + * def __eq__(self, other): + * return ( # <<<<<<<<<<<<<< + * isinstance(other, QueryEntry) + * and self.value == ( other).value */ - __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; + __Pyx_TraceLine(92,0,__PYX_ERR(1, 92, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); - /* "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())) + /* "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(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_TraceLine(93,0,__PYX_ERR(1, 93, __pyx_L1_error)) + __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_other, __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(1, 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_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; - /* "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())) + /* "hunter/_predicates.pyx":94 + * return ( + * isinstance(other, QueryEntry) + * and self.value == ( other).value # <<<<<<<<<<<<<< + * and self.getter_index == ( other).getter_index + * ) */ - __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_TraceLine(94,0,__PYX_ERR(1, 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(1, 94, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 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_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; - /* "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())) + /* "hunter/_predicates.pyx":95 + * isinstance(other, QueryEntry) + * and self.value == ( other).value + * and self.getter_index == ( other).getter_index # <<<<<<<<<<<<<< + * ) + * */ - __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) - } - __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) - } - __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())) - * - */ - __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,0,__PYX_ERR(1, 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(1, 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; + 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_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_TraceReturn(__pyx_r, 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*)(__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_MACROS + __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;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) 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_TraceDeclarations __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); - { - __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; - } + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__3) + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + __Pyx_TraceCall("__reduce_cython__", __pyx_f[0], 1, 0, __PYX_ERR(0, 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,0,__PYX_ERR(0, 2, __pyx_L1_error)) + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_getter_cannot_be_converted, 0, 0); + __PYX_ERR(0, 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_AddTraceback("hunter._predicates.Query.__str__.genexpr.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("hunter._predicates.QueryEntry.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; - __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 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 - 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 *); +/* "(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*)(__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("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 + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __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 **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_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 (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(0, 140, __pyx_L1_error) + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; } - break; + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; } - __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 (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 3, __pyx_L3_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 if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; } 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:; + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); } - __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_v___pyx_state = values[0]; } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(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 */ - 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); + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } -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; +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_TraceDeclarations __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; - } + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__4) + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + __Pyx_TraceCall("__setstate_cython__", __pyx_f[0], 3, 0, __PYX_ERR(0, 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,0,__PYX_ERR(0, 4, __pyx_L1_error)) + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_getter_cannot_be_converted, 0, 0); + __PYX_ERR(0, 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", __pyx_clineno, __pyx_lineno, __pyx_filename); + __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_TraceReturn(__pyx_r, 0); __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) /* 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; +/* "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_MACROS + __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;} + if (__pyx_kwds && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 1))) return -1; + if (__pyx_kwds) { + __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_TraceDeclarations + __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = 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; - PyObject *__pyx_t_7 = NULL; + int __pyx_t_7; 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) + Py_ssize_t __pyx_t_10; + PyObject *(*__pyx_t_11)(PyObject *); + int __pyx_t_12; + Py_UCS4 __pyx_t_13; + int __pyx_t_14; + int __pyx_t_15; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 1); + __Pyx_TraceCall("__init__", __pyx_f[1], 106, 0, __PYX_ERR(1, 106, __pyx_L1_error)); - /* "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), + /* "hunter/_predicates.pyx":130 + * ``threadname``. + * """ + * query_eq = {} # <<<<<<<<<<<<<< + * query_startswith = {} + * query_endswith = {} */ - __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) + __Pyx_TraceLine(130,0,__PYX_ERR(1, 130, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 130, __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_v_query_eq = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "hunter/_predicates.pyx":131 + * """ + * query_eq = {} + * query_startswith = {} # <<<<<<<<<<<<<< + * query_endswith = {} + * query_in = {} */ - __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(131,0,__PYX_ERR(1, 131, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_query_startswith = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "hunter/_predicates.pyx":132 + * query_eq = {} + * query_startswith = {} + * query_endswith = {} # <<<<<<<<<<<<<< + * query_in = {} + * query_contains = {} */ - __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(132,0,__PYX_ERR(1, 132, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_query_endswith = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "hunter/_predicates.pyx":133 + * query_startswith = {} + * query_endswith = {} + * query_in = {} # <<<<<<<<<<<<<< + * query_contains = {} + * query_regex = {} */ - __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_TraceLine(133,0,__PYX_ERR(1, 133, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_query_in = ((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":134 + * query_endswith = {} + * query_in = {} + * query_contains = {} # <<<<<<<<<<<<<< + * query_regex = {} + * query_lt = {} */ - } + __Pyx_TraceLine(134,0,__PYX_ERR(1, 134, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_query_contains = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; - /* "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), + /* "hunter/_predicates.pyx":135 + * query_in = {} + * query_contains = {} + * query_regex = {} # <<<<<<<<<<<<<< + * query_lt = {} + * query_lte = {} */ - __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); + __Pyx_TraceLine(135,0,__PYX_ERR(1, 135, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_query_regex = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; - /* "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), + /* "hunter/_predicates.pyx":136 + * query_contains = {} + * query_regex = {} + * query_lt = {} # <<<<<<<<<<<<<< + * query_lte = {} + * query_gt = {} */ + __Pyx_TraceLine(136,0,__PYX_ERR(1, 136, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_query_lt = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; - /* 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":137 - * self.query_gte = tuple(sorted(query_gte.items())) - * - * def __str__(self): # <<<<<<<<<<<<<< - * return 'Query(%s)' % ( - * ', '.join( + /* "hunter/_predicates.pyx":137 + * query_regex = {} + * query_lt = {} + * query_lte = {} # <<<<<<<<<<<<<< + * query_gt = {} + * query_gte = {} */ - -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); + __Pyx_TraceLine(137,0,__PYX_ERR(1, 137, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 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,0,__PYX_ERR(1, 138, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 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) + * for key, value in query.items(): */ - __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) + __Pyx_TraceLine(139,0,__PYX_ERR(1, 139, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 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( + * for key, value in query.items(): # <<<<<<<<<<<<<< + * parts = [p for p in key.split('_') if p] + * count = len(parts) */ - - /* function exit code */ - __pyx_L1_error:; + __Pyx_TraceLine(141,0,__PYX_ERR(1, 141, __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(1, 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(1, 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 [ + * for key, value in query.items(): + * parts = [p for p in key.split('_') if p] # <<<<<<<<<<<<<< + * count = len(parts) + * if count > 2: */ + __Pyx_TraceLine(142,0,__PYX_ERR(1, 142, __pyx_L1_error)) + { /* enter inner scope */ + __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 142, __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(1, 142, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (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_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_n_s__5}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 142, __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(1, 142, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_11 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_8); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 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_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 142, __pyx_L7_error) + #endif + if (__pyx_t_10 >= __pyx_temp) 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(1, 142, __pyx_L7_error) + #else + __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_8, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 142, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_8); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 142, __pyx_L7_error) + #endif + if (__pyx_t_10 >= __pyx_temp) 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(1, 142, __pyx_L7_error) + #else + __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_8, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 142, __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(1, 142, __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(1, 142, __pyx_L7_error) + if (__pyx_t_12) { + if (unlikely(__Pyx_ListComp_Append(__pyx_t_6, (PyObject*)__pyx_7genexpr__pyx_v_p))) __PYX_ERR(1, 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; -/* 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), + /* "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,0,__PYX_ERR(1, 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(1, 143, __pyx_L1_error) + __pyx_v_count = __pyx_t_10; -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), + /* "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(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(144,0,__PYX_ERR(1, 144, __pyx_L1_error)) + __pyx_t_12 = (__pyx_v_count > 2); + if (unlikely(__pyx_t_12)) { + + /* "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(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); + __Pyx_TraceLine(146,0,__PYX_ERR(1, 146, __pyx_L1_error)) + __pyx_t_6 = PyTuple_New(6); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_10 = 0; + __pyx_t_13 = 127; + __Pyx_INCREF(__pyx_kp_u_Unexpected_argument); + __pyx_t_10 += 20; + __Pyx_GIVEREF(__pyx_kp_u_Unexpected_argument); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_Unexpected_argument); + __pyx_t_8 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_key), __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_13 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_13) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_13; + __pyx_t_10 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_8); + __pyx_t_8 = 0; + __Pyx_INCREF(__pyx_kp_u_Must_be_one_of); + __pyx_t_10 += 17; + __Pyx_GIVEREF(__pyx_kp_u_Must_be_one_of); + PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u_Must_be_one_of); + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_6hunter_11_predicates_ALLOWED_KEYS, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_13 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_13) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_13; + __pyx_t_10 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_8); + __pyx_t_8 = 0; + __Pyx_INCREF(__pyx_kp_u_with_optional_operators_like); + __pyx_t_10 += 31; + __Pyx_GIVEREF(__pyx_kp_u_with_optional_operators_like); + PyTuple_SET_ITEM(__pyx_t_6, 4, __pyx_kp_u_with_optional_operators_like); + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_6hunter_11_predicates_ALLOWED_OPERATORS, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_13 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_13) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_13; + __pyx_t_10 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_6, 5, __pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_6, 6, __pyx_t_10, __pyx_t_13); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "hunter/_predicates.pyx":168 - * ('query_lte=%r', self.query_lte), - * ('query_gt=%r', self.query_gt), - * ('query_gte=%r', self.query_gte), # <<<<<<<<<<<<<< - * - * ] if mapping + /* "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(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); + __Pyx_TraceLine(145,0,__PYX_ERR(1, 145, __pyx_L1_error)) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 145, __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(1, 145, __pyx_L1_error) - /* "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), + /* "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(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); - __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; - /* "hunter/_predicates.pyx":170 - * ('query_gte=%r', self.query_gte), - * - * ] if mapping # <<<<<<<<<<<<<< - * ) - * + /* "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(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) { + __Pyx_TraceLine(148,0,__PYX_ERR(1, 148, __pyx_L1_error)) + __pyx_t_12 = (__pyx_v_count == 2); + if (__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), + /* "hunter/_predicates.pyx":149 + * ) + * elif count == 2: + * prefix, operator = parts # <<<<<<<<<<<<<< + * if operator in ('startswith', 'sw'): + * if not isinstance(value, basestring): */ - __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_TraceLine(149,0,__PYX_ERR(1, 149, __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(1, 149, __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(1, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 149, __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; - __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":158 - * def __repr__(self): - * return '' % ' '.join( - * fmt % (mapping,) for fmt, mapping in [ # <<<<<<<<<<<<<< - * ('query_eq=%r', self.query_eq), - * ('query_in=%r', self.query_in), + /* "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(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); - - /* 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; -} + __Pyx_TraceLine(150,0,__PYX_ERR(1, 150, __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_startswith, Py_EQ)); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(1, 150, __pyx_L1_error) + if (!__pyx_t_14) { + } else { + __pyx_t_12 = __pyx_t_14; + goto __pyx_L15_bool_binop_done; + } + __pyx_t_14 = (__Pyx_PyString_Equals(__pyx_t_8, __pyx_n_s_sw, Py_EQ)); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(1, 150, __pyx_L1_error) + __pyx_t_12 = __pyx_t_14; + __pyx_L15_bool_binop_done:; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_14 = __pyx_t_12; + if (__pyx_t_14) { -/* "hunter/_predicates.pyx":156 - * ) - * - * def __repr__(self): # <<<<<<<<<<<<<< - * return '' % ' '.join( - * fmt % (mapping,) for fmt, mapping in [ + /* "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,0,__PYX_ERR(1, 151, __pyx_L1_error)) + __pyx_t_14 = __Pyx_PyBaseString_Check(__pyx_v_value); + __pyx_t_12 = (!__pyx_t_14); + if (__pyx_t_12) { -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":157 - * - * def __repr__(self): - * return '' % ' '.join( # <<<<<<<<<<<<<< - * fmt % (mapping,) for fmt, mapping in [ - * ('query_eq=%r', self.query_eq), + /* "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(157,0,__PYX_ERR(0, 157, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); + __Pyx_TraceLine(152,0,__PYX_ERR(1, 152, __pyx_L1_error)) + __pyx_t_14 = PyList_Check(__pyx_v_value); + if (!__pyx_t_14) { + } else { + __pyx_t_12 = __pyx_t_14; + goto __pyx_L19_bool_binop_done; + } + __pyx_t_14 = PySet_Check(__pyx_v_value); + if (!__pyx_t_14) { + } else { + __pyx_t_12 = __pyx_t_14; + goto __pyx_L19_bool_binop_done; + } + __pyx_t_14 = PyTuple_Check(__pyx_v_value); + __pyx_t_12 = __pyx_t_14; + __pyx_L19_bool_binop_done:; + __pyx_t_14 = (!__pyx_t_12); + if (unlikely(__pyx_t_14)) { - /* "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), + /* "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(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); + __Pyx_TraceLine(153,0,__PYX_ERR(1, 153, __pyx_L1_error)) + __pyx_t_8 = PyTuple_New(5); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_10 = 0; + __pyx_t_13 = 127; + __Pyx_INCREF(__pyx_kp_u_Value); + __pyx_t_10 += 6; + __Pyx_GIVEREF(__pyx_kp_u_Value); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_u_Value); + __pyx_t_6 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_value), __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_13 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_13) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_13; + __pyx_t_10 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_kp_u_for); + __pyx_t_10 += 5; + __Pyx_GIVEREF(__pyx_kp_u_for); + PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u_for); + __pyx_t_6 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_key), __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_13 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_13) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_13; + __pyx_t_10 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 3, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_kp_u_is_invalid_Must_be_a_string_lis); + __pyx_t_10 += 50; + __Pyx_GIVEREF(__pyx_kp_u_is_invalid_Must_be_a_string_lis); + PyTuple_SET_ITEM(__pyx_t_8, 4, __pyx_kp_u_is_invalid_Must_be_a_string_lis); + __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_8, 5, __pyx_t_10, __pyx_t_13); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 153, __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(1, 153, __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(1, 153, __pyx_L1_error) - /* "hunter/_predicates.pyx":157 - * - * def __repr__(self): - * return '' % ' '.join( # <<<<<<<<<<<<<< - * fmt % (mapping,) for fmt, mapping in [ - * ('query_eq=%r', self.query_eq), + /* "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(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":156 - * ) - * - * def __repr__(self): # <<<<<<<<<<<<<< - * return '' % ' '.join( - * fmt % (mapping,) for fmt, mapping in [ + /* "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,0,__PYX_ERR(1, 154, __pyx_L1_error)) + __pyx_t_8 = __Pyx_PySequence_Tuple(__pyx_v_value); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 154, __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_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":173 - * ) - * - * def __eq__(self, other): # <<<<<<<<<<<<<< - * return ( - * isinstance(other, Query) + /* "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.') */ + } -/* 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)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -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,0,__PYX_ERR(1, 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 + /* "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(174,0,__PYX_ERR(0, 174, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); + 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 + /* "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(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; - } + __Pyx_TraceLine(156,0,__PYX_ERR(1, 156, __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(1, 156, __pyx_L1_error) + if (!__pyx_t_12) { + } else { + __pyx_t_14 = __pyx_t_12; + goto __pyx_L22_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(1, 156, __pyx_L1_error) + __pyx_t_14 = __pyx_t_12; + __pyx_L22_bool_binop_done:; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_12 = __pyx_t_14; + 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 + /* "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(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; - } + __Pyx_TraceLine(157,0,__PYX_ERR(1, 157, __pyx_L1_error)) + __pyx_t_12 = __Pyx_PyBaseString_Check(__pyx_v_value); + __pyx_t_14 = (!__pyx_t_12); + if (__pyx_t_14) { - /* "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 + /* "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(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; - } + __Pyx_TraceLine(158,0,__PYX_ERR(1, 158, __pyx_L1_error)) + __pyx_t_12 = PyList_Check(__pyx_v_value); + if (!__pyx_t_12) { + } else { + __pyx_t_14 = __pyx_t_12; + goto __pyx_L26_bool_binop_done; + } + __pyx_t_12 = PySet_Check(__pyx_v_value); + if (!__pyx_t_12) { + } else { + __pyx_t_14 = __pyx_t_12; + goto __pyx_L26_bool_binop_done; + } + __pyx_t_12 = PyTuple_Check(__pyx_v_value); + __pyx_t_14 = __pyx_t_12; + __pyx_L26_bool_binop_done:; + __pyx_t_12 = (!__pyx_t_14); + if (unlikely(__pyx_t_12)) { - /* "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 + /* "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(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; - } + __Pyx_TraceLine(159,0,__PYX_ERR(1, 159, __pyx_L1_error)) + __pyx_t_8 = PyTuple_New(5); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_10 = 0; + __pyx_t_13 = 127; + __Pyx_INCREF(__pyx_kp_u_Value); + __pyx_t_10 += 6; + __Pyx_GIVEREF(__pyx_kp_u_Value); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_u_Value); + __pyx_t_6 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_value), __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_13 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_13) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_13; + __pyx_t_10 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_kp_u_for); + __pyx_t_10 += 5; + __Pyx_GIVEREF(__pyx_kp_u_for); + PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u_for); + __pyx_t_6 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_key), __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_13 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_13) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_13; + __pyx_t_10 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 3, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_kp_u_is_invalid_Must_be_a_string_lis); + __pyx_t_10 += 50; + __Pyx_GIVEREF(__pyx_kp_u_is_invalid_Must_be_a_string_lis); + PyTuple_SET_ITEM(__pyx_t_8, 4, __pyx_kp_u_is_invalid_Must_be_a_string_lis); + __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_8, 5, __pyx_t_10, __pyx_t_13); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 159, __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(1, 159, __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(1, 159, __pyx_L1_error) - /* "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 + /* "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(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 + /* "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(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; - } + __Pyx_TraceLine(160,0,__PYX_ERR(1, 160, __pyx_L1_error)) + __pyx_t_8 = __Pyx_PySequence_Tuple(__pyx_v_value); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 160, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_8); + __pyx_t_8 = 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 + /* "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(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":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 + /* "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(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":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; - } + __Pyx_TraceLine(161,0,__PYX_ERR(1, 161, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_query_endswith); + __Pyx_XDECREF_SET(__pyx_v_mapping, __pyx_v_query_endswith); - /* "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 - * ) + /* "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(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; - } + goto __pyx_L14; + } - /* "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 # <<<<<<<<<<<<<< - * ) - * + /* "hunter/_predicates.pyx":162 + * value = tuple(value) + * mapping = query_endswith + * elif operator == 'in': # <<<<<<<<<<<<<< + * mapping = query_in + * elif operator in ('contains', 'has'): */ - __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; + __Pyx_TraceLine(162,0,__PYX_ERR(1, 162, __pyx_L1_error)) + __pyx_t_12 = (__Pyx_PyString_Equals(__pyx_v_operator, __pyx_n_s_in, Py_EQ)); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(1, 162, __pyx_L1_error) + if (__pyx_t_12) { - /* "hunter/_predicates.pyx":173 - * ) - * - * def __eq__(self, other): # <<<<<<<<<<<<<< - * return ( - * isinstance(other, Query) + /* "hunter/_predicates.pyx":163 + * mapping = query_endswith + * elif operator == 'in': + * mapping = query_in # <<<<<<<<<<<<<< + * elif operator in ('contains', 'has'): + * mapping = query_contains */ + __Pyx_TraceLine(163,0,__PYX_ERR(1, 163, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_query_in); + __Pyx_XDECREF_SET(__pyx_v_mapping, __pyx_v_query_in); - /* 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":162 + * value = tuple(value) + * mapping = query_endswith + * elif operator == 'in': # <<<<<<<<<<<<<< + * mapping = query_in + * elif operator in ('contains', 'has'): + */ + goto __pyx_L14; + } -/* "hunter/_predicates.pyx":188 - * ) - * - * def __hash__(self): # <<<<<<<<<<<<<< - * return hash(( - * 'Query', + /* "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,0,__PYX_ERR(1, 164, __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(1, 164, __pyx_L1_error) + if (!__pyx_t_14) { + } else { + __pyx_t_12 = __pyx_t_14; + goto __pyx_L29_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(1, 164, __pyx_L1_error) + __pyx_t_12 = __pyx_t_14; + __pyx_L29_bool_binop_done:; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_14 = __pyx_t_12; + if (__pyx_t_14) { -/* 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":165 + * mapping = query_in + * elif operator in ('contains', 'has'): + * mapping = query_contains # <<<<<<<<<<<<<< + * elif operator in ('regex', 'rx'): + * value = re_compile(value) + */ + __Pyx_TraceLine(165,0,__PYX_ERR(1, 165, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_query_contains); + __Pyx_XDECREF_SET(__pyx_v_mapping, __pyx_v_query_contains); - /* function exit code */ - __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'): + */ + goto __pyx_L14; + } -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":166 + * elif operator in ('contains', 'has'): + * mapping = query_contains + * elif operator in ('regex', 'rx'): # <<<<<<<<<<<<<< + * value = re_compile(value) + * mapping = query_regex + */ + __Pyx_TraceLine(166,0,__PYX_ERR(1, 166, __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_regex, Py_EQ)); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(1, 166, __pyx_L1_error) + if (!__pyx_t_12) { + } else { + __pyx_t_14 = __pyx_t_12; + goto __pyx_L31_bool_binop_done; + } + __pyx_t_12 = (__Pyx_PyString_Equals(__pyx_t_8, __pyx_n_s_rx, Py_EQ)); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(1, 166, __pyx_L1_error) + __pyx_t_14 = __pyx_t_12; + __pyx_L31_bool_binop_done:; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_12 = __pyx_t_14; + if (__pyx_t_12) { - /* "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":167 + * mapping = query_contains + * elif operator in ('regex', 'rx'): + * value = re_compile(value) # <<<<<<<<<<<<<< + * mapping = query_regex + * elif operator == 'lt': + */ + __Pyx_TraceLine(167,0,__PYX_ERR(1, 167, __pyx_L1_error)) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_re_compile); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (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_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_value}; + __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_8); + __pyx_t_8 = 0; - /* "hunter/_predicates.pyx":189 - * - * def __hash__(self): - * return hash(( # <<<<<<<<<<<<<< - * 'Query', - * self.query_eq, + /* "hunter/_predicates.pyx":168 + * elif operator in ('regex', 'rx'): + * value = re_compile(value) + * mapping = query_regex # <<<<<<<<<<<<<< + * elif operator == 'lt': + * mapping = query_lt */ - __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; + __Pyx_TraceLine(168,0,__PYX_ERR(1, 168, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_query_regex); + __Pyx_XDECREF_SET(__pyx_v_mapping, __pyx_v_query_regex); - /* "hunter/_predicates.pyx":188 - * ) - * - * def __hash__(self): # <<<<<<<<<<<<<< - * return hash(( - * 'Query', + /* "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; + } - /* 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":169 + * value = re_compile(value) + * mapping = query_regex + * elif operator == 'lt': # <<<<<<<<<<<<<< + * mapping = query_lt + * elif operator == 'lte': + */ + __Pyx_TraceLine(169,0,__PYX_ERR(1, 169, __pyx_L1_error)) + __pyx_t_12 = (__Pyx_PyString_Equals(__pyx_v_operator, __pyx_n_s_lt, Py_EQ)); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(1, 169, __pyx_L1_error) + if (__pyx_t_12) { -/* "hunter/_predicates.pyx":203 - * )) - * - * def __call__(self, Event event): # <<<<<<<<<<<<<< - * return fast_Query_call(self, event) - * + /* "hunter/_predicates.pyx":170 + * mapping = query_regex + * elif operator == 'lt': + * mapping = query_lt # <<<<<<<<<<<<<< + * elif operator == 'lte': + * mapping = query_lte */ + __Pyx_TraceLine(170,0,__PYX_ERR(1, 170, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_query_lt); + __Pyx_XDECREF_SET(__pyx_v_mapping, __pyx_v_query_lt); -/* 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; -} - -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":204 - * - * def __call__(self, Event event): - * return fast_Query_call(self, event) # <<<<<<<<<<<<<< - * - * def __or__(self, other): + /* "hunter/_predicates.pyx":171 + * elif operator == 'lt': + * mapping = query_lt + * elif operator == 'lte': # <<<<<<<<<<<<<< + * mapping = query_lte + * elif operator == 'gt': */ - __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; + __Pyx_TraceLine(171,0,__PYX_ERR(1, 171, __pyx_L1_error)) + __pyx_t_12 = (__Pyx_PyString_Equals(__pyx_v_operator, __pyx_n_s_lte, Py_EQ)); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(1, 171, __pyx_L1_error) + if (__pyx_t_12) { - /* "hunter/_predicates.pyx":203 - * )) - * - * def __call__(self, Event event): # <<<<<<<<<<<<<< - * return fast_Query_call(self, event) - * + /* "hunter/_predicates.pyx":172 + * mapping = query_lt + * elif operator == 'lte': + * mapping = query_lte # <<<<<<<<<<<<<< + * elif operator == 'gt': + * mapping = query_gt */ + __Pyx_TraceLine(172,0,__PYX_ERR(1, 172, __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_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":171 + * elif operator == 'lt': + * mapping = query_lt + * elif operator == 'lte': # <<<<<<<<<<<<<< + * mapping = query_lte + * elif operator == 'gt': + */ + goto __pyx_L14; + } -/* "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': */ + __Pyx_TraceLine(173,0,__PYX_ERR(1, 173, __pyx_L1_error)) + __pyx_t_12 = (__Pyx_PyString_Equals(__pyx_v_operator, __pyx_n_s_gt, Py_EQ)); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(1, 173, __pyx_L1_error) + if (__pyx_t_12) { -/* 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":174 + * mapping = query_lte + * elif operator == 'gt': + * mapping = query_gt # <<<<<<<<<<<<<< + * elif operator == 'gte': + * mapping = query_gte + */ + __Pyx_TraceLine(174,0,__PYX_ERR(1, 174, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_query_gt); + __Pyx_XDECREF_SET(__pyx_v_mapping, __pyx_v_query_gt); - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":173 + * elif operator == 'lte': + * mapping = query_lte + * elif operator == 'gt': # <<<<<<<<<<<<<< + * mapping = query_gt + * elif operator == 'gte': + */ + goto __pyx_L14; + } -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: + */ + __Pyx_TraceLine(175,0,__PYX_ERR(1, 175, __pyx_L1_error)) + __pyx_t_12 = (__Pyx_PyString_Equals(__pyx_v_operator, __pyx_n_s_gte, Py_EQ)); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(1, 175, __pyx_L1_error) + if (likely(__pyx_t_12)) { - /* "hunter/_predicates.pyx":207 - * - * def __or__(self, other): - * return Or(self, other) # <<<<<<<<<<<<<< - * - * def __and__(self, other): + /* "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(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; + __Pyx_TraceLine(176,0,__PYX_ERR(1, 176, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_query_gte); + __Pyx_XDECREF_SET(__pyx_v_mapping, __pyx_v_query_gte); - /* "hunter/_predicates.pyx":206 - * return fast_Query_call(self, event) - * - * def __or__(self, other): # <<<<<<<<<<<<<< - * return Or(self, other) - * + /* "hunter/_predicates.pyx":175 + * elif operator == 'gt': + * mapping = query_gt + * elif operator == 'gte': # <<<<<<<<<<<<<< + * mapping = query_gte + * else: */ + goto __pyx_L14; + } - /* 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":209 - * return Or(self, other) - * - * def __and__(self, other): # <<<<<<<<<<<<<< - * return And(self, other) - * + /* "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,0,__PYX_ERR(1, 178, __pyx_L1_error)) + /*else*/ { + __pyx_t_8 = PyTuple_New(5); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_10 = 0; + __pyx_t_13 = 127; + __Pyx_INCREF(__pyx_kp_u_Unexpected_operator); + __pyx_t_10 += 20; + __Pyx_GIVEREF(__pyx_kp_u_Unexpected_operator); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_u_Unexpected_operator); + __pyx_t_6 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_operator), __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_13 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_13) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_13; + __pyx_t_10 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_kp_u_Must_be_one_of); + __pyx_t_10 += 17; + __Pyx_GIVEREF(__pyx_kp_u_Must_be_one_of); + PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u_Must_be_one_of); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_6hunter_11_predicates_ALLOWED_OPERATORS, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_13 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_13) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_13; + __pyx_t_10 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 3, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_kp_u__6); + __pyx_t_10 += 1; + __Pyx_GIVEREF(__pyx_kp_u__6); + PyTuple_SET_ITEM(__pyx_t_8, 4, __pyx_kp_u__6); + __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_8, 5, __pyx_t_10, __pyx_t_13); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 178, __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_TypeError, __pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 178, __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(1, 178, __pyx_L1_error) + } + __pyx_L14:; -/* 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)); + /* "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; + } - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":180 + * raise TypeError(f'Unexpected operator {operator!r}. Must be one of {ALLOWED_OPERATORS}.') + * else: + * mapping = query_eq # <<<<<<<<<<<<<< + * prefix = key + * + */ + __Pyx_TraceLine(180,0,__PYX_ERR(1, 180, __pyx_L1_error)) + /*else*/ { + __Pyx_INCREF(__pyx_v_query_eq); + __Pyx_XDECREF_SET(__pyx_v_mapping, __pyx_v_query_eq); -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":181 + * else: + * mapping = query_eq + * prefix = key # <<<<<<<<<<<<<< + * + * if prefix not in ALLOWED_KEYS: + */ + __Pyx_TraceLine(181,0,__PYX_ERR(1, 181, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_key); + __Pyx_XDECREF_SET(__pyx_v_prefix, __pyx_v_key); + } + __pyx_L13:; - /* "hunter/_predicates.pyx":210 + /* "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}.') * - * 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); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; + __Pyx_TraceLine(183,0,__PYX_ERR(1, 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(1, 183, __pyx_L1_error) + if (unlikely(__pyx_t_12)) { - /* "hunter/_predicates.pyx":209 - * return Or(self, other) + /* "hunter/_predicates.pyx":184 * - * 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}.') # <<<<<<<<<<<<<< * + * mapping[prefix] = QueryEntry(value, prefix) */ + __Pyx_TraceLine(184,0,__PYX_ERR(1, 184, __pyx_L1_error)) + __pyx_t_8 = PyTuple_New(5); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_10 = 0; + __pyx_t_13 = 127; + __Pyx_INCREF(__pyx_kp_u_Unexpected_argument); + __pyx_t_10 += 20; + __Pyx_GIVEREF(__pyx_kp_u_Unexpected_argument); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_u_Unexpected_argument); + __pyx_t_6 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_key), __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_13 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_13) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_13; + __pyx_t_10 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_kp_u_Must_be_one_of); + __pyx_t_10 += 17; + __Pyx_GIVEREF(__pyx_kp_u_Must_be_one_of); + PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u_Must_be_one_of); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_6hunter_11_predicates_ALLOWED_KEYS, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_13 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_13) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_13; + __pyx_t_10 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 3, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_kp_u__6); + __pyx_t_10 += 1; + __Pyx_GIVEREF(__pyx_kp_u__6); + PyTuple_SET_ITEM(__pyx_t_8, 4, __pyx_kp_u__6); + __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_8, 5, __pyx_t_10, __pyx_t_13); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 184, __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_TypeError, __pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 184, __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(1, 184, __pyx_L1_error) - /* 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; -} - -/* "hunter/_predicates.pyx":212 - * return And(self, other) + /* "hunter/_predicates.pyx":183 + * prefix = key * - * def __invert__(self): # <<<<<<<<<<<<<< - * return Not(self) + * 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_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)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -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":213 + /* "hunter/_predicates.pyx":186 + * raise TypeError(f'Unexpected argument {key!r}. Must be one of {ALLOWED_KEYS}.') * - * def __invert__(self): - * return Not(self) # <<<<<<<<<<<<<< + * mapping[prefix] = QueryEntry(value, prefix) # <<<<<<<<<<<<<< * - * cdef fast_Query_call(Query self, Event event): + * self.query_eq = tuple(sorted(query_eq.items())) */ - __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) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + __Pyx_TraceLine(186,0,__PYX_ERR(1, 186, __pyx_L1_error)) + __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_value)) __PYX_ERR(1, 186, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_prefix); + __Pyx_GIVEREF(__pyx_v_prefix); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_v_prefix)) __PYX_ERR(1, 186, __pyx_L1_error); + __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_QueryEntry), __pyx_t_8, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely((PyDict_SetItem(__pyx_v_mapping, __pyx_v_prefix, __pyx_t_6) < 0))) __PYX_ERR(1, 186, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "hunter/_predicates.pyx":212 - * return And(self, other) - * - * def __invert__(self): # <<<<<<<<<<<<<< - * return Not(self) + /* "hunter/_predicates.pyx":188 + * mapping[prefix] = QueryEntry(value, prefix) * + * 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,0,__PYX_ERR(1, 188, __pyx_L1_error)) + __pyx_t_6 = __Pyx_PyDict_Items(__pyx_v_query_eq); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = PySequence_List(__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_1 = ((PyObject*)__pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_15 = PyList_Sort(__pyx_t_1); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(1, 188, __pyx_L1_error) + __pyx_t_8 = PyList_AsTuple(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GIVEREF(__pyx_t_8); + __Pyx_GOTREF(__pyx_v_self->query_eq); + __Pyx_DECREF(__pyx_v_self->query_eq); + __pyx_v_self->query_eq = ((PyObject*)__pyx_t_8); + __pyx_t_8 = 0; - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.Query.__invert__", __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":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,0,__PYX_ERR(1, 189, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_Items(__pyx_v_query_startswith); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = PySequence_List(__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_8 = ((PyObject*)__pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_15 = PyList_Sort(__pyx_t_8); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(1, 189, __pyx_L1_error) + __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_8)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GIVEREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_v_self->query_startswith); + __Pyx_DECREF(__pyx_v_self->query_startswith); + __pyx_v_self->query_startswith = ((PyObject*)__pyx_t_6); + __pyx_t_6 = 0; -/* "hunter/_predicates.pxd":10 - * cdef class Query: - * cdef: - * readonly tuple query_contains # <<<<<<<<<<<<<< - * readonly tuple query_endswith - * readonly tuple query_eq + /* "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,0,__PYX_ERR(1, 190, __pyx_L1_error)) + __pyx_t_8 = __Pyx_PyDict_Items(__pyx_v_query_endswith); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_1 = PySequence_List(__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_6 = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_15 = PyList_Sort(__pyx_t_6); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(1, 190, __pyx_L1_error) + __pyx_t_1 = PyList_AsTuple(((PyObject*)__pyx_t_6)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_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) { - 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)); + /* "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,0,__PYX_ERR(1, 191, __pyx_L1_error)) + __pyx_t_6 = __Pyx_PyDict_Items(__pyx_v_query_in); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 191, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = PySequence_List(__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 191, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_1 = ((PyObject*)__pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_15 = PyList_Sort(__pyx_t_1); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(1, 191, __pyx_L1_error) + __pyx_t_8 = PyList_AsTuple(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 191, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GIVEREF(__pyx_t_8); + __Pyx_GOTREF(__pyx_v_self->query_in); + __Pyx_DECREF(__pyx_v_self->query_in); + __pyx_v_self->query_in = ((PyObject*)__pyx_t_8); + __pyx_t_8 = 0; - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "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,0,__PYX_ERR(1, 192, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_Items(__pyx_v_query_contains); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = PySequence_List(__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_8 = ((PyObject*)__pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_15 = PyList_Sort(__pyx_t_8); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(1, 192, __pyx_L1_error) + __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_8)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GIVEREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_v_self->query_contains); + __Pyx_DECREF(__pyx_v_self->query_contains); + __pyx_v_self->query_contains = ((PyObject*)__pyx_t_6); + __pyx_t_6 = 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_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; + /* "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,0,__PYX_ERR(1, 193, __pyx_L1_error)) + __pyx_t_8 = __Pyx_PyDict_Items(__pyx_v_query_regex); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_1 = PySequence_List(__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_6 = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_15 = PyList_Sort(__pyx_t_6); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(1, 193, __pyx_L1_error) + __pyx_t_1 = PyList_AsTuple(((PyObject*)__pyx_t_6)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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; - /* 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.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,0,__PYX_ERR(1, 194, __pyx_L1_error)) + __pyx_t_6 = __Pyx_PyDict_Items(__pyx_v_query_lt); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = PySequence_List(__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_1 = ((PyObject*)__pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_15 = PyList_Sort(__pyx_t_1); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(1, 194, __pyx_L1_error) + __pyx_t_8 = PyList_AsTuple(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GIVEREF(__pyx_t_8); + __Pyx_GOTREF(__pyx_v_self->query_lt); + __Pyx_DECREF(__pyx_v_self->query_lt); + __pyx_v_self->query_lt = ((PyObject*)__pyx_t_8); + __pyx_t_8 = 0; -/* "hunter/_predicates.pxd":11 - * cdef: - * readonly tuple query_contains - * readonly tuple query_endswith # <<<<<<<<<<<<<< - * readonly tuple query_eq - * readonly tuple query_gt + /* "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,0,__PYX_ERR(1, 195, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_Items(__pyx_v_query_lte); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 195, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = PySequence_List(__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 195, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_8 = ((PyObject*)__pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_15 = PyList_Sort(__pyx_t_8); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(1, 195, __pyx_L1_error) + __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_8)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 195, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GIVEREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_v_self->query_lte); + __Pyx_DECREF(__pyx_v_self->query_lte); + __pyx_v_self->query_lte = ((PyObject*)__pyx_t_6); + __pyx_t_6 = 0; -/* 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)); + /* "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())) + * + */ + __Pyx_TraceLine(196,0,__PYX_ERR(1, 196, __pyx_L1_error)) + __pyx_t_8 = __Pyx_PyDict_Items(__pyx_v_query_gt); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_1 = PySequence_List(__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_6 = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_15 = PyList_Sort(__pyx_t_6); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(1, 196, __pyx_L1_error) + __pyx_t_1 = PyList_AsTuple(((PyObject*)__pyx_t_6)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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; - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "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,0,__PYX_ERR(1, 197, __pyx_L1_error)) + __pyx_t_6 = __Pyx_PyDict_Items(__pyx_v_query_gte); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 197, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = PySequence_List(__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 197, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_1 = ((PyObject*)__pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_15 = PyList_Sort(__pyx_t_1); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(1, 197, __pyx_L1_error) + __pyx_t_8 = PyList_AsTuple(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 197, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GIVEREF(__pyx_t_8); + __Pyx_GOTREF(__pyx_v_self->query_gte); + __Pyx_DECREF(__pyx_v_self->query_gte); + __pyx_v_self->query_gte = ((PyObject*)__pyx_t_8); + __pyx_t_8 = 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_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; + /* "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; + goto __pyx_L0; __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.Query.query_endswith.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __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_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_TraceReturn(Py_None, 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 +/* "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_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) { +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_8query_eq___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_8query_eq___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], 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; + 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_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(1, 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, 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(1, 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_eq.__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":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; } -static PyObject *__pyx_pf_6hunter_11_predicates_5Query_8query_gt___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 + 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 *); + Py_ssize_t __pyx_t_9; + Py_UCS4 __pyx_t_10; + 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], 13, 0, __PYX_ERR(1, 13, __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.pxd":14 - * readonly tuple query_eq - * readonly tuple query_gt - * readonly tuple query_gte # <<<<<<<<<<<<<< - * readonly tuple query_in - * readonly tuple query_lt - */ - -/* 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)); + __Pyx_RefNannySetupContext("genexpr", 0); + __Pyx_TraceCall("genexpr", __pyx_f[1], 202, 0, __PYX_ERR(1, 202, __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(1, 202, __pyx_L1_error) + if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(1, 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(1, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 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_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 202, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) 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(1, 202, __pyx_L1_error) + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 202, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) 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(1, 202, __pyx_L1_error) + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 202, __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(1, 202, __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(1, 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_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(1, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 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(1, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_8 = __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(1, 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(1, 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_t_4 = PyTuple_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_cur_scope->__pyx_v_key, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6); + __pyx_t_6 = 0; + if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_8genexpr1__pyx_v_kind)) { __Pyx_RaiseClosureNameError("kind"); __PYX_ERR(1, 202, __pyx_L1_error) } + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_cur_scope->__pyx_outer_scope->__pyx_8genexpr1__pyx_v_kind, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_kp_u__7); + __pyx_t_9 += 1; + __Pyx_GIVEREF(__pyx_kp_u__7); + PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_kp_u__7); + __pyx_t_6 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_cur_scope->__pyx_v_value), __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_4, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 202, __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(1, 202, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -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; + PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; - - /* function exit code */ __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.Query.query_gte.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_Generator_Replace_StopIteration(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); + __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); + __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.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":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_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) { - 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)); - - /* 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_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_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 15, 0, __PYX_ERR(1, 15, __pyx_L1_error)); - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->query_in); - __pyx_r = __pyx_v_self->query_in; - goto __pyx_L0; - - /* 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; -} + 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_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(1, 199, __pyx_L1_error) + } else { + __Pyx_GOTREF((PyObject *)__pyx_cur_scope); + } + __Pyx_TraceCall("__str__", __pyx_f[1], 199, 0, __PYX_ERR(1, 199, __pyx_L1_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":200 + * + * def __str__(self): + * return 'Query(%s)' % ( # <<<<<<<<<<<<<< + * ', '.join([ + * ', '.join(f'{key}{kind}={value!r}' for key, value in mapping) */ - -/* 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)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -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_TraceLine(200,0,__PYX_ERR(1, 200, __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.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,0,__PYX_ERR(1, 201, __pyx_L1_error)) + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 201, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_1); -/* "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":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,0,__PYX_ERR(1, 204, __pyx_L5_error)) + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 204, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_kp_s__9); + __Pyx_GIVEREF(__pyx_kp_s__9); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_s__9)) __PYX_ERR(1, 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)) __PYX_ERR(1, 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,0,__PYX_ERR(1, 205, __pyx_L5_error)) + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 205, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_n_s_in_2); + __Pyx_GIVEREF(__pyx_n_s_in_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_in_2)) __PYX_ERR(1, 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)) __PYX_ERR(1, 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,0,__PYX_ERR(1, 206, __pyx_L5_error)) + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 206, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_n_s_contains_2); + __Pyx_GIVEREF(__pyx_n_s_contains_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_n_s_contains_2)) __PYX_ERR(1, 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)) __PYX_ERR(1, 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,0,__PYX_ERR(1, 207, __pyx_L5_error)) + __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 207, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_n_s_startswith_2); + __Pyx_GIVEREF(__pyx_n_s_startswith_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_n_s_startswith_2)) __PYX_ERR(1, 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)) __PYX_ERR(1, 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,0,__PYX_ERR(1, 208, __pyx_L5_error)) + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 208, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_INCREF(__pyx_n_s_endswith_2); + __Pyx_GIVEREF(__pyx_n_s_endswith_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_n_s_endswith_2)) __PYX_ERR(1, 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)) __PYX_ERR(1, 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,0,__PYX_ERR(1, 209, __pyx_L5_error)) + __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 209, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_INCREF(__pyx_n_s_regex_2); + __Pyx_GIVEREF(__pyx_n_s_regex_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_n_s_regex_2)) __PYX_ERR(1, 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)) __PYX_ERR(1, 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,0,__PYX_ERR(1, 210, __pyx_L5_error)) + __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 210, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_INCREF(__pyx_n_s_lt_2); + __Pyx_GIVEREF(__pyx_n_s_lt_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_n_s_lt_2)) __PYX_ERR(1, 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)) __PYX_ERR(1, 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,0,__PYX_ERR(1, 211, __pyx_L5_error)) + __pyx_t_9 = PyTuple_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 211, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_INCREF(__pyx_n_s_lte_2); + __Pyx_GIVEREF(__pyx_n_s_lte_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_n_s_lte_2)) __PYX_ERR(1, 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)) __PYX_ERR(1, 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,0,__PYX_ERR(1, 212, __pyx_L5_error)) + __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 212, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_INCREF(__pyx_n_s_gt_2); + __Pyx_GIVEREF(__pyx_n_s_gt_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_n_s_gt_2)) __PYX_ERR(1, 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)) __PYX_ERR(1, 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,0,__PYX_ERR(1, 213, __pyx_L5_error)) + __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 213, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_INCREF(__pyx_n_s_gte_2); + __Pyx_GIVEREF(__pyx_n_s_gte_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_n_s_gte_2)) __PYX_ERR(1, 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)) __PYX_ERR(1, 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,0,__PYX_ERR(1, 203, __pyx_L5_error)) + __pyx_t_12 = PyTuple_New(10); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 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)) __PYX_ERR(1, 203, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_t_3)) __PYX_ERR(1, 203, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 2, __pyx_t_4)) __PYX_ERR(1, 203, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 3, __pyx_t_5)) __PYX_ERR(1, 203, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 4, __pyx_t_6)) __PYX_ERR(1, 203, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 5, __pyx_t_7)) __PYX_ERR(1, 203, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 6, __pyx_t_8)) __PYX_ERR(1, 203, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_9); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 7, __pyx_t_9)) __PYX_ERR(1, 203, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_10); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 8, __pyx_t_10)) __PYX_ERR(1, 203, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_11); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 9, __pyx_t_11)) __PYX_ERR(1, 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 = PyTuple_GET_ITEM(__pyx_t_11, __pyx_t_13); __Pyx_INCREF(__pyx_t_12); __pyx_t_13++; if (unlikely((0 < 0))) __PYX_ERR(1, 203, __pyx_L5_error) + #else + __pyx_t_12 = __Pyx_PySequence_ITEM(__pyx_t_11, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 203, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_12); + #endif + if (likely(__pyx_t_12 != Py_None)) { + PyObject* sequence = __pyx_t_12; + 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(1, 203, __pyx_L5_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_10 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_9 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(__pyx_t_9); + #else + __pyx_t_10 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 203, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_9 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 203, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_9); + #endif + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 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; + + /* "hunter/_predicates.pyx":215 + * ('_gte', self.query_gte), + * ] + * if mapping # <<<<<<<<<<<<<< + * ]) + * ) */ + __Pyx_TraceLine(215,0,__PYX_ERR(1, 215, __pyx_L5_error)) + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_8genexpr1__pyx_v_mapping); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(1, 215, __pyx_L5_error) + if (__pyx_t_14) { -/* 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":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,0,__PYX_ERR(1, 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(1, 202, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_9 = __Pyx_PyString_Join(__pyx_kp_s__8, __pyx_t_12); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 202, __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(1, 201, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "hunter/_predicates.pyx":215 + * ('_gte', self.query_gte), + * ] + * if mapping # <<<<<<<<<<<<<< + * ]) + * ) + */ + } -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":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,0,__PYX_ERR(1, 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 */ - /* 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":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,0,__PYX_ERR(1, 201, __pyx_L1_error)) + __pyx_t_11 = __Pyx_PyString_Join(__pyx_kp_s__8, __pyx_t_1); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; -/* "hunter/_predicates.pxd":18 - * readonly tuple query_lt - * readonly tuple query_lte - * readonly tuple query_regex # <<<<<<<<<<<<<< - * readonly tuple query_startswith + /* "hunter/_predicates.pyx":200 * + * def __str__(self): + * return 'Query(%s)' % ( # <<<<<<<<<<<<<< + * ', '.join([ + * ', '.join(f'{key}{kind}={value!r}' for key, value in mapping) */ - -/* 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)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -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; + __Pyx_TraceLine(200,0,__PYX_ERR(1, 200, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Query_s, __pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 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; 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_regex.__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_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_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 + * def __repr__(self): # <<<<<<<<<<<<<< + * return '' % ' '.join([ + * fmt % (mapping,) */ /* 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) { +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_16query_startswith___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_16query_startswith___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_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 19, 0, __PYX_ERR(1, 19, __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_RefNannySetupContext("__repr__", 1); + __Pyx_TraceCall("__repr__", __pyx_f[1], 219, 0, __PYX_ERR(1, 219, __pyx_L1_error)); + + /* "hunter/_predicates.pyx":220 + * + * def __repr__(self): + * return '' % ' '.join([ # <<<<<<<<<<<<<< + * fmt % (mapping,) + * for fmt, mapping in [ + */ + __Pyx_TraceLine(220,0,__PYX_ERR(1, 220, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->query_startswith); - __pyx_r = __pyx_v_self->query_startswith; - goto __pyx_L0; + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 220, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_1); - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.Query.query_startswith.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; + /* "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,0,__PYX_ERR(1, 223, __pyx_L5_error)) + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 223, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_kp_s_query_eq_r); + __Pyx_GIVEREF(__pyx_kp_s_query_eq_r); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_s_query_eq_r)) __PYX_ERR(1, 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)) __PYX_ERR(1, 223, __pyx_L5_error); + + /* "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,0,__PYX_ERR(1, 224, __pyx_L5_error)) + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 224, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_kp_s_query_in_r); + __Pyx_GIVEREF(__pyx_kp_s_query_in_r); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_s_query_in_r)) __PYX_ERR(1, 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)) __PYX_ERR(1, 224, __pyx_L5_error); + + /* "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,0,__PYX_ERR(1, 225, __pyx_L5_error)) + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 225, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_kp_s_query_contains_r); + __Pyx_GIVEREF(__pyx_kp_s_query_contains_r); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_kp_s_query_contains_r)) __PYX_ERR(1, 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)) __PYX_ERR(1, 225, __pyx_L5_error); + + /* "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,0,__PYX_ERR(1, 226, __pyx_L5_error)) + __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 226, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_kp_s_query_startswith_r); + __Pyx_GIVEREF(__pyx_kp_s_query_startswith_r); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_kp_s_query_startswith_r)) __PYX_ERR(1, 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)) __PYX_ERR(1, 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,0,__PYX_ERR(1, 227, __pyx_L5_error)) + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 227, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_INCREF(__pyx_kp_s_query_endswith_r); + __Pyx_GIVEREF(__pyx_kp_s_query_endswith_r); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_s_query_endswith_r)) __PYX_ERR(1, 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)) __PYX_ERR(1, 227, __pyx_L5_error); + + /* "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,0,__PYX_ERR(1, 228, __pyx_L5_error)) + __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 228, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_INCREF(__pyx_kp_s_query_regex_r); + __Pyx_GIVEREF(__pyx_kp_s_query_regex_r); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_s_query_regex_r)) __PYX_ERR(1, 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)) __PYX_ERR(1, 228, __pyx_L5_error); + + /* "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,0,__PYX_ERR(1, 229, __pyx_L5_error)) + __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 229, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_INCREF(__pyx_kp_s_query_lt_r); + __Pyx_GIVEREF(__pyx_kp_s_query_lt_r); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_s_query_lt_r)) __PYX_ERR(1, 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)) __PYX_ERR(1, 229, __pyx_L5_error); + + /* "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,0,__PYX_ERR(1, 230, __pyx_L5_error)) + __pyx_t_9 = PyTuple_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 230, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_INCREF(__pyx_kp_s_query_lte_r); + __Pyx_GIVEREF(__pyx_kp_s_query_lte_r); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_kp_s_query_lte_r)) __PYX_ERR(1, 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)) __PYX_ERR(1, 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,0,__PYX_ERR(1, 231, __pyx_L5_error)) + __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 231, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_INCREF(__pyx_kp_s_query_gt_r); + __Pyx_GIVEREF(__pyx_kp_s_query_gt_r); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_kp_s_query_gt_r)) __PYX_ERR(1, 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)) __PYX_ERR(1, 231, __pyx_L5_error); + + /* "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,0,__PYX_ERR(1, 232, __pyx_L5_error)) + __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 232, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_INCREF(__pyx_kp_s_query_gte_r); + __Pyx_GIVEREF(__pyx_kp_s_query_gte_r); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_kp_s_query_gte_r)) __PYX_ERR(1, 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)) __PYX_ERR(1, 232, __pyx_L5_error); + + /* "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,0,__PYX_ERR(1, 222, __pyx_L5_error)) + __pyx_t_12 = PyTuple_New(10); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 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)) __PYX_ERR(1, 222, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_t_3)) __PYX_ERR(1, 222, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 2, __pyx_t_4)) __PYX_ERR(1, 222, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 3, __pyx_t_5)) __PYX_ERR(1, 222, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 4, __pyx_t_6)) __PYX_ERR(1, 222, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 5, __pyx_t_7)) __PYX_ERR(1, 222, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 6, __pyx_t_8)) __PYX_ERR(1, 222, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_9); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 7, __pyx_t_9)) __PYX_ERR(1, 222, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_10); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 8, __pyx_t_10)) __PYX_ERR(1, 222, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_11); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 9, __pyx_t_11)) __PYX_ERR(1, 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 = PyTuple_GET_ITEM(__pyx_t_11, __pyx_t_13); __Pyx_INCREF(__pyx_t_12); __pyx_t_13++; if (unlikely((0 < 0))) __PYX_ERR(1, 222, __pyx_L5_error) + #else + __pyx_t_12 = __Pyx_PySequence_ITEM(__pyx_t_11, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 222, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_12); + #endif + if (likely(__pyx_t_12 != Py_None)) { + PyObject* sequence = __pyx_t_12; + 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(1, 222, __pyx_L5_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_10 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_9 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(__pyx_t_9); + #else + __pyx_t_10 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 222, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_9 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 222, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_9); + #endif + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 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; + + /* "hunter/_predicates.pyx":234 + * ('query_gte=%r', self.query_gte), + * ] + * if mapping # <<<<<<<<<<<<<< + * ]) + * + */ + __Pyx_TraceLine(234,0,__PYX_ERR(1, 234, __pyx_L5_error)) + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_8genexpr3__pyx_v_mapping); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(1, 234, __pyx_L5_error) + if (__pyx_t_14) { + + /* "hunter/_predicates.pyx":221 + * def __repr__(self): + * return '' % ' '.join([ + * fmt % (mapping,) # <<<<<<<<<<<<<< + * for fmt, mapping in [ + * ('query_eq=%r', self.query_eq), + */ + __Pyx_TraceLine(221,0,__PYX_ERR(1, 221, __pyx_L5_error)) + __pyx_t_12 = PyTuple_New(1); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 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)) __PYX_ERR(1, 221, __pyx_L5_error); + __pyx_t_9 = PyNumber_Remainder(__pyx_8genexpr3__pyx_v_fmt, __pyx_t_12); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 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(1, 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 # <<<<<<<<<<<<<< + * ]) + * + */ + } + + /* "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,0,__PYX_ERR(1, 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 */ + + /* "hunter/_predicates.pyx":220 + * + * def __repr__(self): + * return '' % ' '.join([ # <<<<<<<<<<<<<< + * fmt % (mapping,) + * for fmt, mapping in [ + */ + __Pyx_TraceLine(220,0,__PYX_ERR(1, 220, __pyx_L1_error)) + __pyx_t_11 = __Pyx_PyString_Join(__pyx_kp_s__10, __pyx_t_1); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_hunter_predicates_Query_s, __pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 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; + goto __pyx_L0; + + /* "hunter/_predicates.pyx":219 + * ) + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return '' % ' '.join([ + * fmt % (mapping,) + */ + + /* 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_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_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_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_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_RefNannySetupContext("__eq__", 1); + __Pyx_TraceCall("__eq__", __pyx_f[1], 237, 0, __PYX_ERR(1, 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: + /* "hunter/_predicates.pyx":238 + * + * def __eq__(self, other): + * return ( # <<<<<<<<<<<<<< + * isinstance(other, Query) + * and self.query_eq == ( other).query_eq */ - __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; + __Pyx_TraceLine(238,0,__PYX_ERR(1, 238, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); - /* "(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,) + /* "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(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; + __Pyx_TraceLine(239,0,__PYX_ERR(1, 239, __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(1, 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)":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 + /* "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(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) { + __Pyx_TraceLine(240,0,__PYX_ERR(1, 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(1, 240, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 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)":8 - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: - * state += (_dict,) # <<<<<<<<<<<<<< - * use_setstate = True - * else: + /* "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(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; + __Pyx_TraceLine(241,0,__PYX_ERR(1, 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(1, 241, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 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)":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 + /* "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(9,0,__PYX_ERR(2, 9, __pyx_L1_error)) - __pyx_v_use_setstate = 1; + __Pyx_TraceLine(242,0,__PYX_ERR(1, 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(1, 242, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 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; + } - /* "(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 + /* "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 */ - goto __pyx_L3; + __Pyx_TraceLine(243,0,__PYX_ERR(1, 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(1, 243, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 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)":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 + /* "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(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; + __Pyx_TraceLine(244,0,__PYX_ERR(1, 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(1, 244, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 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; } - __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: + /* "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(12,0,__PYX_ERR(2, 12, __pyx_L1_error)) - __pyx_t_3 = (__pyx_v_use_setstate != 0); - if (__pyx_t_3) { + __Pyx_TraceLine(245,0,__PYX_ERR(1, 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(1, 245, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 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)":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) + /* "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(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; + __Pyx_TraceLine(246,0,__PYX_ERR(1, 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(1, 246, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 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)":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":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,0,__PYX_ERR(1, 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(1, 247, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 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; } - /* "(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) + /* "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(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; + __Pyx_TraceLine(248,0,__PYX_ERR(1, 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(1, 248, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 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; } - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict + /* "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,0,__PYX_ERR(1, 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(1, 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; + 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_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_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)); - - /* function exit code */ + __Pyx_RefNannySetupContext("__call__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __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 **__pyx_pyargnames[] = {&__pyx_n_s_event,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_event)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 252, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__call__") < 0)) __PYX_ERR(1, 252, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + } + __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(1, 252, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(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_ptype_6hunter_6_event_Event, 1, "event", 0))) __PYX_ERR(1, 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; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } __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_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_RefNannySetupContext("__call__", 1); + __Pyx_TraceCall("__call__", __pyx_f[1], 252, 0, __PYX_ERR(1, 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) # <<<<<<<<<<<<<< + /* "hunter/_predicates.pyx":253 + * + * def __call__(self, Event event): + * return fast_Query_call(self, event) # <<<<<<<<<<<<<< + * + * def __or__(self, other): */ - __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) + __Pyx_TraceLine(253,0,__PYX_ERR(1, 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(1, 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; + 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_AddTraceback("hunter._predicates.Query.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -6801,4069 +9479,3500 @@ static PyObject *__pyx_pf_6hunter_11_predicates_5Query_20__setstate_cython__(str return __pyx_r; } -/* "hunter/_predicates.pyx":215 - * return Not(self) +/* "hunter/_predicates.pyx":255 + * return fast_Query_call(self, event) + * + * def __or__(self, other): # <<<<<<<<<<<<<< + * return Or(self, other) * - * cdef fast_Query_call(Query self, Event event): # <<<<<<<<<<<<<< - * for key, value in self.query_eq: - * evalue = event[key] */ -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_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - Py_ssize_t __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)(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)); + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__or__", 1); + __Pyx_TraceCall("__or__", __pyx_f[1], 255, 0, __PYX_ERR(1, 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: + * def __or__(self, other): + * return Or(self, other) # <<<<<<<<<<<<<< + * + * def __and__(self, other): */ - __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) - } - __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_TraceLine(256,0,__PYX_ERR(1, 256, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_self); + __Pyx_GIVEREF(__pyx_v_self); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self)) __PYX_ERR(1, 256, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_other); + __Pyx_GIVEREF(__pyx_v_other); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_other)) __PYX_ERR(1, 256, __pyx_L1_error); + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_Or), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 256, __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; - /* "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 + /* "hunter/_predicates.pyx":255 + * return fast_Query_call(self, event) + * + * def __or__(self, other): # <<<<<<<<<<<<<< + * return Or(self, other) + * */ - __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":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_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":219 - * evalue = event[key] - * if evalue != value: - * return False # <<<<<<<<<<<<<< - * for key, value in self.query_in: - * evalue = event[key] +/* "hunter/_predicates.pyx":258 + * return Or(self, other) + * + * def __and__(self, other): # <<<<<<<<<<<<<< + * return And(self, other) + * */ - __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":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)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_11_predicates_5Query_12__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; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__and__", 1); + __Pyx_TraceCall("__and__", __pyx_f[1], 258, 0, __PYX_ERR(1, 258, __pyx_L1_error)); - /* "hunter/_predicates.pyx":216 + /* "hunter/_predicates.pyx":259 + * + * def __and__(self, other): + * return And(self, other) # <<<<<<<<<<<<<< * - * cdef fast_Query_call(Query self, Event event): - * for key, value in self.query_eq: # <<<<<<<<<<<<<< - * evalue = event[key] - * if evalue != value: + * def __invert__(self): */ - __Pyx_TraceLine(216,0,__PYX_ERR(0, 216, __pyx_L1_error)) - } + __Pyx_TraceLine(259,0,__PYX_ERR(1, 259, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 259, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_self); + __Pyx_GIVEREF(__pyx_v_self); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self)) __PYX_ERR(1, 259, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_other); + __Pyx_GIVEREF(__pyx_v_other); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_other)) __PYX_ERR(1, 259, __pyx_L1_error); + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_And), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 259, __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; - /* "hunter/_predicates.pyx":220 - * if evalue != value: - * return False - * for key, value in self.query_in: # <<<<<<<<<<<<<< - * evalue = event[key] - * if evalue not in value: + /* "hunter/_predicates.pyx":258 + * return Or(self, other) + * + * def __and__(self, other): # <<<<<<<<<<<<<< + * return And(self, other) + * */ - __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) - } - __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; - /* "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; + /* 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; +} - /* "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: +/* "hunter/_predicates.pyx":261 + * return And(self, other) + * + * def __invert__(self): # <<<<<<<<<<<<<< + * return Not(self) + * */ - __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) { - /* "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; +/* 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":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: - */ - } + /* 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)) - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; +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_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__invert__", 1); + __Pyx_TraceCall("__invert__", __pyx_f[1], 261, 0, __PYX_ERR(1, 261, __pyx_L1_error)); - /* "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: + /* "hunter/_predicates.pyx":262 + * + * def __invert__(self): + * return Not(self) # <<<<<<<<<<<<<< + * + * cdef inline fast_Query_call(Query self, Event event): */ - __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) - } - __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_TraceLine(262,0,__PYX_ERR(1, 262, __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(1, 262, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + 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 + /* "hunter/_predicates.pyx":261 + * return And(self, other) + * + * def __invert__(self): # <<<<<<<<<<<<<< + * return Not(self) + * */ - __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":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_AddTraceback("hunter._predicates.Query.__invert__", __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":227 - * evalue = event[key] - * if value not in evalue: - * return False # <<<<<<<<<<<<<< - * for key, value in self.query_startswith: - * evalue = event[key] +/* "hunter/_predicates.pxd":10 + * cdef class Query: + * cdef: + * readonly tuple query_contains # <<<<<<<<<<<<<< + * readonly tuple query_endswith + * readonly tuple query_eq */ - __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.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_TraceDeclarations + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[2], 10, 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; + 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_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.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: +/* "hunter/_predicates.pxd":11 + * cdef: + * readonly tuple query_contains + * readonly tuple query_endswith # <<<<<<<<<<<<<< + * readonly tuple query_eq + * readonly tuple query_gt */ - __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.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_TraceDeclarations + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[2], 11, 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; + 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_AddTraceback("hunter._predicates.Query.query_endswith.__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":233 - * return False - * for key, value in self.query_endswith: - * evalue = event[key] # <<<<<<<<<<<<<< - * if not evalue.endswith(value): - * return False +/* "hunter/_predicates.pxd":12 + * readonly tuple query_contains + * readonly tuple query_endswith + * readonly tuple query_eq # <<<<<<<<<<<<<< + * readonly tuple query_gt + * readonly tuple query_gte */ - __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.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_TraceDeclarations + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[2], 12, 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; + 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_AddTraceback("hunter._predicates.Query.query_eq.__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":236 - * if not evalue.endswith(value): - * return False - * for key, value in self.query_regex: # <<<<<<<<<<<<<< - * evalue = event[key] - * if not value.match(evalue): +/* "hunter/_predicates.pxd":13 + * readonly tuple query_endswith + * readonly tuple query_eq + * readonly tuple query_gt # <<<<<<<<<<<<<< + * readonly tuple query_gte + * readonly tuple query_in */ - __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.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_TraceDeclarations + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[2], 13, 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; + 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_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":236 - * if not evalue.endswith(value): - * return False - * for key, value in self.query_regex: # <<<<<<<<<<<<<< - * evalue = event[key] - * if not value.match(evalue): +/* "hunter/_predicates.pxd":14 + * readonly tuple query_eq + * readonly tuple query_gt + * readonly tuple query_gte # <<<<<<<<<<<<<< + * readonly tuple query_in + * readonly tuple query_lt */ - __Pyx_TraceLine(236,0,__PYX_ERR(0, 236, __pyx_L1_error)) - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "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_TraceDeclarations + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[2], 14, 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; + 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_AddTraceback("hunter._predicates.Query.query_gte.__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":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_TraceDeclarations + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[2], 15, 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; + 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) { + /* 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":247 - * evalue = event[key] - * if not evalue >= value: - * return False # <<<<<<<<<<<<<< - * for key, value in self.query_lt: - * evalue = event[key] +/* "hunter/_predicates.pxd":16 + * readonly tuple query_gte + * readonly tuple query_in + * readonly tuple query_lt # <<<<<<<<<<<<<< + * readonly tuple query_lte + * readonly tuple query_regex */ - __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; - - /* "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.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_TraceDeclarations + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[2], 16, 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; + 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_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.pyx":255 - * evalue = event[key] - * if not evalue <= value: - * return False # <<<<<<<<<<<<<< - * - * return True +/* "hunter/_predicates.pxd":17 + * readonly tuple query_in + * readonly tuple query_lt + * readonly tuple query_lte # <<<<<<<<<<<<<< + * readonly tuple query_regex + * readonly tuple query_startswith */ - __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.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_TraceDeclarations + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[2], 17, 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; 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_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_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":268 - * """ +/* "hunter/_predicates.pxd":18 + * readonly tuple query_lt + * readonly tuple query_lte + * readonly tuple query_regex # <<<<<<<<<<<<<< + * readonly tuple query_startswith * - * def __init__(self, condition, *actions): # <<<<<<<<<<<<<< - * if not actions: - * raise TypeError('Must give at least one action.') */ /* 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_TraceDeclarations __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_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[2], 18, 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; + goto __pyx_L0; /* function exit code */ __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.When.__init__.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __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_TraceReturn(__pyx_r, 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_TraceDeclarations + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[2], 19, 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; 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_AddTraceback("hunter._predicates.Query.query_startswith.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; __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_XGIVEREF(__pyx_r); __Pyx_TraceReturn(__pyx_r, 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; +/* 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*)(__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 + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __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;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) 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_TraceDeclarations __Pyx_RefNannyDeclarations - int __pyx_t_1; + 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(__pyx_codeobj__11) + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + __Pyx_TraceCall("__reduce_cython__", __pyx_f[0], 1, 0, __PYX_ERR(0, 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 + /* "(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(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)) { - - /* "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(5,0,__PYX_ERR(0, 5, __pyx_L1_error)) + __pyx_t_1 = PyTuple_New(10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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)) __PYX_ERR(0, 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)) __PYX_ERR(0, 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)) __PYX_ERR(0, 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)) __PYX_ERR(0, 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)) __PYX_ERR(0, 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)) __PYX_ERR(0, 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)) __PYX_ERR(0, 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)) __PYX_ERR(0, 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)) __PYX_ERR(0, 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)) __PYX_ERR(0, 5, __pyx_L1_error); + __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(0, 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(0, 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(0, 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(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) + __Pyx_TraceLine(8,0,__PYX_ERR(0, 8, __pyx_L1_error)) + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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)) __PYX_ERR(0, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 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,0,__PYX_ERR(0, 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 + /* "(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(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; + __Pyx_TraceLine(11,0,__PYX_ERR(0, 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) - * + /* "(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(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); + __Pyx_TraceLine(12,0,__PYX_ERR(0, 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) + /* "(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(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; + __Pyx_TraceLine(13,0,__PYX_ERR(0, 13, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_Query); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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))))) __PYX_ERR(0, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_89143876); + __Pyx_GIVEREF(__pyx_int_89143876); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_89143876)) __PYX_ERR(0, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(0, 13, __pyx_L1_error); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 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)) __PYX_ERR(0, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1)) __PYX_ERR(0, 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)) __PYX_ERR(0, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + 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,0,__PYX_ERR(0, 15, __pyx_L1_error)) + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_Query); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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))))) __PYX_ERR(0, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_89143876); + __Pyx_GIVEREF(__pyx_int_89143876); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_89143876)) __PYX_ERR(0, 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)) __PYX_ERR(0, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 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)) __PYX_ERR(0, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(0, 15, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + 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_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_TraceReturn(__pyx_r, 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*)(__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)); - - /* function exit code */ - __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; - PyObject *__pyx_r = NULL; - __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_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __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 **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; } - __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); + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; { - __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; + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(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 */ - __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.When.__str__.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); - __Pyx_XGIVEREF(__pyx_r); + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(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) /* 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); +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_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], 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)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(0, 279, __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; - 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, 279, __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, 279, __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 = PyObject_Repr(__pyx_cur_scope->__pyx_v_p); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 279, __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) - } + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__12) + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + __Pyx_TraceCall("__setstate_cython__", __pyx_f[0], 16, 0, __PYX_ERR(0, 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,0,__PYX_ERR(0, 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(0, 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(0, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + + /* "(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 */ - 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_3); - __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("hunter._predicates.Query.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; __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_XGIVEREF(__pyx_r); __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":276 - * for action in actions) +/* "hunter/_predicates.pyx":264 + * return Not(self) * - * def __str__(self): # <<<<<<<<<<<<<< - * return 'When(%s, %s)' % ( - * self.condition, + * cdef inline fast_Query_call(Query self, Event event): # <<<<<<<<<<<<<< + * for key, entry in self.query_eq: + * value_from_event = ( entry).getter(event) */ -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; +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_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); + Py_ssize_t __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)(PyObject *); + int __pyx_t_8; + int __pyx_t_9; + int __pyx_t_10; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("fast_Query_call", 1); + __Pyx_TraceCall("fast_Query_call", __pyx_f[1], 264, 0, __PYX_ERR(1, 264, __pyx_L1_error)); - /* "hunter/_predicates.pyx":277 + /* "hunter/_predicates.pyx":265 * - * def __str__(self): - * return 'When(%s, %s)' % ( # <<<<<<<<<<<<<< - * self.condition, - * ', '.join(repr(p) for p in self.actions) + * 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(277,0,__PYX_ERR(0, 277, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); + __Pyx_TraceLine(265,0,__PYX_ERR(1, 265, __pyx_L1_error)) + if (unlikely(__pyx_v_self->query_eq == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(1, 265, __pyx_L1_error) + } + __pyx_t_1 = __pyx_v_self->query_eq; __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_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 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(1, 265, __pyx_L1_error) + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 265, __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(1, 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_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(1, 265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 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(1, 265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = __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(1, 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(1, 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; - /* "hunter/_predicates.pyx":279 - * return 'When(%s, %s)' % ( - * self.condition, - * ', '.join(repr(p) for p in self.actions) # <<<<<<<<<<<<<< - * ) - * + /* "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(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); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_TraceLine(266,0,__PYX_ERR(1, 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(1, 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":278 - * def __str__(self): - * return 'When(%s, %s)' % ( - * self.condition, # <<<<<<<<<<<<<< - * ', '.join(repr(p) for p in self.actions) - * ) + /* "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(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; + __Pyx_TraceLine(267,0,__PYX_ERR(1, 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(1, 267, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(1, 267, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_8) { - /* "hunter/_predicates.pyx":277 - * - * def __str__(self): - * return 'When(%s, %s)' % ( # <<<<<<<<<<<<<< - * self.condition, - * ', '.join(repr(p) for p in self.actions) + /* "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(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; - __pyx_t_2 = 0; - goto __pyx_L0; + __Pyx_TraceLine(268,0,__PYX_ERR(1, 268, __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":276 - * for action in actions) + /* "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":265 * - * def __str__(self): # <<<<<<<<<<<<<< - * return 'When(%s, %s)' % ( - * self.condition, + * 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,0,__PYX_ERR(1, 265, __pyx_L1_error)) + } + __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_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; -} + /* "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,0,__PYX_ERR(1, 269, __pyx_L1_error)) + if (unlikely(__pyx_v_self->query_in == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(1, 269, __pyx_L1_error) + } + __pyx_t_1 = __pyx_v_self->query_in; __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_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 269, __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(1, 269, __pyx_L1_error) + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 269, __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(1, 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_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(1, 269, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 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(1, 269, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = __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(1, 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(1, 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; -/* "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,0,__PYX_ERR(1, 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(1, 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,0,__PYX_ERR(1, 271, __pyx_L1_error)) + if (!(likely(PyString_CheckExact(__pyx_v_value_from_event)) || __Pyx_RaiseUnexpectedTypeError("str", __pyx_v_value_from_event))) __PYX_ERR(1, 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(1, 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,0,__PYX_ERR(1, 272, __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_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): + /* "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(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); + __Pyx_TraceLine(269,0,__PYX_ERR(1, 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) - * + /* "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,0,__PYX_ERR(1, 273, __pyx_L1_error)) + if (unlikely(__pyx_v_self->query_contains == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(1, 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_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 273, __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(1, 273, __pyx_L1_error) + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 273, __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(1, 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_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(1, 273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 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(1, 273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = __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(1, 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(1, 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; - /* 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":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,0,__PYX_ERR(1, 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(1, 274, __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_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)); - - /* 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,0,__PYX_ERR(1, 275, __pyx_L1_error)) + if (!(likely(PyString_CheckExact(__pyx_v_value_from_event)) || __Pyx_RaiseUnexpectedTypeError("str", __pyx_v_value_from_event))) __PYX_ERR(1, 275, __pyx_L1_error) + __pyx_t_8 = (__Pyx_PySequence_ContainsTF(((struct __pyx_obj_6hunter_11_predicates_QueryEntry *)__pyx_v_entry)->value, __pyx_v_value_from_event, Py_NE)); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(1, 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,0,__PYX_ERR(1, 276, __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":286 - * - * def __eq__(self, other): - * return ( # <<<<<<<<<<<<<< - * isinstance(other, When) - * and self.condition == ( other).condition + /* "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(286,0,__PYX_ERR(0, 286, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); + } - /* "hunter/_predicates.pyx":287 - * def __eq__(self, other): - * return ( - * isinstance(other, When) # <<<<<<<<<<<<<< - * and self.condition == ( other).condition - * and self.actions == ( other).actions + /* "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(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; + __Pyx_TraceLine(273,0,__PYX_ERR(1, 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 - * ) + /* "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(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; + __Pyx_TraceLine(277,0,__PYX_ERR(1, 277, __pyx_L1_error)) + if (unlikely(__pyx_v_self->query_startswith == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(1, 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_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 277, __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(1, 277, __pyx_L1_error) + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 277, __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(1, 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_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(1, 277, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 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(1, 277, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = __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(1, 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(1, 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; - /* "hunter/_predicates.pyx":289 - * isinstance(other, When) - * and self.condition == ( other).condition - * and self.actions == ( other).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(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; + __Pyx_TraceLine(278,0,__PYX_ERR(1, 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(1, 278, __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":285 - * return '' % (self.condition, self.actions) - * - * def __eq__(self, other): # <<<<<<<<<<<<<< - * return ( - * isinstance(other, When) + /* "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,0,__PYX_ERR(1, 279, __pyx_L1_error)) + if (!(likely(PyString_CheckExact(__pyx_v_value_from_event)) || __Pyx_RaiseUnexpectedTypeError("str", __pyx_v_value_from_event))) __PYX_ERR(1, 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(1, 279, __pyx_L1_error) + } + __pyx_t_8 = __Pyx_PyStr_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(1, 279, __pyx_L1_error) + __pyx_t_9 = (!__pyx_t_8); + if (__pyx_t_9) { - /* 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":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,0,__PYX_ERR(1, 280, __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 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)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -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":293 - * - * def __hash__(self): - * return hash(('When', self.condition, self.actions)) # <<<<<<<<<<<<<< - * - * def __call__(self, Event event): + /* "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(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) - __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)) - * + /* "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,0,__PYX_ERR(1, 277, __pyx_L1_error)) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* 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) - * + /* "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): */ - -/* 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; + __Pyx_TraceLine(281,0,__PYX_ERR(1, 281, __pyx_L1_error)) + if (unlikely(__pyx_v_self->query_endswith == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(1, 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_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 281, __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(1, 281, __pyx_L1_error) + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 281, __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(1, 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_t_5 = PyTuple_GET_ITEM(sequence, 1); + } else { + __pyx_t_4 = PyList_GET_ITEM(sequence, 0); + __pyx_t_5 = PyList_GET_ITEM(sequence, 1); } - } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { - goto __pyx_L5_argtuple_error; + __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(1, 281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 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(1, 281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = __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(1, 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(1, 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; -} - -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)); + __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; - /* "hunter/_predicates.pyx":296 - * - * def __call__(self, Event event): - * return fast_When_call(self, event) # <<<<<<<<<<<<<< - * - * def __or__(self, other): + /* "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(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; + __Pyx_TraceLine(282,0,__PYX_ERR(1, 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(1, 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":295 - * return hash(('When', self.condition, self.actions)) - * - * def __call__(self, Event event): # <<<<<<<<<<<<<< - * return fast_When_call(self, event) - * + /* "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,0,__PYX_ERR(1, 283, __pyx_L1_error)) + if (!(likely(PyString_CheckExact(__pyx_v_value_from_event)) || __Pyx_RaiseUnexpectedTypeError("str", __pyx_v_value_from_event))) __PYX_ERR(1, 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(1, 283, __pyx_L1_error) + } + __pyx_t_9 = __Pyx_PyStr_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(1, 283, __pyx_L1_error) + __pyx_t_8 = (!__pyx_t_9); + if (__pyx_t_8) { - /* 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":298 - * return fast_When_call(self, event) - * - * def __or__(self, other): # <<<<<<<<<<<<<< - * return Or(self, other) - * + /* "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,0,__PYX_ERR(1, 284, __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_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":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":299 - * - * def __or__(self, other): - * return Or(self, other) # <<<<<<<<<<<<<< - * - * def __and__(self, other): + /* "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(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); + __Pyx_TraceLine(281,0,__PYX_ERR(1, 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) - * + /* "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,0,__PYX_ERR(1, 285, __pyx_L1_error)) + if (unlikely(__pyx_v_self->query_regex == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(1, 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_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 285, __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(1, 285, __pyx_L1_error) + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 285, __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(1, 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_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(1, 285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 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(1, 285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = __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(1, 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(1, 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; - /* 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":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,0,__PYX_ERR(1, 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(1, 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)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -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":302 - * - * def __and__(self, other): - * return And(self, other) # <<<<<<<<<<<<<< - * - * def __invert__(self): + /* "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(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); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; + __Pyx_TraceLine(287,0,__PYX_ERR(1, 287, __pyx_L1_error)) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((struct __pyx_obj_6hunter_11_predicates_QueryEntry *)__pyx_v_entry)->value, __pyx_n_s_match); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 287, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_10 = 0; + #if CYTHON_UNPACK_METHODS + if (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_10 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_value_from_event}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_10, 1+__pyx_t_10); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 287, __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(1, 287, __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":301 - * return Or(self, other) - * - * def __and__(self, other): # <<<<<<<<<<<<<< - * return And(self, other) - * + /* "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,0,__PYX_ERR(1, 288, __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_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":304 - * return And(self, other) - * - * def __invert__(self): # <<<<<<<<<<<<<< - * return Not(self) - * + /* "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: */ + } -/* 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)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -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":305 - * - * def __invert__(self): - * return Not(self) # <<<<<<<<<<<<<< - * - * cdef inline fast_When_call(When self, Event event): + /* "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(305,0,__PYX_ERR(0, 305, __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; - goto __pyx_L0; + __Pyx_TraceLine(285,0,__PYX_ERR(1, 285, __pyx_L1_error)) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "hunter/_predicates.pyx":304 - * return And(self, other) - * - * def __invert__(self): # <<<<<<<<<<<<<< - * return Not(self) - * + /* "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,0,__PYX_ERR(1, 289, __pyx_L1_error)) + if (unlikely(__pyx_v_self->query_gt == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(1, 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_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 289, __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(1, 289, __pyx_L1_error) + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 289, __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(1, 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_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(1, 289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 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(1, 289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = __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(1, 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(1, 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; - /* 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_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "hunter/_predicates.pxd":39 - * cdef class When: - * cdef: - * readonly object condition # <<<<<<<<<<<<<< - * readonly tuple actions - * + /* "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,0,__PYX_ERR(1, 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(1, 290, __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_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)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -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_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; - - /* function exit code */ - __pyx_L1_error:; - __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_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: + */ + __Pyx_TraceLine(291,0,__PYX_ERR(1, 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(1, 291, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(1, 291, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_8 = (!__pyx_t_9); + if (__pyx_t_8) { -/* "hunter/_predicates.pxd":40 - * cdef: - * readonly object condition - * readonly tuple actions # <<<<<<<<<<<<<< - * - * @cython.final + /* "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,0,__PYX_ERR(1, 292, __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_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":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: + */ + } - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "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,0,__PYX_ERR(1, 289, __pyx_L1_error)) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; -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":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,0,__PYX_ERR(1, 293, __pyx_L1_error)) + if (unlikely(__pyx_v_self->query_gte == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(1, 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_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 293, __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(1, 293, __pyx_L1_error) + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 293, __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(1, 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_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(1, 293, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 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(1, 293, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = __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(1, 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(1, 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; - /* function exit code */ - __pyx_L1_error:; - __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_RefNannyFinishContext(); - return __pyx_r; -} + /* "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,0,__PYX_ERR(1, 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(1, 294, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_value_from_event, __pyx_t_3); + __pyx_t_3 = 0; -/* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict + /* "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,0,__PYX_ERR(1, 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(1, 295, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(1, 295, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_9 = (!__pyx_t_8); + if (__pyx_t_9) { -/* 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)); + /* "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,0,__PYX_ERR(1, 296, __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":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: + */ + } -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 - __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)); + /* "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,0,__PYX_ERR(1, 293, __pyx_L1_error)) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "(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: + /* "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(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; + __Pyx_TraceLine(297,0,__PYX_ERR(1, 297, __pyx_L1_error)) + if (unlikely(__pyx_v_self->query_lt == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(1, 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_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 297, __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(1, 297, __pyx_L1_error) + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 297, __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(1, 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_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(1, 297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 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(1, 297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = __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(1, 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(1, 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; - /* "(tree fragment)":6 - * cdef bint use_setstate - * state = (self.actions, self.condition) - * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< - * if _dict is not None: - * state += (_dict,) + /* "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(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; + __Pyx_TraceLine(298,0,__PYX_ERR(1, 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(1, 298, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_value_from_event, __pyx_t_3); + __pyx_t_3 = 0; - /* "(tree fragment)":7 - * state = (self.actions, self.condition) - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: # <<<<<<<<<<<<<< - * state += (_dict,) - * use_setstate = True + /* "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(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) { + __Pyx_TraceLine(299,0,__PYX_ERR(1, 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(1, 299, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(1, 299, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_8 = (!__pyx_t_9); + if (__pyx_t_8) { - /* "(tree fragment)":8 - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: - * state += (_dict,) # <<<<<<<<<<<<<< - * use_setstate = True - * else: + /* "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(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; + __Pyx_TraceLine(300,0,__PYX_ERR(1, 300, __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; - /* "(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 + /* "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(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 + /* "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: */ - goto __pyx_L3; + __Pyx_TraceLine(297,0,__PYX_ERR(1, 297, __pyx_L1_error)) } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "(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 + /* "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(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) { + __Pyx_TraceLine(301,0,__PYX_ERR(1, 301, __pyx_L1_error)) + if (unlikely(__pyx_v_self->query_lte == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(1, 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_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 301, __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(1, 301, __pyx_L1_error) + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 301, __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(1, 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_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(1, 301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { - __pyx_t_3 = __pyx_t_5; - goto __pyx_L4_bool_binop_done; + Py_ssize_t index = -1; + __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = __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(1, 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(1, 301, __pyx_L1_error) + __pyx_L60_unpacking_done:; } - __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_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; - /* "(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":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(12,0,__PYX_ERR(2, 12, __pyx_L1_error)) - __pyx_t_3 = (__pyx_v_use_setstate != 0); - if (__pyx_t_3) { + __Pyx_TraceLine(302,0,__PYX_ERR(1, 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(1, 302, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_value_from_event, __pyx_t_3); + __pyx_t_3 = 0; - /* "(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) + /* "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 + * */ - __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; + __Pyx_TraceLine(303,0,__PYX_ERR(1, 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(1, 303, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(1, 303, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_9 = (!__pyx_t_8); + if (__pyx_t_9) { - /* "(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":304 + * value_from_event = ( entry).getter(event) + * if not value_from_event <= ( entry).value: + * return False # <<<<<<<<<<<<<< + * + * return True */ - } + __Pyx_TraceLine(304,0,__PYX_ERR(1, 304, __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; - /* "(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) + /* "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 + * */ - __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; - } + } - /* "(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_4); - __Pyx_XDECREF(__pyx_t_6); - __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_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) - */ - -/* 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) { - 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)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -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) { - 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) - */ - - /* 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_r = NULL; - __pyx_L0:; - __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 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_TraceDeclarations - __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)); - - /* "hunter/_predicates.pyx":310 - * cdef object result - * - * result = fast_call(self.condition, event) # <<<<<<<<<<<<<< - * - * 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_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_result = __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) - */ - __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) { - - /* "hunter/_predicates.pyx":313 - * - * if result: - * for action in self.actions: # <<<<<<<<<<<<<< - * action(event) - * - */ - __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; - - /* "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; - - /* "hunter/_predicates.pyx":313 - * - * if result: - * for action in self.actions: # <<<<<<<<<<<<<< - * action(event) - * - */ - __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) + /* "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,0,__PYX_ERR(1, 301, __pyx_L1_error)) } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "hunter/_predicates.pyx":316 - * action(event) + /* "hunter/_predicates.pyx":306 + * return False * - * return result # <<<<<<<<<<<<<< + * return True # <<<<<<<<<<<<<< * * */ - __Pyx_TraceLine(316,0,__PYX_ERR(0, 316, __pyx_L1_error)) + __Pyx_TraceLine(306,0,__PYX_ERR(1, 306, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_result); - __pyx_r = __pyx_v_result; + __Pyx_INCREF(Py_True); + __pyx_r = Py_True; goto __pyx_L0; - /* "hunter/_predicates.pyx":307 + /* "hunter/_predicates.pyx":264 * return Not(self) * - * cdef inline fast_When_call(When self, Event event): # <<<<<<<<<<<<<< - * cdef object result - * + * 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_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._predicates.fast_When_call", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("hunter._predicates.fast_Query_call", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; - __Pyx_XDECREF(__pyx_v_result); - __Pyx_XDECREF(__pyx_v_action); + __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_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":325 +/* "hunter/_predicates.pyx":317 * """ * - * def __init__(self, condition, predicate=None, watermark=0): # <<<<<<<<<<<<<< - * self.condition = condition - * self.predicate = predicate + * def __init__(self, condition, *actions): # <<<<<<<<<<<<<< + * if not actions: + * raise TypeError('Must give at least one action.') */ /* 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) { +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_predicate = 0; - PyObject *__pyx_v_watermark = 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_MACROS + __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); { - 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)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_condition,0}; + if (__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); + switch (__pyx_nargs) { + default: + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; - default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { 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 (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_condition)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[0]); + kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 317, __pyx_L3_error) + 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, 325, __pyx_L3_error) + 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 (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, used_pos_args, "__init__") < 0)) __PYX_ERR(1, 317, __pyx_L3_error) } + } else if (unlikely(__pyx_nargs < 1)) { + goto __pyx_L5_argtuple_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; - } + values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); } __pyx_v_condition = values[0]; - __pyx_v_predicate = values[1]; - __pyx_v_watermark = values[2]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 325, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 1, __pyx_nargs); __PYX_ERR(1, 317, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - __Pyx_AddTraceback("hunter._predicates.From.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(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_4From___init__(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_self), __pyx_v_condition, __pyx_v_predicate, __pyx_v_watermark); + __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 */ + __Pyx_DECREF(__pyx_v_actions); + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } __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 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 - __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)); - - /* "hunter/_predicates.pyx":326 +/* "hunter/_predicates.pyx":322 + * self.condition = condition + * self.actions = tuple( + * action() if isclass(action) and issubclass(action, Action) else action # <<<<<<<<<<<<<< + * for action in actions) * - * 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; - - /* "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":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":330 - * self.watermark = watermark - * self.origin_depth = -1 - * self.origin_calls = -1 # <<<<<<<<<<<<<< - * - * def __str__(self): - */ - __Pyx_TraceLine(330,0,__PYX_ERR(0, 330, __pyx_L1_error)) - __pyx_v_self->origin_calls = -1; - - /* "hunter/_predicates.pyx":325 - * """ - * - * def __init__(self, condition, predicate=None, watermark=0): # <<<<<<<<<<<<<< - * self.condition = condition - * self.predicate = predicate - */ - - /* 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_L0:; - __Pyx_TraceReturn(Py_None, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "hunter/_predicates.pyx":332 - * 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_3__str__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_4From_3__str__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; +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_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)); + 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_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(1, 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, 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(1, 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.__init__.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_pf_6hunter_11_predicates_4From_2__str__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self) { +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_TraceDeclarations - __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)); + 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; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("genexpr", 0); + __Pyx_TraceCall("genexpr", __pyx_f[1], 322, 0, __PYX_ERR(1, 322, __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(1, 322, __pyx_L1_error) - /* "hunter/_predicates.pyx":333 + /* "hunter/_predicates.pyx":323 + * self.actions = tuple( + * action() if isclass(action) and issubclass(action, Action) else action + * for action in actions) # <<<<<<<<<<<<<< * * 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); + __Pyx_TraceLine(323,0,__PYX_ERR(1, 323, __pyx_L1_error)) + if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(1, 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_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 323, __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(1, 323, __pyx_L1_error) + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 323, __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":334 - * def __str__(self): - * return 'From(%s, %s, watermark=%s)' % ( - * self.condition, self.predicate, self.watermark # <<<<<<<<<<<<<< - * ) + /* "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(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; + __Pyx_TraceLine(322,0,__PYX_ERR(1, 322, __pyx_L1_error)) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_isclass); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(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_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_cur_scope->__pyx_v_action}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(1, 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_n_s_Action); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 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(1, 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_INCREF(__pyx_cur_scope->__pyx_v_action); + __pyx_t_6 = __pyx_cur_scope->__pyx_v_action; __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(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_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 0+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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(1, 322, __pyx_L1_error) - /* "hunter/_predicates.pyx":333 + /* "hunter/_predicates.pyx":323 + * self.actions = tuple( + * action() if isclass(action) and issubclass(action, Action) else action + * for action in actions) # <<<<<<<<<<<<<< * * 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) - __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; + __Pyx_TraceLine(323,0,__PYX_ERR(1, 323, __pyx_L1_error)) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); - /* "hunter/_predicates.pyx":332 - * self.origin_calls = -1 + /* "hunter/_predicates.pyx":322 + * self.condition = condition + * self.actions = tuple( + * action() if isclass(action) and issubclass(action, Action) else action # <<<<<<<<<<<<<< + * for action in actions) * - * def __str__(self): # <<<<<<<<<<<<<< - * return 'From(%s, %s, watermark=%s)' % ( - * self.condition, self.predicate, self.watermark */ /* function exit code */ + PyErr_SetNone(PyExc_StopIteration); + goto __pyx_L0; __pyx_L1_error:; + __Pyx_Generator_Replace_StopIteration(0); __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("hunter._predicates.From.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __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_XGIVEREF(__pyx_r); + __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":337 - * ) +/* "hunter/_predicates.pyx":317 + * """ * - * def __repr__(self): # <<<<<<<<<<<<<< - * return '' % ( - * self.condition, self.predicate, self.watermark + * 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_4From_5__repr__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6hunter_11_predicates_4From_5__repr__(PyObject *__pyx_v_self) { - 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)); - - /* 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) { - PyObject *__pyx_r = NULL; +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_TraceDeclarations __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); + int __pyx_t_1; + 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_RefNannySetupContext("__init__", 1); + __Pyx_TraceCall("__init__", __pyx_f[1], 317, 0, __PYX_ERR(1, 317, __pyx_L1_error)); - /* "hunter/_predicates.pyx":339 - * def __repr__(self): - * return '' % ( - * self.condition, self.predicate, self.watermark # <<<<<<<<<<<<<< - * ) + /* "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(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; + __Pyx_TraceLine(318,0,__PYX_ERR(1, 318, __pyx_L1_error)) + __pyx_t_1 = (PyTuple_GET_SIZE(__pyx_v_actions) != 0); + __pyx_t_2 = (!__pyx_t_1); + if (unlikely(__pyx_t_2)) { - /* "hunter/_predicates.pyx":338 - * - * def __repr__(self): - * return '' % ( # <<<<<<<<<<<<<< - * self.condition, self.predicate, self.watermark - * ) + /* "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(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; - __pyx_t_1 = 0; - goto __pyx_L0; + __Pyx_TraceLine(319,0,__PYX_ERR(1, 319, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 319, __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(1, 319, __pyx_L1_error) - /* "hunter/_predicates.pyx":337 - * ) + /* "hunter/_predicates.pyx":318 * - * def __repr__(self): # <<<<<<<<<<<<<< - * return '' % ( - * self.condition, self.predicate, self.watermark + * def __init__(self, condition, *actions): + * if not actions: # <<<<<<<<<<<<<< + * raise TypeError('Must give at least one action.') + * self.condition = condition */ + } - /* 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_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "hunter/_predicates.pyx":342 - * ) - * - * def __eq__(self, other): # <<<<<<<<<<<<<< - * return ( - * isinstance(other, From) + /* "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,0,__PYX_ERR(1, 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; -/* 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) { - 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)); - - /* 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) { - 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], 342, 0, __PYX_ERR(0, 342, __pyx_L1_error)); - - /* "hunter/_predicates.pyx":343 + /* "hunter/_predicates.pyx":322 + * self.condition = condition + * self.actions = tuple( + * action() if isclass(action) and issubclass(action, Action) else action # <<<<<<<<<<<<<< + * for action in actions) * - * def __eq__(self, other): - * return ( # <<<<<<<<<<<<<< - * isinstance(other, From) - * and self.condition == ( other).condition - */ - __Pyx_TraceLine(343,0,__PYX_ERR(0, 343, __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_DECREF(__pyx_t_3); __pyx_t_3 = 0; - goto __pyx_L3_bool_binop_done; - } + __Pyx_TraceLine(322,0,__PYX_ERR(1, 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(1, 322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); - /* "hunter/_predicates.pyx":346 - * isinstance(other, From) - * and self.condition == ( other).condition - * and self.predicate == ( other).predicate # <<<<<<<<<<<<<< - * ) - * + /* "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(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_TraceLine(321,0,__PYX_ERR(1, 321, __pyx_L1_error)) + __pyx_t_4 = __Pyx_PySequence_Tuple(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 321, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); __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; + __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; - /* "hunter/_predicates.pyx":342 - * ) + /* "hunter/_predicates.pyx":317 + * """ * - * def __eq__(self, other): # <<<<<<<<<<<<<< - * return ( - * isinstance(other, From) + * def __init__(self, condition, *actions): # <<<<<<<<<<<<<< + * if not actions: + * raise TypeError('Must give at least one action.') */ /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("hunter._predicates.From.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("hunter._predicates.When.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_XDECREF(__pyx_gb_6hunter_11_predicates_4When_8__init___2generator1); + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":349 - * ) - * - * def __hash__(self): # <<<<<<<<<<<<<< - * return hash(('From', self.condition, self.predicate)) +/* "hunter/_predicates.pyx":325 + * for action in actions) * + * def __str__(self): # <<<<<<<<<<<<<< + * return 'When(%s, %s)' % ( + * self.condition, */ /* 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_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("__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("__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 */ -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 - __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)); - - /* "hunter/_predicates.pyx":350 - * - * def __hash__(self): - * return hash(('From', self.condition, self.predicate)) # <<<<<<<<<<<<<< - * - * 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; - goto __pyx_L0; - - /* "hunter/_predicates.pyx":349 +/* "hunter/_predicates.pyx":328 + * return 'When(%s, %s)' % ( + * self.condition, + * ', '.join(repr(p) for p in self.actions) # <<<<<<<<<<<<<< * ) * - * def __hash__(self): # <<<<<<<<<<<<<< - * return hash(('From', self.condition, self.predicate)) - * */ +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_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_3_genexpr *)__pyx_tp_new_6hunter_11_predicates___pyx_scope_struct_3_genexpr(__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_3_genexpr, __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(1, 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, 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(1, 328, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + /* 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_L0:; - if (unlikely(__pyx_r == -1) && !PyErr_Occurred()) __pyx_r = -2; - __Pyx_TraceReturn(Py_None, 0); + __Pyx_AddTraceback("hunter._predicates.When.__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":352 - * return hash(('From', self.condition, self.predicate)) - * - * def __call__(self, Event event): # <<<<<<<<<<<<<< - * return fast_From_call(self, event) - * - */ - -/* 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; - 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); +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_TraceDeclarations + 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); + __Pyx_TraceCall("genexpr", __pyx_f[1], 328, 0, __PYX_ERR(1, 328, __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(1, 328, __pyx_L1_error) + if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(1, 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(1, 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_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 328, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; } - __pyx_v_event = ((struct __pyx_obj_6hunter_6_event_Event *)values[0]); + #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(1, 328, __pyx_L1_error) + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 328, __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 = PyObject_Repr(__pyx_cur_scope->__pyx_v_p); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 328, __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(1, 328, __pyx_L1_error) } - 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_DECREF(__pyx_t_1); __pyx_t_1 = 0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* function exit code */ + PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; - __pyx_r = NULL; + __Pyx_Generator_Replace_StopIteration(0); + __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; } -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) { +/* "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_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)); + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__str__", 1); + __Pyx_TraceCall("__str__", __pyx_f[1], 325, 0, __PYX_ERR(1, 325, __pyx_L1_error)); - /* "hunter/_predicates.pyx":353 - * - * def __call__(self, Event event): - * return fast_From_call(self, event) # <<<<<<<<<<<<<< + /* "hunter/_predicates.pyx":326 * - * def __or__(self, other): + * def __str__(self): + * return 'When(%s, %s)' % ( # <<<<<<<<<<<<<< + * self.condition, + * ', '.join(repr(p) for p in self.actions) */ - __Pyx_TraceLine(353,0,__PYX_ERR(0, 353, __pyx_L1_error)) + __Pyx_TraceLine(326,0,__PYX_ERR(1, 326, __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; - 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) + /* "hunter/_predicates.pyx":328 + * return 'When(%s, %s)' % ( + * self.condition, + * ', '.join(repr(p) for p in self.actions) # <<<<<<<<<<<<<< + * ) * */ + __Pyx_TraceLine(328,0,__PYX_ERR(1, 328, __pyx_L1_error)) + __pyx_t_1 = __pyx_pf_6hunter_11_predicates_4When_7__str___genexpr(NULL, __pyx_v_self->actions); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 328, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyString_Join(__pyx_kp_s__8, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 328, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __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_RefNannyFinishContext(); - return __pyx_r; -} - -/* "hunter/_predicates.pyx":355 - * return fast_From_call(self, event) - * - * def __or__(self, other): # <<<<<<<<<<<<<< - * return Or(self, other) - * + /* "hunter/_predicates.pyx":327 + * def __str__(self): + * return 'When(%s, %s)' % ( + * self.condition, # <<<<<<<<<<<<<< + * ', '.join(repr(p) for p in self.actions) + * ) */ + __Pyx_TraceLine(327,0,__PYX_ERR(1, 327, __pyx_L1_error)) + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 327, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_self->condition); + __Pyx_GIVEREF(__pyx_v_self->condition); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->condition)) __PYX_ERR(1, 327, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_2)) __PYX_ERR(1, 327, __pyx_L1_error); + __pyx_t_2 = 0; -/* 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) { - 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)); - - /* 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) { - 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], 355, 0, __PYX_ERR(0, 355, __pyx_L1_error)); - - /* "hunter/_predicates.pyx":356 - * - * def __or__(self, other): - * return Or(self, other) # <<<<<<<<<<<<<< + /* "hunter/_predicates.pyx":326 * - * def __and__(self, other): + * def __str__(self): + * return 'When(%s, %s)' % ( # <<<<<<<<<<<<<< + * self.condition, + * ', '.join(repr(p) for p in self.actions) */ - __Pyx_TraceLine(356,0,__PYX_ERR(0, 356, __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_TraceLine(326,0,__PYX_ERR(1, 326, __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(1, 326, __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; - /* "hunter/_predicates.pyx":355 - * return fast_From_call(self, event) - * - * def __or__(self, other): # <<<<<<<<<<<<<< - * return Or(self, other) + /* "hunter/_predicates.pyx":325 + * 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.From.__or__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __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_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":358 - * return Or(self, other) +/* "hunter/_predicates.pyx":331 + * ) * - * def __and__(self, other): # <<<<<<<<<<<<<< - * return And(self, other) + * def __repr__(self): # <<<<<<<<<<<<<< + * return '' % (self.condition, self.actions) * */ /* 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_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("__and__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_4From_14__and__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + __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)); /* 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_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("__and__", 0); - __Pyx_TraceCall("__and__", __pyx_f[0], 358, 0, __PYX_ERR(0, 358, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__repr__", 1); + __Pyx_TraceCall("__repr__", __pyx_f[1], 331, 0, __PYX_ERR(1, 331, __pyx_L1_error)); - /* "hunter/_predicates.pyx":359 + /* "hunter/_predicates.pyx":332 * - * def __and__(self, other): - * return And(self, other) # <<<<<<<<<<<<<< + * def __repr__(self): + * return '' % (self.condition, self.actions) # <<<<<<<<<<<<<< * - * def __invert__(self): + * def __eq__(self, other): */ - __Pyx_TraceLine(359,0,__PYX_ERR(0, 359, __pyx_L1_error)) + __Pyx_TraceLine(332,0,__PYX_ERR(1, 332, __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) + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 332, __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_INCREF(__pyx_v_self->condition); + __Pyx_GIVEREF(__pyx_v_self->condition); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->condition)) __PYX_ERR(1, 332, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->actions); + __Pyx_GIVEREF(__pyx_v_self->actions); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->actions)) __PYX_ERR(1, 332, __pyx_L1_error); + __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_hunter__predicates_When_conditi, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 332, __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; - /* "hunter/_predicates.pyx":358 - * return Or(self, other) + /* "hunter/_predicates.pyx":331 + * ) * - * def __and__(self, other): # <<<<<<<<<<<<<< - * return And(self, other) + * def __repr__(self): # <<<<<<<<<<<<<< + * return '' % (self.condition, self.actions) * */ @@ -10871,7 +12980,7 @@ static PyObject *__pyx_pf_6hunter_11_predicates_4From_14__and__(PyObject *__pyx_ __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_AddTraceback("hunter._predicates.When.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -10880,62 +12989,119 @@ static PyObject *__pyx_pf_6hunter_11_predicates_4From_14__and__(PyObject *__pyx_ return __pyx_r; } -/* "hunter/_predicates.pyx":361 - * return And(self, other) - * - * def __invert__(self): # <<<<<<<<<<<<<< - * return Not(self) +/* "hunter/_predicates.pyx":334 + * return '' % (self.condition, self.actions) * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return ( + * isinstance(other, When) */ /* 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) { +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("__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("__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 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_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; - __Pyx_RefNannySetupContext("__invert__", 0); - __Pyx_TraceCall("__invert__", __pyx_f[0], 361, 0, __PYX_ERR(0, 361, __pyx_L1_error)); + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__eq__", 1); + __Pyx_TraceCall("__eq__", __pyx_f[1], 334, 0, __PYX_ERR(1, 334, __pyx_L1_error)); - /* "hunter/_predicates.pyx":362 - * - * def __invert__(self): - * return Not(self) # <<<<<<<<<<<<<< + /* "hunter/_predicates.pyx":335 * - * cdef inline fast_From_call(From self, Event event): + * def __eq__(self, other): + * return ( # <<<<<<<<<<<<<< + * isinstance(other, When) + * and self.condition == ( other).condition */ - __Pyx_TraceLine(362,0,__PYX_ERR(0, 362, __pyx_L1_error)) + __Pyx_TraceLine(335,0,__PYX_ERR(1, 335, __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) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - /* "hunter/_predicates.pyx":361 - * return And(self, other) + /* "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,0,__PYX_ERR(1, 336, __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(1, 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":337 + * return ( + * isinstance(other, When) + * and self.condition == ( other).condition # <<<<<<<<<<<<<< + * and self.actions == ( other).actions + * ) + */ + __Pyx_TraceLine(337,0,__PYX_ERR(1, 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(1, 337, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 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":338 + * isinstance(other, When) + * and self.condition == ( other).condition + * and self.actions == ( other).actions # <<<<<<<<<<<<<< + * ) * - * def __invert__(self): # <<<<<<<<<<<<<< - * return Not(self) + */ + __Pyx_TraceLine(338,0,__PYX_ERR(1, 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(1, 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; + goto __pyx_L0; + + /* "hunter/_predicates.pyx":334 + * 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_AddTraceback("hunter._predicates.From.__invert__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __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); @@ -10944,41 +13110,136 @@ static PyObject *__pyx_pf_6hunter_11_predicates_4From_16__invert__(struct __pyx_ return __pyx_r; } -/* "hunter/_predicates.pxd":45 - * cdef class From: - * cdef: - * readonly object condition # <<<<<<<<<<<<<< - * readonly object predicate - * readonly int watermark +/* "hunter/_predicates.pyx":341 + * ) + * + * def __call__(self, Event event): # <<<<<<<<<<<<<< + * return fast_When_call(self, event) + * */ /* 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) { +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("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_4From_9condition___get__(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__call__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __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 **__pyx_pyargnames[] = {&__pyx_n_s_event,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_event)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 341, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__call__") < 0)) __PYX_ERR(1, 341, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + } + __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(1, 341, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(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_ptype_6hunter_6_event_Event, 1, "event", 0))) __PYX_ERR(1, 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; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_4From_9condition___get__(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_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 45, 0, __PYX_ERR(1, 45, __pyx_L1_error)); + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__call__", 1); + __Pyx_TraceCall("__call__", __pyx_f[1], 341, 0, __PYX_ERR(1, 341, __pyx_L1_error)); + + /* "hunter/_predicates.pyx":342 + * + * def __call__(self, Event event): + * return fast_When_call(self, event) # <<<<<<<<<<<<<< + * + * def __or__(self, other): + */ + __Pyx_TraceLine(342,0,__PYX_ERR(1, 342, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->condition); - __pyx_r = __pyx_v_self->condition; + __pyx_t_1 = __pyx_f_6hunter_11_predicates_fast_When_call(__pyx_v_self, __pyx_v_event); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 342, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; goto __pyx_L0; + /* "hunter/_predicates.pyx":341 + * ) + * + * def __call__(self, Event event): # <<<<<<<<<<<<<< + * return fast_When_call(self, event) + * + */ + /* function exit code */ __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.From.condition.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __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); @@ -10987,41 +13248,78 @@ static PyObject *__pyx_pf_6hunter_11_predicates_4From_9condition___get__(struct return __pyx_r; } -/* "hunter/_predicates.pxd":46 - * cdef: - * readonly object condition - * readonly object predicate # <<<<<<<<<<<<<< - * readonly int watermark - * readonly int origin_depth +/* "hunter/_predicates.pyx":344 + * return fast_When_call(self, event) + * + * def __or__(self, other): # <<<<<<<<<<<<<< + * return Or(self, other) + * */ /* 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) { +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("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_4From_9predicate___get__(((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_9predicate___get__(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_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 46, 0, __PYX_ERR(1, 46, __pyx_L1_error)); + 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("__or__", 1); + __Pyx_TraceCall("__or__", __pyx_f[1], 344, 0, __PYX_ERR(1, 344, __pyx_L1_error)); + + /* "hunter/_predicates.pyx":345 + * + * def __or__(self, other): + * return Or(self, other) # <<<<<<<<<<<<<< + * + * def __and__(self, other): + */ + __Pyx_TraceLine(345,0,__PYX_ERR(1, 345, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->predicate); - __pyx_r = __pyx_v_self->predicate; + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 345, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_self); + __Pyx_GIVEREF(__pyx_v_self); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self)) __PYX_ERR(1, 345, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_other); + __Pyx_GIVEREF(__pyx_v_other); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_other)) __PYX_ERR(1, 345, __pyx_L1_error); + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_Or), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 345, __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; + /* "hunter/_predicates.pyx":344 + * return fast_When_call(self, event) + * + * def __or__(self, other): # <<<<<<<<<<<<<< + * return Or(self, other) + * + */ + /* function exit code */ __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.From.predicate.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __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); @@ -11030,45 +13328,78 @@ static PyObject *__pyx_pf_6hunter_11_predicates_4From_9predicate___get__(struct 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":347 + * return Or(self, other) + * + * def __and__(self, other): # <<<<<<<<<<<<<< + * return And(self, other) + * */ /* 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) { +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("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_4From_9watermark___get__(((struct __pyx_obj_6hunter_11_predicates_From *)__pyx_v_self)); + __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_9watermark___get__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self) { +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_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)); + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__and__", 1); + __Pyx_TraceCall("__and__", __pyx_f[1], 347, 0, __PYX_ERR(1, 347, __pyx_L1_error)); + + /* "hunter/_predicates.pyx":348 + * + * def __and__(self, other): + * return And(self, other) # <<<<<<<<<<<<<< + * + * def __invert__(self): + */ + __Pyx_TraceLine(348,0,__PYX_ERR(1, 348, __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_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 348, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; + __Pyx_INCREF(__pyx_v_self); + __Pyx_GIVEREF(__pyx_v_self); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self)) __PYX_ERR(1, 348, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_other); + __Pyx_GIVEREF(__pyx_v_other); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_other)) __PYX_ERR(1, 348, __pyx_L1_error); + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_And), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 348, __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; + /* "hunter/_predicates.pyx":347 + * return Or(self, other) + * + * def __and__(self, other): # <<<<<<<<<<<<<< + * return And(self, other) + * + */ + /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.From.watermark.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __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); @@ -11077,45 +13408,67 @@ static PyObject *__pyx_pf_6hunter_11_predicates_4From_9watermark___get__(struct return __pyx_r; } -/* "hunter/_predicates.pxd":48 - * readonly object predicate - * readonly int watermark - * readonly int origin_depth # <<<<<<<<<<<<<< - * readonly int origin_calls +/* "hunter/_predicates.pyx":350 + * return And(self, other) + * + * def __invert__(self): # <<<<<<<<<<<<<< + * return Not(self) * */ /* 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_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("__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("__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 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_4When_14__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("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 48, 0, __PYX_ERR(1, 48, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__invert__", 1); + __Pyx_TraceCall("__invert__", __pyx_f[1], 350, 0, __PYX_ERR(1, 350, __pyx_L1_error)); + + /* "hunter/_predicates.pyx":351 + * + * def __invert__(self): + * return Not(self) # <<<<<<<<<<<<<< + * + * cdef inline fast_When_call(When self, Event event): + */ + __Pyx_TraceLine(351,0,__PYX_ERR(1, 351, __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) + __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_6hunter_11_predicates_Not), ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 351, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; + /* "hunter/_predicates.pyx":350 + * return And(self, other) + * + * def __invert__(self): # <<<<<<<<<<<<<< + * return Not(self) + * + */ + /* 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_AddTraceback("hunter._predicates.When.__invert__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -11124,45 +13477,94 @@ static PyObject *__pyx_pf_6hunter_11_predicates_4From_12origin_depth___get__(str return __pyx_r; } -/* "hunter/_predicates.pxd":49 - * readonly int watermark - * readonly int origin_depth - * readonly int origin_calls # <<<<<<<<<<<<<< +/* "hunter/_predicates.pxd":43 + * cdef class When: + * cdef: + * readonly object condition # <<<<<<<<<<<<<< + * readonly tuple actions * - * cdef fast_And_call(And self, Event event) */ /* 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_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("__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_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 */ __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_4When_9condition___get__(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("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 49, 0, __PYX_ERR(1, 49, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[2], 43, 0, __PYX_ERR(2, 43, __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) - __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; goto __pyx_L0; /* 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_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_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/_predicates.pxd":44 + * cdef: + * readonly object condition + * readonly tuple actions # <<<<<<<<<<<<<< + * + * + */ + +/* 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) { + 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_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_4When_7actions___get__(struct __pyx_obj_6hunter_11_predicates_When *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[2], 44, 0, __PYX_ERR(2, 44, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->actions); + __pyx_r = __pyx_v_self->actions; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("hunter._predicates.When.actions.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -11178,19 +13580,47 @@ static PyObject *__pyx_pf_6hunter_11_predicates_4From_12origin_calls___get__(str */ /* 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_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*)(__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("__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)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __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;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) 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_18__reduce_cython__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self) { +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; @@ -11198,73 +13628,59 @@ static PyObject *__pyx_pf_6hunter_11_predicates_4From_18__reduce_cython__(struct __Pyx_TraceDeclarations __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)); + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__14) + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + __Pyx_TraceCall("__reduce_cython__", __pyx_f[0], 1, 0, __PYX_ERR(0, 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) # <<<<<<<<<<<<<< + * 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 = __Pyx_PyInt_From_int(__pyx_v_self->origin_calls); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5, __pyx_L1_error) + __Pyx_TraceLine(5,0,__PYX_ERR(0, 5, __pyx_L1_error)) + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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->actions); + __Pyx_GIVEREF(__pyx_v_self->actions); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->actions)) __PYX_ERR(0, 5, __pyx_L1_error); __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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->condition)) __PYX_ERR(0, 5, __pyx_L1_error); + __pyx_v_state = ((PyObject*)__pyx_t_1); __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) + * 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_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; + __Pyx_TraceLine(6,0,__PYX_ERR(0, 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(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; /* "(tree fragment)":7 - * state = (self.condition, self.origin_calls, self.origin_depth, self.predicate, self.watermark) + * 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_5 = (__pyx_v__dict != Py_None); - __pyx_t_6 = (__pyx_t_5 != 0); - if (__pyx_t_6) { + __Pyx_TraceLine(7,0,__PYX_ERR(0, 7, __pyx_L1_error)) + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { /* "(tree fragment)":8 * _dict = getattr(self, '__dict__', None) @@ -11273,15 +13689,15 @@ static PyObject *__pyx_pf_6hunter_11_predicates_4From_18__reduce_cython__(struct * 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_TraceLine(8,0,__PYX_ERR(0, 8, __pyx_L1_error)) + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); __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) + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(0, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); __pyx_t_3 = 0; @@ -11290,13 +13706,13 @@ static PyObject *__pyx_pf_6hunter_11_predicates_4From_18__reduce_cython__(struct * state += (_dict,) * use_setstate = True # <<<<<<<<<<<<<< * else: - * use_setstate = self.condition is not None or self.predicate is not None + * 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_TraceLine(9,0,__PYX_ERR(0, 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) + * state = (self.actions, self.condition) * _dict = getattr(self, '__dict__', None) * if _dict is not None: # <<<<<<<<<<<<<< * state += (_dict,) @@ -11308,115 +13724,112 @@ static PyObject *__pyx_pf_6hunter_11_predicates_4From_18__reduce_cython__(struct /* "(tree fragment)":11 * use_setstate = True * else: - * use_setstate = self.condition is not None or self.predicate is not None # <<<<<<<<<<<<<< + * use_setstate = self.actions is not None or self.condition is not None # <<<<<<<<<<<<<< * if use_setstate: - * return __pyx_unpickle_From, (type(self), 0x1acd5f7, None), state + * return __pyx_unpickle_When, (type(self), 0xe710366, None), state */ - __Pyx_TraceLine(11,0,__PYX_ERR(2, 11, __pyx_L1_error)) + __Pyx_TraceLine(11,0,__PYX_ERR(0, 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) { + __pyx_t_4 = (__pyx_v_self->actions != ((PyObject*)Py_None)); + if (!__pyx_t_4) { } else { - __pyx_t_6 = __pyx_t_7; + __pyx_t_2 = __pyx_t_4; 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_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_6; + __pyx_v_use_setstate = __pyx_t_2; } __pyx_L3:; /* "(tree fragment)":12 * else: - * use_setstate = self.condition is not None or self.predicate is not None + * use_setstate = self.actions is not None or self.condition is not None * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_From, (type(self), 0x1acd5f7, None), state + * return __pyx_unpickle_When, (type(self), 0xe710366, 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) { + __Pyx_TraceLine(12,0,__PYX_ERR(0, 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 + * use_setstate = self.actions is not None or self.condition is not None * if use_setstate: - * return __pyx_unpickle_From, (type(self), 0x1acd5f7, None), state # <<<<<<<<<<<<<< + * return __pyx_unpickle_When, (type(self), 0xe710366, None), state # <<<<<<<<<<<<<< * else: - * return __pyx_unpickle_From, (type(self), 0x1acd5f7, state) + * return __pyx_unpickle_When, (type(self), 0xe710366, state) */ - __Pyx_TraceLine(13,0,__PYX_ERR(2, 13, __pyx_L1_error)) + __Pyx_TraceLine(13,0,__PYX_ERR(0, 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_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_When); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 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_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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_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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(0, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_242287462); + __Pyx_GIVEREF(__pyx_int_242287462); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_242287462)) __PYX_ERR(0, 13, __pyx_L1_error); __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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(0, 13, __pyx_L1_error); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); __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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(0, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); - PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state)) __PYX_ERR(0, 13, __pyx_L1_error); __pyx_t_3 = 0; - __pyx_t_4 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; goto __pyx_L0; /* "(tree fragment)":12 * else: - * use_setstate = self.condition is not None or self.predicate is not None + * use_setstate = self.actions is not None or self.condition is not None * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_From, (type(self), 0x1acd5f7, None), state + * return __pyx_unpickle_When, (type(self), 0xe710366, None), state * else: */ } /* "(tree fragment)":15 - * return __pyx_unpickle_From, (type(self), 0x1acd5f7, None), state + * return __pyx_unpickle_When, (type(self), 0xe710366, None), state * else: - * return __pyx_unpickle_From, (type(self), 0x1acd5f7, state) # <<<<<<<<<<<<<< + * return __pyx_unpickle_When, (type(self), 0xe710366, state) # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_From__set_state(self, __pyx_state) + * __pyx_unpickle_When__set_state(self, __pyx_state) */ - __Pyx_TraceLine(15,0,__PYX_ERR(2, 15, __pyx_L1_error)) + __Pyx_TraceLine(15,0,__PYX_ERR(0, 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_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_When); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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_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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(0, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_242287462); + __Pyx_GIVEREF(__pyx_int_242287462); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_242287462)) __PYX_ERR(0, 15, __pyx_L1_error); __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) + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(0, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 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_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5)) __PYX_ERR(0, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(0, 15, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_1 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; @@ -11431,10 +13844,9 @@ static PyObject *__pyx_pf_6hunter_11_predicates_4From_18__reduce_cython__(struct /* 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_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("hunter._predicates.When.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_state); @@ -11447,48 +13859,135 @@ static PyObject *__pyx_pf_6hunter_11_predicates_4From_18__reduce_cython__(struct /* "(tree fragment)":16 * else: - * return __pyx_unpickle_From, (type(self), 0x1acd5f7, state) + * return __pyx_unpickle_When, (type(self), 0xe710366, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle_From__set_state(self, __pyx_state) + * __pyx_unpickle_When__set_state(self, __pyx_state) */ /* 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_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*)(__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("__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)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __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 **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __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(0, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(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 */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __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) { +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_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(__pyx_codeobj__15) + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + __Pyx_TraceCall("__setstate_cython__", __pyx_f[0], 16, 0, __PYX_ERR(0, 16, __pyx_L1_error)); /* "(tree fragment)":17 - * return __pyx_unpickle_From, (type(self), 0x1acd5f7, state) + * return __pyx_unpickle_When, (type(self), 0xe710366, state) * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_From__set_state(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_From__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 17, __pyx_L1_error) + __Pyx_TraceLine(17,0,__PYX_ERR(0, 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(0, 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(0, 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) + * return __pyx_unpickle_When, (type(self), 0xe710366, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle_From__set_state(self, __pyx_state) + * __pyx_unpickle_When__set_state(self, __pyx_state) */ /* function exit code */ @@ -11496,7 +13995,7 @@ static PyObject *__pyx_pf_6hunter_11_predicates_4From_20__setstate_cython__(stru goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.From.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("hunter._predicates.When.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -11505,373 +14004,382 @@ static PyObject *__pyx_pf_6hunter_11_predicates_4From_20__setstate_cython__(stru return __pyx_r; } -/* "hunter/_predicates.pyx":364 +/* "hunter/_predicates.pyx":353 * return Not(self) * - * cdef inline fast_From_call(From self, Event event): # <<<<<<<<<<<<<< + * cdef inline fast_When_call(When self, Event event): # <<<<<<<<<<<<<< * cdef object result - * cdef int delta_depth + * */ -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) { +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; - int __pyx_v_delta_depth; - int __pyx_v_delta_calls; - struct __pyx_obj_6hunter_6_event_Event *__pyx_v_relative_event = NULL; + PyObject *__pyx_v_action = NULL; PyObject *__pyx_r = NULL; __Pyx_TraceDeclarations __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)); + int __pyx_t_3; + Py_ssize_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("fast_When_call", 1); + __Pyx_TraceCall("fast_When_call", __pyx_f[1], 353, 0, __PYX_ERR(1, 353, __pyx_L1_error)); - /* "hunter/_predicates.pyx":369 - * cdef int delta_calls + /* "hunter/_predicates.pyx":356 + * cdef object result * - * if self.origin_depth == -1: # <<<<<<<<<<<<<< - * result = fast_call(self.condition, event) + * result = fast_call(self.condition, event) # <<<<<<<<<<<<<< * + * if result: */ - __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) { + __Pyx_TraceLine(356,0,__PYX_ERR(1, 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(1, 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; - /* "hunter/_predicates.pyx":370 - * - * if self.origin_depth == -1: - * result = fast_call(self.condition, event) # <<<<<<<<<<<<<< + /* "hunter/_predicates.pyx":358 + * result = fast_call(self.condition, event) * - * 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 + * if result: # <<<<<<<<<<<<<< + * for action in self.actions: + * action(event) */ - __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) { + __Pyx_TraceLine(358,0,__PYX_ERR(1, 358, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_result); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 358, __pyx_L1_error) + if (__pyx_t_3) { - /* "hunter/_predicates.pyx":373 + /* "hunter/_predicates.pyx":359 * - * 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; - - /* "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; - - /* "hunter/_predicates.pyx":372 - * result = fast_call(self.condition, event) + * if result: + * for action in self.actions: # <<<<<<<<<<<<<< + * action(event) * - * if result: # <<<<<<<<<<<<<< - * self.origin_depth = event.depth - * self.origin_calls = event.calls - */ - goto __pyx_L4; - } - - /* "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_TraceLine(359,0,__PYX_ERR(1, 359, __pyx_L1_error)) + if (unlikely(__pyx_v_self->actions == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(1, 359, __pyx_L1_error) } - __pyx_L4:; + __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_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 359, __pyx_L1_error) + #endif + if (__pyx_t_4 >= __pyx_temp) 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(1, 359, __pyx_L1_error) + #else + __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 359, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + __Pyx_XDECREF_SET(__pyx_v_action, __pyx_t_1); + __pyx_t_1 = 0; - /* "hunter/_predicates.pyx":369 - * cdef int delta_calls - * - * if self.origin_depth == -1: # <<<<<<<<<<<<<< - * result = fast_call(self.condition, event) + /* "hunter/_predicates.pyx":360 + * if result: + * for action in self.actions: + * action(event) # <<<<<<<<<<<<<< * + * return result */ - goto __pyx_L3; - } - - /* "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) { + __Pyx_TraceLine(360,0,__PYX_ERR(1, 360, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_action); + __pyx_t_5 = __pyx_v_action; __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (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_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, ((PyObject *)__pyx_v_event)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 360, __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; - /* "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":359 * - */ - __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 # <<<<<<<<<<<<<< + * if result: + * for action in self.actions: # <<<<<<<<<<<<<< + * action(event) * - * 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_TraceLine(359,0,__PYX_ERR(1, 359, __pyx_L1_error)) } - } - __pyx_L3:; - - /* "hunter/_predicates.pyx":385 - * return False - * - * 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 - * - * 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; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "hunter/_predicates.pyx":385 - * return False + /* "hunter/_predicates.pyx":358 + * result = fast_call(self.condition, event) * - * if self.predicate is None: # <<<<<<<<<<<<<< - * return True - * else: + * if result: # <<<<<<<<<<<<<< + * for action in self.actions: + * action(event) */ } - /* "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; - - /* "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; - - /* "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":362 + * action(event) + * + * return result # <<<<<<<<<<<<<< * - */ - __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) # <<<<<<<<<<<<<< * - * @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); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - } + __Pyx_TraceLine(362,0,__PYX_ERR(1, 362, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; - /* "hunter/_predicates.pyx":364 + /* "hunter/_predicates.pyx":353 * return Not(self) * - * cdef inline fast_From_call(From self, Event event): # <<<<<<<<<<<<<< + * cdef inline fast_When_call(When 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_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_L0:; __Pyx_XDECREF(__pyx_v_result); - __Pyx_XDECREF((PyObject *)__pyx_v_relative_event); + __Pyx_XDECREF(__pyx_v_action); __Pyx_XGIVEREF(__pyx_r); __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":398 - * `And` predicate. Exits at the first sub-predicate that returns ``False``. +/* "hunter/_predicates.pyx":371 * """ - * def __init__(self, *predicates): # <<<<<<<<<<<<<< - * self.predicates = predicates * + * def __init__(self, condition, predicate=None, watermark=0): # <<<<<<<<<<<<<< + * self.condition = condition + * self.predicate = predicate */ /* 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; +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("__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); + #if CYTHON_ASSUME_SAFE_MACROS + __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 **__pyx_pyargnames[] = {&__pyx_n_s_condition,&__pyx_n_s_predicate,&__pyx_n_s_watermark,0}; + values[1] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)Py_None)); + values[2] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)__pyx_int_0)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_condition)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 371, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_predicate); + if (value) { values[1] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 371, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_watermark); + if (value) { values[2] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 371, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(1, 371, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_VARARGS(__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_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 3, __pyx_nargs); __PYX_ERR(1, 371, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(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 */ - __Pyx_XDECREF(__pyx_v_predicates); + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } __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) { +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 __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__init__", 0); - __Pyx_TraceCall("__init__", __pyx_f[0], 398, 0, __PYX_ERR(0, 398, __pyx_L1_error)); + int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 1); + __Pyx_TraceCall("__init__", __pyx_f[1], 371, 0, __PYX_ERR(1, 371, __pyx_L1_error)); - /* "hunter/_predicates.pyx":399 - * """ - * def __init__(self, *predicates): - * self.predicates = predicates # <<<<<<<<<<<<<< + /* "hunter/_predicates.pyx":372 + * + * def __init__(self, condition, predicate=None, watermark=0): + * self.condition = condition # <<<<<<<<<<<<<< + * self.predicate = predicate + * self.watermark = watermark + */ + __Pyx_TraceLine(372,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 374, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_watermark); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 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,0,__PYX_ERR(1, 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(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; + __Pyx_TraceLine(376,0,__PYX_ERR(1, 376, __pyx_L1_error)) + __pyx_v_self->origin_calls = -1; - /* "hunter/_predicates.pyx":398 - * `And` predicate. Exits at the first sub-predicate that returns ``False``. + /* "hunter/_predicates.pyx":371 * """ - * def __init__(self, *predicates): # <<<<<<<<<<<<<< - * self.predicates = predicates * + * def __init__(self, condition, predicate=None, watermark=0): # <<<<<<<<<<<<<< + * self.condition = condition + * self.predicate = predicate */ /* 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_AddTraceback("hunter._predicates.From.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_TraceReturn(Py_None, 0); @@ -11879,287 +14387,204 @@ static int __pyx_pf_6hunter_11_predicates_3And___init__(struct __pyx_obj_6hunter return __pyx_r; } -/* "hunter/_predicates.pyx":401 - * self.predicates = predicates +/* "hunter/_predicates.pyx":378 + * self.origin_calls = -1 * * def __str__(self): # <<<<<<<<<<<<<< - * return 'And(%s)' % ', '.join(str(p) for p in self.predicates) - * + * return 'From(%s, %s, watermark=%s)' % ( + * self.condition, self.predicate, self.watermark */ /* 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_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("__str__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_3And_2__str__(((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v_self)); + __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_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 +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_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_RefNannySetupContext("__str__", 1); + __Pyx_TraceCall("__str__", __pyx_f[1], 378, 0, __PYX_ERR(1, 378, __pyx_L1_error)); + + /* "hunter/_predicates.pyx":379 * * def __str__(self): - * return 'And(%s)' % ', '.join(str(p) for p in self.predicates) # <<<<<<<<<<<<<< + * return 'From(%s, %s, watermark=%s)' % ( # <<<<<<<<<<<<<< + * self.condition, self.predicate, self.watermark + * ) + */ + __Pyx_TraceLine(379,0,__PYX_ERR(1, 379, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + + /* "hunter/_predicates.pyx":380 + * def __str__(self): + * return 'From(%s, %s, watermark=%s)' % ( + * self.condition, self.predicate, self.watermark # <<<<<<<<<<<<<< + * ) * - * def __repr__(self): */ + __Pyx_TraceLine(380,0,__PYX_ERR(1, 380, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->watermark); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 380, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 380, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_self->condition); + __Pyx_GIVEREF(__pyx_v_self->condition); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_self->condition)) __PYX_ERR(1, 380, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->predicate); + __Pyx_GIVEREF(__pyx_v_self->predicate); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_self->predicate)) __PYX_ERR(1, 380, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_1)) __PYX_ERR(1, 380, __pyx_L1_error); + __pyx_t_1 = 0; -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; - PyObject *__pyx_r = NULL; - __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; - } + /* "hunter/_predicates.pyx":379 + * + * def __str__(self): + * return 'From(%s, %s, watermark=%s)' % ( # <<<<<<<<<<<<<< + * self.condition, self.predicate, self.watermark + * ) + */ + __Pyx_TraceLine(379,0,__PYX_ERR(1, 379, __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(1, 379, __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":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_AddTraceback("hunter._predicates.And.__str__.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("hunter._predicates.From.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; - __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 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); - - /* 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; +/* "hunter/_predicates.pyx":383 + * ) + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return '' % ( + * self.condition, self.predicate, self.watermark + */ + +/* 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) { + 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_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_4__repr__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self) { 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_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); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__repr__", 1); + __Pyx_TraceCall("__repr__", __pyx_f[1], 383, 0, __PYX_ERR(1, 383, __pyx_L1_error)); - /* "hunter/_predicates.pyx":402 - * - * def __str__(self): - * return 'And(%s)' % ', '.join(str(p) for p in self.predicates) # <<<<<<<<<<<<<< + /* "hunter/_predicates.pyx":384 * * def __repr__(self): + * return '' % ( # <<<<<<<<<<<<<< + * self.condition, self.predicate, self.watermark + * ) */ - __Pyx_TraceLine(402,0,__PYX_ERR(0, 402, __pyx_L1_error)) + __Pyx_TraceLine(384,0,__PYX_ERR(1, 384, __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_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":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_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":404 - * return 'And(%s)' % ', '.join(str(p) for p in self.predicates) - * - * def __repr__(self): # <<<<<<<<<<<<<< - * return '' % (self.predicates,) + /* "hunter/_predicates.pyx":385 + * def __repr__(self): + * return '' % ( + * self.condition, self.predicate, self.watermark # <<<<<<<<<<<<<< + * ) * */ + __Pyx_TraceLine(385,0,__PYX_ERR(1, 385, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->watermark); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 385, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 385, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_self->condition); + __Pyx_GIVEREF(__pyx_v_self->condition); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_self->condition)) __PYX_ERR(1, 385, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->predicate); + __Pyx_GIVEREF(__pyx_v_self->predicate); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_self->predicate)) __PYX_ERR(1, 385, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_1)) __PYX_ERR(1, 385, __pyx_L1_error); + __pyx_t_1 = 0; -/* 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) { - 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)); - - /* 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) { - 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], 404, 0, __PYX_ERR(0, 404, __pyx_L1_error)); - - /* "hunter/_predicates.pyx":405 + /* "hunter/_predicates.pyx":384 * * def __repr__(self): - * return '' % (self.predicates,) # <<<<<<<<<<<<<< - * - * def __eq__(self, other): + * return '' % ( # <<<<<<<<<<<<<< + * self.condition, self.predicate, self.watermark + * ) */ - __Pyx_TraceLine(405,0,__PYX_ERR(0, 405, __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_TraceLine(384,0,__PYX_ERR(1, 384, __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(1, 384, __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_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; goto __pyx_L0; - /* "hunter/_predicates.pyx":404 - * return 'And(%s)' % ', '.join(str(p) for p in self.predicates) + /* "hunter/_predicates.pyx":383 + * ) * * def __repr__(self): # <<<<<<<<<<<<<< - * return '' % (self.predicates,) - * + * return '' % ( + * self.condition, self.predicate, self.watermark */ /* 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_AddTraceback("hunter._predicates.From.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -12168,74 +14593,98 @@ static PyObject *__pyx_pf_6hunter_11_predicates_3And_4__repr__(struct __pyx_obj_ return __pyx_r; } -/* "hunter/_predicates.pyx":407 - * return '' % (self.predicates,) +/* "hunter/_predicates.pyx":388 + * ) * * def __eq__(self, other): # <<<<<<<<<<<<<< * return ( - * isinstance(other, And) + * isinstance(other, From) */ /* 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_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("__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_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_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_6__eq__(struct __pyx_obj_6hunter_11_predicates_From *__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], 407, 0, __PYX_ERR(0, 407, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__eq__", 1); + __Pyx_TraceCall("__eq__", __pyx_f[1], 388, 0, __PYX_ERR(1, 388, __pyx_L1_error)); - /* "hunter/_predicates.pyx":408 + /* "hunter/_predicates.pyx":389 * * def __eq__(self, other): * return ( # <<<<<<<<<<<<<< - * isinstance(other, And) - * and self.predicates == ( other).predicates + * isinstance(other, From) + * and self.condition == ( other).condition */ - __Pyx_TraceLine(408,0,__PYX_ERR(0, 408, __pyx_L1_error)) + __Pyx_TraceLine(389,0,__PYX_ERR(1, 389, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - /* "hunter/_predicates.pyx":409 + /* "hunter/_predicates.pyx":390 * def __eq__(self, other): * return ( - * isinstance(other, And) # <<<<<<<<<<<<<< - * and self.predicates == ( other).predicates - * ) + * isinstance(other, From) # <<<<<<<<<<<<<< + * and self.condition == ( other).condition + * and self.predicate == ( other).predicate */ - __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); + __Pyx_TraceLine(390,0,__PYX_ERR(1, 390, __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, 409, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 390, __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 + /* "hunter/_predicates.pyx":391 * return ( - * isinstance(other, And) - * and self.predicates == ( other).predicates # <<<<<<<<<<<<<< + * isinstance(other, From) + * and self.condition == ( other).condition # <<<<<<<<<<<<<< + * and self.predicate == ( other).predicate + * ) + */ + __Pyx_TraceLine(391,0,__PYX_ERR(1, 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(1, 391, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 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; + } + + /* "hunter/_predicates.pyx":392 + * isinstance(other, From) + * and self.condition == ( other).condition + * and self.predicate == ( other).predicate # <<<<<<<<<<<<<< * ) * */ - __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_TraceLine(392,0,__PYX_ERR(1, 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(1, 392, __pyx_L1_error) __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = __pyx_t_3; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -12244,19 +14693,19 @@ static PyObject *__pyx_pf_6hunter_11_predicates_3And_6__eq__(struct __pyx_obj_6h __pyx_t_1 = 0; goto __pyx_L0; - /* "hunter/_predicates.pyx":407 - * return '' % (self.predicates,) + /* "hunter/_predicates.pyx":388 + * ) * * def __eq__(self, other): # <<<<<<<<<<<<<< * return ( - * isinstance(other, And) + * isinstance(other, From) */ /* 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_AddTraceback("hunter._predicates.From.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -12265,175 +14714,136 @@ static PyObject *__pyx_pf_6hunter_11_predicates_3And_6__eq__(struct __pyx_obj_6h return __pyx_r; } -/* "hunter/_predicates.pyx":413 - * ) - * - * def __hash__(self): # <<<<<<<<<<<<<< - * return hash(('And', self.predicates)) - * - */ - -/* 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; - __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)); - - /* 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 - __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)); - - /* "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) - __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; - - /* "hunter/_predicates.pyx":413 +/* "hunter/_predicates.pyx":395 * ) * - * def __hash__(self): # <<<<<<<<<<<<<< - * return hash(('And', self.predicates)) - * - */ - - /* 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_L0:; - if (unlikely(__pyx_r == -1) && !PyErr_Occurred()) __pyx_r = -2; - __Pyx_TraceReturn(Py_None, 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) + * return fast_From_call(self, event) * */ /* 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) { +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("__call__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __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_event,0}; - PyObject* values[1] = {0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_event,0}; + if (__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); + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_event)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_event)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 395, __pyx_L3_error) 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 (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__call__") < 0)) __PYX_ERR(1, 395, __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_Arg_VARARGS(__pyx_args, 0); } __pyx_v_event = ((struct __pyx_obj_6hunter_6_event_Event *)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("__call__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 395, __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); + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(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_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); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_event), __pyx_ptype_6hunter_6_event_Event, 1, "event", 0))) __PYX_ERR(1, 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 */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(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_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_TraceDeclarations __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_RefNannySetupContext("__call__", 1); + __Pyx_TraceCall("__call__", __pyx_f[1], 395, 0, __PYX_ERR(1, 395, __pyx_L1_error)); - /* "hunter/_predicates.pyx":417 + /* "hunter/_predicates.pyx":396 * * def __call__(self, Event event): - * return fast_And_call(self, event) # <<<<<<<<<<<<<< + * return fast_From_call(self, event) # <<<<<<<<<<<<<< * * def __or__(self, other): */ - __Pyx_TraceLine(417,0,__PYX_ERR(0, 417, __pyx_L1_error)) + __Pyx_TraceLine(396,0,__PYX_ERR(1, 396, __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) + __pyx_t_1 = __pyx_f_6hunter_11_predicates_fast_From_call(__pyx_v_self, __pyx_v_event); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 396, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "hunter/_predicates.pyx":416 - * return hash(('And', self.predicates)) + /* "hunter/_predicates.pyx":395 + * ) * * def __call__(self, Event event): # <<<<<<<<<<<<<< - * return fast_And_call(self, event) + * return fast_From_call(self, event) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.And.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("hunter._predicates.From.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -12442,8 +14852,8 @@ static PyObject *__pyx_pf_6hunter_11_predicates_3And_10__call__(struct __pyx_obj return __pyx_r; } -/* "hunter/_predicates.pyx":419 - * return fast_And_call(self, event) +/* "hunter/_predicates.pyx":398 + * return fast_From_call(self, event) * * def __or__(self, other): # <<<<<<<<<<<<<< * return Or(self, other) @@ -12451,53 +14861,58 @@ static PyObject *__pyx_pf_6hunter_11_predicates_3And_10__call__(struct __pyx_obj */ /* 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) { +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_r = __pyx_pf_6hunter_11_predicates_3And_12__or__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + __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_3And_12__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { +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_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; - __Pyx_RefNannySetupContext("__or__", 0); - __Pyx_TraceCall("__or__", __pyx_f[0], 419, 0, __PYX_ERR(0, 419, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__or__", 1); + __Pyx_TraceCall("__or__", __pyx_f[1], 398, 0, __PYX_ERR(1, 398, __pyx_L1_error)); - /* "hunter/_predicates.pyx":420 + /* "hunter/_predicates.pyx":399 * * def __or__(self, other): * return Or(self, other) # <<<<<<<<<<<<<< * * def __and__(self, other): */ - __Pyx_TraceLine(420,0,__PYX_ERR(0, 420, __pyx_L1_error)) + __Pyx_TraceLine(399,0,__PYX_ERR(1, 399, __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_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 399, __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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self)) __PYX_ERR(1, 399, __pyx_L1_error); __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) + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_other)) __PYX_ERR(1, 399, __pyx_L1_error); + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_Or), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 399, __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; - /* "hunter/_predicates.pyx":419 - * return fast_And_call(self, event) + /* "hunter/_predicates.pyx":398 + * return fast_From_call(self, event) * * def __or__(self, other): # <<<<<<<<<<<<<< * return Or(self, other) @@ -12508,7 +14923,7 @@ static PyObject *__pyx_pf_6hunter_11_predicates_3And_12__or__(PyObject *__pyx_v_ __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_AddTraceback("hunter._predicates.From.__or__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -12517,184 +14932,88 @@ static PyObject *__pyx_pf_6hunter_11_predicates_3And_12__or__(PyObject *__pyx_v_ return __pyx_r; } -/* "hunter/_predicates.pyx":422 +/* "hunter/_predicates.pyx":401 * return Or(self, other) * * def __and__(self, other): # <<<<<<<<<<<<<< - * cdef list predicates - * if type(self) is And: + * return And(self, other) + * */ /* 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) { +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_r = __pyx_pf_6hunter_11_predicates_3And_14__and__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + __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)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_3And_14__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { - PyObject *__pyx_v_predicates = 0; +static PyObject *__pyx_pf_6hunter_11_predicates_4From_12__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { 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":424 - * def __and__(self, other): - * cdef list predicates - * if type(self) is And: # <<<<<<<<<<<<<< - * predicates = list((self).predicates) - * 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) { - - /* "hunter/_predicates.pyx":425 - * cdef list predicates - * if type(self) is And: - * predicates = list((self).predicates) # <<<<<<<<<<<<<< - * 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; - - /* "hunter/_predicates.pyx":424 - * def __and__(self, other): - * cdef list predicates - * if type(self) is And: # <<<<<<<<<<<<<< - * predicates = list((self).predicates) - * else: - */ - 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)) - /*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_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); - 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; - - /* "hunter/_predicates.pyx":428 - * else: - * predicates = [self] - * if isinstance(other, And): # <<<<<<<<<<<<<< - * predicates.extend(( other).predicates) - * else: - */ - goto __pyx_L4; - } + 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("__and__", 1); + __Pyx_TraceCall("__and__", __pyx_f[1], 401, 0, __PYX_ERR(1, 401, __pyx_L1_error)); - /* "hunter/_predicates.pyx":431 - * predicates.extend(( other).predicates) - * else: - * predicates.append(other) # <<<<<<<<<<<<<< - * return And(*predicates) + /* "hunter/_predicates.pyx":402 * - */ - __Pyx_TraceLine(431,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:; - - /* "hunter/_predicates.pyx":432 - * else: - * predicates.append(other) - * return And(*predicates) # <<<<<<<<<<<<<< + * def __and__(self, other): + * return And(self, other) # <<<<<<<<<<<<<< * * def __invert__(self): */ - __Pyx_TraceLine(432,0,__PYX_ERR(0, 432, __pyx_L1_error)) + __Pyx_TraceLine(402,0,__PYX_ERR(1, 402, __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; + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 402, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_self); + __Pyx_GIVEREF(__pyx_v_self); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self)) __PYX_ERR(1, 402, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_other); + __Pyx_GIVEREF(__pyx_v_other); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_other)) __PYX_ERR(1, 402, __pyx_L1_error); + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_And), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 402, __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; - /* "hunter/_predicates.pyx":422 + /* "hunter/_predicates.pyx":401 * return Or(self, other) * * def __and__(self, other): # <<<<<<<<<<<<<< - * cdef list predicates - * if type(self) is And: + * return And(self, other) + * */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("hunter._predicates.And.__and__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("hunter._predicates.From.__and__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF(__pyx_v_predicates); __Pyx_XGIVEREF(__pyx_r); __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":434 - * return And(*predicates) +/* "hunter/_predicates.pyx":404 + * return And(self, other) * * def __invert__(self): # <<<<<<<<<<<<<< * return Not(self) @@ -12702,43 +15021,48 @@ static PyObject *__pyx_pf_6hunter_11_predicates_3And_14__and__(PyObject *__pyx_v */ /* 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) { +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_r = __pyx_pf_6hunter_11_predicates_3And_16__invert__(((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v_self)); + __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)); /* function exit code */ __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) { +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_TraceDeclarations __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_RefNannySetupContext("__invert__", 1); + __Pyx_TraceCall("__invert__", __pyx_f[1], 404, 0, __PYX_ERR(1, 404, __pyx_L1_error)); - /* "hunter/_predicates.pyx":435 + /* "hunter/_predicates.pyx":405 * * def __invert__(self): * return Not(self) # <<<<<<<<<<<<<< * - * cdef inline fast_And_call(And self, Event event): + * cdef inline fast_From_call(From self, Event event): */ - __Pyx_TraceLine(435,0,__PYX_ERR(0, 435, __pyx_L1_error)) + __Pyx_TraceLine(405,0,__PYX_ERR(1, 405, __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_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_6hunter_11_predicates_Not), ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 405, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "hunter/_predicates.pyx":434 - * return And(*predicates) + /* "hunter/_predicates.pyx":404 + * return And(self, other) * * def __invert__(self): # <<<<<<<<<<<<<< * return Not(self) @@ -12748,7 +15072,7 @@ static PyObject *__pyx_pf_6hunter_11_predicates_3And_16__invert__(struct __pyx_o /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.And.__invert__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("hunter._predicates.From.__invert__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -12757,41 +15081,46 @@ static PyObject *__pyx_pf_6hunter_11_predicates_3And_16__invert__(struct __pyx_o return __pyx_r; } -/* "hunter/_predicates.pxd":24 - * cdef class And: +/* "hunter/_predicates.pxd":50 + * cdef class From: * cdef: - * readonly tuple predicates # <<<<<<<<<<<<<< - * - * @cython.final + * readonly object condition # <<<<<<<<<<<<<< + * readonly object predicate + * readonly int watermark */ /* 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_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("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_3And_10predicates___get__(((struct __pyx_obj_6hunter_11_predicates_And *)__pyx_v_self)); + __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_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6hunter_11_predicates_3And_10predicates___get__(struct __pyx_obj_6hunter_11_predicates_And *__pyx_v_self) { +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], 24, 0, __PYX_ERR(1, 24, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[2], 50, 0, __PYX_ERR(2, 50, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->predicates); - __pyx_r = __pyx_v_self->predicates; + __Pyx_INCREF(__pyx_v_self->condition); + __pyx_r = __pyx_v_self->condition; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.And.predicates.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("hunter._predicates.From.condition.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -12800,80 +15129,334 @@ static PyObject *__pyx_pf_6hunter_11_predicates_3And_10predicates___get__(struct return __pyx_r; } -/* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict +/* "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_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) { +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("__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("__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_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; +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 - 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)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[2], 51, 0, __PYX_ERR(2, 51, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->predicate); + __pyx_r = __pyx_v_self->predicate; + goto __pyx_L0; - /* "(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; + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("hunter._predicates.From.predicate.__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; +} - /* "(tree fragment)":6 - * cdef bint use_setstate - * state = (self.predicates,) - * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< - * if _dict is not None: - * state += (_dict,) +/* "hunter/_predicates.pxd":52 + * readonly object condition + * readonly object predicate + * readonly int watermark # <<<<<<<<<<<<<< + * readonly int origin_depth + * readonly int origin_calls */ - __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) + +/* 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 */ + __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 + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[2], 52, 0, __PYX_ERR(2, 52, __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(2, 52, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_v__dict = __pyx_t_1; + __pyx_r = __pyx_t_1; __pyx_t_1 = 0; + goto __pyx_L0; - /* "(tree fragment)":7 - * state = (self.predicates,) - * _dict = getattr(self, '__dict__', None) + /* function exit code */ + __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_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "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_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("__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_4From_12origin_depth___get__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[2], 53, 0, __PYX_ERR(2, 53, __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(2, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("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_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/_predicates.pxd":54 + * readonly int watermark + * readonly int origin_depth + * readonly int origin_calls # <<<<<<<<<<<<<< + * + * + */ + +/* 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) { + 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_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_4From_12origin_calls___get__(struct __pyx_obj_6hunter_11_predicates_From *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[2], 54, 0, __PYX_ERR(2, 54, __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(2, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("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_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_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*)(__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("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __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;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) 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 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_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + 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(__pyx_codeobj__16) + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + __Pyx_TraceCall("__reduce_cython__", __pyx_f[0], 1, 0, __PYX_ERR(0, 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(0, 5, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->origin_calls); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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(0, 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(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 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)) __PYX_ERR(0, 5, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_2)) __PYX_ERR(0, 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)) __PYX_ERR(0, 5, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 4, __pyx_t_3)) __PYX_ERR(0, 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; + + /* "(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(0, 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(0, 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,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) { + __Pyx_TraceLine(7,0,__PYX_ERR(0, 7, __pyx_L1_error)) + __pyx_t_5 = (__pyx_v__dict != Py_None); + if (__pyx_t_5) { /* "(tree fragment)":8 * _dict = getattr(self, '__dict__', None) @@ -12882,30 +15465,30 @@ static PyObject *__pyx_pf_6hunter_11_predicates_3And_18__reduce_cython__(struct * 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_TraceLine(8,0,__PYX_ERR(0, 8, __pyx_L1_error)) + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); __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; + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v__dict)) __PYX_ERR(0, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 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.predicates is not None + * 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_TraceLine(9,0,__PYX_ERR(0, 9, __pyx_L1_error)) __pyx_v_use_setstate = 1; /* "(tree fragment)":7 - * state = (self.predicates,) + * 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,) @@ -12917,107 +15500,114 @@ static PyObject *__pyx_pf_6hunter_11_predicates_3And_18__reduce_cython__(struct /* "(tree fragment)":11 * use_setstate = True * else: - * use_setstate = self.predicates is not None # <<<<<<<<<<<<<< + * use_setstate = self.condition is not None or self.predicate is not None # <<<<<<<<<<<<<< * if use_setstate: - * return __pyx_unpickle_And, (type(self), 0xaa8cbda, None), state + * return __pyx_unpickle_From, (type(self), 0xcfd05cc, None), state */ - __Pyx_TraceLine(11,0,__PYX_ERR(2, 11, __pyx_L1_error)) + __Pyx_TraceLine(11,0,__PYX_ERR(0, 11, __pyx_L1_error)) /*else*/ { - __pyx_t_3 = (__pyx_v_self->predicates != ((PyObject*)Py_None)); - __pyx_v_use_setstate = __pyx_t_3; + __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.predicates is not None + * use_setstate = self.condition is not None or self.predicate is not None * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_And, (type(self), 0xaa8cbda, None), state + * return __pyx_unpickle_From, (type(self), 0xcfd05cc, 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) { + __Pyx_TraceLine(12,0,__PYX_ERR(0, 12, __pyx_L1_error)) + if (__pyx_v_use_setstate) { /* "(tree fragment)":13 - * use_setstate = self.predicates is not None + * use_setstate = self.condition is not None or self.predicate is not None * if use_setstate: - * return __pyx_unpickle_And, (type(self), 0xaa8cbda, None), state # <<<<<<<<<<<<<< + * return __pyx_unpickle_From, (type(self), 0xcfd05cc, None), state # <<<<<<<<<<<<<< * else: - * return __pyx_unpickle_And, (type(self), 0xaa8cbda, state) + * return __pyx_unpickle_From, (type(self), 0xcfd05cc, state) */ - __Pyx_TraceLine(13,0,__PYX_ERR(2, 13, __pyx_L1_error)) + __Pyx_TraceLine(13,0,__PYX_ERR(0, 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_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_From); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(0, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_217908684); + __Pyx_GIVEREF(__pyx_int_217908684); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_int_217908684)) __PYX_ERR(0, 13, __pyx_L1_error); __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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, Py_None)) __PYX_ERR(0, 13, __pyx_L1_error); + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 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)) __PYX_ERR(0, 13, __pyx_L1_error); __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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4)) __PYX_ERR(0, 13, __pyx_L1_error); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); - PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_state)) __PYX_ERR(0, 13, __pyx_L1_error); + __pyx_t_3 = 0; __pyx_t_4 = 0; - __pyx_t_1 = 0; - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; goto __pyx_L0; /* "(tree fragment)":12 * else: - * use_setstate = self.predicates is not None + * use_setstate = self.condition is not None or self.predicate is not None * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_And, (type(self), 0xaa8cbda, None), state + * return __pyx_unpickle_From, (type(self), 0xcfd05cc, None), state * else: */ } /* "(tree fragment)":15 - * return __pyx_unpickle_And, (type(self), 0xaa8cbda, None), state + * return __pyx_unpickle_From, (type(self), 0xcfd05cc, None), state * else: - * return __pyx_unpickle_And, (type(self), 0xaa8cbda, state) # <<<<<<<<<<<<<< + * return __pyx_unpickle_From, (type(self), 0xcfd05cc, state) # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_And__set_state(self, __pyx_state) + * __pyx_unpickle_From__set_state(self, __pyx_state) */ - __Pyx_TraceLine(15,0,__PYX_ERR(2, 15, __pyx_L1_error)) + __Pyx_TraceLine(15,0,__PYX_ERR(0, 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_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_pyx_unpickle_From); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 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_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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(0, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_217908684); + __Pyx_GIVEREF(__pyx_int_217908684); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_int_217908684)) __PYX_ERR(0, 15, __pyx_L1_error); __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; + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(0, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 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)) __PYX_ERR(0, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4)) __PYX_ERR(0, 15, __pyx_L1_error); + __pyx_t_2 = 0; __pyx_t_4 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; goto __pyx_L0; } @@ -13030,9 +15620,10 @@ static PyObject *__pyx_pf_6hunter_11_predicates_3And_18__reduce_cython__(struct /* 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.And.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("hunter._predicates.From.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_state); @@ -13045,48 +15636,135 @@ static PyObject *__pyx_pf_6hunter_11_predicates_3And_18__reduce_cython__(struct /* "(tree fragment)":16 * else: - * return __pyx_unpickle_And, (type(self), 0xaa8cbda, state) + * return __pyx_unpickle_From, (type(self), 0xcfd05cc, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle_And__set_state(self, __pyx_state) + * __pyx_unpickle_From__set_state(self, __pyx_state) */ /* 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_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*)(__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("__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)); - - /* 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) { - PyObject *__pyx_r = NULL; + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __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 **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __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(0, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(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:; + __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 */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +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_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(__pyx_codeobj__17) + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + __Pyx_TraceCall("__setstate_cython__", __pyx_f[0], 16, 0, __PYX_ERR(0, 16, __pyx_L1_error)); /* "(tree fragment)":17 - * return __pyx_unpickle_And, (type(self), 0xaa8cbda, state) + * return __pyx_unpickle_From, (type(self), 0xcfd05cc, state) * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_And__set_state(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_And__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 17, __pyx_L1_error) + __Pyx_TraceLine(17,0,__PYX_ERR(0, 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(0, 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(0, 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_And, (type(self), 0xaa8cbda, state) + * return __pyx_unpickle_From, (type(self), 0xcfd05cc, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle_And__set_state(self, __pyx_state) + * __pyx_unpickle_From__set_state(self, __pyx_state) */ /* function exit code */ @@ -13094,7 +15772,7 @@ static PyObject *__pyx_pf_6hunter_11_predicates_3And_20__setstate_cython__(struc 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_AddTraceback("hunter._predicates.From.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -13103,197 +15781,375 @@ static PyObject *__pyx_pf_6hunter_11_predicates_3And_20__setstate_cython__(struc return __pyx_r; } -/* "hunter/_predicates.pyx":437 +/* "hunter/_predicates.pyx":407 * return Not(self) * - * cdef inline fast_And_call(And self, Event event): # <<<<<<<<<<<<<< - * for predicate in self.predicates: - * if not fast_call(predicate, event): + * cdef inline fast_From_call(From self, Event event): # <<<<<<<<<<<<<< + * cdef object result + * cdef int delta_depth */ -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; +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_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - Py_ssize_t __pyx_t_2; + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; 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_RefNannySetupContext("fast_From_call", 1); + __Pyx_TraceCall("fast_From_call", __pyx_f[1], 407, 0, __PYX_ERR(1, 407, __pyx_L1_error)); - /* "hunter/_predicates.pyx":438 + /* "hunter/_predicates.pyx":412 + * cdef int delta_calls + * + * if self.origin_depth == -1: # <<<<<<<<<<<<<< + * result = fast_call(self.condition, event) * - * 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) + __Pyx_TraceLine(412,0,__PYX_ERR(1, 412, __pyx_L1_error)) + __pyx_t_1 = (__pyx_v_self->origin_depth == -1L); + if (__pyx_t_1) { + + /* "hunter/_predicates.pyx":413 + * + * if self.origin_depth == -1: + * result = fast_call(self.condition, event) # <<<<<<<<<<<<<< + * + * if result: + */ + __Pyx_TraceLine(413,0,__PYX_ERR(1, 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(1, 413, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - #endif - __Pyx_XDECREF_SET(__pyx_v_predicate, __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":439 - * cdef inline fast_And_call(And self, Event event): - * for predicate in self.predicates: - * if not fast_call(predicate, event): # <<<<<<<<<<<<<< + /* "hunter/_predicates.pyx":415 + * result = fast_call(self.condition, event) + * + * if result: # <<<<<<<<<<<<<< + * self.origin_depth = event.depth + * self.origin_calls = event.calls + */ + __Pyx_TraceLine(415,0,__PYX_ERR(1, 415, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_result); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 415, __pyx_L1_error) + if (__pyx_t_1) { + + /* "hunter/_predicates.pyx":416 + * + * if result: + * self.origin_depth = event.depth # <<<<<<<<<<<<<< + * self.origin_calls = event.calls + * delta_depth = delta_calls = 0 + */ + __Pyx_TraceLine(416,0,__PYX_ERR(1, 416, __pyx_L1_error)) + __pyx_t_4 = __pyx_v_event->depth; + __pyx_v_self->origin_depth = __pyx_t_4; + + /* "hunter/_predicates.pyx":417 + * if result: + * self.origin_depth = event.depth + * self.origin_calls = event.calls # <<<<<<<<<<<<<< + * delta_depth = delta_calls = 0 + * else: + */ + __Pyx_TraceLine(417,0,__PYX_ERR(1, 417, __pyx_L1_error)) + __pyx_t_4 = __pyx_v_event->calls; + __pyx_v_self->origin_calls = __pyx_t_4; + + /* "hunter/_predicates.pyx":418 + * self.origin_depth = event.depth + * self.origin_calls = event.calls + * delta_depth = delta_calls = 0 # <<<<<<<<<<<<<< + * else: * 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) { + __Pyx_TraceLine(418,0,__PYX_ERR(1, 418, __pyx_L1_error)) + __pyx_v_delta_depth = 0; + __pyx_v_delta_calls = 0; - /* "hunter/_predicates.pyx":440 - * for predicate in self.predicates: - * if not fast_call(predicate, event): + /* "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: - * return True + * delta_depth = event.depth - self.origin_depth */ - __Pyx_TraceLine(440,0,__PYX_ERR(0, 440, __pyx_L1_error)) + __Pyx_TraceLine(420,0,__PYX_ERR(1, 420, __pyx_L1_error)) + /*else*/ { __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_L4:; - /* "hunter/_predicates.pyx":439 - * cdef inline fast_And_call(And self, Event event): - * for predicate in self.predicates: - * if not fast_call(predicate, event): # <<<<<<<<<<<<<< + /* "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":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,0,__PYX_ERR(1, 422, __pyx_L1_error)) + /*else*/ { + __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,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 424, __pyx_L1_error)) + __pyx_t_1 = (__pyx_v_delta_depth < __pyx_v_self->watermark); + if (__pyx_t_1) { - /* "hunter/_predicates.pyx":438 + /* "hunter/_predicates.pyx":425 + * delta_calls = event.calls - self.origin_calls + * if delta_depth < self.watermark: + * self.origin_depth = -1 # <<<<<<<<<<<<<< + * return False * - * cdef inline fast_And_call(And self, Event event): - * for predicate in self.predicates: # <<<<<<<<<<<<<< - * if not fast_call(predicate, event): + */ + __Pyx_TraceLine(425,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 426, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + 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_TraceLine(438,0,__PYX_ERR(0, 438, __pyx_L1_error)) + } } - /*else*/ { + __pyx_L3:; - /* "hunter/_predicates.pyx":442 + /* "hunter/_predicates.pyx":428 * return False - * else: - * return True # <<<<<<<<<<<<<< * + * if self.predicate is None: # <<<<<<<<<<<<<< + * return True + * else: + */ + __Pyx_TraceLine(428,0,__PYX_ERR(1, 428, __pyx_L1_error)) + __pyx_t_1 = (__pyx_v_self->predicate == Py_None); + if (__pyx_t_1) { + + /* "hunter/_predicates.pyx":429 * + * if self.predicate is None: + * return True # <<<<<<<<<<<<<< + * else: + * relative_event = fast_clone(event) */ - __Pyx_TraceLine(442,0,__PYX_ERR(0, 442, __pyx_L1_error)) + __Pyx_TraceLine(429,0,__PYX_ERR(1, 429, __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 - * - * cdef inline fast_And_call(And self, Event event): - * for predicate in self.predicates: # <<<<<<<<<<<<<< - * if not fast_call(predicate, event): + /* "hunter/_predicates.pyx":428 * return False + * + * if self.predicate is None: # <<<<<<<<<<<<<< + * return True + * else: */ - __Pyx_TraceLine(438,0,__PYX_ERR(0, 438, __pyx_L1_error)) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } - /* "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): + /* "hunter/_predicates.pyx":431 + * return True + * else: + * relative_event = fast_clone(event) # <<<<<<<<<<<<<< + * relative_event.depth = delta_depth + * relative_event.calls = delta_calls */ + __Pyx_TraceLine(431,0,__PYX_ERR(1, 431, __pyx_L1_error)) + /*else*/ { + __pyx_t_3 = ((PyObject *)__pyx_f_6hunter_6_event_fast_clone(__pyx_v_event)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 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; - /* function exit code */ + /* "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,0,__PYX_ERR(1, 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) + * + */ + __Pyx_TraceLine(433,0,__PYX_ERR(1, 433, __pyx_L1_error)) + __pyx_v_relative_event->calls = __pyx_v_delta_calls; + + /* "hunter/_predicates.pyx":434 + * relative_event.depth = delta_depth + * relative_event.calls = delta_calls + * return fast_call(self.predicate, relative_event) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_TraceLine(434,0,__PYX_ERR(1, 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(1, 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; + 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_1); + __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("hunter._predicates.fast_And_call", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("hunter._predicates.fast_From_call", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; - __Pyx_XDECREF(__pyx_v_predicate); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF((PyObject *)__pyx_v_relative_event); __Pyx_XGIVEREF(__pyx_r); __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":451 +/* "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 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) { +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("__init__ (wrapper)", 0); - if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1; + #if CYTHON_ASSUME_SAFE_MACROS + __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_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && 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_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_XDECREF(__pyx_v_predicates); + __Pyx_DECREF(__pyx_v_predicates); __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) { +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 __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__init__", 0); - __Pyx_TraceCall("__init__", __pyx_f[0], 451, 0, __PYX_ERR(0, 451, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 1); + __Pyx_TraceCall("__init__", __pyx_f[1], 442, 0, __PYX_ERR(1, 442, __pyx_L1_error)); - /* "hunter/_predicates.pyx":452 - * + /* "hunter/_predicates.pyx":443 + * """ * def __init__(self, *predicates): * self.predicates = predicates # <<<<<<<<<<<<<< * * def __str__(self): */ - __Pyx_TraceLine(452,0,__PYX_ERR(0, 452, __pyx_L1_error)) + __Pyx_TraceLine(443,0,__PYX_ERR(1, 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":451 + /* "hunter/_predicates.pyx":442 + * `And` predicate. Exits at the first sub-predicate that returns ``False``. * """ - * * def __init__(self, *predicates): # <<<<<<<<<<<<<< * self.predicates = predicates * @@ -13303,7 +16159,7 @@ static int __pyx_pf_6hunter_11_predicates_2Or___init__(struct __pyx_obj_6hunter_ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.Or.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("hunter._predicates.And.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_TraceReturn(Py_None, 0); @@ -13311,54 +16167,59 @@ static int __pyx_pf_6hunter_11_predicates_2Or___init__(struct __pyx_obj_6hunter_ return __pyx_r; } -/* "hunter/_predicates.pyx":454 +/* "hunter/_predicates.pyx":445 * self.predicates = predicates * * def __str__(self): # <<<<<<<<<<<<<< - * return 'Or(%s)' % ', '.join(str(p) for p in self.predicates) + * return 'And(%s)' % ', '.join(str(p) for p in self.predicates) * */ /* 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_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("__str__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_2Or_2__str__(((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_self)); + __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_2Or_7__str___2generator6(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ +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 */ -/* "hunter/_predicates.pyx":455 +/* "hunter/_predicates.pyx":446 * * def __str__(self): - * return 'Or(%s)' % ', '.join(str(p) for p in self.predicates) # <<<<<<<<<<<<<< + * return 'And(%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_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_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_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); + __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_12_genexpr *)Py_None); + __pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_4_genexpr *)Py_None); __Pyx_INCREF(Py_None); - __PYX_ERR(0, 455, __pyx_L1_error) + __PYX_ERR(1, 446, __pyx_L1_error) } else { - __Pyx_GOTREF(__pyx_cur_scope); + __Pyx_GOTREF((PyObject *)__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); + __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___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_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_6hunter_11_predicates_3And_7__str___2generator3, 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(1, 446, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; @@ -13366,25 +16227,28 @@ static PyObject *__pyx_pf_6hunter_11_predicates_2Or_7__str___genexpr(PyObject *_ /* function exit code */ __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.Or.__str__.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("hunter._predicates.And.__str__.genexpr", __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; } -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 */ +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_12_genexpr *__pyx_cur_scope = ((struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_12_genexpr *)__pyx_generator->closure); + 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; 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); - __Pyx_TraceCall("genexpr", __pyx_f[0], 455, 0, __PYX_ERR(0, 455, __pyx_L1_error)); + __Pyx_TraceCall("genexpr", __pyx_f[1], 446, 0, __PYX_ERR(1, 446, __pyx_L1_error)); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L6_resume_from_yield; @@ -13394,26 +16258,33 @@ static PyObject *__pyx_gb_6hunter_11_predicates_2Or_7__str___2generator6(__pyx_C 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)) { + if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 446, __pyx_L1_error) + if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(1, 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, 455, __pyx_L1_error) + __PYX_ERR(1, 446, __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; + __pyx_t_1 = __pyx_cur_scope->__pyx_genexpr_arg_0; __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_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 446, __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, 455, __pyx_L1_error) + __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(1, 446, __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_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 446, __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_t_3 = __Pyx_PyObject_Str(__pyx_cur_scope->__pyx_v_p); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 446, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; @@ -13432,7 +16303,7 @@ static PyObject *__pyx_gb_6hunter_11_predicates_2Or_7__str___2generator6(__pyx_C __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) + if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 446, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); @@ -13441,6 +16312,7 @@ static PyObject *__pyx_gb_6hunter_11_predicates_2Or_7__str___2generator6(__pyx_C PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; + __Pyx_Generator_Replace_StopIteration(0); __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); @@ -13456,61 +16328,53 @@ static PyObject *__pyx_gb_6hunter_11_predicates_2Or_7__str___2generator6(__pyx_C return __pyx_r; } -/* "hunter/_predicates.pyx":454 +/* "hunter/_predicates.pyx":445 * self.predicates = predicates * * def __str__(self): # <<<<<<<<<<<<<< - * return 'Or(%s)' % ', '.join(str(p) for p in self.predicates) + * return 'And(%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_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_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_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); - } - __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); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__str__", 1); + __Pyx_TraceCall("__str__", __pyx_f[1], 445, 0, __PYX_ERR(1, 445, __pyx_L1_error)); - /* "hunter/_predicates.pyx":455 + /* "hunter/_predicates.pyx":446 * * def __str__(self): - * return 'Or(%s)' % ', '.join(str(p) for p in self.predicates) # <<<<<<<<<<<<<< + * return 'And(%s)' % ', '.join(str(p) for p in self.predicates) # <<<<<<<<<<<<<< * * def __repr__(self): */ - __Pyx_TraceLine(455,0,__PYX_ERR(0, 455, __pyx_L1_error)) + __Pyx_TraceLine(446,0,__PYX_ERR(1, 446, __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_t_1 = __pyx_pf_6hunter_11_predicates_3And_7__str___genexpr(NULL, __pyx_v_self->predicates); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 446, __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 = __Pyx_PyString_Join(__pyx_kp_s__8, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 446, __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_t_1 = __Pyx_PyString_Format(__pyx_kp_s_And_s, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 446, __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":454 + /* "hunter/_predicates.pyx":445 * self.predicates = predicates * * def __str__(self): # <<<<<<<<<<<<<< - * return 'Or(%s)' % ', '.join(str(p) for p in self.predicates) + * return 'And(%s)' % ', '.join(str(p) for p in self.predicates) * */ @@ -13518,72 +16382,77 @@ static PyObject *__pyx_pf_6hunter_11_predicates_2Or_2__str__(struct __pyx_obj_6h __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_AddTraceback("hunter._predicates.And.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __Pyx_XDECREF(__pyx_gb_6hunter_11_predicates_3And_7__str___2generator3); __Pyx_XGIVEREF(__pyx_r); __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":457 - * return 'Or(%s)' % ', '.join(str(p) for p in self.predicates) +/* "hunter/_predicates.pyx":448 + * return 'And(%s)' % ', '.join(str(p) for p in self.predicates) * * def __repr__(self): # <<<<<<<<<<<<<< - * return '' % (self.predicates,) + * return '' % (self.predicates,) * */ /* 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_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("__repr__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_2Or_4__repr__(((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_self)); + __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_2Or_4__repr__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self) { +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_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)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__repr__", 1); + __Pyx_TraceCall("__repr__", __pyx_f[1], 448, 0, __PYX_ERR(1, 448, __pyx_L1_error)); - /* "hunter/_predicates.pyx":458 + /* "hunter/_predicates.pyx":449 * * def __repr__(self): - * return '' % (self.predicates,) # <<<<<<<<<<<<<< + * return '' % (self.predicates,) # <<<<<<<<<<<<<< * * def __eq__(self, other): */ - __Pyx_TraceLine(458,0,__PYX_ERR(0, 458, __pyx_L1_error)) + __Pyx_TraceLine(449,0,__PYX_ERR(1, 449, __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_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 449, __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) + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->predicates)) __PYX_ERR(1, 449, __pyx_L1_error); + __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_hunter__predicates_And_predicat, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 449, __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; - /* "hunter/_predicates.pyx":457 - * return 'Or(%s)' % ', '.join(str(p) for p in self.predicates) + /* "hunter/_predicates.pyx":448 + * return 'And(%s)' % ', '.join(str(p) for p in self.predicates) * * def __repr__(self): # <<<<<<<<<<<<<< - * return '' % (self.predicates,) + * return '' % (self.predicates,) * */ @@ -13591,7 +16460,7 @@ static PyObject *__pyx_pf_6hunter_11_predicates_2Or_4__repr__(struct __pyx_obj_6 __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_AddTraceback("hunter._predicates.And.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -13600,74 +16469,79 @@ static PyObject *__pyx_pf_6hunter_11_predicates_2Or_4__repr__(struct __pyx_obj_6 return __pyx_r; } -/* "hunter/_predicates.pyx":460 - * return '' % (self.predicates,) +/* "hunter/_predicates.pyx":451 + * return '' % (self.predicates,) * * def __eq__(self, other): # <<<<<<<<<<<<<< * return ( - * isinstance(other, Or) + * isinstance(other, And) */ /* 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_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_r = __pyx_pf_6hunter_11_predicates_2Or_6__eq__(((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + __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_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_6__eq__(struct __pyx_obj_6hunter_11_predicates_And *__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], 460, 0, __PYX_ERR(0, 460, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__eq__", 1); + __Pyx_TraceCall("__eq__", __pyx_f[1], 451, 0, __PYX_ERR(1, 451, __pyx_L1_error)); - /* "hunter/_predicates.pyx":461 + /* "hunter/_predicates.pyx":452 * * def __eq__(self, other): * return ( # <<<<<<<<<<<<<< - * isinstance(other, Or) - * and self.predicates == ( other).predicates + * isinstance(other, And) + * and self.predicates == ( other).predicates */ - __Pyx_TraceLine(461,0,__PYX_ERR(0, 461, __pyx_L1_error)) + __Pyx_TraceLine(452,0,__PYX_ERR(1, 452, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - /* "hunter/_predicates.pyx":462 + /* "hunter/_predicates.pyx":453 * def __eq__(self, other): * return ( - * isinstance(other, Or) # <<<<<<<<<<<<<< - * and self.predicates == ( other).predicates + * isinstance(other, And) # <<<<<<<<<<<<<< + * 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); + __Pyx_TraceLine(453,0,__PYX_ERR(1, 453, __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, 462, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 453, __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 + /* "hunter/_predicates.pyx":454 * return ( - * isinstance(other, Or) - * and self.predicates == ( other).predicates # <<<<<<<<<<<<<< + * isinstance(other, And) + * 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_TraceLine(454,0,__PYX_ERR(1, 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(1, 454, __pyx_L1_error) __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = __pyx_t_3; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -13676,19 +16550,19 @@ static PyObject *__pyx_pf_6hunter_11_predicates_2Or_6__eq__(struct __pyx_obj_6hu __pyx_t_1 = 0; goto __pyx_L0; - /* "hunter/_predicates.pyx":460 - * return '' % (self.predicates,) + /* "hunter/_predicates.pyx":451 + * return '' % (self.predicates,) * * def __eq__(self, other): # <<<<<<<<<<<<<< * return ( - * isinstance(other, Or) + * isinstance(other, And) */ /* 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_AddTraceback("hunter._predicates.And.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -13697,175 +16571,136 @@ static PyObject *__pyx_pf_6hunter_11_predicates_2Or_6__eq__(struct __pyx_obj_6hu return __pyx_r; } -/* "hunter/_predicates.pyx":466 - * ) - * - * def __hash__(self): # <<<<<<<<<<<<<< - * return hash(('Or', self.predicates)) - * - */ - -/* 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; - __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)); - - /* 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 - __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)); - - /* "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) - __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; - - /* "hunter/_predicates.pyx":466 +/* "hunter/_predicates.pyx":457 * ) * - * def __hash__(self): # <<<<<<<<<<<<<< - * return hash(('Or', self.predicates)) - * - */ - - /* 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_L0:; - if (unlikely(__pyx_r == -1) && !PyErr_Occurred()) __pyx_r = -2; - __Pyx_TraceReturn(Py_None, 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) + * return fast_And_call(self, event) * */ /* 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) { +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("__call__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __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_event,0}; - PyObject* values[1] = {0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_event,0}; + if (__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); + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_event)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_event)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 457, __pyx_L3_error) 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, 469, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__call__") < 0)) __PYX_ERR(1, 457, __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_Arg_VARARGS(__pyx_args, 0); } __pyx_v_event = ((struct __pyx_obj_6hunter_6_event_Event *)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("__call__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 457, __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); + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(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_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); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_event), __pyx_ptype_6hunter_6_event_Event, 1, "event", 0))) __PYX_ERR(1, 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 */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(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_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_TraceDeclarations __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_RefNannySetupContext("__call__", 1); + __Pyx_TraceCall("__call__", __pyx_f[1], 457, 0, __PYX_ERR(1, 457, __pyx_L1_error)); - /* "hunter/_predicates.pyx":470 + /* "hunter/_predicates.pyx":458 * * def __call__(self, Event event): - * return fast_Or_call(self, event) # <<<<<<<<<<<<<< + * return fast_And_call(self, event) # <<<<<<<<<<<<<< * * def __or__(self, other): */ - __Pyx_TraceLine(470,0,__PYX_ERR(0, 470, __pyx_L1_error)) + __Pyx_TraceLine(458,0,__PYX_ERR(1, 458, __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) + __pyx_t_1 = __pyx_f_6hunter_11_predicates_fast_And_call(__pyx_v_self, __pyx_v_event); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 458, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "hunter/_predicates.pyx":469 - * return hash(('Or', self.predicates)) + /* "hunter/_predicates.pyx":457 + * ) * * def __call__(self, Event event): # <<<<<<<<<<<<<< - * return fast_Or_call(self, event) + * return fast_And_call(self, event) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.Or.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("hunter._predicates.And.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -13874,259 +16709,266 @@ static PyObject *__pyx_pf_6hunter_11_predicates_2Or_10__call__(struct __pyx_obj_ return __pyx_r; } -/* "hunter/_predicates.pyx":472 - * return fast_Or_call(self, event) +/* "hunter/_predicates.pyx":460 + * return fast_And_call(self, event) * * def __or__(self, other): # <<<<<<<<<<<<<< - * cdef list predicates - * if type(self) is Or: + * return Or(self, other) + * */ /* 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) { +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("__or__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_2Or_12__or__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + __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_pf_6hunter_11_predicates_2Or_12__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { - PyObject *__pyx_v_predicates = 0; +static PyObject *__pyx_pf_6hunter_11_predicates_3And_10__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { 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("__or__", 0); - __Pyx_TraceCall("__or__", __pyx_f[0], 472, 0, __PYX_ERR(0, 472, __pyx_L1_error)); + 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("__or__", 1); + __Pyx_TraceCall("__or__", __pyx_f[1], 460, 0, __PYX_ERR(1, 460, __pyx_L1_error)); - /* "hunter/_predicates.pyx":474 + /* "hunter/_predicates.pyx":461 + * * def __or__(self, other): - * cdef list predicates - * if type(self) is Or: # <<<<<<<<<<<<<< - * predicates = list(( self).predicates) - * else: + * return Or(self, other) # <<<<<<<<<<<<<< + * + * def __and__(self, other): */ - __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) { + __Pyx_TraceLine(461,0,__PYX_ERR(1, 461, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 461, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_self); + __Pyx_GIVEREF(__pyx_v_self); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self)) __PYX_ERR(1, 461, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_other); + __Pyx_GIVEREF(__pyx_v_other); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_other)) __PYX_ERR(1, 461, __pyx_L1_error); + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_Or), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 461, __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; + + /* "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_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; +} - /* "hunter/_predicates.pyx":475 +/* "hunter/_predicates.pyx":463 + * return Or(self, other) + * + * def __and__(self, other): # <<<<<<<<<<<<<< * cdef list predicates - * if type(self) is Or: - * predicates = list(( self).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("__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 */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +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_RefNannyDeclarations + 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_RefNannySetupContext("__and__", 1); + __Pyx_TraceCall("__and__", __pyx_f[1], 463, 0, __PYX_ERR(1, 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,0,__PYX_ERR(1, 465, __pyx_L1_error)) + __pyx_t_1 = (((PyObject *)Py_TYPE(__pyx_v_self)) == ((PyObject *)__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(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; + __Pyx_TraceLine(466,0,__PYX_ERR(1, 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(1, 466, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_predicates = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; - /* "hunter/_predicates.pyx":474 - * def __or__(self, other): + /* "hunter/_predicates.pyx":465 + * def __and__(self, other): * cdef list predicates - * if type(self) is Or: # <<<<<<<<<<<<<< - * predicates = list(( self).predicates) + * if type(self) is And: # <<<<<<<<<<<<<< + * predicates = list(( self).predicates) * else: */ goto __pyx_L3; } - /* "hunter/_predicates.pyx":477 - * predicates = list(( self).predicates) + /* "hunter/_predicates.pyx":468 + * predicates = list(( self).predicates) * else: * predicates = [self] # <<<<<<<<<<<<<< - * if type(other) is Or: - * predicates.extend(( other).predicates) + * if isinstance(other, And): + * predicates.extend(( other).predicates) */ - __Pyx_TraceLine(477,0,__PYX_ERR(0, 477, __pyx_L1_error)) + __Pyx_TraceLine(468,0,__PYX_ERR(1, 468, __pyx_L1_error)) /*else*/ { - __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 477, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 468, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __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; + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_v_self)) __PYX_ERR(1, 468, __pyx_L1_error); + __pyx_v_predicates = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; } __pyx_L3:; - /* "hunter/_predicates.pyx":478 + /* "hunter/_predicates.pyx":469 * else: * predicates = [self] - * if type(other) is Or: # <<<<<<<<<<<<<< - * predicates.extend(( other).predicates) + * if isinstance(other, And): # <<<<<<<<<<<<<< + * 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); + __Pyx_TraceLine(469,0,__PYX_ERR(1, 469, __pyx_L1_error)) + __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_other, __pyx_ptype_6hunter_11_predicates_And); if (__pyx_t_1) { - /* "hunter/_predicates.pyx":479 + /* "hunter/_predicates.pyx":470 * predicates = [self] - * if type(other) is Or: - * predicates.extend(( other).predicates) # <<<<<<<<<<<<<< + * if isinstance(other, And): + * 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) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_TraceLine(470,0,__PYX_ERR(1, 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(1, 470, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "hunter/_predicates.pyx":478 + /* "hunter/_predicates.pyx":469 * else: * predicates = [self] - * if type(other) is Or: # <<<<<<<<<<<<<< - * predicates.extend(( other).predicates) + * if isinstance(other, And): # <<<<<<<<<<<<<< + * predicates.extend(( other).predicates) * else: */ goto __pyx_L4; } - /* "hunter/_predicates.pyx":481 - * predicates.extend(( other).predicates) + /* "hunter/_predicates.pyx":472 + * predicates.extend(( other).predicates) * else: * predicates.append(other) # <<<<<<<<<<<<<< - * return Or(*predicates) + * return And(*predicates) * */ - __Pyx_TraceLine(481,0,__PYX_ERR(0, 481, __pyx_L1_error)) + __Pyx_TraceLine(472,0,__PYX_ERR(1, 472, __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) + __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_predicates, __pyx_v_other); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 472, __pyx_L1_error) } __pyx_L4:; - /* "hunter/_predicates.pyx":482 + /* "hunter/_predicates.pyx":473 * else: * predicates.append(other) - * return Or(*predicates) # <<<<<<<<<<<<<< - * - * 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; - - /* "hunter/_predicates.pyx":472 - * return fast_Or_call(self, event) - * - * def __or__(self, other): # <<<<<<<<<<<<<< - * cdef list predicates - * if type(self) is Or: - */ - - /* function exit code */ - __pyx_L1_error:; - __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_L0:; - __Pyx_XDECREF(__pyx_v_predicates); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "hunter/_predicates.pyx":484 - * return Or(*predicates) - * - * def __and__(self, other): # <<<<<<<<<<<<<< - * return And(self, other) - * - */ - -/* 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; - __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)); - - /* function exit code */ - __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 - __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)); - - /* "hunter/_predicates.pyx":485 - * - * def __and__(self, other): - * return And(self, other) # <<<<<<<<<<<<<< + * return And(*predicates) # <<<<<<<<<<<<<< * * def __invert__(self): */ - __Pyx_TraceLine(485,0,__PYX_ERR(0, 485, __pyx_L1_error)) + __Pyx_TraceLine(473,0,__PYX_ERR(1, 473, __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_t_2 = PySequence_Tuple(__pyx_v_predicates); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 473, __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_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_And), __pyx_t_2, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 473, __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; goto __pyx_L0; - /* "hunter/_predicates.pyx":484 - * return Or(*predicates) + /* "hunter/_predicates.pyx":463 + * return Or(self, other) * * def __and__(self, other): # <<<<<<<<<<<<<< - * return 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.__and__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("hunter._predicates.And.__and__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; + __Pyx_XDECREF(__pyx_v_predicates); __Pyx_XGIVEREF(__pyx_r); __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":487 - * return And(self, other) +/* "hunter/_predicates.pyx":475 + * return And(*predicates) * * def __invert__(self): # <<<<<<<<<<<<<< * return Not(self) @@ -14134,43 +16976,48 @@ static PyObject *__pyx_pf_6hunter_11_predicates_2Or_14__and__(PyObject *__pyx_v_ */ /* 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_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("__invert__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_2Or_16__invert__(((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_self)); + __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_16__invert__(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_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__invert__", 0); - __Pyx_TraceCall("__invert__", __pyx_f[0], 487, 0, __PYX_ERR(0, 487, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__invert__", 1); + __Pyx_TraceCall("__invert__", __pyx_f[1], 475, 0, __PYX_ERR(1, 475, __pyx_L1_error)); - /* "hunter/_predicates.pyx":488 + /* "hunter/_predicates.pyx":476 * * def __invert__(self): * return Not(self) # <<<<<<<<<<<<<< * - * cdef inline fast_Or_call(Or self, Event event): + * cdef inline fast_And_call(And self, Event event): */ - __Pyx_TraceLine(488,0,__PYX_ERR(0, 488, __pyx_L1_error)) + __Pyx_TraceLine(476,0,__PYX_ERR(1, 476, __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_PyObject_CallOneArg(((PyObject *)__pyx_ptype_6hunter_11_predicates_Not), ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 476, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "hunter/_predicates.pyx":487 - * return And(self, other) + /* "hunter/_predicates.pyx":475 + * return And(*predicates) * * def __invert__(self): # <<<<<<<<<<<<<< * return Not(self) @@ -14180,7 +17027,7 @@ static PyObject *__pyx_pf_6hunter_11_predicates_2Or_16__invert__(struct __pyx_ob /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.Or.__invert__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("hunter._predicates.And.__invert__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -14189,33 +17036,38 @@ static PyObject *__pyx_pf_6hunter_11_predicates_2Or_16__invert__(struct __pyx_ob return __pyx_r; } -/* "hunter/_predicates.pxd":29 - * cdef class Or: +/* "hunter/_predicates.pxd":25 + * cdef class And: * cdef: * readonly tuple predicates # <<<<<<<<<<<<<< * - * @cython.final + * */ /* 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_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("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_2Or_10predicates___get__(((struct __pyx_obj_6hunter_11_predicates_Or *)__pyx_v_self)); + __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_10predicates___get__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self) { +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_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 29, 0, __PYX_ERR(1, 29, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[2], 25, 0, __PYX_ERR(2, 25, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->predicates); __pyx_r = __pyx_v_self->predicates; @@ -14223,7 +17075,7 @@ static PyObject *__pyx_pf_6hunter_11_predicates_2Or_10predicates___get__(struct /* function exit code */ __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.Or.predicates.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("hunter._predicates.And.predicates.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -14239,19 +17091,47 @@ static PyObject *__pyx_pf_6hunter_11_predicates_2Or_10predicates___get__(struct */ /* 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_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*)(__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("__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)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __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;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) 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 PyObject *__pyx_pf_6hunter_11_predicates_2Or_18__reduce_cython__(struct __pyx_obj_6hunter_11_predicates_Or *__pyx_v_self) { +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; @@ -14260,11 +17140,14 @@ static PyObject *__pyx_pf_6hunter_11_predicates_2Or_18__reduce_cython__(struct _ __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; - int __pyx_t_3; + PyObject *__pyx_t_3 = NULL; 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)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__18) + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + __Pyx_TraceCall("__reduce_cython__", __pyx_f[0], 1, 0, __PYX_ERR(0, 1, __pyx_L1_error)); /* "(tree fragment)":5 * cdef object _dict @@ -14273,12 +17156,12 @@ static PyObject *__pyx_pf_6hunter_11_predicates_2Or_18__reduce_cython__(struct _ * _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_TraceLine(5,0,__PYX_ERR(0, 5, __pyx_L1_error)) + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->predicates)) __PYX_ERR(0, 5, __pyx_L1_error); __pyx_v_state = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; @@ -14289,8 +17172,8 @@ static PyObject *__pyx_pf_6hunter_11_predicates_2Or_18__reduce_cython__(struct _ * 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_TraceLine(6,0,__PYX_ERR(0, 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(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v__dict = __pyx_t_1; __pyx_t_1 = 0; @@ -14302,10 +17185,9 @@ static PyObject *__pyx_pf_6hunter_11_predicates_2Or_18__reduce_cython__(struct _ * state += (_dict,) * use_setstate = True */ - __Pyx_TraceLine(7,0,__PYX_ERR(2, 7, __pyx_L1_error)) + __Pyx_TraceLine(7,0,__PYX_ERR(0, 7, __pyx_L1_error)) __pyx_t_2 = (__pyx_v__dict != Py_None); - __pyx_t_3 = (__pyx_t_2 != 0); - if (__pyx_t_3) { + if (__pyx_t_2) { /* "(tree fragment)":8 * _dict = getattr(self, '__dict__', None) @@ -14314,17 +17196,17 @@ static PyObject *__pyx_pf_6hunter_11_predicates_2Or_18__reduce_cython__(struct _ * 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_TraceLine(8,0,__PYX_ERR(0, 8, __pyx_L1_error)) + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(0, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 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_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: @@ -14333,7 +17215,7 @@ static PyObject *__pyx_pf_6hunter_11_predicates_2Or_18__reduce_cython__(struct _ * else: * use_setstate = self.predicates is not None */ - __Pyx_TraceLine(9,0,__PYX_ERR(2, 9, __pyx_L1_error)) + __Pyx_TraceLine(9,0,__PYX_ERR(0, 9, __pyx_L1_error)) __pyx_v_use_setstate = 1; /* "(tree fragment)":7 @@ -14351,12 +17233,12 @@ static PyObject *__pyx_pf_6hunter_11_predicates_2Or_18__reduce_cython__(struct _ * else: * use_setstate = self.predicates is not None # <<<<<<<<<<<<<< * if use_setstate: - * return __pyx_unpickle_Or, (type(self), 0xaa8cbda, None), state + * return __pyx_unpickle_And, (type(self), 0x8e21672, None), state */ - __Pyx_TraceLine(11,0,__PYX_ERR(2, 11, __pyx_L1_error)) + __Pyx_TraceLine(11,0,__PYX_ERR(0, 11, __pyx_L1_error)) /*else*/ { - __pyx_t_3 = (__pyx_v_self->predicates != ((PyObject*)Py_None)); - __pyx_v_use_setstate = __pyx_t_3; + __pyx_t_2 = (__pyx_v_self->predicates != ((PyObject*)Py_None)); + __pyx_v_use_setstate = __pyx_t_2; } __pyx_L3:; @@ -14364,92 +17246,91 @@ static PyObject *__pyx_pf_6hunter_11_predicates_2Or_18__reduce_cython__(struct _ * else: * use_setstate = self.predicates is not None * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_Or, (type(self), 0xaa8cbda, None), state + * return __pyx_unpickle_And, (type(self), 0x8e21672, 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) { + __Pyx_TraceLine(12,0,__PYX_ERR(0, 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_Or, (type(self), 0xaa8cbda, None), state # <<<<<<<<<<<<<< + * return __pyx_unpickle_And, (type(self), 0x8e21672, None), state # <<<<<<<<<<<<<< * else: - * return __pyx_unpickle_Or, (type(self), 0xaa8cbda, state) + * return __pyx_unpickle_And, (type(self), 0x8e21672, state) */ - __Pyx_TraceLine(13,0,__PYX_ERR(2, 13, __pyx_L1_error)) + __Pyx_TraceLine(13,0,__PYX_ERR(0, 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_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_And); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(0, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_149034610); + __Pyx_GIVEREF(__pyx_int_149034610); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_149034610)) __PYX_ERR(0, 13, __pyx_L1_error); __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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(0, 13, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 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)) __PYX_ERR(0, 13, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); - PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state); - __pyx_t_4 = 0; + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(0, 13, __pyx_L1_error); + __pyx_t_3 = 0; __pyx_t_1 = 0; - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; - goto __pyx_L0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 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 + * return __pyx_unpickle_And, (type(self), 0x8e21672, None), state * else: */ } /* "(tree fragment)":15 - * return __pyx_unpickle_Or, (type(self), 0xaa8cbda, None), state + * return __pyx_unpickle_And, (type(self), 0x8e21672, None), state * else: - * return __pyx_unpickle_Or, (type(self), 0xaa8cbda, state) # <<<<<<<<<<<<<< + * return __pyx_unpickle_And, (type(self), 0x8e21672, state) # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_Or__set_state(self, __pyx_state) + * __pyx_unpickle_And__set_state(self, __pyx_state) */ - __Pyx_TraceLine(15,0,__PYX_ERR(2, 15, __pyx_L1_error)) + __Pyx_TraceLine(15,0,__PYX_ERR(0, 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_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_And); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(0, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_149034610); + __Pyx_GIVEREF(__pyx_int_149034610); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_149034610)) __PYX_ERR(0, 15, __pyx_L1_error); __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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(0, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 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)) __PYX_ERR(0, 15, __pyx_L1_error); __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; + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(0, 15, __pyx_L1_error); __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; goto __pyx_L0; } @@ -14462,9 +17343,9 @@ static PyObject *__pyx_pf_6hunter_11_predicates_2Or_18__reduce_cython__(struct _ /* 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_AddTraceback("hunter._predicates.Or.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("hunter._predicates.And.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_state); @@ -14477,48 +17358,135 @@ static PyObject *__pyx_pf_6hunter_11_predicates_2Or_18__reduce_cython__(struct _ /* "(tree fragment)":16 * else: - * return __pyx_unpickle_Or, (type(self), 0xaa8cbda, state) + * return __pyx_unpickle_And, (type(self), 0x8e21672, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle_Or__set_state(self, __pyx_state) + * __pyx_unpickle_And__set_state(self, __pyx_state) */ /* 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_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*)(__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("__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)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __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 **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __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(0, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(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:; + __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 */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __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_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_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(__pyx_codeobj__19) + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + __Pyx_TraceCall("__setstate_cython__", __pyx_f[0], 16, 0, __PYX_ERR(0, 16, __pyx_L1_error)); /* "(tree fragment)":17 - * return __pyx_unpickle_Or, (type(self), 0xaa8cbda, state) + * return __pyx_unpickle_And, (type(self), 0x8e21672, state) * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_Or__set_state(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_Or__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 17, __pyx_L1_error) + __Pyx_TraceLine(17,0,__PYX_ERR(0, 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(0, 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(0, 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_Or, (type(self), 0xaa8cbda, state) + * return __pyx_unpickle_And, (type(self), 0x8e21672, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle_Or__set_state(self, __pyx_state) + * __pyx_unpickle_And__set_state(self, __pyx_state) */ /* function exit code */ @@ -14526,7 +17494,7 @@ static PyObject *__pyx_pf_6hunter_11_predicates_2Or_20__setstate_cython__(struct 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_AddTraceback("hunter._predicates.And.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -14535,15 +17503,15 @@ static PyObject *__pyx_pf_6hunter_11_predicates_2Or_20__setstate_cython__(struct return __pyx_r; } -/* "hunter/_predicates.pyx":490 +/* "hunter/_predicates.pyx":478 * return Not(self) * - * cdef inline fast_Or_call(Or self, Event event): # <<<<<<<<<<<<<< + * cdef inline fast_And_call(And self, Event event): # <<<<<<<<<<<<<< * for predicate in self.predicates: - * if fast_call(predicate, event): + * if not fast_call(predicate, event): */ -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) { +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 @@ -14552,119 +17520,121 @@ static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_fast_Or_call(struct 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_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("fast_And_call", 1); + __Pyx_TraceCall("fast_And_call", __pyx_f[1], 478, 0, __PYX_ERR(1, 478, __pyx_L1_error)); - /* "hunter/_predicates.pyx":491 + /* "hunter/_predicates.pyx":479 * - * cdef inline fast_Or_call(Or self, Event event): + * cdef inline fast_And_call(And self, Event event): * for predicate in self.predicates: # <<<<<<<<<<<<<< - * if fast_call(predicate, event): - * return True + * if not fast_call(predicate, event): + * return False */ - __Pyx_TraceLine(491,0,__PYX_ERR(0, 491, __pyx_L1_error)) + __Pyx_TraceLine(479,0,__PYX_ERR(1, 479, __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) + __PYX_ERR(1, 479, __pyx_L1_error) } - __pyx_t_1 = __pyx_v_self->predicates; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + __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; + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 479, __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, 491, __pyx_L1_error) + __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(1, 479, __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_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 479, __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): + /* "hunter/_predicates.pyx":480 + * cdef inline fast_And_call(And self, Event event): * for predicate in self.predicates: - * if fast_call(predicate, event): # <<<<<<<<<<<<<< - * return True + * if not fast_call(predicate, event): # <<<<<<<<<<<<<< + * return False * 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_TraceLine(480,0,__PYX_ERR(1, 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(1, 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, 492, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(1, 480, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_4) { + __pyx_t_5 = (!__pyx_t_4); + if (__pyx_t_5) { - /* "hunter/_predicates.pyx":493 + /* "hunter/_predicates.pyx":481 * for predicate in self.predicates: - * if fast_call(predicate, event): - * return True # <<<<<<<<<<<<<< + * if not fast_call(predicate, event): + * return False # <<<<<<<<<<<<<< * else: - * return False + * return True */ - __Pyx_TraceLine(493,0,__PYX_ERR(0, 493, __pyx_L1_error)) + __Pyx_TraceLine(481,0,__PYX_ERR(1, 481, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(Py_True); - __pyx_r = Py_True; + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; - /* "hunter/_predicates.pyx":492 - * cdef inline fast_Or_call(Or self, Event event): + /* "hunter/_predicates.pyx":480 + * cdef inline fast_And_call(And self, Event event): * for predicate in self.predicates: - * if fast_call(predicate, event): # <<<<<<<<<<<<<< - * return True + * if not fast_call(predicate, event): # <<<<<<<<<<<<<< + * return False * else: */ } - /* "hunter/_predicates.pyx":491 + /* "hunter/_predicates.pyx":479 * - * cdef inline fast_Or_call(Or self, Event event): + * cdef inline fast_And_call(And self, Event event): * for predicate in self.predicates: # <<<<<<<<<<<<<< - * if fast_call(predicate, event): - * return True + * if not fast_call(predicate, event): + * return False */ - __Pyx_TraceLine(491,0,__PYX_ERR(0, 491, __pyx_L1_error)) + __Pyx_TraceLine(479,0,__PYX_ERR(1, 479, __pyx_L1_error)) } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /*else*/ { - /* "hunter/_predicates.pyx":495 - * return True + /* "hunter/_predicates.pyx":483 + * return False * else: - * return False # <<<<<<<<<<<<<< + * return True # <<<<<<<<<<<<<< * * */ - __Pyx_TraceLine(495,0,__PYX_ERR(0, 495, __pyx_L1_error)) + __Pyx_TraceLine(483,0,__PYX_ERR(1, 483, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(Py_False); - __pyx_r = Py_False; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_INCREF(Py_True); + __pyx_r = Py_True; goto __pyx_L0; } - /* "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)) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "hunter/_predicates.pyx":490 + /* "hunter/_predicates.pyx":478 * return Not(self) * - * cdef inline fast_Or_call(Or self, Event event): # <<<<<<<<<<<<<< + * cdef inline fast_And_call(And self, Event event): # <<<<<<<<<<<<<< * for predicate in self.predicates: - * if fast_call(predicate, event): + * if not fast_call(predicate, event): */ /* 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_AddTraceback("hunter._predicates.fast_And_call", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_predicate); @@ -14674,90 +17644,69 @@ static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_fast_Or_call(struct return __pyx_r; } -/* "hunter/_predicates.pyx":502 - * `Not` predicate. +/* "hunter/_predicates.pyx":492 * """ - * def __init__(self, predicate): # <<<<<<<<<<<<<< - * self.predicate = predicate + * + * def __init__(self, *predicates): # <<<<<<<<<<<<<< + * self.predicates = predicates * */ /* 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; +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("__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); + #if CYTHON_ASSUME_SAFE_MACROS + __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_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && 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); /* function exit code */ + __Pyx_DECREF(__pyx_v_predicates); __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) { +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 __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__init__", 0); - __Pyx_TraceCall("__init__", __pyx_f[0], 502, 0, __PYX_ERR(0, 502, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 1); + __Pyx_TraceCall("__init__", __pyx_f[1], 492, 0, __PYX_ERR(1, 492, __pyx_L1_error)); - /* "hunter/_predicates.pyx":503 - * """ - * def __init__(self, predicate): - * self.predicate = predicate # <<<<<<<<<<<<<< + /* "hunter/_predicates.pyx":493 + * + * def __init__(self, *predicates): + * self.predicates = predicates # <<<<<<<<<<<<<< * * 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; + __Pyx_TraceLine(493,0,__PYX_ERR(1, 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":502 - * `Not` predicate. + /* "hunter/_predicates.pyx":492 * """ - * def __init__(self, predicate): # <<<<<<<<<<<<<< - * self.predicate = predicate + * + * def __init__(self, *predicates): # <<<<<<<<<<<<<< + * self.predicates = predicates * */ @@ -14765,7 +17714,7 @@ static int __pyx_pf_6hunter_11_predicates_3Not___init__(struct __pyx_obj_6hunter __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.Not.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("hunter._predicates.Or.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_TraceReturn(Py_None, 0); @@ -14773,126 +17722,300 @@ static int __pyx_pf_6hunter_11_predicates_3Not___init__(struct __pyx_obj_6hunter return __pyx_r; } -/* "hunter/_predicates.pyx":505 - * self.predicate = predicate +/* "hunter/_predicates.pyx":495 + * self.predicates = predicates * * def __str__(self): # <<<<<<<<<<<<<< - * return 'Not(%s)' % self.predicate + * return 'Or(%s)' % ', '.join(str(p) for p in self.predicates) * */ /* 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_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("__str__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_3Not_2__str__(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self)); + __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 */ -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_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)); - - /* "hunter/_predicates.pyx":506 +/* "hunter/_predicates.pyx":496 * * def __str__(self): - * return 'Not(%s)' % self.predicate # <<<<<<<<<<<<<< + * return 'Or(%s)' % ', '.join(str(p) for p in self.predicates) # <<<<<<<<<<<<<< * * def __repr__(self): */ - __Pyx_TraceLine(506,0,__PYX_ERR(0, 506, __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_1 = 0; - goto __pyx_L0; - /* "hunter/_predicates.pyx":505 - * self.predicate = predicate - * - * def __str__(self): # <<<<<<<<<<<<<< - * return 'Not(%s)' % self.predicate - * - */ +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_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_ptype_6hunter_11_predicates___pyx_scope_struct_5_genexpr, __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(1, 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, 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(1, 496, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.Not.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("hunter._predicates.Or.__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":508 - * return 'Not(%s)' % self.predicate +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_TraceDeclarations + 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); + __Pyx_TraceCall("genexpr", __pyx_f[1], 496, 0, __PYX_ERR(1, 496, __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(1, 496, __pyx_L1_error) + if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(1, 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(1, 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_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 496, __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(1, 496, __pyx_L1_error) + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 496, __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_Str(__pyx_cur_scope->__pyx_v_p); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 496, __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(1, 496, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + + /* function exit code */ + PyErr_SetNone(PyExc_StopIteration); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_Generator_Replace_StopIteration(0); + __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":495 + * 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) { + PyObject *__pyx_gb_6hunter_11_predicates_2Or_7__str___2generator4 = 0; + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations + __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_RefNannySetupContext("__str__", 1); + __Pyx_TraceCall("__str__", __pyx_f[1], 495, 0, __PYX_ERR(1, 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,0,__PYX_ERR(1, 496, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_pf_6hunter_11_predicates_2Or_7__str___genexpr(NULL, __pyx_v_self->predicates); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 496, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyString_Join(__pyx_kp_s__8, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 496, __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(1, 496, __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":495 + * self.predicates = predicates + * + * 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_XDECREF(__pyx_t_2); + __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_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/_predicates.pyx":498 + * return 'Or(%s)' % ', '.join(str(p) for p in self.predicates) * * def __repr__(self): # <<<<<<<<<<<<<< - * return '' % self.predicate + * return '' % (self.predicates,) * */ /* 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_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("__repr__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_3Not_4__repr__(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self)); + __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_3Not_4__repr__(struct __pyx_obj_6hunter_11_predicates_Not *__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_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)); + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__repr__", 1); + __Pyx_TraceCall("__repr__", __pyx_f[1], 498, 0, __PYX_ERR(1, 498, __pyx_L1_error)); - /* "hunter/_predicates.pyx":509 + /* "hunter/_predicates.pyx":499 * * def __repr__(self): - * return '' % self.predicate # <<<<<<<<<<<<<< + * return '' % (self.predicates,) # <<<<<<<<<<<<<< * * def __eq__(self, other): */ - __Pyx_TraceLine(509,0,__PYX_ERR(0, 509, __pyx_L1_error)) + __Pyx_TraceLine(499,0,__PYX_ERR(1, 499, __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_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 499, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; + __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)) __PYX_ERR(1, 499, __pyx_L1_error); + __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_hunter__predicates_Or_predicate, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 499, __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; - /* "hunter/_predicates.pyx":508 - * return 'Not(%s)' % self.predicate + /* "hunter/_predicates.pyx":498 + * return 'Or(%s)' % ', '.join(str(p) for p in self.predicates) * * def __repr__(self): # <<<<<<<<<<<<<< - * return '' % self.predicate + * return '' % (self.predicates,) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.Not.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("hunter._predicates.Or.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -14901,74 +18024,79 @@ static PyObject *__pyx_pf_6hunter_11_predicates_3Not_4__repr__(struct __pyx_obj_ return __pyx_r; } -/* "hunter/_predicates.pyx":511 - * return '' % self.predicate +/* "hunter/_predicates.pyx":501 + * return '' % (self.predicates,) * * def __eq__(self, other): # <<<<<<<<<<<<<< * return ( - * isinstance(other, Not) + * isinstance(other, Or) */ /* 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_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("__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_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_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_6__eq__(struct __pyx_obj_6hunter_11_predicates_Or *__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], 511, 0, __PYX_ERR(0, 511, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__eq__", 1); + __Pyx_TraceCall("__eq__", __pyx_f[1], 501, 0, __PYX_ERR(1, 501, __pyx_L1_error)); - /* "hunter/_predicates.pyx":512 + /* "hunter/_predicates.pyx":502 * * def __eq__(self, other): * return ( # <<<<<<<<<<<<<< - * isinstance(other, Not) - * and self.predicate == ( other).predicate + * isinstance(other, Or) + * and self.predicates == ( other).predicates */ - __Pyx_TraceLine(512,0,__PYX_ERR(0, 512, __pyx_L1_error)) + __Pyx_TraceLine(502,0,__PYX_ERR(1, 502, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - /* "hunter/_predicates.pyx":513 + /* "hunter/_predicates.pyx":503 * def __eq__(self, other): * return ( - * isinstance(other, Not) # <<<<<<<<<<<<<< - * and self.predicate == ( other).predicate + * isinstance(other, Or) # <<<<<<<<<<<<<< + * and self.predicates == ( other).predicates * ) */ - __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); + __Pyx_TraceLine(503,0,__PYX_ERR(1, 503, __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, 513, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 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; } - /* "hunter/_predicates.pyx":514 + /* "hunter/_predicates.pyx":504 * return ( - * isinstance(other, Not) - * and self.predicate == ( other).predicate # <<<<<<<<<<<<<< + * isinstance(other, Or) + * and self.predicates == ( other).predicates # <<<<<<<<<<<<<< * ) * */ - __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_TraceLine(504,0,__PYX_ERR(1, 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(1, 504, __pyx_L1_error) __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = __pyx_t_3; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -14977,19 +18105,19 @@ static PyObject *__pyx_pf_6hunter_11_predicates_3Not_6__eq__(struct __pyx_obj_6h __pyx_t_1 = 0; goto __pyx_L0; - /* "hunter/_predicates.pyx":511 - * return '' % self.predicate + /* "hunter/_predicates.pyx":501 + * return '' % (self.predicates,) * * def __eq__(self, other): # <<<<<<<<<<<<<< * return ( - * isinstance(other, Not) + * isinstance(other, Or) */ /* 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_AddTraceback("hunter._predicates.Or.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -14998,175 +18126,136 @@ static PyObject *__pyx_pf_6hunter_11_predicates_3Not_6__eq__(struct __pyx_obj_6h return __pyx_r; } -/* "hunter/_predicates.pyx":517 - * ) - * - * def __hash__(self): # <<<<<<<<<<<<<< - * return hash(('Not', self.predicate)) - * - */ - -/* 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)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -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)); - - /* "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; - - /* "hunter/_predicates.pyx":517 +/* "hunter/_predicates.pyx":507 * ) * - * def __hash__(self): # <<<<<<<<<<<<<< - * return hash(('Not', self.predicate)) - * - */ - - /* 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_L0:; - if (unlikely(__pyx_r == -1) && !PyErr_Occurred()) __pyx_r = -2; - __Pyx_TraceReturn(Py_None, 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) + * return fast_Or_call(self, event) * */ /* 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) { +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("__call__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __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_event,0}; - PyObject* values[1] = {0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_event,0}; + if (__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); + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_event)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_event)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 507, __pyx_L3_error) 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 (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__call__") < 0)) __PYX_ERR(1, 507, __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_Arg_VARARGS(__pyx_args, 0); } __pyx_v_event = ((struct __pyx_obj_6hunter_6_event_Event *)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("__call__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 507, __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); + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(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_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); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_event), __pyx_ptype_6hunter_6_event_Event, 1, "event", 0))) __PYX_ERR(1, 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; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(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_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_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_RefNannySetupContext("__call__", 1); + __Pyx_TraceCall("__call__", __pyx_f[1], 507, 0, __PYX_ERR(1, 507, __pyx_L1_error)); - /* "hunter/_predicates.pyx":521 + /* "hunter/_predicates.pyx":508 * * def __call__(self, Event event): - * return fast_Not_call(self, event) # <<<<<<<<<<<<<< + * return fast_Or_call(self, event) # <<<<<<<<<<<<<< * * def __or__(self, other): */ - __Pyx_TraceLine(521,0,__PYX_ERR(0, 521, __pyx_L1_error)) + __Pyx_TraceLine(508,0,__PYX_ERR(1, 508, __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) + __pyx_t_1 = __pyx_f_6hunter_11_predicates_fast_Or_call(__pyx_v_self, __pyx_v_event); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 508, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "hunter/_predicates.pyx":520 - * return hash(('Not', self.predicate)) + /* "hunter/_predicates.pyx":507 + * ) * * def __call__(self, Event event): # <<<<<<<<<<<<<< - * return fast_Not_call(self, event) + * return fast_Or_call(self, event) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("hunter._predicates.Not.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("hunter._predicates.Or.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -15175,272 +18264,256 @@ static PyObject *__pyx_pf_6hunter_11_predicates_3Not_10__call__(struct __pyx_obj return __pyx_r; } -/* "hunter/_predicates.pyx":523 - * return fast_Not_call(self, event) +/* "hunter/_predicates.pyx":510 + * return fast_Or_call(self, event) * * def __or__(self, other): # <<<<<<<<<<<<<< - * if type(self) is Not and type(other) is Not: - * return Not(And(( self).predicate, ( other).predicate)) + * cdef list predicates + * if type(self) is Or: */ /* 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) { +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_r = __pyx_pf_6hunter_11_predicates_3Not_12__or__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + __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_3Not_12__or__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { +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_RefNannyDeclarations int __pyx_t_1; - int __pyx_t_2; + PyObject *__pyx_t_2 = NULL; 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)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__or__", 1); + __Pyx_TraceCall("__or__", __pyx_f[1], 510, 0, __PYX_ERR(1, 510, __pyx_L1_error)); - /* "hunter/_predicates.pyx":524 - * + /* "hunter/_predicates.pyx":512 * def __or__(self, other): - * if type(self) is Not and type(other) is Not: # <<<<<<<<<<<<<< - * return Not(And(( self).predicate, ( other).predicate)) + * cdef list predicates + * if type(self) is Or: # <<<<<<<<<<<<<< + * predicates = list(( self).predicates) * 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; - } - __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:; + __Pyx_TraceLine(512,0,__PYX_ERR(1, 512, __pyx_L1_error)) + __pyx_t_1 = (((PyObject *)Py_TYPE(__pyx_v_self)) == ((PyObject *)__pyx_ptype_6hunter_11_predicates_Or)); if (__pyx_t_1) { - /* "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)) # <<<<<<<<<<<<<< + /* "hunter/_predicates.pyx":513 + * cdef list predicates + * if type(self) is Or: + * predicates = list(( self).predicates) # <<<<<<<<<<<<<< * else: - * return Or(self, other) + * predicates = [self] */ - __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; + __Pyx_TraceLine(513,0,__PYX_ERR(1, 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(1, 513, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_predicates = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; - /* "hunter/_predicates.pyx":524 - * + /* "hunter/_predicates.pyx":512 * def __or__(self, other): - * if type(self) is Not and type(other) is Not: # <<<<<<<<<<<<<< - * return Not(And(( self).predicate, ( other).predicate)) + * cdef list predicates + * if type(self) is Or: # <<<<<<<<<<<<<< + * predicates = list(( self).predicates) * else: */ + goto __pyx_L3; } - /* "hunter/_predicates.pyx":527 - * return Not(And(( self).predicate, ( other).predicate)) + /* "hunter/_predicates.pyx":515 + * predicates = list(( self).predicates) * else: - * return Or(self, other) # <<<<<<<<<<<<<< - * - * def __and__(self, other): + * predicates = [self] # <<<<<<<<<<<<<< + * if type(other) is Or: + * predicates.extend(( other).predicates) */ - __Pyx_TraceLine(527,0,__PYX_ERR(0, 527, __pyx_L1_error)) + __Pyx_TraceLine(515,0,__PYX_ERR(1, 515, __pyx_L1_error)) /*else*/ { - __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_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 515, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __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; - goto __pyx_L0; + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_v_self)) __PYX_ERR(1, 515, __pyx_L1_error); + __pyx_v_predicates = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; } + __pyx_L3:; - /* "hunter/_predicates.pyx":523 - * return fast_Not_call(self, event) + /* "hunter/_predicates.pyx":516 + * else: + * predicates = [self] + * if type(other) is Or: # <<<<<<<<<<<<<< + * predicates.extend(( other).predicates) + * else: + */ + __Pyx_TraceLine(516,0,__PYX_ERR(1, 516, __pyx_L1_error)) + __pyx_t_1 = (((PyObject *)Py_TYPE(__pyx_v_other)) == ((PyObject *)__pyx_ptype_6hunter_11_predicates_Or)); + if (__pyx_t_1) { + + /* "hunter/_predicates.pyx":517 + * predicates = [self] + * if type(other) is Or: + * predicates.extend(( other).predicates) # <<<<<<<<<<<<<< + * else: + * predicates.append(other) + */ + __Pyx_TraceLine(517,0,__PYX_ERR(1, 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(1, 517, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "hunter/_predicates.pyx":516 + * else: + * predicates = [self] + * if type(other) is Or: # <<<<<<<<<<<<<< + * predicates.extend(( other).predicates) + * else: + */ + goto __pyx_L4; + } + + /* "hunter/_predicates.pyx":519 + * predicates.extend(( other).predicates) + * else: + * predicates.append(other) # <<<<<<<<<<<<<< + * return Or(*predicates) + * + */ + __Pyx_TraceLine(519,0,__PYX_ERR(1, 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(1, 519, __pyx_L1_error) + } + __pyx_L4:; + + /* "hunter/_predicates.pyx":520 + * else: + * predicates.append(other) + * return Or(*predicates) # <<<<<<<<<<<<<< + * + * def __and__(self, other): + */ + __Pyx_TraceLine(520,0,__PYX_ERR(1, 520, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = PySequence_Tuple(__pyx_v_predicates); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 520, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_Or), __pyx_t_2, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 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; + goto __pyx_L0; + + /* "hunter/_predicates.pyx":510 + * return fast_Or_call(self, event) * * def __or__(self, other): # <<<<<<<<<<<<<< - * if type(self) is Not and type(other) is Not: - * return Not(And(( self).predicate, ( other).predicate)) + * cdef list predicates + * if type(self) is Or: */ /* function exit code */ __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("hunter._predicates.Not.__or__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("hunter._predicates.Or.__or__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; + __Pyx_XDECREF(__pyx_v_predicates); __Pyx_XGIVEREF(__pyx_r); __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":529 - * return Or(self, other) +/* "hunter/_predicates.pyx":522 + * return Or(*predicates) * * def __and__(self, other): # <<<<<<<<<<<<<< - * if type(self) is Not and type(other) is Not: - * return Not(Or(( self).predicate, ( other).predicate)) + * return And(self, other) + * */ /* 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) { +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("__and__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_3Not_14__and__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + __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 PyObject *__pyx_pf_6hunter_11_predicates_3Not_14__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { +static PyObject *__pyx_pf_6hunter_11_predicates_2Or_12__and__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { PyObject *__pyx_r = NULL; __Pyx_TraceDeclarations __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; + 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("__and__", 1); + __Pyx_TraceCall("__and__", __pyx_f[1], 522, 0, __PYX_ERR(1, 522, __pyx_L1_error)); - /* "hunter/_predicates.pyx":530 + /* "hunter/_predicates.pyx":523 * * 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":533 - * return Not(Or(( self).predicate, ( other).predicate)) - * else: - * return And(self, other) # <<<<<<<<<<<<<< + * return And(self, other) # <<<<<<<<<<<<<< * * 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; - } + __Pyx_TraceLine(523,0,__PYX_ERR(1, 523, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 523, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_self); + __Pyx_GIVEREF(__pyx_v_self); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self)) __PYX_ERR(1, 523, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_other); + __Pyx_GIVEREF(__pyx_v_other); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_other)) __PYX_ERR(1, 523, __pyx_L1_error); + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_And), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 523, __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; - /* "hunter/_predicates.pyx":529 - * return Or(self, other) + /* "hunter/_predicates.pyx":522 + * return Or(*predicates) * * def __and__(self, other): # <<<<<<<<<<<<<< - * if type(self) is Not and type(other) is Not: - * return Not(Or(( self).predicate, ( other).predicate)) + * return And(self, other) + * */ /* function exit code */ __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_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_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -15449,58 +18522,67 @@ static PyObject *__pyx_pf_6hunter_11_predicates_3Not_14__and__(PyObject *__pyx_v return __pyx_r; } -/* "hunter/_predicates.pyx":535 - * return And(self, other) +/* "hunter/_predicates.pyx":525 + * return And(self, other) * * def __invert__(self): # <<<<<<<<<<<<<< - * return self.predicate + * return Not(self) * */ /* 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_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("__invert__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_3Not_16__invert__(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self)); + __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_16__invert__(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_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_RefNannySetupContext("__invert__", 1); + __Pyx_TraceCall("__invert__", __pyx_f[1], 525, 0, __PYX_ERR(1, 525, __pyx_L1_error)); - /* "hunter/_predicates.pyx":536 + /* "hunter/_predicates.pyx":526 * * def __invert__(self): - * return self.predicate # <<<<<<<<<<<<<< + * return Not(self) # <<<<<<<<<<<<<< * - * cdef inline fast_Not_call(Not self, Event event): + * cdef inline fast_Or_call(Or self, Event event): */ - __Pyx_TraceLine(536,0,__PYX_ERR(0, 536, __pyx_L1_error)) + __Pyx_TraceLine(526,0,__PYX_ERR(1, 526, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->predicate); - __pyx_r = __pyx_v_self->predicate; + __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_6hunter_11_predicates_Not), ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 526, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; goto __pyx_L0; - /* "hunter/_predicates.pyx":535 - * return And(self, other) + /* "hunter/_predicates.pyx":525 + * return And(self, other) * * def __invert__(self): # <<<<<<<<<<<<<< - * return self.predicate + * return Not(self) * */ /* function exit code */ __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.Not.__invert__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("hunter._predicates.Or.__invert__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -15509,41 +18591,46 @@ static PyObject *__pyx_pf_6hunter_11_predicates_3Not_16__invert__(struct __pyx_o return __pyx_r; } -/* "hunter/_predicates.pxd":34 - * cdef class Not: +/* "hunter/_predicates.pxd":31 + * cdef class Or: * cdef: - * readonly object predicate # <<<<<<<<<<<<<< + * readonly tuple predicates # <<<<<<<<<<<<<< + * * - * @cython.final */ /* 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_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("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_6hunter_11_predicates_3Not_9predicate___get__(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self)); + __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_9predicate___get__(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_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[1], 34, 0, __PYX_ERR(1, 34, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[2], 31, 0, __PYX_ERR(2, 31, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->predicate); - __pyx_r = __pyx_v_self->predicate; + __Pyx_INCREF(__pyx_v_self->predicates); + __pyx_r = __pyx_v_self->predicates; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; - __Pyx_AddTraceback("hunter._predicates.Not.predicate.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("hunter._predicates.Or.predicates.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -15559,19 +18646,47 @@ static PyObject *__pyx_pf_6hunter_11_predicates_3Not_9predicate___get__(struct _ */ /* 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_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*)(__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("__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)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __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;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) 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_18__reduce_cython__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self) { +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; @@ -15580,52 +18695,54 @@ static PyObject *__pyx_pf_6hunter_11_predicates_3Not_18__reduce_cython__(struct __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; - int __pyx_t_3; + PyObject *__pyx_t_3 = NULL; 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)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__20) + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + __Pyx_TraceCall("__reduce_cython__", __pyx_f[0], 1, 0, __PYX_ERR(0, 1, __pyx_L1_error)); /* "(tree fragment)":5 * cdef object _dict * cdef bint use_setstate - * state = (self.predicate,) # <<<<<<<<<<<<<< + * 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_TraceLine(5,0,__PYX_ERR(0, 5, __pyx_L1_error)) + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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_INCREF(__pyx_v_self->predicates); + __Pyx_GIVEREF(__pyx_v_self->predicates); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->predicates)) __PYX_ERR(0, 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,) + * 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_TraceLine(6,0,__PYX_ERR(0, 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(0, 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,) + * 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_TraceLine(7,0,__PYX_ERR(0, 7, __pyx_L1_error)) __pyx_t_2 = (__pyx_v__dict != Py_None); - __pyx_t_3 = (__pyx_t_2 != 0); - if (__pyx_t_3) { + if (__pyx_t_2) { /* "(tree fragment)":8 * _dict = getattr(self, '__dict__', None) @@ -15634,30 +18751,30 @@ static PyObject *__pyx_pf_6hunter_11_predicates_3Not_18__reduce_cython__(struct * 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_TraceLine(8,0,__PYX_ERR(0, 8, __pyx_L1_error)) + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(0, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 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_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.predicate is not None + * use_setstate = self.predicates is not None */ - __Pyx_TraceLine(9,0,__PYX_ERR(2, 9, __pyx_L1_error)) + __Pyx_TraceLine(9,0,__PYX_ERR(0, 9, __pyx_L1_error)) __pyx_v_use_setstate = 1; /* "(tree fragment)":7 - * state = (self.predicate,) + * state = (self.predicates,) * _dict = getattr(self, '__dict__', None) * if _dict is not None: # <<<<<<<<<<<<<< * state += (_dict,) @@ -15669,107 +18786,106 @@ static PyObject *__pyx_pf_6hunter_11_predicates_3Not_18__reduce_cython__(struct /* "(tree fragment)":11 * use_setstate = True * else: - * use_setstate = self.predicate is not None # <<<<<<<<<<<<<< + * use_setstate = self.predicates is not None # <<<<<<<<<<<<<< * if use_setstate: - * return __pyx_unpickle_Not, (type(self), 0xf670ef6, None), state + * return __pyx_unpickle_Or, (type(self), 0x8e21672, None), state */ - __Pyx_TraceLine(11,0,__PYX_ERR(2, 11, __pyx_L1_error)) + __Pyx_TraceLine(11,0,__PYX_ERR(0, 11, __pyx_L1_error)) /*else*/ { - __pyx_t_3 = (__pyx_v_self->predicate != Py_None); - __pyx_v_use_setstate = __pyx_t_3; + __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.predicate is not None + * use_setstate = self.predicates is not None * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_Not, (type(self), 0xf670ef6, None), state + * return __pyx_unpickle_Or, (type(self), 0x8e21672, 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) { + __Pyx_TraceLine(12,0,__PYX_ERR(0, 12, __pyx_L1_error)) + if (__pyx_v_use_setstate) { /* "(tree fragment)":13 - * use_setstate = self.predicate is not None + * use_setstate = self.predicates is not None * if use_setstate: - * return __pyx_unpickle_Not, (type(self), 0xf670ef6, None), state # <<<<<<<<<<<<<< + * return __pyx_unpickle_Or, (type(self), 0x8e21672, None), state # <<<<<<<<<<<<<< * else: - * return __pyx_unpickle_Not, (type(self), 0xf670ef6, state) + * return __pyx_unpickle_Or, (type(self), 0x8e21672, state) */ - __Pyx_TraceLine(13,0,__PYX_ERR(2, 13, __pyx_L1_error)) + __Pyx_TraceLine(13,0,__PYX_ERR(0, 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_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_Or); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(0, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_149034610); + __Pyx_GIVEREF(__pyx_int_149034610); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_149034610)) __PYX_ERR(0, 13, __pyx_L1_error); __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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(0, 13, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 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)) __PYX_ERR(0, 13, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); - PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state); - __pyx_t_4 = 0; + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(0, 13, __pyx_L1_error); + __pyx_t_3 = 0; __pyx_t_1 = 0; - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; goto __pyx_L0; /* "(tree fragment)":12 * else: - * use_setstate = self.predicate is not None + * use_setstate = self.predicates is not None * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_Not, (type(self), 0xf670ef6, None), state + * return __pyx_unpickle_Or, (type(self), 0x8e21672, None), state * else: */ } /* "(tree fragment)":15 - * return __pyx_unpickle_Not, (type(self), 0xf670ef6, None), state + * return __pyx_unpickle_Or, (type(self), 0x8e21672, None), state * else: - * return __pyx_unpickle_Not, (type(self), 0xf670ef6, state) # <<<<<<<<<<<<<< + * return __pyx_unpickle_Or, (type(self), 0x8e21672, state) # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_Not__set_state(self, __pyx_state) + * __pyx_unpickle_Or__set_state(self, __pyx_state) */ - __Pyx_TraceLine(15,0,__PYX_ERR(2, 15, __pyx_L1_error)) + __Pyx_TraceLine(15,0,__PYX_ERR(0, 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_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Or); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(0, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_149034610); + __Pyx_GIVEREF(__pyx_int_149034610); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_149034610)) __PYX_ERR(0, 15, __pyx_L1_error); __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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(0, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 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)) __PYX_ERR(0, 15, __pyx_L1_error); __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; + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(0, 15, __pyx_L1_error); __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; goto __pyx_L0; } @@ -15782,9 +18898,9 @@ static PyObject *__pyx_pf_6hunter_11_predicates_3Not_18__reduce_cython__(struct /* 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_AddTraceback("hunter._predicates.Not.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("hunter._predicates.Or.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_state); @@ -15797,48 +18913,135 @@ static PyObject *__pyx_pf_6hunter_11_predicates_3Not_18__reduce_cython__(struct /* "(tree fragment)":16 * else: - * return __pyx_unpickle_Not, (type(self), 0xf670ef6, state) + * return __pyx_unpickle_Or, (type(self), 0x8e21672, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle_Not__set_state(self, __pyx_state) + * __pyx_unpickle_Or__set_state(self, __pyx_state) */ /* 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_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*)(__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("__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)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __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 **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __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(0, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(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:; + __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 */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __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_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_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(__pyx_codeobj__21) + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + __Pyx_TraceCall("__setstate_cython__", __pyx_f[0], 16, 0, __PYX_ERR(0, 16, __pyx_L1_error)); /* "(tree fragment)":17 - * return __pyx_unpickle_Not, (type(self), 0xf670ef6, state) + * return __pyx_unpickle_Or, (type(self), 0x8e21672, state) * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_Not__set_state(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_Not__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 17, __pyx_L1_error) + __Pyx_TraceLine(17,0,__PYX_ERR(0, 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(0, 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(0, 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_Not, (type(self), 0xf670ef6, state) + * return __pyx_unpickle_Or, (type(self), 0x8e21672, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle_Not__set_state(self, __pyx_state) + * __pyx_unpickle_Or__set_state(self, __pyx_state) */ /* function exit code */ @@ -15846,7 +19049,7 @@ static PyObject *__pyx_pf_6hunter_11_predicates_3Not_20__setstate_cython__(struc 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_AddTraceback("hunter._predicates.Or.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -15855,347 +19058,509 @@ static PyObject *__pyx_pf_6hunter_11_predicates_3Not_20__setstate_cython__(struc 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":528 + * return Not(self) * + * cdef inline fast_Or_call(Or self, Event event): # <<<<<<<<<<<<<< + * for predicate in self.predicates: + * if fast_call(predicate, event): */ -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) { +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_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)); + 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_RefNannySetupContext("fast_Or_call", 1); + __Pyx_TraceCall("fast_Or_call", __pyx_f[1], 528, 0, __PYX_ERR(1, 528, __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":529 * + * cdef inline fast_Or_call(Or self, Event event): + * for predicate in self.predicates: # <<<<<<<<<<<<<< + * if fast_call(predicate, event): + * return True + */ + __Pyx_TraceLine(529,0,__PYX_ERR(1, 529, __pyx_L1_error)) + if (unlikely(__pyx_v_self->predicates == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(1, 529, __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_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 529, __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(1, 529, __pyx_L1_error) + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 529, __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":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,0,__PYX_ERR(1, 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(1, 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(1, 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,0,__PYX_ERR(1, 531, __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":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":529 * + * cdef inline fast_Or_call(Or self, Event event): + * for predicate in self.predicates: # <<<<<<<<<<<<<< + * if fast_call(predicate, event): + * return True */ - __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_TraceLine(529,0,__PYX_ERR(1, 529, __pyx_L1_error)) + } __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; + /*else*/ { - /* "hunter/_predicates.pyx":538 - * return self.predicate + /* "hunter/_predicates.pyx":533 + * return True + * else: + * return False # <<<<<<<<<<<<<< * - * cdef inline fast_Not_call(Not self, Event event): # <<<<<<<<<<<<<< - * return not fast_call(self.predicate, event) * + */ + __Pyx_TraceLine(533,0,__PYX_ERR(1, 533, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + goto __pyx_L0; + } + + /* "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): */ /* 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_XDECREF(__pyx_t_3); + __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_RefNannyFinishContext(); return __pyx_r; } -/* "hunter/_predicates.pyx":542 - * +/* "hunter/_predicates.pyx":540 + * `Not` predicate. + * """ + * def __init__(self, predicate): # <<<<<<<<<<<<<< + * self.predicate = predicate * - * cdef inline fast_call(callable, Event event): # <<<<<<<<<<<<<< - * if type(callable) is Query: - * return fast_Query_call( callable, event) */ -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; +/* 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; + 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_MACROS + __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 **__pyx_pyargnames[] = {&__pyx_n_s_predicate,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_predicate)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 540, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(1, 540, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + } + __pyx_v_predicate = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 540, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(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 */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } + __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 __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)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 1); + __Pyx_TraceCall("__init__", __pyx_f[1], 540, 0, __PYX_ERR(1, 540, __pyx_L1_error)); - /* "hunter/_predicates.pyx":543 + /* "hunter/_predicates.pyx":541 + * """ + * def __init__(self, predicate): + * self.predicate = predicate # <<<<<<<<<<<<<< * - * cdef inline fast_call(callable, Event event): - * if type(callable) is Query: # <<<<<<<<<<<<<< - * return fast_Query_call( callable, event) - * elif type(callable) is Or: + * def __str__(self): */ - __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); - if (__pyx_t_2) { + __Pyx_TraceLine(541,0,__PYX_ERR(1, 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":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) + /* "hunter/_predicates.pyx":540 + * `Not` predicate. + * """ + * def __init__(self, predicate): # <<<<<<<<<<<<<< + * self.predicate = predicate + * */ - __Pyx_TraceLine(544,0,__PYX_ERR(0, 544, __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_3 = 0; - goto __pyx_L0; - /* "hunter/_predicates.pyx":543 + /* 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_L0:; + __Pyx_TraceReturn(Py_None, 0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/_predicates.pyx":543 + * self.predicate = predicate + * + * def __str__(self): # <<<<<<<<<<<<<< + * return 'Not(%s)' % self.predicate * - * 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":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) { +/* 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) { + 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_3Not_2__str__(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self)); - /* "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)) - __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_3 = 0; - goto __pyx_L0; + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "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: - */ - } +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_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__str__", 1); + __Pyx_TraceCall("__str__", __pyx_f[1], 543, 0, __PYX_ERR(1, 543, __pyx_L1_error)); - /* "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":544 + * + * def __str__(self): + * return 'Not(%s)' % self.predicate # <<<<<<<<<<<<<< + * + * def __repr__(self): */ - __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) { + __Pyx_TraceLine(544,0,__PYX_ERR(1, 544, __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(1, 544, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; - /* "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) + /* "hunter/_predicates.pyx":543 + * self.predicate = predicate + * + * def __str__(self): # <<<<<<<<<<<<<< + * return 'Not(%s)' % self.predicate + * */ - __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":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: - */ - } + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __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_RefNannyFinishContext(); + return __pyx_r; +} - /* "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":546 + * return 'Not(%s)' % self.predicate + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return '' % self.predicate + * */ - __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; +/* 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) { + 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_3Not_4__repr__(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self)); - /* "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: - */ - } + /* function exit code */ + __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: - */ - __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) { +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_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__repr__", 1); + __Pyx_TraceCall("__repr__", __pyx_f[1], 546, 0, __PYX_ERR(1, 546, __pyx_L1_error)); - /* "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) + /* "hunter/_predicates.pyx":547 + * + * def __repr__(self): + * return '' % self.predicate # <<<<<<<<<<<<<< + * + * def __eq__(self, other): */ - __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; + __Pyx_TraceLine(547,0,__PYX_ERR(1, 547, __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(1, 547, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; - /* "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":546 + * return 'Not(%s)' % self.predicate + * + * def __repr__(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) { + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __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_RefNannyFinishContext(); + return __pyx_r; +} - /* "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) +/* "hunter/_predicates.pyx":549 + * return '' % self.predicate + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return ( + * isinstance(other, Not) */ - __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; - /* "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: +/* 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) { + 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_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_6__eq__(struct __pyx_obj_6hunter_11_predicates_Not *__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; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__eq__", 1); + __Pyx_TraceCall("__eq__", __pyx_f[1], 549, 0, __PYX_ERR(1, 549, __pyx_L1_error)); + + /* "hunter/_predicates.pyx":550 + * + * def __eq__(self, other): + * return ( # <<<<<<<<<<<<<< + * isinstance(other, Not) + * and self.predicate == ( other).predicate */ - } + __Pyx_TraceLine(550,0,__PYX_ERR(1, 550, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); - /* "hunter/_predicates.pyx":556 - * return fast_From_call( callable, event) - * else: - * return callable(event) # <<<<<<<<<<<<<< + /* "hunter/_predicates.pyx":551 + * def __eq__(self, other): + * return ( + * isinstance(other, Not) # <<<<<<<<<<<<<< + * and self.predicate == ( other).predicate + * ) */ - __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_TraceLine(551,0,__PYX_ERR(1, 551, __pyx_L1_error)) + __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_other, __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(1, 551, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_r = __pyx_t_3; + __pyx_t_1 = __pyx_t_3; __pyx_t_3 = 0; - goto __pyx_L0; + goto __pyx_L3_bool_binop_done; } - /* "hunter/_predicates.pyx":542 + /* "hunter/_predicates.pyx":552 + * return ( + * isinstance(other, Not) + * and self.predicate == ( other).predicate # <<<<<<<<<<<<<< + * ) * + */ + __Pyx_TraceLine(552,0,__PYX_ERR(1, 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(1, 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; + goto __pyx_L0; + + /* "hunter/_predicates.pyx":549 + * return '' % self.predicate * - * cdef inline fast_call(callable, Event event): # <<<<<<<<<<<<<< - * if type(callable) is Query: - * return fast_Query_call( callable, event) + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return ( + * isinstance(other, Not) */ /* 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_AddTraceback("hunter._predicates.fast_call", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; + __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); @@ -16203,513 +19568,415 @@ static CYTHON_INLINE PyObject *__pyx_f_6hunter_11_predicates_fast_call(PyObject 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.pyx":555 + * ) + * + * def __call__(self, Event event): # <<<<<<<<<<<<<< + * return fast_Not_call(self, event) + * */ /* 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_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("__pyx_unpickle_Query (wrapper)", 0); + __Pyx_RefNannySetupContext("__call__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __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)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_event,0}; + if (__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); + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { 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 (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_event)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[0]); + kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 555, __pyx_L3_error) + else goto __pyx_L5_argtuple_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) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__call__") < 0)) __PYX_ERR(1, 555, __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_Arg_VARARGS(__pyx_args, 0); } - __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 = ((struct __pyx_obj_6hunter_6_event_Event *)values[0]); } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __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_RaiseArgtupleInvalid("__call__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 555, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_Query", __pyx_clineno, __pyx_lineno, __pyx_filename); + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("hunter._predicates.Not.__call__", __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); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_event), __pyx_ptype_6hunter_6_event_Event, 1, "event", 0))) __PYX_ERR(1, 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; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } __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_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_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)); + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__call__", 1); + __Pyx_TraceCall("__call__", __pyx_f[1], 555, 0, __PYX_ERR(1, 555, __pyx_L1_error)); - /* "(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) + /* "hunter/_predicates.pyx":556 + * + * def __call__(self, Event event): + * return fast_Not_call(self, event) # <<<<<<<<<<<<<< + * + * def __or__(self, other): */ - __Pyx_TraceLine(4,0,__PYX_ERR(2, 4, __pyx_L1_error)) - __pyx_t_1 = ((__pyx_v___pyx_checksum != 0x4eca0a2) != 0); - if (__pyx_t_1) { + __Pyx_TraceLine(556,0,__PYX_ERR(1, 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(1, 556, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; - /* "(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) + /* "hunter/_predicates.pyx":555 + * ) + * + * def __call__(self, Event event): # <<<<<<<<<<<<<< + * return fast_Not_call(self, event) + * */ - __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 != 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) + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __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_RefNannyFinishContext(); + return __pyx_r; +} - /* "(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) +/* "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)) */ - } - /* "(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; +/* 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)); - /* "(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 + /* 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_RefNannyDeclarations + int __pyx_t_1; + 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_RefNannySetupContext("__or__", 1); + __Pyx_TraceCall("__or__", __pyx_f[1], 558, 0, __PYX_ERR(1, 558, __pyx_L1_error)); + + /* "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(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_TraceLine(559,0,__PYX_ERR(1, 559, __pyx_L1_error)) + __pyx_t_2 = (((PyObject *)Py_TYPE(__pyx_v_self)) == ((PyObject *)__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_ptype_6hunter_11_predicates_Not)); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { - /* "(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): + /* "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(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) + __Pyx_TraceLine(560,0,__PYX_ERR(1, 560, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 560, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); + __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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, ((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self)->predicate)) __PYX_ERR(1, 560, __pyx_L1_error); + __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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, ((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_other)->predicate)) __PYX_ERR(1, 560, __pyx_L1_error); + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_And), __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 560, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_6hunter_11_predicates_Not), __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 560, __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; - /* "(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 + /* "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: */ } - /* "(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] + /* "hunter/_predicates.pyx":562 + * return Not(And(( self).predicate, ( other).predicate)) + * else: + * return Or(self, other) # <<<<<<<<<<<<<< + * + * def __and__(self, other): */ - __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; + __Pyx_TraceLine(562,0,__PYX_ERR(1, 562, __pyx_L1_error)) + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 562, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_self); + __Pyx_GIVEREF(__pyx_v_self); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_self)) __PYX_ERR(1, 562, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_other); + __Pyx_GIVEREF(__pyx_v_other); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_other)) __PYX_ERR(1, 562, __pyx_L1_error); + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_Or), __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 562, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + 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 + /* "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_2); __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_AddTraceback("hunter._predicates.Not.__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_TraceReturn(__pyx_r, 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__'): +/* "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)) */ -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) { +/* 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_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; + int __pyx_t_1; 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)); + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__and__", 1); + __Pyx_TraceCall("__and__", __pyx_f[1], 564, 0, __PYX_ERR(1, 564, __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]) + /* "hunter/_predicates.pyx":565 + * + * def __and__(self, other): + * if type(self) is Not and type(other) is Not: # <<<<<<<<<<<<<< + * return Not(Or(( self).predicate, ( other).predicate)) + * else: */ - __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_TraceLine(565,0,__PYX_ERR(1, 565, __pyx_L1_error)) + __pyx_t_2 = (((PyObject *)Py_TYPE(__pyx_v_self)) == ((PyObject *)__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_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_2 = (((PyObject *)Py_TYPE(__pyx_v_other)) == ((PyObject *)__pyx_ptype_6hunter_11_predicates_Not)); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "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,0,__PYX_ERR(1, 566, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 566, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, ((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self)->predicate)) __PYX_ERR(1, 566, __pyx_L1_error); + __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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, ((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_other)->predicate)) __PYX_ERR(1, 566, __pyx_L1_error); + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_Or), __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 566, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_6hunter_11_predicates_Not), __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 566, __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":565 + * + * def __and__(self, other): + * if type(self) is Not and type(other) is Not: # <<<<<<<<<<<<<< + * return Not(Or(( self).predicate, ( other).predicate)) + * else: + */ } - __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]) + /* "hunter/_predicates.pyx":568 + * return Not(Or(( self).predicate, ( other).predicate)) + * else: + * return And(self, other) # <<<<<<<<<<<<<< + * + * def __invert__(self): */ + __Pyx_TraceLine(568,0,__PYX_ERR(1, 568, __pyx_L1_error)) + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 568, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_self); + __Pyx_GIVEREF(__pyx_v_self); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_self)) __PYX_ERR(1, 568, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_other); + __Pyx_GIVEREF(__pyx_v_other); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_other)) __PYX_ERR(1, 568, __pyx_L1_error); + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_And), __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 568, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; } - /* "(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__'): + /* "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)) */ /* 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_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("hunter._predicates.Not.__and__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_TraceReturn(__pyx_r, 0); @@ -16717,1672 +19984,1754 @@ static PyObject *__pyx_f_6hunter_11_predicates___pyx_unpickle_Query__set_state(s 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 +/* "hunter/_predicates.pyx":570 + * return And(self, other) + * + * def __invert__(self): # <<<<<<<<<<<<<< + * return self.predicate + * */ /* 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; - PyObject *__pyx_v___pyx_state = 0; +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("__pyx_unpickle_When (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_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) - } - } 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_When", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1, __pyx_L3_error) - __pyx_L3_error:; - __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); + __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)); /* function exit code */ __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_14__invert__(struct __pyx_obj_6hunter_11_predicates_Not *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_TraceDeclarations __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)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__invert__", 1); + __Pyx_TraceCall("__invert__", __pyx_f[1], 570, 0, __PYX_ERR(1, 570, __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) + /* "hunter/_predicates.pyx":571 + * + * def __invert__(self): + * return self.predicate # <<<<<<<<<<<<<< + * + * cdef inline fast_Not_call(Not self, Event event): */ - __Pyx_TraceLine(4,0,__PYX_ERR(2, 4, __pyx_L1_error)) - __pyx_t_1 = ((__pyx_v___pyx_checksum != 0xb55b71c) != 0); - if (__pyx_t_1) { + __Pyx_TraceLine(571,0,__PYX_ERR(1, 571, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->predicate); + __pyx_r = __pyx_v_self->predicate; + goto __pyx_L0; - /* "(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) + /* "hunter/_predicates.pyx":570 + * return And(self, other) + * + * def __invert__(self): # <<<<<<<<<<<<<< + * return self.predicate + * */ - __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; + /* function exit code */ + __pyx_L1_error:; + __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_RefNannyFinishContext(); + return __pyx_r; +} - /* "(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 +/* "hunter/_predicates.pxd":37 + * cdef class Not: + * cdef: + * readonly object predicate # <<<<<<<<<<<<<< + * + * */ - __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; +/* 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) { + 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_3Not_9predicate___get__(((struct __pyx_obj_6hunter_11_predicates_Not *)__pyx_v_self)); - /* "(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 - */ - } + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "(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)) +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_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[2], 37, 0, __PYX_ERR(2, 37, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v___pyx_result); - __pyx_r = __pyx_v___pyx_result; + __Pyx_INCREF(__pyx_v_self->predicate); + __pyx_r = __pyx_v_self->predicate; 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 - */ - /* 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_When", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("hunter._predicates.Not.predicate.__get__", __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_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__'): +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict */ -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) { +/* 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*)(__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_MACROS + __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;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_6hunter_11_predicates_3Not_16__reduce_cython__(((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__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_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_When__set_state", 0); - __Pyx_TraceCall("__pyx_unpickle_When__set_state", __pyx_f[2], 11, 0, __PYX_ERR(2, 11, __pyx_L1_error)); + 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(__pyx_codeobj__22) + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + __Pyx_TraceCall("__reduce_cython__", __pyx_f[0], 1, 0, __PYX_ERR(0, 1, __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]) + /* "(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(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_TraceLine(5,0,__PYX_ERR(0, 5, __pyx_L1_error)) + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __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_INCREF(__pyx_v_self->predicate); + __Pyx_GIVEREF(__pyx_v_self->predicate); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->predicate)) __PYX_ERR(0, 5, __pyx_L1_error); + __pyx_v_state = ((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) + + /* "(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(0, 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(0, 6, __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_v__dict = __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]) + /* "(tree fragment)":7 + * state = (self.predicate,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True */ - __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:; + __Pyx_TraceLine(7,0,__PYX_ERR(0, 7, __pyx_L1_error)) + __pyx_t_2 = (__pyx_v__dict != Py_None); 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]) # <<<<<<<<<<<<<< + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: */ - __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_TraceLine(8,0,__PYX_ERR(0, 8, __pyx_L1_error)) + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(0, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 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)":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]) + /* "(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(0, 9, __pyx_L1_error)) + __pyx_v_use_setstate = 1; - /* "(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__'): + /* "(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,0,__PYX_ERR(0, 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,0,__PYX_ERR(0, 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,0,__PYX_ERR(0, 13, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_Not); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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))))) __PYX_ERR(0, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_37183945); + __Pyx_GIVEREF(__pyx_int_37183945); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_37183945)) __PYX_ERR(0, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(0, 13, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 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)) __PYX_ERR(0, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(0, 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)) __PYX_ERR(0, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "(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)":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,0,__PYX_ERR(0, 15, __pyx_L1_error)) + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Not); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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))))) __PYX_ERR(0, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_37183945); + __Pyx_GIVEREF(__pyx_int_37183945); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_37183945)) __PYX_ERR(0, 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)) __PYX_ERR(0, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 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)) __PYX_ERR(0, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(0, 15, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _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_When__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("hunter._predicates.Not.__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)":1 - * def __pyx_unpickle_From(__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_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; +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*)(__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_From (wrapper)", 0); + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __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)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__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); + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { 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 (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_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) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 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_Arg_FASTCALL(__pyx_args, 0); } - __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_From", 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(0, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_From", __pyx_clineno, __pyx_lineno, __pyx_filename); + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(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_4__pyx_unpickle_From(__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 */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __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; +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_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)); + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__23) + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + __Pyx_TraceCall("__setstate_cython__", __pyx_f[0], 16, 0, __PYX_ERR(0, 16, __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) + /* "(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(4,0,__PYX_ERR(2, 4, __pyx_L1_error)) - __pyx_t_1 = ((__pyx_v___pyx_checksum != 0x1acd5f7) != 0); - if (__pyx_t_1) { + __Pyx_TraceLine(17,0,__PYX_ERR(0, 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(0, 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(0, 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 != 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) + /* "(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(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 != 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) - __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) + /* 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_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "(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":573 + * return self.predicate + * + * cdef inline fast_Not_call(Not self, Event event): # <<<<<<<<<<<<<< + * return not fast_call(self.predicate, event) + * */ - } - /* "(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) +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_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("fast_Not_call", 1); + __Pyx_TraceCall("fast_Not_call", __pyx_f[1], 573, 0, __PYX_ERR(1, 573, __pyx_L1_error)); + + /* "hunter/_predicates.pyx":574 + * + * cdef inline fast_Not_call(Not self, Event event): + * return not fast_call(self.predicate, event) # <<<<<<<<<<<<<< + * + * */ - __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_TraceLine(574,0,__PYX_ERR(1, 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(1, 574, __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_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 574, __pyx_L1_error) __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) { - - /* "(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; - - /* "(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 - */ - } - - /* "(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; + __pyx_t_2 = __Pyx_PyBool_FromLong((!__pyx_t_3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; 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 + /* "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_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_From", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_AddTraceback("hunter._predicates.fast_Not_call", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __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_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) */ -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) { +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_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_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; 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)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("fast_call", 1); + __Pyx_TraceCall("fast_call", __pyx_f[1], 577, 0, __PYX_ERR(1, 577, __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]) + /* "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(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) - } - __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; + __Pyx_TraceLine(578,0,__PYX_ERR(1, 578, __pyx_L1_error)) + __pyx_t_1 = (((PyObject *)Py_TYPE(__pyx_v_callable)) == ((PyObject *)__pyx_ptype_6hunter_11_predicates_Query)); + if (__pyx_t_1) { - /* "(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]) + /* "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,0,__PYX_ERR(1, 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(1, 579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "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(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 > 5) != 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:; - 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]) # <<<<<<<<<<<<<< + /* "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(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, 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); - } - } - __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; + __Pyx_TraceLine(580,0,__PYX_ERR(1, 580, __pyx_L1_error)) + __pyx_t_1 = (((PyObject *)Py_TYPE(__pyx_v_callable)) == ((PyObject *)__pyx_ptype_6hunter_11_predicates_Or)); + if (__pyx_t_1) { - /* "(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]) + /* "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,0,__PYX_ERR(1, 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(1, 581, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + 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":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: */ + } - /* 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_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "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,0,__PYX_ERR(1, 582, __pyx_L1_error)) + __pyx_t_1 = (((PyObject *)Py_TYPE(__pyx_v_callable)) == ((PyObject *)__pyx_ptype_6hunter_11_predicates_And)); + if (__pyx_t_1) { -/* "(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":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,0,__PYX_ERR(1, 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(1, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; -/* 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; + /* "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: + */ + } + + /* "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,0,__PYX_ERR(1, 584, __pyx_L1_error)) + __pyx_t_1 = (((PyObject *)Py_TYPE(__pyx_v_callable)) == ((PyObject *)__pyx_ptype_6hunter_11_predicates_Not)); + if (__pyx_t_1) { + + /* "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,0,__PYX_ERR(1, 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(1, 585, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + 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: + */ + } + + /* "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,0,__PYX_ERR(1, 586, __pyx_L1_error)) + __pyx_t_1 = (((PyObject *)Py_TYPE(__pyx_v_callable)) == ((PyObject *)__pyx_ptype_6hunter_11_predicates_When)); + if (__pyx_t_1) { + + /* "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,0,__PYX_ERR(1, 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(1, 587, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "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: + */ + } + + /* "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,0,__PYX_ERR(1, 588, __pyx_L1_error)) + __pyx_t_1 = (((PyObject *)Py_TYPE(__pyx_v_callable)) == ((PyObject *)__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,0,__PYX_ERR(1, 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(1, 589, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + 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: + */ + } + + /* "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,0,__PYX_ERR(1, 590, __pyx_L1_error)) + __pyx_t_1 = (((PyObject *)Py_TYPE(__pyx_v_callable)) == ((PyObject *)__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,0,__PYX_ERR(1, 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(1, 591, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + 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: + */ + } + + /* "hunter/_predicates.pyx":593 + * return fast_Backlog_call( callable, event) + * else: + * return callable(event) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_TraceLine(593,0,__PYX_ERR(1, 593, __pyx_L1_error)) + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_callable); + __pyx_t_3 = __pyx_v_callable; __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(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_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, ((PyObject *)__pyx_v_event)}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 593, __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; + goto __pyx_L0; + } + + /* "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_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __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_RefNannyFinishContext(); + return __pyx_r; +} + +/* "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 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_MACROS + __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)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_condition,&__pyx_n_s_size,&__pyx_n_s_stack,&__pyx_n_s_vars,&__pyx_n_s_strip,&__pyx_n_s_action,&__pyx_n_s_filter,0}; + values[1] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)__pyx_int_100)); + values[2] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)__pyx_int_10)); + values[3] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)Py_False)); + values[4] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)Py_True)); + values[5] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)Py_None)); + values[6] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)Py_None)); + if (__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); + switch (__pyx_nargs) { + case 7: values[6] = __Pyx_Arg_VARARGS(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_VARARGS(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_VARARGS(__pyx_args, 4); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 4: values[3] = __Pyx_Arg_VARARGS(__pyx_args, 3); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_condition)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 598, __pyx_L3_error) 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_And", 1, 3, 3, 1); __PYX_ERR(2, 1, __pyx_L3_error) + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_size); + if (value) { values[1] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 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 (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_stack); + if (value) { values[2] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 598, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_vars); + if (value) { values[3] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 598, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_strip); + if (value) { values[4] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 598, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_action); + if (value) { values[5] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 598, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_filter); + if (value) { values[6] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 598, __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) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(1, 598, __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); + switch (__pyx_nargs) { + case 7: values[6] = __Pyx_Arg_VARARGS(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_VARARGS(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_VARARGS(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_VARARGS(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_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]; - } - 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(1, 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); + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(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 */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(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; +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_TraceDeclarations __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) + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 1); + __Pyx_TraceCall("__init__", __pyx_f[1], 598, 0, __PYX_ERR(1, 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,0,__PYX_ERR(1, 599, __pyx_L1_error)) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_isclass); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 599, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (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_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_action}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 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); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(1, 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_n_s_Action); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 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(1, 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_INCREF(__pyx_v_action); + __pyx_t_4 = __pyx_v_action; __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (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_2); + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_6 = 1; } } - __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) - */ - } - - /* "(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); + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 599, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } + __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = 0; + } else { + __Pyx_INCREF(__pyx_v_action); + __pyx_t_1 = __pyx_v_action; } - __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; + __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)":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 */ - __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_TraceLine(600,0,__PYX_ERR(1, 600, __pyx_L1_error)) + __pyx_t_1 = __pyx_v_self->action; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_ColorStreamAction); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyObject_IsInstance(__pyx_t_1, __pyx_t_3); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(1, 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): + /* "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(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_TraceLine(601,0,__PYX_ERR(1, 601, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Action_r_must_be_a_ColorStreamAc, __pyx_v_self->action); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 601, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 601, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 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__'): + /* "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,0,__PYX_ERR(1, 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; -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]) + /* "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(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_TraceLine(603,0,__PYX_ERR(1, 603, __pyx_L1_error)) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_deque); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 603, __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; + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 603, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_maxlen, __pyx_v_size) < 0) __PYX_ERR(1, 603, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 603, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GIVEREF(__pyx_t_4); + __Pyx_GOTREF(__pyx_v_self->queue); + __Pyx_DECREF(__pyx_v_self->queue); + __pyx_v_self->queue = __pyx_t_4; + __pyx_t_4 = 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]) - */ - __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) { + /* "hunter/_predicates.pyx":604 + * self.condition = condition + * self.queue = deque(maxlen=size) + * self.size = size # <<<<<<<<<<<<<< + * self.stack = stack + * self.strip = strip + */ + __Pyx_TraceLine(604,0,__PYX_ERR(1, 604, __pyx_L1_error)) + __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_v_size); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 604, __pyx_L1_error) + __pyx_v_self->size = __pyx_t_6; + + /* "hunter/_predicates.pyx":605 + * self.queue = deque(maxlen=size) + * self.size = size + * self.stack = stack # <<<<<<<<<<<<<< + * self.strip = strip + * self.vars = vars + */ + __Pyx_TraceLine(605,0,__PYX_ERR(1, 605, __pyx_L1_error)) + __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_v_stack); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 605, __pyx_L1_error) + __pyx_v_self->stack = __pyx_t_6; + + /* "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,0,__PYX_ERR(1, 606, __pyx_L1_error)) + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_strip); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 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,0,__PYX_ERR(1, 607, __pyx_L1_error)) + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_vars); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 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,0,__PYX_ERR(1, 608, __pyx_L1_error)) + if (__pyx_v_self->vars) { + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->action, __pyx_n_s_try_repr); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 608, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __pyx_t_3; + __pyx_t_3 = 0; } else { - __pyx_t_2 = __pyx_t_4; - goto __pyx_L4_bool_binop_done; + __Pyx_INCREF(Py_None); + __pyx_t_4 = Py_None; } - __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; + __Pyx_GIVEREF(__pyx_t_4); + __Pyx_GOTREF(__pyx_v_self->_try_repr); + __Pyx_DECREF(__pyx_v_self->_try_repr); + __pyx_v_self->_try_repr = __pyx_t_4; + __pyx_t_4 = 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":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,0,__PYX_ERR(1, 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; - /* "(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":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; 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_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_TraceReturn(Py_None, 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_MACROS + __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)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_event,0}; + if (__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); + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { 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 (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_event)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[0]); + kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 611, __pyx_L3_error) + else goto __pyx_L5_argtuple_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 (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__call__") < 0)) __PYX_ERR(1, 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_Arg_VARARGS(__pyx_args, 0); } - __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(1, 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); + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(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 */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(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_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)); + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__call__", 1); + __Pyx_TraceCall("__call__", __pyx_f[1], 611, 0, __PYX_ERR(1, 611, __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) + /* "hunter/_predicates.pyx":612 + * + * def __call__(self, event): + * return fast_Backlog_call(self, event) # <<<<<<<<<<<<<< + * + * def __str__(self): */ - __Pyx_TraceLine(4,0,__PYX_ERR(2, 4, __pyx_L1_error)) - __pyx_t_1 = ((__pyx_v___pyx_checksum != 0xaa8cbda) != 0); - if (__pyx_t_1) { + __Pyx_TraceLine(612,0,__PYX_ERR(1, 612, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + if (!(likely(((__pyx_v_event) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_event, __pyx_ptype_6hunter_6_event_Event))))) __PYX_ERR(1, 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(1, 612, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; - /* "(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) + /* "hunter/_predicates.pyx":611 + * self._filter = filter + * + * def __call__(self, event): # <<<<<<<<<<<<<< + * return fast_Backlog_call(self, event) + * */ - __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 != 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) + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("hunter._predicates.Backlog.__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; +} - /* "(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) +/* "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)":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; +/* 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)":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) { + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "(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): +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_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__str__", 1); + __Pyx_TraceCall("__str__", __pyx_f[1], 614, 0, __PYX_ERR(1, 614, __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(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; + __Pyx_TraceLine(615,0,__PYX_ERR(1, 615, __pyx_L1_error)) + __Pyx_XDECREF(__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 + /* "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,0,__PYX_ERR(1, 616, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->size); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->stack); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_self->vars); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(6); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 616, __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)) __PYX_ERR(1, 616, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(1, 616, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_2)) __PYX_ERR(1, 616, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_t_3)) __PYX_ERR(1, 616, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->action); + __Pyx_GIVEREF(__pyx_v_self->action); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 4, __pyx_v_self->action)) __PYX_ERR(1, 616, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->_filter); + __Pyx_GIVEREF(__pyx_v_self->_filter); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 5, __pyx_v_self->_filter)) __PYX_ERR(1, 616, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; - /* "(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] + /* "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(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; + __Pyx_TraceLine(615,0,__PYX_ERR(1, 615, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_Backlog_s_size_s_stack_s_vars_s, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 615, __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; - /* "(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_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_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_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_Or__set_state", 0); - __Pyx_TraceCall("__pyx_unpickle_Or__set_state", __pyx_f[2], 11, 0, __PYX_ERR(2, 11, __pyx_L1_error)); + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__repr__", 1); + __Pyx_TraceCall("__repr__", __pyx_f[1], 619, 0, __PYX_ERR(1, 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]) + /* "hunter/_predicates.pyx":620 + * + * def __repr__(self): + * return '' % ( # <<<<<<<<<<<<<< + * self.condition, self.size, self.stack, self.vars, self.action, self._filter + * ) */ - __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_TraceLine(620,0,__PYX_ERR(1, 620, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + + /* "hunter/_predicates.pyx":621 + * def __repr__(self): + * return '' % ( + * self.condition, self.size, self.stack, self.vars, self.action, self._filter # <<<<<<<<<<<<<< + * ) + * + */ + __Pyx_TraceLine(621,0,__PYX_ERR(1, 621, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->size); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 621, __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_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->stack); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 621, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_self->vars); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 621, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(6); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 621, __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)) __PYX_ERR(1, 621, __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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(1, 621, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_2)) __PYX_ERR(1, 621, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_t_3)) __PYX_ERR(1, 621, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->action); + __Pyx_GIVEREF(__pyx_v_self->action); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 4, __pyx_v_self->action)) __PYX_ERR(1, 621, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->_filter); + __Pyx_GIVEREF(__pyx_v_self->_filter); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 5, __pyx_v_self->_filter)) __PYX_ERR(1, 621, __pyx_L1_error); __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 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":620 + * + * def __repr__(self): + * return '' % ( # <<<<<<<<<<<<<< + * self.condition, self.size, self.stack, self.vars, self.action, self._filter + * ) */ - __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]) - */ - } + __Pyx_TraceLine(620,0,__PYX_ERR(1, 620, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_hunter_predicates_Backlog_condi, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 620, __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; - /* "(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_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_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __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); @@ -18390,404 +21739,334 @@ static PyObject *__pyx_f_6hunter_11_predicates___pyx_unpickle_Or__set_state(stru 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_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_RefNannySetupContext("__eq__", 1); + __Pyx_TraceCall("__eq__", __pyx_f[1], 624, 0, __PYX_ERR(1, 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) + /* "hunter/_predicates.pyx":625 + * + * def __eq__(self, other): + * return ( # <<<<<<<<<<<<<< + * isinstance(other, Backlog) and + * self.condition == ( other).condition and */ - __Pyx_TraceLine(4,0,__PYX_ERR(2, 4, __pyx_L1_error)) - __pyx_t_1 = ((__pyx_v___pyx_checksum != 0xf670ef6) != 0); - if (__pyx_t_1) { + __Pyx_TraceLine(625,0,__PYX_ERR(1, 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) + /* "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(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_TraceLine(626,0,__PYX_ERR(1, 626, __pyx_L1_error)) + __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_other, __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(1, 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,0,__PYX_ERR(1, 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(1, 627, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 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) + /* "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(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_TraceLine(628,0,__PYX_ERR(1, 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(1, 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; } - __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) { - /* "(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): + /* "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(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) + __Pyx_TraceLine(629,0,__PYX_ERR(1, 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(1, 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,0,__PYX_ERR(1, 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(1, 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] + /* "hunter/_predicates.pyx":631 + * self.stack == ( other).stack and + * self.vars == ( other).vars and + * self.action == ( other).action # <<<<<<<<<<<<<< + * ) + * */ - __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; + __Pyx_TraceLine(631,0,__PYX_ERR(1, 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(1, 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; 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_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_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_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; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__or__", 1); + __Pyx_TraceCall("__or__", __pyx_f[1], 634, 0, __PYX_ERR(1, 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]) + /* "hunter/_predicates.pyx":635 + * + * def __or__(self, other): + * return Or(self, other) # <<<<<<<<<<<<<< + * + * def __and__(self, other): */ - __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_TraceLine(635,0,__PYX_ERR(1, 635, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 635, __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; + __Pyx_INCREF(__pyx_v_self); + __Pyx_GIVEREF(__pyx_v_self); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self)) __PYX_ERR(1, 635, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_other); + __Pyx_GIVEREF(__pyx_v_other); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_other)) __PYX_ERR(1, 635, __pyx_L1_error); + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_Or), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 635, __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; - /* "(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]) + /* "hunter/_predicates.pyx":634 + * ) + * + * def __or__(self, other): # <<<<<<<<<<<<<< + * return Or(self, other) + * */ - __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.predicate = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): - * __pyx_result.__dict__.update(__pyx_state[1]) # <<<<<<<<<<<<<< + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("hunter._predicates.Backlog.__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":637 + * return Or(self, other) + * + * def __and__(self, other): # <<<<<<<<<<<<<< + * return And(self, other) + * */ - __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_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]) +/* 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_TraceDeclarations + __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_RefNannySetupContext("__and__", 1); + __Pyx_TraceCall("__and__", __pyx_f[1], 637, 0, __PYX_ERR(1, 637, __pyx_L1_error)); + + /* "hunter/_predicates.pyx":638 + * + * def __and__(self, other): + * return And(self, other) # <<<<<<<<<<<<<< + * + * def __invert__(self): */ - } + __Pyx_TraceLine(638,0,__PYX_ERR(1, 638, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 638, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_self); + __Pyx_GIVEREF(__pyx_v_self); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self)) __PYX_ERR(1, 638, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_other); + __Pyx_GIVEREF(__pyx_v_other); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_other)) __PYX_ERR(1, 638, __pyx_L1_error); + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_And), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 638, __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; - /* "(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":637 + * return Or(self, other) + * + * def __and__(self, other): # <<<<<<<<<<<<<< + * return And(self, other) + * */ /* 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_Not__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("hunter._predicates.Backlog.__and__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_TraceReturn(__pyx_r, 0); @@ -18795,3897 +22074,3924 @@ static PyObject *__pyx_f_6hunter_11_predicates___pyx_unpickle_Not__set_state(str 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; -} +/* "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) + * + */ -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); +/* 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 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; - } - return 0; +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_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__invert__", 1); + __Pyx_TraceCall("__invert__", __pyx_f[1], 640, 0, __PYX_ERR(1, 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,0,__PYX_ERR(1, 641, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_6hunter_11_predicates_Not), __pyx_v_self->condition); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 641, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 641, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1)) __PYX_ERR(1, 641, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 641, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->size); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 641, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_size, __pyx_t_3) < 0) __PYX_ERR(1, 641, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->stack); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 641, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_stack, __pyx_t_3) < 0) __PYX_ERR(1, 641, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_self->vars); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 641, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_vars, __pyx_t_3) < 0) __PYX_ERR(1, 641, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_action, __pyx_v_self->action) < 0) __PYX_ERR(1, 641, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_filter, __pyx_v_self->_filter) < 0) __PYX_ERR(1, 641, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_Backlog), __pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 641, __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_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "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_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __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_RefNannyFinishContext(); + return __pyx_r; } -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; +/* "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 + * + */ + +/* 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*)(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_MACROS + __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); + if (unlikely(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "filter", 1))) return NULL; + if (unlikely(__pyx_kwds)) { + __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); + } + __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); + + /* 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_TraceDeclarations + __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; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__24) + __Pyx_RefNannySetupContext("filter", 0); + __Pyx_TraceCall("filter", __pyx_f[1], 643, 0, __PYX_ERR(1, 643, __pyx_L1_error)); + __Pyx_INCREF(__pyx_v_predicates); + + /* "hunter/_predicates.pyx":644 + * + * def filter(self, *predicates, **kwargs): + * from hunter import _merge # <<<<<<<<<<<<<< + * + * if self._filter is not None: + */ + __Pyx_TraceLine(644,0,__PYX_ERR(1, 644, __pyx_L1_error)) + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 644, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_merge); + __Pyx_GIVEREF(__pyx_n_s_merge); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_merge)) __PYX_ERR(1, 644, __pyx_L1_error); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_hunter, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 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_n_s_merge); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 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; + + /* "hunter/_predicates.pyx":646 + * from hunter import _merge + * + * if self._filter is not None: # <<<<<<<<<<<<<< + * predicates = (self._filter, *predicates) + * + */ + __Pyx_TraceLine(646,0,__PYX_ERR(1, 646, __pyx_L1_error)) + __pyx_t_3 = (__pyx_v_self->_filter != Py_None); + if (__pyx_t_3) { + + /* "hunter/_predicates.pyx":647 + * + * if self._filter is not None: + * predicates = (self._filter, *predicates) # <<<<<<<<<<<<<< + * + * return Backlog( + */ + __Pyx_TraceLine(647,0,__PYX_ERR(1, 647, __pyx_L1_error)) + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 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)) __PYX_ERR(1, 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(1, 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(1, 647, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); } + __Pyx_DECREF_SET(__pyx_v_predicates, ((PyObject*)__pyx_t_2)); + __pyx_t_2 = 0; + + /* "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_contains(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_11_predicates_5Query_14query_contains_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,0,__PYX_ERR(1, 649, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); -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":650 + * + * return Backlog( + * self.condition, # <<<<<<<<<<<<<< + * size=self.size, stack=self.stack, vars=self.vars, action=self.action, + * filter=_merge(*predicates, **kwargs) + */ + __Pyx_TraceLine(650,0,__PYX_ERR(1, 650, __pyx_L1_error)) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 649, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_self->condition); + __Pyx_GIVEREF(__pyx_v_self->condition); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_self->condition)) __PYX_ERR(1, 649, __pyx_L1_error); -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":651 + * return Backlog( + * self.condition, + * size=self.size, stack=self.stack, vars=self.vars, action=self.action, # <<<<<<<<<<<<<< + * filter=_merge(*predicates, **kwargs) + * ) + */ + __Pyx_TraceLine(651,0,__PYX_ERR(1, 651, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 651, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_self->size); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 651, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_size, __pyx_t_4) < 0) __PYX_ERR(1, 651, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_self->stack); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 651, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_stack, __pyx_t_4) < 0) __PYX_ERR(1, 651, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_self->vars); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 651, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_vars, __pyx_t_4) < 0) __PYX_ERR(1, 651, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_action, __pyx_v_self->action) < 0) __PYX_ERR(1, 651, __pyx_L1_error) -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":652 + * self.condition, + * size=self.size, stack=self.stack, vars=self.vars, action=self.action, + * filter=_merge(*predicates, **kwargs) # <<<<<<<<<<<<<< + * ) + * + */ + __Pyx_TraceLine(652,0,__PYX_ERR(1, 652, __pyx_L1_error)) + __pyx_t_4 = PyDict_Copy(__pyx_v_kwargs); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 652, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_v__merge, __pyx_v_predicates, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 652, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_filter, __pyx_t_5) < 0) __PYX_ERR(1, 651, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; -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,0,__PYX_ERR(1, 649, __pyx_L1_error)) + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_11_predicates_Backlog), __pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 649, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; -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":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_lt(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6hunter_11_predicates_5Query_8query_lt_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_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_TraceReturn(__pyx_r, 0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -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.pxd":60 + * cdef class Backlog: + * cdef: + * readonly object condition # <<<<<<<<<<<<<< + * readonly int size + * readonly int stack + */ -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); -} +/* 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 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); + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -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} -}; - -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} -}; +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_TraceDeclarations + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[2], 60, 0, __PYX_ERR(2, 60, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->condition); + __pyx_r = __pyx_v_self->condition; + goto __pyx_L0; -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*/ - #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 -}; + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("hunter._predicates.Backlog.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; +} -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_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[2], 61, 0, __PYX_ERR(2, 61, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_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; + 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_AddTraceback("hunter._predicates.Backlog.size.__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; } -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 + */ -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); -} +/* 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)); -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} -}; + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} -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} -}; +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_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[2], 62, 0, __PYX_ERR(2, 62, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_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; + goto __pyx_L0; -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*/ - #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 -}; + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("hunter._predicates.Backlog.stack.__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; +} -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":63 + * readonly int size + * readonly int stack + * readonly bint vars # <<<<<<<<<<<<<< + * readonly bint strip + * readonly object action + */ -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_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 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); + /* function exit code */ + __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; -} +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_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[2], 63, 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; + goto __pyx_L0; -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; + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("hunter._predicates.Backlog.vars.__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; } -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":64 + * readonly int stack + * readonly bint vars + * readonly bint strip # <<<<<<<<<<<<<< + * readonly object action + * readonly object _try_repr + */ + +/* 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 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_5strip___get__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[2], 64, 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; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("hunter._predicates.Backlog.strip.__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; } -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":65 + * readonly bint vars + * readonly bint strip + * readonly object action # <<<<<<<<<<<<<< + * readonly object _try_repr + * readonly object _filter + */ -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_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)); -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*/ - #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 -}; + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} -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_pf_6hunter_11_predicates_7Backlog_6action___get__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[2], 65, 0, __PYX_ERR(2, 65, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->action); + __pyx_r = __pyx_v_self->action; + goto __pyx_L0; -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; + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("hunter._predicates.Backlog.action.__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; } -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":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 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; +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_TraceDeclarations + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[2], 66, 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; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("hunter._predicates.Backlog._try_repr.__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; } -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; +/* "hunter/_predicates.pxd":67 + * readonly object action + * readonly object _try_repr + * readonly object _filter # <<<<<<<<<<<<<< + * readonly object queue + * + */ + +/* 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)); + + /* 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_7_filter___get__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[2], 67, 0, __PYX_ERR(2, 67, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_filter); + __pyx_r = __pyx_v_self->_filter; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("hunter._predicates.Backlog._filter.__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; } -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); +/* "hunter/_predicates.pxd":68 + * readonly object _try_repr + * readonly object _filter + * readonly object queue # <<<<<<<<<<<<<< + * + * cdef fast_And_call(And self, Event event) + */ + +/* 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)); + + /* function exit code */ + __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 PyObject *__pyx_pf_6hunter_11_predicates_7Backlog_5queue___get__(struct __pyx_obj_6hunter_11_predicates_Backlog *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[2], 68, 0, __PYX_ERR(2, 68, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->queue); + __pyx_r = __pyx_v_self->queue; + goto __pyx_L0; -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} -}; + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("hunter._predicates.Backlog.queue.__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; +} -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*/ - #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_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*/ +/* 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*)(__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 - #if PY_VERSION_HEX >= 0x030800b1 - 0, /*tp_vectorcall*/ + 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_MACROS + __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 -}; + __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;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_6hunter_11_predicates_7Backlog_18__reduce_cython__(((struct __pyx_obj_6hunter_11_predicates_Backlog *)__pyx_v_self)); -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; -} - -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 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; -} - -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; + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -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); - } - } -} +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_TraceDeclarations + __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(__pyx_codeobj__25) + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + __Pyx_TraceCall("__reduce_cython__", __pyx_f[0], 1, 0, __PYX_ERR(0, 1, __pyx_L1_error)); -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)":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,0,__PYX_ERR(0, 5, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->stack); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 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(0, 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(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(9); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 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)) __PYX_ERR(0, 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)) __PYX_ERR(0, 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)) __PYX_ERR(0, 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)) __PYX_ERR(0, 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)) __PYX_ERR(0, 5, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 5, __pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 6, __pyx_t_2)) __PYX_ERR(0, 5, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 7, __pyx_t_3)) __PYX_ERR(0, 5, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 8, __pyx_t_4)) __PYX_ERR(0, 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 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)":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,0,__PYX_ERR(0, 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(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_v__dict = __pyx_t_5; + __pyx_t_5 = 0; -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)":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,0,__PYX_ERR(0, 7, __pyx_L1_error)) + __pyx_t_6 = (__pyx_v__dict != Py_None); + if (__pyx_t_6) { -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} -}; - -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 -}; - -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*/ - #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; -} + /* "(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(0, 8, __pyx_L1_error)) + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 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)) __PYX_ERR(0, 8, __pyx_L1_error); + __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 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; -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)":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,0,__PYX_ERR(0, 9, __pyx_L1_error)) + __pyx_v_use_setstate = 1; -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; - } - if (p->predicate) { - e = (*v)(p->predicate, a); if (e) return e; + /* "(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; } - 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); + /* "(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,0,__PYX_ERR(0, 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_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; + __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; } -} - -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); -} + __pyx_L3:; -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); -} + /* "(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,0,__PYX_ERR(0, 12, __pyx_L1_error)) + if (__pyx_v_use_setstate) { -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[] = { - {"__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} -}; - -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 -}; - -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 -}; - -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; + /* "(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,0,__PYX_ERR(0, 13, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Backlog); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 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))))) __PYX_ERR(0, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_21139105); + __Pyx_GIVEREF(__pyx_int_21139105); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_21139105)) __PYX_ERR(0, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, Py_None)) __PYX_ERR(0, 13, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 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)) __PYX_ERR(0, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_5)) __PYX_ERR(0, 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)) __PYX_ERR(0, 13, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_5 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; -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; + /* "(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: + */ } - 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; - 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); + /* "(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,0,__PYX_ERR(0, 15, __pyx_L1_error)) + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_Backlog); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 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))))) __PYX_ERR(0, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_21139105); + __Pyx_GIVEREF(__pyx_int_21139105); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_21139105)) __PYX_ERR(0, 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)) __PYX_ERR(0, 15, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 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)) __PYX_ERR(0, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_5)) __PYX_ERR(0, 15, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_5 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; } -} -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; -} + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ -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; + /* 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.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_TraceReturn(__pyx_r, 0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -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*/ +/* "(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) + */ + +/* 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*)(__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_MACROS + __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 - 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 -}; - -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; - -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; + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; } - 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; - 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); + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } } -} + __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 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; + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } } - return 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -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 -}; - -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; +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_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__26) + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + __Pyx_TraceCall("__setstate_cython__", __pyx_f[0], 16, 0, __PYX_ERR(0, 16, __pyx_L1_error)); -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; - } - return 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,0,__PYX_ERR(0, 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(0, 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(0, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; -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); - } -} + /* "(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___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; - } - return 0; + /* 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.Backlog.__setstate_cython__", __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; } -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*/ - #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_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; - } - return 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; + PyFrameObject *__pyx_v_first_frame = 0; + PyFrameObject *__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_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + long __pyx_t_6; + long __pyx_t_7; + int __pyx_t_8; + Py_ssize_t __pyx_t_9; + PyObject *(*__pyx_t_10)(PyObject *); + PyObject *__pyx_t_11 = NULL; + int __pyx_t_12; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("fast_Backlog_call", 1); + __Pyx_TraceCall("fast_Backlog_call", __pyx_f[1], 655, 0, __PYX_ERR(1, 655, __pyx_L1_error)); -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); - } -} + /* "hunter/_predicates.pyx":669 + * cdef object stack_events + * + * result = fast_call(self.condition, event) # <<<<<<<<<<<<<< + * if result: + * if self.queue: + */ + __Pyx_TraceLine(669,0,__PYX_ERR(1, 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(1, 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 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; - } - return 0; -} + /* "hunter/_predicates.pyx":670 + * + * result = fast_call(self.condition, event) + * if result: # <<<<<<<<<<<<<< + * if self.queue: + * self.action.cleanup() + */ + __Pyx_TraceLine(670,0,__PYX_ERR(1, 670, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_result); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 670, __pyx_L1_error) + if (__pyx_t_3) { -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; -} + /* "hunter/_predicates.pyx":671 + * result = fast_call(self.condition, event) + * if result: + * if self.queue: # <<<<<<<<<<<<<< + * self.action.cleanup() + * + */ + __Pyx_TraceLine(671,0,__PYX_ERR(1, 671, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_self->queue); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 671, __pyx_L1_error) + if (__pyx_t_3) { -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 -}; + /* "hunter/_predicates.pyx":672 + * if result: + * if self.queue: + * self.action.cleanup() # <<<<<<<<<<<<<< + * + * first_event = self.queue[0] + */ + __Pyx_TraceLine(672,0,__PYX_ERR(1, 672, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->action, __pyx_n_s_cleanup); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 672, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 672, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __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,0,__PYX_ERR(1, 674, __pyx_L1_error)) + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_self->queue, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 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 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; + /* "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,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 677, __pyx_L1_error)) + __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_first_event->kind, __pyx_n_s_call, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 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,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 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 = (((PyObject *)__pyx_v_first_event->frame) != 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,0,__PYX_ERR(1, 681, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_first_event->frame), __pyx_n_s_f_back); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 681, __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(1, 681, __pyx_L1_error) + __pyx_v_first_frame = ((PyFrameObject *)__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 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; -} + /* "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,0,__PYX_ERR(1, 683, __pyx_L1_error)) + /*else*/ { + __pyx_t_1 = ((PyObject *)__pyx_v_first_event->frame); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_first_frame = ((PyFrameObject *)__pyx_t_1); + __pyx_t_1 = 0; + } + __pyx_L6:; -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); - } -} + /* "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,0,__PYX_ERR(1, 684, __pyx_L1_error)) + __pyx_t_3 = (((PyObject *)__pyx_v_first_frame) != 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,0,__PYX_ERR(1, 685, __pyx_L1_error)) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_deque); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 685, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(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_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 685, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __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,0,__PYX_ERR(1, 686, __pyx_L1_error)) + __Pyx_INCREF((PyObject *)__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,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 688, __pyx_L1_error)) + while (1) { + __pyx_t_8 = __Pyx_PyObject_IsTrue(((PyObject *)__pyx_v_frame)); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(1, 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":690 + * 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 + */ + __Pyx_TraceLine(690,0,__PYX_ERR(1, 690, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyDict_NewPresized(6); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 690, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_frame, ((PyObject *)__pyx_v_frame)) < 0) __PYX_ERR(1, 690, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_kind, __pyx_int_0) < 0) __PYX_ERR(1, 690, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_arg, Py_None) < 0) __PYX_ERR(1, 690, __pyx_L1_error) + + /* "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,0,__PYX_ERR(1, 691, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_event->threading_support); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 691, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_threading_support, __pyx_t_2) < 0) __PYX_ERR(1, 690, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "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,0,__PYX_ERR(1, 692, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyInt_From_long(((__pyx_v_first_depth - __pyx_v_depth_delta) - 1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 692, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_depth, __pyx_t_2) < 0) __PYX_ERR(1, 690, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_calls, __pyx_int_neg_1) < 0) __PYX_ERR(1, 690, __pyx_L1_error) + + /* "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,0,__PYX_ERR(1, 689, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6hunter_6_event_Event), __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 689, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF_SET(__pyx_v_stack_event, ((struct __pyx_obj_6hunter_6_event_Event *)__pyx_t_2)); + __pyx_t_2 = 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,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 696, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 696, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_stack_event->_locals); + __Pyx_DECREF(__pyx_v_stack_event->_locals); + __pyx_v_stack_event->_locals = __pyx_t_2; + __pyx_t_2 = 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,0,__PYX_ERR(1, 697, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 697, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_stack_event->_globals); + __Pyx_DECREF(__pyx_v_stack_event->_globals); + __pyx_v_stack_event->_globals = __pyx_t_2; + __pyx_t_2 = 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,0,__PYX_ERR(1, 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_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; - } - if (p->__pyx_t_0) { - e = (*v)(p->__pyx_t_0, a); if (e) return e; - } - 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,0,__PYX_ERR(1, 699, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_stack_events, __pyx_n_s_appendleft); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 699, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, ((PyObject *)__pyx_v_stack_event)}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 699, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 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,0,__PYX_ERR(1, 700, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_frame), __pyx_n_s_f_back); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 700, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_6hunter_7_tracer_FrameType))))) __PYX_ERR(1, 700, __pyx_L1_error) + __Pyx_DECREF_SET(__pyx_v_frame, ((PyFrameObject *)__pyx_t_2)); + __pyx_t_2 = 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,0,__PYX_ERR(1, 701, __pyx_L1_error)) + __pyx_v_depth_delta = (__pyx_v_depth_delta + 1); + } -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 -}; + /* "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,0,__PYX_ERR(1, 702, __pyx_L1_error)) + if (likely(PyList_CheckExact(__pyx_v_stack_events)) || PyTuple_CheckExact(__pyx_v_stack_events)) { + __pyx_t_2 = __pyx_v_stack_events; __Pyx_INCREF(__pyx_t_2); + __pyx_t_9 = 0; + __pyx_t_10 = NULL; + } else { + __pyx_t_9 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_stack_events); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 702, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 702, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_10)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 702, __pyx_L1_error) + #endif + if (__pyx_t_9 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_9); __Pyx_INCREF(__pyx_t_1); __pyx_t_9++; if (unlikely((0 < 0))) __PYX_ERR(1, 702, __pyx_L1_error) + #else + __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 702, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 702, __pyx_L1_error) + #endif + if (__pyx_t_9 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_9); __Pyx_INCREF(__pyx_t_1); __pyx_t_9++; if (unlikely((0 < 0))) __PYX_ERR(1, 702, __pyx_L1_error) + #else + __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 702, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } + } else { + __pyx_t_1 = __pyx_t_10(__pyx_t_2); + if (unlikely(!__pyx_t_1)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 702, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_1); + } + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_6hunter_6_event_Event))))) __PYX_ERR(1, 702, __pyx_L1_error) + __Pyx_XDECREF_SET(__pyx_v_stack_event, ((struct __pyx_obj_6hunter_6_event_Event *)__pyx_t_1)); + __pyx_t_1 = 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: + */ + __Pyx_TraceLine(703,0,__PYX_ERR(1, 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_INCREF(__pyx_v_self->_filter); + __pyx_t_4 = __pyx_v_self->_filter; __pyx_t_11 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_11, ((PyObject *)__pyx_v_stack_event)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 703, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(1, 703, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 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,0,__PYX_ERR(1, 704, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_self->action); + __pyx_t_4 = __pyx_v_self->action; __pyx_t_11 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_11, ((PyObject *)__pyx_v_stack_event)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 704, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 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_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; + /* "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,0,__PYX_ERR(1, 702, __pyx_L1_error)) + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 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; -} + /* "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_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); - } -} + /* "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_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; -} + /* "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,0,__PYX_ERR(1, 705, __pyx_L1_error)) + if (likely(PyList_CheckExact(__pyx_v_self->queue)) || PyTuple_CheckExact(__pyx_v_self->queue)) { + __pyx_t_2 = __pyx_v_self->queue; __Pyx_INCREF(__pyx_t_2); + __pyx_t_9 = 0; + __pyx_t_10 = NULL; + } else { + __pyx_t_9 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_self->queue); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 705, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 705, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_10)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 705, __pyx_L1_error) + #endif + if (__pyx_t_9 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_9); __Pyx_INCREF(__pyx_t_1); __pyx_t_9++; if (unlikely((0 < 0))) __PYX_ERR(1, 705, __pyx_L1_error) + #else + __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 705, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 705, __pyx_L1_error) + #endif + if (__pyx_t_9 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_9); __Pyx_INCREF(__pyx_t_1); __pyx_t_9++; if (unlikely((0 < 0))) __PYX_ERR(1, 705, __pyx_L1_error) + #else + __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 705, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } + } else { + __pyx_t_1 = __pyx_t_10(__pyx_t_2); + if (unlikely(!__pyx_t_1)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 705, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_XDECREF_SET(__pyx_v_backlog_event, __pyx_t_1); + __pyx_t_1 = 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): + */ + __Pyx_TraceLine(706,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 707, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_self->action); + __pyx_t_4 = __pyx_v_self->action; __pyx_t_11 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_11, __pyx_v_backlog_event}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 707, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; -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; -} + /* "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_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 -}; + /* "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,0,__PYX_ERR(1, 708, __pyx_L1_error)) + __pyx_t_1 = __pyx_v_self->_filter; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = __pyx_f_6hunter_11_predicates_fast_call(__pyx_t_1, ((struct __pyx_obj_6hunter_6_event_Event *)__pyx_v_backlog_event)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 708, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 708, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 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,0,__PYX_ERR(1, 709, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_self->action); + __pyx_t_1 = __pyx_v_self->action; __pyx_t_11 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_11, __pyx_v_backlog_event}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 709, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; -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; + /* "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:; -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; - } - return o; -} + /* "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,0,__PYX_ERR(1, 705, __pyx_L1_error)) + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; -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); - } -} + /* "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,0,__PYX_ERR(1, 710, __pyx_L1_error)) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->queue, __pyx_n_s_clear); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 710, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 710, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; -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; - } - 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; + /* "hunter/_predicates.pyx":671 + * result = fast_call(self.condition, event) + * if result: + * if self.queue: # <<<<<<<<<<<<<< + * self.action.cleanup() + * + */ + } + + /* "hunter/_predicates.pyx":670 + * + * result = fast_call(self.condition, event) + * if result: # <<<<<<<<<<<<<< + * if self.queue: + * self.action.cleanup() + */ + goto __pyx_L3; } - 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; + /* "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,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 715, __pyx_L1_error)) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->queue, __pyx_n_s_clear); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 715, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 715, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 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; - } - return 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. + */ + } -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); - } else { - (*Py_TYPE(o)->tp_free)(o); - } -} + /* "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,0,__PYX_ERR(1, 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_INCREF(__pyx_v_self->_filter); + __pyx_t_4 = __pyx_v_self->_filter; __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, ((PyObject *)__pyx_v_event)}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 716, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(1, 716, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 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,0,__PYX_ERR(1, 717, __pyx_L1_error)) + __pyx_t_2 = __pyx_v_self->_try_repr; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_4 = ((PyObject *)__pyx_f_6hunter_6_event_fast_detach(__pyx_v_event, __pyx_t_2)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 717, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_detached_event = ((struct __pyx_obj_6hunter_6_event_Event *)__pyx_t_4); + __pyx_t_4 = 0; -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; - } - return 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,0,__PYX_ERR(1, 718, __pyx_L1_error)) + __pyx_t_4 = ((PyObject *)__pyx_v_event->frame); + __Pyx_INCREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + __Pyx_GOTREF((PyObject *)__pyx_v_detached_event->frame); + __Pyx_DECREF((PyObject *)__pyx_v_detached_event->frame); + __pyx_v_detached_event->frame = ((PyFrameObject *)__pyx_t_4); + __pyx_t_4 = 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; -} + /* "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,0,__PYX_ERR(1, 719, __pyx_L1_error)) + __pyx_t_12 = __Pyx_PyObject_Append(__pyx_v_self->queue, ((PyObject *)__pyx_v_detached_event)); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(1, 719, __pyx_L1_error) -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*/ - #endif -}; + /* "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_L3:; -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; + /* "hunter/_predicates.pyx":721 + * self.queue.append(detached_event) + * + * return result # <<<<<<<<<<<<<< + */ + __Pyx_TraceLine(721,0,__PYX_ERR(1, 721, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; -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; -} + /* "hunter/_predicates.pyx":655 + * ) + * + * cdef inline fast_Backlog_call(Backlog self, Event event): # <<<<<<<<<<<<<< + * cdef bint first_is_call + * cdef Event detached_event + */ -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); - } + /* 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_11); + __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((PyObject *)__pyx_v_first_frame); + __Pyx_XDECREF((PyObject *)__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_TraceReturn(__pyx_r, 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_Query(__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*/ +/* 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*)(__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_MACROS + __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 - 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*/ - #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 **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Query", 1, 3, 3, 1); __PYX_ERR(0, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Query", 1, 3, 3, 2); __PYX_ERR(0, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_Query") < 0)) __PYX_ERR(0, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__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(0, 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_Query", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(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_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 */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(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___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_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__27) + __Pyx_RefNannySetupContext("__pyx_unpickle_Query", 1); + __Pyx_TraceCall("__pyx_unpickle_Query", __pyx_f[0], 1, 0, __PYX_ERR(0, 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 (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,0,__PYX_ERR(0, 4, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__28, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 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 (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,0,__PYX_ERR(0, 5, __pyx_L1_error)) + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(0, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 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_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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 (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,0,__PYX_ERR(0, 6, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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(0, 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 (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_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; + /* "(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,0,__PYX_ERR(0, 7, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_6hunter_11_predicates_Query), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (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_t_5 = 1; + } } - if (p->__pyx_t_0) { - e = (*v)(p->__pyx_t_0, a); if (e) return e; + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } - 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 (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,0,__PYX_ERR(0, 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 = 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(0, 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(0, 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(0, 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 (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 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_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(0, 10, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + 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_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_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_XDECREF(__pyx_t_4); + __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_TraceReturn(__pyx_r, 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_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_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_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; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Query__set_state", 1); + __Pyx_TraceCall("__pyx_unpickle_Query__set_state", __pyx_f[0], 11, 0, __PYX_ERR(0, 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_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(0, 12, __pyx_L1_error)) + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 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_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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(0, 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(0, 12, __pyx_L1_error) } -} - -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; + __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(0, 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(0, 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(0, 12, __pyx_L1_error) } - if (p->__pyx_v_p) { - e = (*v)(p->__pyx_v_p, a); if (e) return e; + __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(0, 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(0, 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(0, 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_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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(0, 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(0, 12, __pyx_L1_error) } - return 0; -} + __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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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 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)":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(0, 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(0, 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(0, 13, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 > 10); + 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(0, 13, __pyx_L1_error) + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { -static PyMethodDef __pyx_methods[] = { - {0, 0, 0, 0} -}; + /* "(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(0, 14, __pyx_L1_error)) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 14, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 10, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (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_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 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__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)":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]) + */ + } -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 */ - #else - NULL, /* m_reload */ - #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 + /* "(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 __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; + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; __pyx_L1_error:; - return -1; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __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; } -static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { - __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( +/* "(tree fragment)":1 + * def __pyx_unpickle_When(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result */ - __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); - /* "hunter/_predicates.pyx":18 - * - * __all__ = ( - * 'And', # <<<<<<<<<<<<<< - * 'From', - * 'Not', +/* 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*)(__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_MACROS + __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 **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_When", 1, 3, 3, 1); __PYX_ERR(0, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_When", 1, 3, 3, 2); __PYX_ERR(0, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_When") < 0)) __PYX_ERR(0, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__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(0, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_When", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(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); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(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; + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__29) + __Pyx_RefNannySetupContext("__pyx_unpickle_When", 1); + __Pyx_TraceCall("__pyx_unpickle_When", __pyx_f[0], 1, 0, __PYX_ERR(0, 1, __pyx_L1_error)); + + /* "(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_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); + __Pyx_TraceLine(4,0,__PYX_ERR(0, 4, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__30, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 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', - * ) + /* "(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_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); + __Pyx_TraceLine(5,0,__PYX_ERR(0, 5, __pyx_L1_error)) + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(0, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 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_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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', + /* "(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_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); + __Pyx_TraceLine(6,0,__PYX_ERR(0, 6, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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(0, 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 + * 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_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; -} + /* "(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,0,__PYX_ERR(0, 7, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_6hunter_11_predicates_When), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (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_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; -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)":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,0,__PYX_ERR(0, 8, __pyx_L1_error)) + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { -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)":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(0, 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(0, 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(0, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; -static int __Pyx_modinit_variable_export_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); - /*--- Variable export code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} + /* "(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 + */ + } -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)":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(0, 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 + */ + + /* function exit code */ __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __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_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); - return -1; + return __pyx_r; } -static int __Pyx_modinit_type_init_code(void) { +/* "(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 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_TraceDeclarations __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; - } - __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_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_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; + 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; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_When__set_state", 1); + __Pyx_TraceCall("__pyx_unpickle_When__set_state", __pyx_f[0], 11, 0, __PYX_ERR(0, 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(0, 12, __pyx_L1_error)) + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 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, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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(0, 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(0, 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, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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(0, 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(0, 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_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 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; } - __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_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 13, __pyx_L1_error) + __pyx_t_2 = __pyx_t_4; + __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(0, 14, __pyx_L1_error)) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 14, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (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_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__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_ptype_6hunter_11_predicates___pyx_scope_struct_12_genexpr = &__pyx_type_6hunter_11_predicates___pyx_scope_struct_12_genexpr; - __Pyx_RefNannyFinishContext(); - return 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__'): + */ + + /* 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_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __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_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); - return -1; + return __pyx_r; } -static int __Pyx_modinit_type_import_code(void) { +/* "(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 +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_11_predicates_5__pyx_unpickle_From = {"__pyx_unpickle_From", (PyCFunction)(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 - 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), + __Pyx_RefNannySetupContext("__pyx_unpickle_From (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else - sizeof(PyHeapTypeObject), + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #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; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_From", 1, 3, 3, 1); __PYX_ERR(0, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_From", 1, 3, 3, 2); __PYX_ERR(0, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_From") < 0)) __PYX_ERR(0, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__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(0, 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(0, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("hunter._predicates.__pyx_unpickle_From", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); - return -1; -} + 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 int __Pyx_modinit_variable_import_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); - /*--- Variable import code ---*/ + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); - return 0; + return __pyx_r; } -static int __Pyx_modinit_function_import_code(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_TraceDeclarations __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); - /*--- Function import code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__31) + __Pyx_RefNannySetupContext("__pyx_unpickle_From", 1); + __Pyx_TraceCall("__pyx_unpickle_From", __pyx_f[0], 1, 0, __PYX_ERR(0, 1, __pyx_L1_error)); + /* "(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,0,__PYX_ERR(0, 4, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__32, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { -#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 - + /* "(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,0,__PYX_ERR(0, 5, __pyx_L1_error)) + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(0, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 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_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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; -#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; -} + /* "(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,0,__PYX_ERR(0, 6, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_3, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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(0, 6, __pyx_L1_error) + /* "(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 + */ + } -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; - __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; + /* "(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,0,__PYX_ERR(0, 7, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_6hunter_11_predicates_From), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (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_t_5 = 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); - #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___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 { - 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 *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } - #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)); + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; - /* "hunter/_predicates.pyx":4 - * from __future__ import absolute_import - * - * import inspect # <<<<<<<<<<<<<< - * import re - * from itertools import chain + /* "(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(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; + __Pyx_TraceLine(8,0,__PYX_ERR(0, 8, __pyx_L1_error)) + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { - /* "hunter/_predicates.pyx":5 - * - * import inspect - * import re # <<<<<<<<<<<<<< - * from itertools import chain - * + /* "(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(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; + __Pyx_TraceLine(9,0,__PYX_ERR(0, 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(0, 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(0, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "hunter/_predicates.pyx":6 - * import inspect - * import re - * from itertools import chain # <<<<<<<<<<<<<< - * - * cimport cython + /* "(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(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) - __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_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } - /* "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; - - /* "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) - - /* "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); - - /* "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); - - /* "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)) - - - /* "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)) - - - /* "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)) - - - /* "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)) - - - /* "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)) - - - /* "hunter/_predicates.pyx":542 - * - * - * cdef inline fast_call(callable, Event event): # <<<<<<<<<<<<<< - * if type(callable) is Query: - * return fast_Query_call( callable, event) + /* "(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(542,0,__PYX_ERR(0, 542, __pyx_L1_error)) - + __Pyx_TraceLine(10,0,__PYX_ERR(0, 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_Query(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * def __pyx_unpickle_From(__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)":11 - * __pyx_unpickle_Query__set_state( __pyx_result, __pyx_state) + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __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; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_From__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__'): + * 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)) +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; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_From__set_state", 1); + __Pyx_TraceCall("__pyx_unpickle_From__set_state", __pyx_f[0], 11, 0, __PYX_ERR(0, 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 + /* "(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(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_TraceLine(12,0,__PYX_ERR(0, 12, __pyx_L1_error)) + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 12, __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_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->watermark = __pyx_t_2; - /* "(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__'): + /* "(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(11,0,__PYX_ERR(2, 11, __pyx_L1_error)) + __Pyx_TraceLine(13,0,__PYX_ERR(0, 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(0, 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(0, 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_t_5 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 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,0,__PYX_ERR(0, 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(0, 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(0, 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(0, 14, __pyx_L1_error) + } + __pyx_t_6 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 5, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = NULL; + __pyx_t_2 = 0; + #if CYTHON_UNPACK_METHODS + if (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_2 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+1-__pyx_t_2, 1+__pyx_t_2); + __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(0, 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)":1 - * def __pyx_unpickle_From(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result + /* "(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(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) - __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_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } /* "(tree fragment)":11 * __pyx_unpickle_From__set_state( __pyx_result, __pyx_state) @@ -22694,501 +26000,9474 @@ if (!__Pyx_RefNanny) { * __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)":1 - * def __pyx_unpickle_And(__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) - __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; - /* "(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__'): + /* 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_From__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_And(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result */ - __Pyx_TraceLine(11,0,__PYX_ERR(2, 11, __pyx_L1_error)) +/* 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 +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_6hunter_11_predicates_7__pyx_unpickle_And = {"__pyx_unpickle_And", (PyCFunction)(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 +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_And (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __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 **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_And", 1, 3, 3, 1); __PYX_ERR(0, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_And", 1, 3, 3, 2); __PYX_ERR(0, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_And") < 0)) __PYX_ERR(0, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__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(0, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_And", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(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); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "(tree fragment)":1 - * def __pyx_unpickle_Or(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< +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 + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__33) + __Pyx_RefNannySetupContext("__pyx_unpickle_And", 1); + __Pyx_TraceCall("__pyx_unpickle_And", __pyx_f[0], 1, 0, __PYX_ERR(0, 1, __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(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_TraceLine(4,0,__PYX_ERR(0, 4, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); 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_pyx_unpickle_Or, __pyx_t_1) < 0) __PYX_ERR(2, 1, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__34, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { - /* "(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__'): + /* "(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(11,0,__PYX_ERR(2, 11, __pyx_L1_error)) + __Pyx_TraceLine(5,0,__PYX_ERR(0, 5, __pyx_L1_error)) + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(0, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 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_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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 = And.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __Pyx_TraceLine(6,0,__PYX_ERR(0, 6, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_4, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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(0, 6, __pyx_L1_error) - /* "(tree fragment)":1 - * def __pyx_unpickle_Not(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + /* "(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(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; + } - /* "(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__'): + /* "(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(11,0,__PYX_ERR(2, 11, __pyx_L1_error)) + __Pyx_TraceLine(7,0,__PYX_ERR(0, 7, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_6hunter_11_predicates_And), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (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_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __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 = 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(0, 8, __pyx_L1_error)) + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { - /* "hunter/_predicates.pyx":1 - * # cython: linetrace=True, language_level=3str # <<<<<<<<<<<<<< - * from __future__ import absolute_import - * + /* "(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(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(9,0,__PYX_ERR(0, 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(0, 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(0, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /*--- Wrapped vars code ---*/ + /* "(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 + */ + } + /* "(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(0, 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_1); - __Pyx_XDECREF(__pyx_t_2); - if (__pyx_m) { - if (__pyx_d) { - __Pyx_AddTraceback("init hunter._predicates", __pyx_clineno, __pyx_lineno, __pyx_filename); - } - Py_CLEAR(__pyx_m); - } else if (!PyErr_Occurred()) { - PyErr_SetString(PyExc_ImportError, "init hunter._predicates"); - } + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __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(); - #if CYTHON_PEP489_MULTI_PHASE_INIT - return (__pyx_m != NULL) ? 0 : -1; - #elif PY_MAJOR_VERSION >= 3 - return __pyx_m; - #else - return; - #endif + 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; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_And__set_state", 1); + __Pyx_TraceCall("__pyx_unpickle_And__set_state", __pyx_f[0], 11, 0, __PYX_ERR(0, 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(0, 12, __pyx_L1_error)) + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 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(0, 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(0, 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_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(0, 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(0, 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(0, 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_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 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,0,__PYX_ERR(0, 14, __pyx_L1_error)) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 14, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (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_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __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_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__'): + */ + + /* 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_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __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_TraceReturn(__pyx_r, 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 + */ + +/* 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*)(__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_MACROS + __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 **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Or", 1, 3, 3, 1); __PYX_ERR(0, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Or", 1, 3, 3, 2); __PYX_ERR(0, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_Or") < 0)) __PYX_ERR(0, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__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(0, 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(0, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(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 */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(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; + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__35) + __Pyx_RefNannySetupContext("__pyx_unpickle_Or", 1); + __Pyx_TraceCall("__pyx_unpickle_Or", __pyx_f[0], 1, 0, __PYX_ERR(0, 1, __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,0,__PYX_ERR(0, 4, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__34, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 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 (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,0,__PYX_ERR(0, 5, __pyx_L1_error)) + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(0, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 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_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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,0,__PYX_ERR(0, 6, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_4, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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(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 + */ + } + + /* "(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,0,__PYX_ERR(0, 7, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_6hunter_11_predicates_Or), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (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_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __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,0,__PYX_ERR(0, 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,0,__PYX_ERR(0, 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(0, 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(0, 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,0,__PYX_ERR(0, 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_Or(__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_XDECREF(__pyx_t_4); + __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_TraceReturn(__pyx_r, 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_TraceDeclarations + __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; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Or__set_state", 1); + __Pyx_TraceCall("__pyx_unpickle_Or__set_state", __pyx_f[0], 11, 0, __PYX_ERR(0, 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,0,__PYX_ERR(0, 12, __pyx_L1_error)) + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 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(0, 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(0, 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,0,__PYX_ERR(0, 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(0, 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(0, 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_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 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,0,__PYX_ERR(0, 14, __pyx_L1_error)) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 14, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (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_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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]) + */ + } + + /* "(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__'): + */ + + /* 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_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __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_TraceReturn(__pyx_r, 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*)(__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_MACROS + __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 **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Not", 1, 3, 3, 1); __PYX_ERR(0, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Not", 1, 3, 3, 2); __PYX_ERR(0, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_Not") < 0)) __PYX_ERR(0, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__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(0, 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(0, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(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 */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(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_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__36) + __Pyx_RefNannySetupContext("__pyx_unpickle_Not", 1); + __Pyx_TraceCall("__pyx_unpickle_Not", __pyx_f[0], 1, 0, __PYX_ERR(0, 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,0,__PYX_ERR(0, 4, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__37, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 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,0,__PYX_ERR(0, 5, __pyx_L1_error)) + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(0, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 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_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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,0,__PYX_ERR(0, 6, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_5, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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(0, 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,0,__PYX_ERR(0, 7, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_6hunter_11_predicates_Not), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (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_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __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,0,__PYX_ERR(0, 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,0,__PYX_ERR(0, 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(0, 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(0, 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,0,__PYX_ERR(0, 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_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_XDECREF(__pyx_t_4); + __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_TraceReturn(__pyx_r, 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_TraceDeclarations + __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; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Not__set_state", 1); + __Pyx_TraceCall("__pyx_unpickle_Not__set_state", __pyx_f[0], 11, 0, __PYX_ERR(0, 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,0,__PYX_ERR(0, 12, __pyx_L1_error)) + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 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(0, 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,0,__PYX_ERR(0, 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(0, 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(0, 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_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 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,0,__PYX_ERR(0, 14, __pyx_L1_error)) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 14, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (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_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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]) + */ + } + + /* "(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); + 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_AddTraceback("hunter._predicates.__pyx_unpickle_Not__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_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*)(__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_MACROS + __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 **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Backlog", 1, 3, 3, 1); __PYX_ERR(0, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Backlog", 1, 3, 3, 2); __PYX_ERR(0, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_Backlog") < 0)) __PYX_ERR(0, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__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(0, 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(0, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(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 */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(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_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__38) + __Pyx_RefNannySetupContext("__pyx_unpickle_Backlog", 1); + __Pyx_TraceCall("__pyx_unpickle_Backlog", __pyx_f[0], 1, 0, __PYX_ERR(0, 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,0,__PYX_ERR(0, 4, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__39, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 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,0,__PYX_ERR(0, 5, __pyx_L1_error)) + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(0, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 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_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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,0,__PYX_ERR(0, 6, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_6, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 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(0, 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,0,__PYX_ERR(0, 7, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_6hunter_11_predicates_Backlog), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (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_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __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,0,__PYX_ERR(0, 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,0,__PYX_ERR(0, 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(0, 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(0, 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,0,__PYX_ERR(0, 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_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_XDECREF(__pyx_t_4); + __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_TraceReturn(__pyx_r, 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_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; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Backlog__set_state", 1); + __Pyx_TraceCall("__pyx_unpickle_Backlog__set_state", __pyx_f[0], 11, 0, __PYX_ERR(0, 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,0,__PYX_ERR(0, 12, __pyx_L1_error)) + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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(0, 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,0,__PYX_ERR(0, 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(0, 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(0, 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_n_s_dict); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 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,0,__PYX_ERR(0, 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(0, 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(0, 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(0, 14, __pyx_L1_error) + } + __pyx_t_6 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 9, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = NULL; + __pyx_t_2 = 0; + #if CYTHON_UNPACK_METHODS + if (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_2 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+1-__pyx_t_2, 1+__pyx_t_2); + __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(0, 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_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); + 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_Backlog__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; +} + +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 || CYTHON_COMPILING_IN_PYPY + (*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; + 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 PyObject *__pyx_specialmethod___pyx_pw_6hunter_11_predicates_5Query_5__repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + return __pyx_pw_6hunter_11_predicates_5Query_5__repr__(self); +} + +static PyMethodDef __pyx_methods_6hunter_11_predicates_Query[] = { + {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_pw_6hunter_11_predicates_5Query_5__repr__, METH_NOARGS|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_5Query_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(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[] = { + {(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} +}; +#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*/ + #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_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*/ + #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_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*/ + 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 PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #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 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 || CYTHON_COMPILING_IN_PYPY + (*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; + 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 PyObject *__pyx_specialmethod___pyx_pw_6hunter_11_predicates_3And_5__repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + return __pyx_pw_6hunter_11_predicates_3And_5__repr__(self); +} + +static PyMethodDef __pyx_methods_6hunter_11_predicates_And[] = { + {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_pw_6hunter_11_predicates_3And_5__repr__, METH_NOARGS|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_3And_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(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[] = { + {(char *)"predicates", __pyx_getprop_6hunter_11_predicates_3And_predicates, 0, (char *)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*/ + #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_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*/ + #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_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*/ + 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 PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #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 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 || CYTHON_COMPILING_IN_PYPY + (*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; + 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 PyObject *__pyx_specialmethod___pyx_pw_6hunter_11_predicates_2Or_5__repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + return __pyx_pw_6hunter_11_predicates_2Or_5__repr__(self); +} + +static PyMethodDef __pyx_methods_6hunter_11_predicates_Or[] = { + {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_pw_6hunter_11_predicates_2Or_5__repr__, METH_NOARGS|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_2Or_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(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[] = { + {(char *)"predicates", __pyx_getprop_6hunter_11_predicates_2Or_predicates, 0, (char *)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*/ + #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_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*/ + #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*/ + 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 PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #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 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 || CYTHON_COMPILING_IN_PYPY + (*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; + 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 PyObject *__pyx_specialmethod___pyx_pw_6hunter_11_predicates_3Not_5__repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + return __pyx_pw_6hunter_11_predicates_3Not_5__repr__(self); +} + +static PyMethodDef __pyx_methods_6hunter_11_predicates_Not[] = { + {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_pw_6hunter_11_predicates_3Not_5__repr__, METH_NOARGS|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_3Not_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(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[] = { + {(char *)"predicate", __pyx_getprop_6hunter_11_predicates_3Not_predicate, 0, (char *)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*/ + #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_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*/ + #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_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*/ + 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 PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #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 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 || CYTHON_COMPILING_IN_PYPY + (*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; + 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 PyObject *__pyx_specialmethod___pyx_pw_6hunter_11_predicates_4When_5__repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + return __pyx_pw_6hunter_11_predicates_4When_5__repr__(self); +} + +static PyMethodDef __pyx_methods_6hunter_11_predicates_When[] = { + {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_pw_6hunter_11_predicates_4When_5__repr__, METH_NOARGS|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_4When_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(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[] = { + {(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} +}; +#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*/ + #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_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*/ + #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_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*/ + 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 PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #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 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 || CYTHON_COMPILING_IN_PYPY + (*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; + 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 PyObject *__pyx_specialmethod___pyx_pw_6hunter_11_predicates_4From_5__repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + return __pyx_pw_6hunter_11_predicates_4From_5__repr__(self); +} + +static PyMethodDef __pyx_methods_6hunter_11_predicates_From[] = { + {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_pw_6hunter_11_predicates_4From_5__repr__, METH_NOARGS|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_4From_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(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[] = { + {(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} +}; +#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*/ + #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_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*/ + #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_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*/ + 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 PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #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 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 || CYTHON_COMPILING_IN_PYPY + (*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; + 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 PyObject *__pyx_specialmethod___pyx_pw_6hunter_11_predicates_7Backlog_7__repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + return __pyx_pw_6hunter_11_predicates_7Backlog_7__repr__(self); +} + +static PyMethodDef __pyx_methods_6hunter_11_predicates_Backlog[] = { + {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_pw_6hunter_11_predicates_7Backlog_7__repr__, METH_NOARGS|METH_COEXIST, 0}, + {"filter", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6hunter_11_predicates_7Backlog_17filter, METH_VARARGS|METH_KEYWORDS, 0}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_7Backlog_19__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(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[] = { + {(char *)"condition", __pyx_getprop_6hunter_11_predicates_7Backlog_condition, 0, (char *)0, 0}, + {(char *)"size", __pyx_getprop_6hunter_11_predicates_7Backlog_size, 0, (char *)0, 0}, + {(char *)"stack", __pyx_getprop_6hunter_11_predicates_7Backlog_stack, 0, (char *)0, 0}, + {(char *)"vars", __pyx_getprop_6hunter_11_predicates_7Backlog_vars, 0, (char *)0, 0}, + {(char *)"strip", __pyx_getprop_6hunter_11_predicates_7Backlog_strip, 0, (char *)0, 0}, + {(char *)"action", __pyx_getprop_6hunter_11_predicates_7Backlog_action, 0, (char *)0, 0}, + {(char *)"_try_repr", __pyx_getprop_6hunter_11_predicates_7Backlog__try_repr, 0, (char *)0, 0}, + {(char *)"_filter", __pyx_getprop_6hunter_11_predicates_7Backlog__filter, 0, (char *)0, 0}, + {(char *)"queue", __pyx_getprop_6hunter_11_predicates_7Backlog_queue, 0, (char *)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*/ + #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_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*/ + #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_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*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __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 PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #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 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 || CYTHON_COMPILING_IN_PYPY + (*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; + 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 PyObject *__pyx_specialmethod___pyx_pw_6hunter_11_predicates_10QueryEntry_3__repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + return __pyx_pw_6hunter_11_predicates_10QueryEntry_3__repr__(self); +} + +static PyMethodDef __pyx_methods_6hunter_11_predicates_QueryEntry[] = { + {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_pw_6hunter_11_predicates_10QueryEntry_3__repr__, METH_NOARGS|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_11_predicates_10QueryEntry_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(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*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __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 PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #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 CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +#if CYTHON_USE_FREELISTS +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; +#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_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_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 + #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_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_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 + #endif + { + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*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; + 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*/ + #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|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 PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #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 CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +#if CYTHON_USE_FREELISTS +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; +#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_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_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 + #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); + Py_CLEAR(p->__pyx_t_0); + #if CYTHON_USE_FREELISTS + if (((int)(__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_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 + #endif + { + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*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; + 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; + } + 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_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*/ + #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|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 PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #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 CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +#if CYTHON_USE_FREELISTS +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; +#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_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_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 + #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_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_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 + #endif + { + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*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; + 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*/ + #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|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 PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #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 CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +#if CYTHON_USE_FREELISTS +static struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_3_genexpr *__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_3_genexpr[8]; +static int __pyx_freecount_6hunter_11_predicates___pyx_scope_struct_3_genexpr = 0; +#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_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_freelist_6hunter_11_predicates___pyx_scope_struct_3_genexpr[--__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); + Py_CLEAR(p->__pyx_t_0); + #if CYTHON_USE_FREELISTS + if (((int)(__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_freelist_6hunter_11_predicates___pyx_scope_struct_3_genexpr[__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 || CYTHON_COMPILING_IN_PYPY + (*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; + 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; + } + 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_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*/ + #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|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 PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #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 CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +#if CYTHON_USE_FREELISTS +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; +#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_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_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 + #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); + Py_CLEAR(p->__pyx_t_0); + #if CYTHON_USE_FREELISTS + if (((int)(__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_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 + #endif + { + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*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; + 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; + } + 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_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*/ + #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|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 PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #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 CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +#if CYTHON_USE_FREELISTS +static struct __pyx_obj_6hunter_11_predicates___pyx_scope_struct_5_genexpr *__pyx_freelist_6hunter_11_predicates___pyx_scope_struct_5_genexpr[8]; +static int __pyx_freecount_6hunter_11_predicates___pyx_scope_struct_5_genexpr = 0; +#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_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_freelist_6hunter_11_predicates___pyx_scope_struct_5_genexpr[--__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); + Py_CLEAR(p->__pyx_t_0); + #if CYTHON_USE_FREELISTS + if (((int)(__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_freelist_6hunter_11_predicates___pyx_scope_struct_5_genexpr[__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 || CYTHON_COMPILING_IN_PYPY + (*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; + 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; + } + 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_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*/ + #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|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 PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #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 CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +#if CYTHON_USE_FREELISTS +static 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]; +static int __pyx_freecount___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event = 0; +#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_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_freelist___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event[--__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_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_freelist___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event[__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 || CYTHON_COMPILING_IN_PYPY + (*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*/ + #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_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 PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #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 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} +}; +#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 +/* #### Code section: pystring_table ### */ + +static int __Pyx_CreateStringTabAndInitStrings(void) { + __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s_Action, __pyx_k_Action, sizeof(__pyx_k_Action), 0, 0, 1, 1}, + {&__pyx_kp_s_Action_r_must_be_a_ColorStreamAc, __pyx_k_Action_r_must_be_a_ColorStreamAc, sizeof(__pyx_k_Action_r_must_be_a_ColorStreamAc), 0, 0, 1, 0}, + {&__pyx_n_s_And, __pyx_k_And, sizeof(__pyx_k_And), 0, 0, 1, 1}, + {&__pyx_n_s_And___reduce_cython, __pyx_k_And___reduce_cython, sizeof(__pyx_k_And___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_And___setstate_cython, __pyx_k_And___setstate_cython, sizeof(__pyx_k_And___setstate_cython), 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_Backlog, __pyx_k_Backlog, sizeof(__pyx_k_Backlog), 0, 0, 1, 1}, + {&__pyx_n_s_Backlog___reduce_cython, __pyx_k_Backlog___reduce_cython, sizeof(__pyx_k_Backlog___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Backlog___setstate_cython, __pyx_k_Backlog___setstate_cython, sizeof(__pyx_k_Backlog___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Backlog_filter, __pyx_k_Backlog_filter, sizeof(__pyx_k_Backlog_filter), 0, 0, 1, 1}, + {&__pyx_kp_s_Backlog_s_size_s_stack_s_vars_s, __pyx_k_Backlog_s_size_s_stack_s_vars_s, sizeof(__pyx_k_Backlog_s_size_s_stack_s_vars_s), 0, 0, 1, 0}, + {&__pyx_n_s_ColorStreamAction, __pyx_k_ColorStreamAction, sizeof(__pyx_k_ColorStreamAction), 0, 0, 1, 1}, + {&__pyx_n_s_From, __pyx_k_From, sizeof(__pyx_k_From), 0, 0, 1, 1}, + {&__pyx_n_s_From___reduce_cython, __pyx_k_From___reduce_cython, sizeof(__pyx_k_From___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_From___setstate_cython, __pyx_k_From___setstate_cython, sizeof(__pyx_k_From___setstate_cython), 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_0x_x_vs_0, __pyx_k_Incompatible_checksums_0x_x_vs_0, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0), 0, 0, 1, 0}, + {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_2, __pyx_k_Incompatible_checksums_0x_x_vs_0_2, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0_2), 0, 0, 1, 0}, + {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_3, __pyx_k_Incompatible_checksums_0x_x_vs_0_3, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0_3), 0, 0, 1, 0}, + {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_4, __pyx_k_Incompatible_checksums_0x_x_vs_0_4, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0_4), 0, 0, 1, 0}, + {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_5, __pyx_k_Incompatible_checksums_0x_x_vs_0_5, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0_5), 0, 0, 1, 0}, + {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_6, __pyx_k_Incompatible_checksums_0x_x_vs_0_6, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0_6), 0, 0, 1, 0}, + {&__pyx_kp_u_Must_be_one_of, __pyx_k_Must_be_one_of, sizeof(__pyx_k_Must_be_one_of), 0, 1, 0, 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_n_s_Not___reduce_cython, __pyx_k_Not___reduce_cython, sizeof(__pyx_k_Not___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Not___setstate_cython, __pyx_k_Not___setstate_cython, sizeof(__pyx_k_Not___setstate_cython), 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_n_s_Or___reduce_cython, __pyx_k_Or___reduce_cython, sizeof(__pyx_k_Or___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Or___setstate_cython, __pyx_k_Or___setstate_cython, sizeof(__pyx_k_Or___setstate_cython), 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_Pyx_CFunc_6hunter_11_predicate, __pyx_k_Pyx_CFunc_6hunter_11_predicate, sizeof(__pyx_k_Pyx_CFunc_6hunter_11_predicate), 0, 0, 1, 1}, + {&__pyx_n_s_Query, __pyx_k_Query, sizeof(__pyx_k_Query), 0, 0, 1, 1}, + {&__pyx_n_s_QueryEntry, __pyx_k_QueryEntry, sizeof(__pyx_k_QueryEntry), 0, 0, 1, 1}, + {&__pyx_n_s_QueryEntry___reduce_cython, __pyx_k_QueryEntry___reduce_cython, sizeof(__pyx_k_QueryEntry___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_QueryEntry___setstate_cython, __pyx_k_QueryEntry___setstate_cython, sizeof(__pyx_k_QueryEntry___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Query___reduce_cython, __pyx_k_Query___reduce_cython, sizeof(__pyx_k_Query___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Query___setstate_cython, __pyx_k_Query___setstate_cython, sizeof(__pyx_k_Query___setstate_cython), 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_u_Unexpected_argument, __pyx_k_Unexpected_argument, sizeof(__pyx_k_Unexpected_argument), 0, 1, 0, 0}, + {&__pyx_kp_u_Unexpected_operator, __pyx_k_Unexpected_operator, sizeof(__pyx_k_Unexpected_operator), 0, 1, 0, 0}, + {&__pyx_kp_u_Value, __pyx_k_Value, sizeof(__pyx_k_Value), 0, 1, 0, 0}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_n_s_When, __pyx_k_When, sizeof(__pyx_k_When), 0, 0, 1, 1}, + {&__pyx_n_s_When___reduce_cython, __pyx_k_When___reduce_cython, sizeof(__pyx_k_When___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_When___setstate_cython, __pyx_k_When___setstate_cython, sizeof(__pyx_k_When___setstate_cython), 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__10, __pyx_k__10, sizeof(__pyx_k__10), 0, 0, 1, 0}, + {&__pyx_n_s__48, __pyx_k__48, sizeof(__pyx_k__48), 0, 0, 1, 1}, + {&__pyx_n_s__5, __pyx_k__5, sizeof(__pyx_k__5), 0, 0, 1, 1}, + {&__pyx_kp_u__6, __pyx_k__6, sizeof(__pyx_k__6), 0, 1, 0, 0}, + {&__pyx_kp_u__7, __pyx_k__7, sizeof(__pyx_k__7), 0, 1, 0, 0}, + {&__pyx_kp_s__8, __pyx_k__8, sizeof(__pyx_k__8), 0, 0, 1, 0}, + {&__pyx_kp_s__9, __pyx_k__9, sizeof(__pyx_k__9), 0, 0, 1, 0}, + {&__pyx_n_s_action, __pyx_k_action, sizeof(__pyx_k_action), 0, 0, 1, 1}, + {&__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_append, __pyx_k_append, sizeof(__pyx_k_append), 0, 0, 1, 1}, + {&__pyx_n_s_appendleft, __pyx_k_appendleft, sizeof(__pyx_k_appendleft), 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_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1}, + {&__pyx_n_s_builtin, __pyx_k_builtin, sizeof(__pyx_k_builtin), 0, 0, 1, 1}, + {&__pyx_n_s_call, __pyx_k_call, sizeof(__pyx_k_call), 0, 0, 1, 1}, + {&__pyx_n_s_calls, __pyx_k_calls, sizeof(__pyx_k_calls), 0, 0, 1, 1}, + {&__pyx_n_s_cfunc_to_py, __pyx_k_cfunc_to_py, sizeof(__pyx_k_cfunc_to_py), 0, 0, 1, 1}, + {&__pyx_n_s_cleanup, __pyx_k_cleanup, sizeof(__pyx_k_cleanup), 0, 0, 1, 1}, + {&__pyx_n_s_clear, __pyx_k_clear, sizeof(__pyx_k_clear), 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_collections, __pyx_k_collections, sizeof(__pyx_k_collections), 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_deque, __pyx_k_deque, sizeof(__pyx_k_deque), 0, 0, 1, 1}, + {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1}, + {&__pyx_n_s_dict_2, __pyx_k_dict_2, sizeof(__pyx_k_dict_2), 0, 0, 1, 1}, + {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0}, + {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0}, + {&__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_f_back, __pyx_k_f_back, sizeof(__pyx_k_f_back), 0, 0, 1, 1}, + {&__pyx_n_s_filename, __pyx_k_filename, sizeof(__pyx_k_filename), 0, 0, 1, 1}, + {&__pyx_n_s_filter, __pyx_k_filter, sizeof(__pyx_k_filter), 0, 0, 1, 1}, + {&__pyx_kp_u_for, __pyx_k_for, sizeof(__pyx_k_for), 0, 1, 0, 0}, + {&__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_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0}, + {&__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, __pyx_k_hunter, sizeof(__pyx_k_hunter), 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_When_conditi, __pyx_k_hunter__predicates_When_conditi, sizeof(__pyx_k_hunter__predicates_When_conditi), 0, 0, 1, 0}, + {&__pyx_kp_s_hunter_predicates_Backlog_condi, __pyx_k_hunter_predicates_Backlog_condi, sizeof(__pyx_k_hunter_predicates_Backlog_condi), 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_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_index, __pyx_k_index, sizeof(__pyx_k_index), 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_instruction, __pyx_k_instruction, sizeof(__pyx_k_instruction), 0, 0, 1, 1}, + {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1}, + {&__pyx_kp_u_is_invalid_Must_be_a_string_lis, __pyx_k_is_invalid_Must_be_a_string_lis, sizeof(__pyx_k_is_invalid_Must_be_a_string_lis), 0, 1, 0, 0}, + {&__pyx_n_s_isclass, __pyx_k_isclass, sizeof(__pyx_k_isclass), 0, 0, 1, 1}, + {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0}, + {&__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_kwargs, __pyx_k_kwargs, sizeof(__pyx_k_kwargs), 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_maxlen, __pyx_k_maxlen, sizeof(__pyx_k_maxlen), 0, 0, 1, 1}, + {&__pyx_n_s_merge, __pyx_k_merge, sizeof(__pyx_k_merge), 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_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 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_predicates, __pyx_k_predicates, sizeof(__pyx_k_predicates), 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_Backlog, __pyx_k_pyx_unpickle_Backlog, sizeof(__pyx_k_pyx_unpickle_Backlog), 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_re_compile, __pyx_k_re_compile, sizeof(__pyx_k_re_compile), 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_rx, __pyx_k_rx, sizeof(__pyx_k_rx), 0, 0, 1, 1}, + {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, + {&__pyx_kp_s_self_getter_cannot_be_converted, __pyx_k_self_getter_cannot_be_converted, sizeof(__pyx_k_self_getter_cannot_be_converted), 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_size, __pyx_k_size, sizeof(__pyx_k_size), 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_kp_s_src_hunter__predicates_pyx, __pyx_k_src_hunter__predicates_pyx, sizeof(__pyx_k_src_hunter__predicates_pyx), 0, 0, 1, 0}, + {&__pyx_n_s_stack, __pyx_k_stack, sizeof(__pyx_k_stack), 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_state, __pyx_k_state, sizeof(__pyx_k_state), 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_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0}, + {&__pyx_n_s_strip, __pyx_k_strip, sizeof(__pyx_k_strip), 0, 0, 1, 1}, + {&__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_threading_support, __pyx_k_threading_support, sizeof(__pyx_k_threading_support), 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_try_repr, __pyx_k_try_repr, sizeof(__pyx_k_try_repr), 0, 0, 1, 1}, + {&__pyx_n_s_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1}, + {&__pyx_n_s_use_setstate, __pyx_k_use_setstate, sizeof(__pyx_k_use_setstate), 0, 0, 1, 1}, + {&__pyx_n_s_value, __pyx_k_value, sizeof(__pyx_k_value), 0, 0, 1, 1}, + {&__pyx_n_s_vars, __pyx_k_vars, sizeof(__pyx_k_vars), 0, 0, 1, 1}, + {&__pyx_n_s_watermark, __pyx_k_watermark, sizeof(__pyx_k_watermark), 0, 0, 1, 1}, + {&__pyx_kp_u_with_optional_operators_like, __pyx_k_with_optional_operators_like, sizeof(__pyx_k_with_optional_operators_like), 0, 1, 0, 0}, + {&__pyx_n_s_wrap, __pyx_k_wrap, sizeof(__pyx_k_wrap), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} + }; + return __Pyx_InitStrings(__pyx_string_tab); +} +/* #### Code section: cached_builtins ### */ +static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 2, __pyx_L1_error) + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 153, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: cached_constants ### */ + +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 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) + */ + __pyx_tuple_ = PyTuple_Pack(1, __pyx_n_s_event); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 67, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple_); + __Pyx_GIVEREF(__pyx_tuple_); + __pyx_codeobj__2 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple_, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_wrap, 67, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__2)) __PYX_ERR(0, 67, __pyx_L1_error) + + /* "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_tuple__13 = PyTuple_Pack(1, __pyx_kp_s_Must_give_at_least_one_action); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(1, 319, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__13); + __Pyx_GIVEREF(__pyx_tuple__13); + + /* "(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_tuple__28 = PyTuple_Pack(3, __pyx_int_89143876, __pyx_int_166332997, __pyx_int_82616482); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__28); + __Pyx_GIVEREF(__pyx_tuple__28); + __pyx_tuple__30 = PyTuple_Pack(3, __pyx_int_242287462, __pyx_int_124881844, __pyx_int_190166812); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__30); + __Pyx_GIVEREF(__pyx_tuple__30); + __pyx_tuple__32 = PyTuple_Pack(3, __pyx_int_217908684, __pyx_int_223119700, __pyx_int_28104183); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__32); + __Pyx_GIVEREF(__pyx_tuple__32); + __pyx_tuple__34 = PyTuple_Pack(3, __pyx_int_149034610, __pyx_int_210676054, __pyx_int_178834394); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__34); + __Pyx_GIVEREF(__pyx_tuple__34); + __pyx_tuple__37 = PyTuple_Pack(3, __pyx_int_37183945, __pyx_int_4473905, __pyx_int_258412278); if (unlikely(!__pyx_tuple__37)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__37); + __Pyx_GIVEREF(__pyx_tuple__37); + __pyx_tuple__39 = PyTuple_Pack(3, __pyx_int_21139105, __pyx_int_198256870, __pyx_int_79429044); if (unlikely(!__pyx_tuple__39)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__39); + __Pyx_GIVEREF(__pyx_tuple__39); + + /* "hunter/_predicates.pyx":19 + * + * __all__ = ( + * 'And', # <<<<<<<<<<<<<< + * 'From', + * 'Not', + */ + __pyx_tuple__40 = 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__40)) __PYX_ERR(1, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__40); + __Pyx_GIVEREF(__pyx_tuple__40); + + /* "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_tuple__41 = PyTuple_Pack(17, __pyx_n_s_function, __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_instruction, __pyx_n_s_depth, __pyx_n_s_calls, __pyx_n_s_builtin); if (unlikely(!__pyx_tuple__41)) __PYX_ERR(1, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__41); + __Pyx_GIVEREF(__pyx_tuple__41); + + /* "hunter/_predicates.pyx":32 + * ) + * cdef tuple ALLOWED_OPERATORS = ( + * 'startswith', 'endswith', 'in', 'contains', 'regex', # <<<<<<<<<<<<<< + * 'sw', 'ew', 'has', 'rx', + * 'gt', 'gte', 'lt', 'lte', + */ + __pyx_tuple__42 = 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__42)) __PYX_ERR(1, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__42); + __Pyx_GIVEREF(__pyx_tuple__42); + + /* "(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_tuple__43 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__43)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__43); + __Pyx_GIVEREF(__pyx_tuple__43); + __pyx_codeobj__3 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__43, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__3)) __PYX_ERR(0, 1, __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" + */ + __pyx_tuple__44 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_pyx_state); if (unlikely(!__pyx_tuple__44)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__44); + __Pyx_GIVEREF(__pyx_tuple__44); + __pyx_codeobj__4 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__4)) __PYX_ERR(0, 3, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_tuple__45 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_state, __pyx_n_s_dict_2, __pyx_n_s_use_setstate); if (unlikely(!__pyx_tuple__45)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__45); + __Pyx_GIVEREF(__pyx_tuple__45); + __pyx_codeobj__11 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__45, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__11)) __PYX_ERR(0, 1, __pyx_L1_error) + + /* "(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_codeobj__12 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__12)) __PYX_ERR(0, 16, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__45, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(0, 1, __pyx_L1_error) + + /* "(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_codeobj__15 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__15)) __PYX_ERR(0, 16, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__16 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__45, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__16)) __PYX_ERR(0, 1, __pyx_L1_error) + + /* "(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_codeobj__17 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__17)) __PYX_ERR(0, 16, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__18 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__45, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__18)) __PYX_ERR(0, 1, __pyx_L1_error) + + /* "(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_codeobj__19 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__19)) __PYX_ERR(0, 16, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__20 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__45, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__20)) __PYX_ERR(0, 1, __pyx_L1_error) + + /* "(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_codeobj__21 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__21)) __PYX_ERR(0, 16, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__22 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__45, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__22)) __PYX_ERR(0, 1, __pyx_L1_error) + + /* "(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_codeobj__23 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__23)) __PYX_ERR(0, 16, __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_tuple__46 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_predicates, __pyx_n_s_kwargs, __pyx_n_s_merge); if (unlikely(!__pyx_tuple__46)) __PYX_ERR(1, 643, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__46); + __Pyx_GIVEREF(__pyx_tuple__46); + __pyx_codeobj__24 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__46, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_hunter__predicates_pyx, __pyx_n_s_filter, 643, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__24)) __PYX_ERR(1, 643, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__25 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__45, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__25)) __PYX_ERR(0, 1, __pyx_L1_error) + + /* "(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_codeobj__26 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__26)) __PYX_ERR(0, 16, __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_tuple__47 = 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__47)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__47); + __Pyx_GIVEREF(__pyx_tuple__47); + __pyx_codeobj__27 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__47, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Query, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__27)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_codeobj__29 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__47, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_When, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__29)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_codeobj__31 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__47, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_From, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__31)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_codeobj__33 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__47, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_And, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__33)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_codeobj__35 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__47, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Or, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__35)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_codeobj__36 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__47, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Not, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__36)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_codeobj__38 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__47, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Backlog, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__38)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} +/* #### Code section: init_constants ### */ + +static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) { + __pyx_umethod_PyDict_Type_items.type = (PyObject*)&PyDict_Type; + __pyx_umethod_PyDict_Type_items.method_name = &__pyx_n_s_items; + __pyx_umethod_PyTuple_Type_index.type = (PyObject*)&PyTuple_Type; + __pyx_umethod_PyTuple_Type_index.method_name = &__pyx_n_s_index; + if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(1, 1, __pyx_L1_error); + __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_int_10 = PyInt_FromLong(10); if (unlikely(!__pyx_int_10)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_int_100 = PyInt_FromLong(100); if (unlikely(!__pyx_int_100)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_int_4473905 = PyInt_FromLong(4473905L); if (unlikely(!__pyx_int_4473905)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_int_21139105 = PyInt_FromLong(21139105L); if (unlikely(!__pyx_int_21139105)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_int_28104183 = PyInt_FromLong(28104183L); if (unlikely(!__pyx_int_28104183)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_int_37183945 = PyInt_FromLong(37183945L); if (unlikely(!__pyx_int_37183945)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_int_79429044 = PyInt_FromLong(79429044L); if (unlikely(!__pyx_int_79429044)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_int_82616482 = PyInt_FromLong(82616482L); if (unlikely(!__pyx_int_82616482)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_int_89143876 = PyInt_FromLong(89143876L); if (unlikely(!__pyx_int_89143876)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_int_124881844 = PyInt_FromLong(124881844L); if (unlikely(!__pyx_int_124881844)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_int_149034610 = PyInt_FromLong(149034610L); if (unlikely(!__pyx_int_149034610)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_int_166332997 = PyInt_FromLong(166332997L); if (unlikely(!__pyx_int_166332997)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_int_178834394 = PyInt_FromLong(178834394L); if (unlikely(!__pyx_int_178834394)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_int_190166812 = PyInt_FromLong(190166812L); if (unlikely(!__pyx_int_190166812)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_int_198256870 = PyInt_FromLong(198256870L); if (unlikely(!__pyx_int_198256870)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_int_210676054 = PyInt_FromLong(210676054L); if (unlikely(!__pyx_int_210676054)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_int_217908684 = PyInt_FromLong(217908684L); if (unlikely(!__pyx_int_217908684)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_int_223119700 = PyInt_FromLong(223119700L); if (unlikely(!__pyx_int_223119700)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_int_242287462 = PyInt_FromLong(242287462L); if (unlikely(!__pyx_int_242287462)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_int_258412278 = PyInt_FromLong(258412278L); if (unlikely(!__pyx_int_258412278)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(1, 1, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: init_globals ### */ + +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { + return 0; +} +/* #### Code section: init_module ### */ + +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) { + __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; +} + +static int __Pyx_modinit_variable_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); + /*--- Variable export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_export_code(void) { + __Pyx_RefNannyDeclarations + 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(1, 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(1, 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(1, 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(1, 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(1, 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(1, 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(1, 1, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_type_init_code(void) { + __Pyx_RefNannyDeclarations + 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_ptype_6hunter_11_predicates_Query = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6hunter_11_predicates_Query_spec, NULL); if (unlikely(!__pyx_ptype_6hunter_11_predicates_Query)) __PYX_ERR(1, 100, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_11_predicates_Query_spec, __pyx_ptype_6hunter_11_predicates_Query) < 0) __PYX_ERR(1, 100, __pyx_L1_error) + #else + __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_ptype_6hunter_11_predicates_Query) < 0) __PYX_ERR(1, 100, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_6hunter_11_predicates_Query->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_6hunter_11_predicates_Query->tp_dictoffset && __pyx_ptype_6hunter_11_predicates_Query->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_6hunter_11_predicates_Query->tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + } + #endif + #if CYTHON_UPDATE_DESCRIPTOR_DOC + { + PyObject *wrapper = PyObject_GetAttrString((PyObject *)__pyx_ptype_6hunter_11_predicates_Query, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(1, 100, __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_n_s_Query, (PyObject *) __pyx_ptype_6hunter_11_predicates_Query) < 0) __PYX_ERR(1, 100, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_6hunter_11_predicates_Query) < 0) __PYX_ERR(1, 100, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_6hunter_11_predicates_And = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6hunter_11_predicates_And_spec, NULL); if (unlikely(!__pyx_ptype_6hunter_11_predicates_And)) __PYX_ERR(1, 438, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_11_predicates_And_spec, __pyx_ptype_6hunter_11_predicates_And) < 0) __PYX_ERR(1, 438, __pyx_L1_error) + #else + __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_ptype_6hunter_11_predicates_And) < 0) __PYX_ERR(1, 438, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_6hunter_11_predicates_And->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_6hunter_11_predicates_And->tp_dictoffset && __pyx_ptype_6hunter_11_predicates_And->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_6hunter_11_predicates_And->tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_And, (PyObject *) __pyx_ptype_6hunter_11_predicates_And) < 0) __PYX_ERR(1, 438, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_6hunter_11_predicates_And) < 0) __PYX_ERR(1, 438, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_6hunter_11_predicates_Or = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6hunter_11_predicates_Or_spec, NULL); if (unlikely(!__pyx_ptype_6hunter_11_predicates_Or)) __PYX_ERR(1, 487, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_11_predicates_Or_spec, __pyx_ptype_6hunter_11_predicates_Or) < 0) __PYX_ERR(1, 487, __pyx_L1_error) + #else + __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_ptype_6hunter_11_predicates_Or) < 0) __PYX_ERR(1, 487, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_6hunter_11_predicates_Or->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_6hunter_11_predicates_Or->tp_dictoffset && __pyx_ptype_6hunter_11_predicates_Or->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_6hunter_11_predicates_Or->tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Or, (PyObject *) __pyx_ptype_6hunter_11_predicates_Or) < 0) __PYX_ERR(1, 487, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_6hunter_11_predicates_Or) < 0) __PYX_ERR(1, 487, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_6hunter_11_predicates_Not = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6hunter_11_predicates_Not_spec, NULL); if (unlikely(!__pyx_ptype_6hunter_11_predicates_Not)) __PYX_ERR(1, 536, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_11_predicates_Not_spec, __pyx_ptype_6hunter_11_predicates_Not) < 0) __PYX_ERR(1, 536, __pyx_L1_error) + #else + __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_ptype_6hunter_11_predicates_Not) < 0) __PYX_ERR(1, 536, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_6hunter_11_predicates_Not->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_6hunter_11_predicates_Not->tp_dictoffset && __pyx_ptype_6hunter_11_predicates_Not->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_6hunter_11_predicates_Not->tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Not, (PyObject *) __pyx_ptype_6hunter_11_predicates_Not) < 0) __PYX_ERR(1, 536, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_6hunter_11_predicates_Not) < 0) __PYX_ERR(1, 536, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_6hunter_11_predicates_When = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6hunter_11_predicates_When_spec, NULL); if (unlikely(!__pyx_ptype_6hunter_11_predicates_When)) __PYX_ERR(1, 310, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_11_predicates_When_spec, __pyx_ptype_6hunter_11_predicates_When) < 0) __PYX_ERR(1, 310, __pyx_L1_error) + #else + __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_ptype_6hunter_11_predicates_When) < 0) __PYX_ERR(1, 310, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_6hunter_11_predicates_When->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_6hunter_11_predicates_When->tp_dictoffset && __pyx_ptype_6hunter_11_predicates_When->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_6hunter_11_predicates_When->tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_When, (PyObject *) __pyx_ptype_6hunter_11_predicates_When) < 0) __PYX_ERR(1, 310, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_6hunter_11_predicates_When) < 0) __PYX_ERR(1, 310, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_6hunter_11_predicates_From = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6hunter_11_predicates_From_spec, NULL); if (unlikely(!__pyx_ptype_6hunter_11_predicates_From)) __PYX_ERR(1, 366, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_11_predicates_From_spec, __pyx_ptype_6hunter_11_predicates_From) < 0) __PYX_ERR(1, 366, __pyx_L1_error) + #else + __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_ptype_6hunter_11_predicates_From) < 0) __PYX_ERR(1, 366, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_6hunter_11_predicates_From->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_6hunter_11_predicates_From->tp_dictoffset && __pyx_ptype_6hunter_11_predicates_From->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_6hunter_11_predicates_From->tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_From, (PyObject *) __pyx_ptype_6hunter_11_predicates_From) < 0) __PYX_ERR(1, 366, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_6hunter_11_predicates_From) < 0) __PYX_ERR(1, 366, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_6hunter_11_predicates_Backlog = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6hunter_11_predicates_Backlog_spec, NULL); if (unlikely(!__pyx_ptype_6hunter_11_predicates_Backlog)) __PYX_ERR(1, 597, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_11_predicates_Backlog_spec, __pyx_ptype_6hunter_11_predicates_Backlog) < 0) __PYX_ERR(1, 597, __pyx_L1_error) + #else + __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_ptype_6hunter_11_predicates_Backlog) < 0) __PYX_ERR(1, 597, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_6hunter_11_predicates_Backlog->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_6hunter_11_predicates_Backlog->tp_dictoffset && __pyx_ptype_6hunter_11_predicates_Backlog->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_6hunter_11_predicates_Backlog->tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Backlog, (PyObject *) __pyx_ptype_6hunter_11_predicates_Backlog) < 0) __PYX_ERR(1, 597, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_6hunter_11_predicates_Backlog) < 0) __PYX_ERR(1, 597, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_6hunter_11_predicates_QueryEntry = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6hunter_11_predicates_QueryEntry_spec, NULL); if (unlikely(!__pyx_ptype_6hunter_11_predicates_QueryEntry)) __PYX_ERR(1, 78, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_11_predicates_QueryEntry_spec, __pyx_ptype_6hunter_11_predicates_QueryEntry) < 0) __PYX_ERR(1, 78, __pyx_L1_error) + #else + __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_ptype_6hunter_11_predicates_QueryEntry) < 0) __PYX_ERR(1, 78, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_6hunter_11_predicates_QueryEntry->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_6hunter_11_predicates_QueryEntry->tp_dictoffset && __pyx_ptype_6hunter_11_predicates_QueryEntry->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_6hunter_11_predicates_QueryEntry->tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_QueryEntry, (PyObject *) __pyx_ptype_6hunter_11_predicates_QueryEntry) < 0) __PYX_ERR(1, 78, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_6hunter_11_predicates_QueryEntry) < 0) __PYX_ERR(1, 78, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __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_ptype_6hunter_11_predicates___pyx_scope_struct____str__)) __PYX_ERR(1, 199, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_11_predicates___pyx_scope_struct____str___spec, __pyx_ptype_6hunter_11_predicates___pyx_scope_struct____str__) < 0) __PYX_ERR(1, 199, __pyx_L1_error) + #else + __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_ptype_6hunter_11_predicates___pyx_scope_struct____str__) < 0) __PYX_ERR(1, 199, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_6hunter_11_predicates___pyx_scope_struct____str__->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_6hunter_11_predicates___pyx_scope_struct____str__->tp_dictoffset && __pyx_ptype_6hunter_11_predicates___pyx_scope_struct____str__->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_6hunter_11_predicates___pyx_scope_struct____str__->tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + } + #endif + #if CYTHON_USE_TYPE_SPECS + __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_ptype_6hunter_11_predicates___pyx_scope_struct_1_genexpr)) __PYX_ERR(1, 202, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_11_predicates___pyx_scope_struct_1_genexpr_spec, __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_1_genexpr) < 0) __PYX_ERR(1, 202, __pyx_L1_error) + #else + __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_ptype_6hunter_11_predicates___pyx_scope_struct_1_genexpr) < 0) __PYX_ERR(1, 202, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_1_genexpr->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_1_genexpr->tp_dictoffset && __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_1_genexpr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_1_genexpr->tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + } + #endif + #if CYTHON_USE_TYPE_SPECS + __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_ptype_6hunter_11_predicates___pyx_scope_struct_2_genexpr)) __PYX_ERR(1, 322, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_11_predicates___pyx_scope_struct_2_genexpr_spec, __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_2_genexpr) < 0) __PYX_ERR(1, 322, __pyx_L1_error) + #else + __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_ptype_6hunter_11_predicates___pyx_scope_struct_2_genexpr) < 0) __PYX_ERR(1, 322, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_2_genexpr->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_2_genexpr->tp_dictoffset && __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_2_genexpr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_2_genexpr->tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + } + #endif + #if CYTHON_USE_TYPE_SPECS + __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_ptype_6hunter_11_predicates___pyx_scope_struct_3_genexpr)) __PYX_ERR(1, 328, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_11_predicates___pyx_scope_struct_3_genexpr_spec, __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_3_genexpr) < 0) __PYX_ERR(1, 328, __pyx_L1_error) + #else + __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_ptype_6hunter_11_predicates___pyx_scope_struct_3_genexpr) < 0) __PYX_ERR(1, 328, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_3_genexpr->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_3_genexpr->tp_dictoffset && __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_3_genexpr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_3_genexpr->tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + } + #endif + #if CYTHON_USE_TYPE_SPECS + __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_ptype_6hunter_11_predicates___pyx_scope_struct_4_genexpr)) __PYX_ERR(1, 446, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_11_predicates___pyx_scope_struct_4_genexpr_spec, __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_4_genexpr) < 0) __PYX_ERR(1, 446, __pyx_L1_error) + #else + __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_ptype_6hunter_11_predicates___pyx_scope_struct_4_genexpr) < 0) __PYX_ERR(1, 446, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_4_genexpr->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_4_genexpr->tp_dictoffset && __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_4_genexpr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_4_genexpr->tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + } + #endif + #if CYTHON_USE_TYPE_SPECS + __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_ptype_6hunter_11_predicates___pyx_scope_struct_5_genexpr)) __PYX_ERR(1, 496, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_11_predicates___pyx_scope_struct_5_genexpr_spec, __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_5_genexpr) < 0) __PYX_ERR(1, 496, __pyx_L1_error) + #else + __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_ptype_6hunter_11_predicates___pyx_scope_struct_5_genexpr) < 0) __PYX_ERR(1, 496, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_5_genexpr->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_6hunter_11_predicates___pyx_scope_struct_5_genexpr->tp_dictoffset && __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_5_genexpr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_6hunter_11_predicates___pyx_scope_struct_5_genexpr->tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + } + #endif + #if CYTHON_USE_TYPE_SPECS + __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_ptype___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event)) __PYX_ERR(0, 66, __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_ptype___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event) < 0) __PYX_ERR(0, 66, __pyx_L1_error) + #else + __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_ptype___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event) < 0) __PYX_ERR(0, 66, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event->tp_dictoffset && __pyx_ptype___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype___pyx_scope_struct____Pyx_CFunc_6hunter_11_predicates_object__lParenEvent__rParen_to_py_5event->tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + } + #endif + __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; + 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_3_0_10(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyTypeObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyTypeObject), + #else + sizeof(PyHeapTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyHeapTypeObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_0_10); 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, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_6hunter_7_tracer_FrameType = __Pyx_ImportType_3_0_10(__pyx_t_1, "types", "FrameType", sizeof(PyFrameObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyFrameObject),__Pyx_ImportType_CheckSize_Ignore_3_0_10); if (!__pyx_ptype_6hunter_7_tracer_FrameType) __PYX_ERR(4, 19, __pyx_L1_error) + __pyx_ptype_6hunter_7_tracer_CodeType = __Pyx_ImportType_3_0_10(__pyx_t_1, "types", "CodeType", sizeof(PyCodeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyCodeObject),__Pyx_ImportType_CheckSize_Ignore_3_0_10); if (!__pyx_ptype_6hunter_7_tracer_CodeType) __PYX_ERR(4, 22, __pyx_L1_error) + __pyx_t_2 = PyImport_ImportModule("hunter._tracer"); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_ptype_6hunter_7_tracer_Tracer = __Pyx_ImportType_3_0_10(__pyx_t_2, "hunter._tracer", "Tracer", sizeof(struct __pyx_obj_6hunter_7_tracer_Tracer), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_6hunter_7_tracer_Tracer),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_6hunter_7_tracer_Tracer) __PYX_ERR(4, 36, __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, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_ptype_6hunter_6_event_Event = __Pyx_ImportType_3_0_10(__pyx_t_2, "hunter._event", "Event", sizeof(struct __pyx_obj_6hunter_6_event_Event), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_6hunter_6_event_Event),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_6hunter_6_event_Event) __PYX_ERR(5, 13, __pyx_L1_error) + __pyx_vtabptr_6hunter_6_event_Event = (struct __pyx_vtabstruct_6hunter_6_event_Event*)__Pyx_GetVtable(__pyx_ptype_6hunter_6_event_Event); if (unlikely(!__pyx_vtabptr_6hunter_6_event_Event)) __PYX_ERR(5, 13, __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) { + __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 + 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(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_ImportFunction_3_0_10(__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(1, 1, __pyx_L1_error) + if (__Pyx_ImportFunction_3_0_10(__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(1, 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 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 + +#ifdef __cplusplus +namespace { + struct PyModuleDef __pyx_moduledef = + #else + static struct PyModuleDef __pyx_moduledef = + #endif + { + PyModuleDef_HEAD_INIT, + "_predicates", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #elif CYTHON_USE_MODULE_STATE + sizeof(__pyx_mstate), /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + #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 +#endif + +#ifndef CYTHON_NO_PYINIT_EXPORT +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#elif PY_MAJOR_VERSION < 3 +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" void +#else +#define __Pyx_PyMODINIT_FUNC void +#endif +#else +#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_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; +} +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none) +#else +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 +{ + PyObject *value = PyObject_GetAttrString(spec, from_name); + int result = 0; + if (likely(value)) { + if (allow_none || value != Py_None) { +#if CYTHON_COMPILING_IN_LIMITED_API + result = PyModule_AddObject(module, to_name, value); +#else + result = PyDict_SetItemString(moddict, to_name, value); +#endif + } + 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 (__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; +#if CYTHON_COMPILING_IN_LIMITED_API + moddict = module; +#else + moddict = PyModule_GetDict(module); + if (unlikely(!moddict)) goto bad; +#endif + 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 +{ + int stringtab_initialized = 0; + #if CYTHON_USE_MODULE_STATE + int pystate_addmodule_run = 0; + #endif + __Pyx_TraceDeclarations + 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; + } + #elif PY_MAJOR_VERSION >= 3 + if (__pyx_m) return __Pyx_NewRef(__pyx_m); + #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); + if (unlikely(!__pyx_m)) __PYX_ERR(1, 1, __pyx_L1_error) + #elif CYTHON_USE_MODULE_STATE + __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1, __pyx_L1_error) + { + int add_module_result = PyState_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(1, 1, __pyx_L1_error) + pystate_addmodule_run = 1; + } + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + if (unlikely(!__pyx_m)) __PYX_ERR(1, 1, __pyx_L1_error) + #endif + #endif + CYTHON_UNUSED_VAR(__pyx_t_1); + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(1, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(1, 1, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + #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(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(1, 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(1, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(1, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + PyEval_InitThreads(); + #endif + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitConstants() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + stringtab_initialized = 1; + if (__Pyx_InitGlobals() < 0) __PYX_ERR(1, 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(1, 1, __pyx_L1_error) + #endif + if (__pyx_module_is_main_hunter___predicates) { + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name_2, __pyx_n_s_main) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(1, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "hunter._predicates")) { + if (unlikely((PyDict_SetItemString(modules, "hunter._predicates", __pyx_m) < 0))) __PYX_ERR(1, 1, __pyx_L1_error) + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(1, 1, __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))) __PYX_ERR(1, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_type_init_code() < 0))) __PYX_ERR(1, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_type_import_code() < 0))) __PYX_ERR(1, 1, __pyx_L1_error) + (void)__Pyx_modinit_variable_import_code(); + if (unlikely((__Pyx_modinit_function_import_code() < 0))) __PYX_ERR(1, 1, __pyx_L1_error) + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + #endif + __Pyx_TraceCall("__Pyx_PyMODINIT_FUNC PyInit__predicates(void)", __pyx_f[1], 1, 0, __PYX_ERR(1, 1, __pyx_L1_error)); + + /* "cfunc.to_py":66 + * + * @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')""" + */ + __Pyx_TraceLine(66,0,__PYX_ERR(0, 66, __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,0,__PYX_ERR(1, 4, __pyx_L1_error)) + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_deque); + __Pyx_GIVEREF(__pyx_n_s_deque); + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_deque)) __PYX_ERR(1, 4, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_collections, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 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_n_s_deque); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_deque, __pyx_t_2) < 0) __PYX_ERR(1, 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,0,__PYX_ERR(1, 5, __pyx_L1_error)) + __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_n_s_isclass); + __Pyx_GIVEREF(__pyx_n_s_isclass); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_isclass)) __PYX_ERR(1, 5, __pyx_L1_error); + __pyx_t_2 = __Pyx_patch_inspect(__Pyx_Import(__pyx_n_s_inspect, __pyx_t_3, 0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 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_n_s_isclass); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_isclass, __pyx_t_3) < 0) __PYX_ERR(1, 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,0,__PYX_ERR(1, 6, __pyx_L1_error)) + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_compile); + __Pyx_GIVEREF(__pyx_n_s_compile); + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_compile)) __PYX_ERR(1, 6, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_re, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 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_n_s_compile); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_re_compile, __pyx_t_2) < 0) __PYX_ERR(1, 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,0,__PYX_ERR(1, 15, __pyx_L1_error)) + __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_n_s_Action); + __Pyx_GIVEREF(__pyx_n_s_Action); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_Action)) __PYX_ERR(1, 15, __pyx_L1_error); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_actions, __pyx_t_3, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 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_n_s_Action); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Action, __pyx_t_3) < 0) __PYX_ERR(1, 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,0,__PYX_ERR(1, 16, __pyx_L1_error)) + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_ColorStreamAction); + __Pyx_GIVEREF(__pyx_n_s_ColorStreamAction); + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_ColorStreamAction)) __PYX_ERR(1, 16, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_actions, __pyx_t_2, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 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_n_s_ColorStreamAction); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ColorStreamAction, __pyx_t_2) < 0) __PYX_ERR(1, 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,0,__PYX_ERR(1, 19, __pyx_L1_error)) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_all, __pyx_tuple__40) < 0) __PYX_ERR(1, 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,0,__PYX_ERR(1, 28, __pyx_L1_error)) + __Pyx_INCREF(__pyx_tuple__41); + __Pyx_XGOTREF(__pyx_v_6hunter_11_predicates_ALLOWED_KEYS); + __Pyx_DECREF_SET(__pyx_v_6hunter_11_predicates_ALLOWED_KEYS, __pyx_tuple__41); + __Pyx_GIVEREF(__pyx_tuple__41); + + /* "hunter/_predicates.pyx":32 + * ) + * cdef tuple ALLOWED_OPERATORS = ( + * 'startswith', 'endswith', 'in', 'contains', 'regex', # <<<<<<<<<<<<<< + * 'sw', 'ew', 'has', 'rx', + * 'gt', 'gte', 'lt', 'lte', + */ + __Pyx_TraceLine(32,0,__PYX_ERR(1, 32, __pyx_L1_error)) + __Pyx_INCREF(__pyx_tuple__42); + __Pyx_XGOTREF(__pyx_v_6hunter_11_predicates_ALLOWED_OPERATORS); + __Pyx_DECREF_SET(__pyx_v_6hunter_11_predicates_ALLOWED_OPERATORS, __pyx_tuple__42); + __Pyx_GIVEREF(__pyx_tuple__42); + + /* "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,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 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,0,__PYX_ERR(0, 1, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_10QueryEntry_7__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_QueryEntry___reduce_cython, NULL, __pyx_n_s_hunter__predicates, __pyx_d, ((PyObject *)__pyx_codeobj__3)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_3) < 0) __PYX_ERR(0, 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,0,__PYX_ERR(0, 3, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_10QueryEntry_9__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_QueryEntry___setstate_cython, NULL, __pyx_n_s_hunter__predicates, __pyx_d, ((PyObject *)__pyx_codeobj__4)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_3) < 0) __PYX_ERR(0, 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,0,__PYX_ERR(0, 1, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_5Query_17__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Query___reduce_cython, NULL, __pyx_n_s_hunter__predicates, __pyx_d, ((PyObject *)__pyx_codeobj__11)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6hunter_11_predicates_Query, __pyx_n_s_reduce_cython, __pyx_t_3) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_6hunter_11_predicates_Query); + + /* "(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,0,__PYX_ERR(0, 16, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_5Query_19__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Query___setstate_cython, NULL, __pyx_n_s_hunter__predicates, __pyx_d, ((PyObject *)__pyx_codeobj__12)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6hunter_11_predicates_Query, __pyx_n_s_setstate_cython, __pyx_t_3) < 0) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_6hunter_11_predicates_Query); + + /* "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,0,__PYX_ERR(1, 264, __pyx_L1_error)) + + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __Pyx_TraceLine(1,0,__PYX_ERR(0, 1, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_4When_17__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_When___reduce_cython, NULL, __pyx_n_s_hunter__predicates, __pyx_d, ((PyObject *)__pyx_codeobj__14)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6hunter_11_predicates_When, __pyx_n_s_reduce_cython, __pyx_t_3) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_6hunter_11_predicates_When); + + /* "(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,0,__PYX_ERR(0, 16, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_4When_19__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_When___setstate_cython, NULL, __pyx_n_s_hunter__predicates, __pyx_d, ((PyObject *)__pyx_codeobj__15)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6hunter_11_predicates_When, __pyx_n_s_setstate_cython, __pyx_t_3) < 0) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_6hunter_11_predicates_When); + + /* "hunter/_predicates.pyx":353 + * return Not(self) + * + * cdef inline fast_When_call(When self, Event event): # <<<<<<<<<<<<<< + * cdef object result + * + */ + __Pyx_TraceLine(353,0,__PYX_ERR(1, 353, __pyx_L1_error)) + + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __Pyx_TraceLine(1,0,__PYX_ERR(0, 1, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_4From_17__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_From___reduce_cython, NULL, __pyx_n_s_hunter__predicates, __pyx_d, ((PyObject *)__pyx_codeobj__16)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6hunter_11_predicates_From, __pyx_n_s_reduce_cython, __pyx_t_3) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_6hunter_11_predicates_From); + + /* "(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,0,__PYX_ERR(0, 16, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_4From_19__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_From___setstate_cython, NULL, __pyx_n_s_hunter__predicates, __pyx_d, ((PyObject *)__pyx_codeobj__17)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6hunter_11_predicates_From, __pyx_n_s_setstate_cython, __pyx_t_3) < 0) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_6hunter_11_predicates_From); + + /* "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,0,__PYX_ERR(1, 407, __pyx_L1_error)) + + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __Pyx_TraceLine(1,0,__PYX_ERR(0, 1, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_3And_17__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_And___reduce_cython, NULL, __pyx_n_s_hunter__predicates, __pyx_d, ((PyObject *)__pyx_codeobj__18)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6hunter_11_predicates_And, __pyx_n_s_reduce_cython, __pyx_t_3) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_6hunter_11_predicates_And); + + /* "(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,0,__PYX_ERR(0, 16, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_3And_19__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_And___setstate_cython, NULL, __pyx_n_s_hunter__predicates, __pyx_d, ((PyObject *)__pyx_codeobj__19)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6hunter_11_predicates_And, __pyx_n_s_setstate_cython, __pyx_t_3) < 0) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_6hunter_11_predicates_And); + + /* "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,0,__PYX_ERR(1, 478, __pyx_L1_error)) + + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __Pyx_TraceLine(1,0,__PYX_ERR(0, 1, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_2Or_17__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Or___reduce_cython, NULL, __pyx_n_s_hunter__predicates, __pyx_d, ((PyObject *)__pyx_codeobj__20)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6hunter_11_predicates_Or, __pyx_n_s_reduce_cython, __pyx_t_3) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_6hunter_11_predicates_Or); + + /* "(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,0,__PYX_ERR(0, 16, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_2Or_19__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Or___setstate_cython, NULL, __pyx_n_s_hunter__predicates, __pyx_d, ((PyObject *)__pyx_codeobj__21)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6hunter_11_predicates_Or, __pyx_n_s_setstate_cython, __pyx_t_3) < 0) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_6hunter_11_predicates_Or); + + /* "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,0,__PYX_ERR(1, 528, __pyx_L1_error)) + + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __Pyx_TraceLine(1,0,__PYX_ERR(0, 1, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_3Not_17__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Not___reduce_cython, NULL, __pyx_n_s_hunter__predicates, __pyx_d, ((PyObject *)__pyx_codeobj__22)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6hunter_11_predicates_Not, __pyx_n_s_reduce_cython, __pyx_t_3) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_6hunter_11_predicates_Not); + + /* "(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,0,__PYX_ERR(0, 16, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_3Not_19__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Not___setstate_cython, NULL, __pyx_n_s_hunter__predicates, __pyx_d, ((PyObject *)__pyx_codeobj__23)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6hunter_11_predicates_Not, __pyx_n_s_setstate_cython, __pyx_t_3) < 0) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_6hunter_11_predicates_Not); + + /* "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,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 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,0,__PYX_ERR(1, 643, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_7Backlog_17filter, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Backlog_filter, NULL, __pyx_n_s_hunter__predicates, __pyx_d, ((PyObject *)__pyx_codeobj__24)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 643, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6hunter_11_predicates_Backlog, __pyx_n_s_filter, __pyx_t_3) < 0) __PYX_ERR(1, 643, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_6hunter_11_predicates_Backlog); + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __Pyx_TraceLine(1,0,__PYX_ERR(0, 1, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_7Backlog_19__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Backlog___reduce_cython, NULL, __pyx_n_s_hunter__predicates, __pyx_d, ((PyObject *)__pyx_codeobj__25)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6hunter_11_predicates_Backlog, __pyx_n_s_reduce_cython, __pyx_t_3) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_6hunter_11_predicates_Backlog); + + /* "(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,0,__PYX_ERR(0, 16, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_7Backlog_21__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Backlog___setstate_cython, NULL, __pyx_n_s_hunter__predicates, __pyx_d, ((PyObject *)__pyx_codeobj__26)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6hunter_11_predicates_Backlog, __pyx_n_s_setstate_cython, __pyx_t_3) < 0) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_6hunter_11_predicates_Backlog); + + /* "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,0,__PYX_ERR(1, 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,0,__PYX_ERR(0, 1, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_1__pyx_unpickle_Query, 0, __pyx_n_s_pyx_unpickle_Query, NULL, __pyx_n_s_hunter__predicates, __pyx_d, ((PyObject *)__pyx_codeobj__27)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Query, __pyx_t_3) < 0) __PYX_ERR(0, 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,0,__PYX_ERR(0, 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,0,__PYX_ERR(0, 1, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_3__pyx_unpickle_When, 0, __pyx_n_s_pyx_unpickle_When, NULL, __pyx_n_s_hunter__predicates, __pyx_d, ((PyObject *)__pyx_codeobj__29)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_When, __pyx_t_3) < 0) __PYX_ERR(0, 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,0,__PYX_ERR(0, 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,0,__PYX_ERR(0, 1, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_5__pyx_unpickle_From, 0, __pyx_n_s_pyx_unpickle_From, NULL, __pyx_n_s_hunter__predicates, __pyx_d, ((PyObject *)__pyx_codeobj__31)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_From, __pyx_t_3) < 0) __PYX_ERR(0, 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,0,__PYX_ERR(0, 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,0,__PYX_ERR(0, 1, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_7__pyx_unpickle_And, 0, __pyx_n_s_pyx_unpickle_And, NULL, __pyx_n_s_hunter__predicates, __pyx_d, ((PyObject *)__pyx_codeobj__33)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_And, __pyx_t_3) < 0) __PYX_ERR(0, 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,0,__PYX_ERR(0, 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,0,__PYX_ERR(0, 1, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_9__pyx_unpickle_Or, 0, __pyx_n_s_pyx_unpickle_Or, NULL, __pyx_n_s_hunter__predicates, __pyx_d, ((PyObject *)__pyx_codeobj__35)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Or, __pyx_t_3) < 0) __PYX_ERR(0, 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,0,__PYX_ERR(0, 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,0,__PYX_ERR(0, 1, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_11__pyx_unpickle_Not, 0, __pyx_n_s_pyx_unpickle_Not, NULL, __pyx_n_s_hunter__predicates, __pyx_d, ((PyObject *)__pyx_codeobj__36)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Not, __pyx_t_3) < 0) __PYX_ERR(0, 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,0,__PYX_ERR(0, 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,0,__PYX_ERR(0, 1, __pyx_L1_error)) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_11_predicates_13__pyx_unpickle_Backlog, 0, __pyx_n_s_pyx_unpickle_Backlog, NULL, __pyx_n_s_hunter__predicates, __pyx_d, ((PyObject *)__pyx_codeobj__38)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Backlog, __pyx_t_3) < 0) __PYX_ERR(0, 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,0,__PYX_ERR(0, 11, __pyx_L1_error)) + + + /* "hunter/_predicates.pyx":1 + * # cython: linetrace=True, language_level=3str, c_api_binop_methods=True # <<<<<<<<<<<<<< + * from __future__ import absolute_import + * + */ + __Pyx_TraceLine(1,0,__PYX_ERR(1, 1, __pyx_L1_error)) + __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_3) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_TraceReturn(Py_None, 0); + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + if (__pyx_m) { + if (__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; + #elif PY_MAJOR_VERSION >= 3 + return __pyx_m; + #else + return; + #endif +} +/* #### 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); +#if PY_MAJOR_VERSION >= 3 + 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)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#endif + +/* PyObjectGetAttrStrNoError */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 +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 >= 0x030d00A1 + (void) PyObject_GetOptionalAttr(obj, attr_name, &result); + return result; +#else +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 + 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_b, name); + if (unlikely(!result) && !PyErr_Occurred()) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +/* TupleAndListFromArray */ +#if 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) { + Py_INCREF(__pyx_empty_tuple); + return __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 + 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 + 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; + 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; + } +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 +} + +/* fastcall */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) +{ + Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames); + for (i = 0; i < n; i++) + { + if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i]; + } + for (i = 0; i < n; i++) + { + int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), 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_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { + Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames); + PyObject *dict; + dict = PyDict_New(); + if (unlikely(!dict)) + return NULL; + for (i=0; i= 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 *const *kwvalues, + 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; + int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds)); + while (1) { + Py_XDECREF(key); key = NULL; + Py_XDECREF(value); value = NULL; + if (kwds_is_tuple) { + Py_ssize_t size; +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(kwds); +#else + size = PyTuple_Size(kwds); + if (size < 0) goto bad; +#endif + if (pos >= size) break; +#if CYTHON_AVOID_BORROWED_REFS + key = __Pyx_PySequence_ITEM(kwds, pos); + if (!key) goto bad; +#elif CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kwds, pos); +#else + key = PyTuple_GetItem(kwds, pos); + if (!key) goto bad; +#endif + value = kwvalues[pos]; + pos++; + } + else + { + if (!PyDict_Next(kwds, &pos, &key, &value)) break; +#if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(key); +#endif + } + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; +#if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(value); + Py_DECREF(key); +#endif + key = NULL; + value = NULL; + continue; + } +#if !CYTHON_AVOID_BORROWED_REFS + Py_INCREF(key); +#endif + Py_INCREF(value); + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (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; +#if CYTHON_AVOID_BORROWED_REFS + value = NULL; +#endif + 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 = ( + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key) + ); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; +#if CYTHON_AVOID_BORROWED_REFS + value = NULL; +#endif + 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 + (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(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; + } + } + Py_XDECREF(key); + Py_XDECREF(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: + #if PY_MAJOR_VERSION < 3 + PyErr_Format(PyExc_TypeError, + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + Py_XDECREF(key); + Py_XDECREF(value); + 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); +} + +/* ArgTypeTest */ +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +{ + __Pyx_TypeName type_name; + __Pyx_TypeName obj_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; + } + type_name = __Pyx_PyType_GetName(type); + obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME + ", got " __Pyx_FMT_TYPENAME ")", name, type_name, obj_type_name); + __Pyx_DECREF_TypeName(type_name); + __Pyx_DECREF_TypeName(obj_type_name); + return 0; +} + +/* 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; + } +#if PY_VERSION_HEX < 0x030400B1 + } else { + (*frame)->f_tstate = tstate; +#endif + } + __Pyx_PyFrame_SetLineNumber(*frame, firstlineno); + retval = 1; + __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 (retval) { + __Pyx_ErrRestoreInState(tstate, type, value, traceback); + return __Pyx_IsTracing(tstate, 0, 0) && 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*/ + ); +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); +#endif + return py_code; +} +#endif + +/* FixUpExtensionType */ +#if CYTHON_USE_TYPE_SPECS +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) { +#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + CYTHON_UNUSED_VAR(spec); + CYTHON_UNUSED_VAR(type); +#else + const PyType_Slot *slot = spec->slots; + while (slot && slot->slot && slot->slot != Py_tp_members) + slot++; + if (slot && slot->slot == Py_tp_members) { + int changed = 0; +#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON) + const +#endif + PyMemberDef *memb = (PyMemberDef*) slot->pfunc; + while (memb && memb->name) { + if (memb->name[0] == '_' && memb->name[1] == '_') { +#if PY_VERSION_HEX < 0x030900b1 + 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 +#else + if ((0)); +#endif +#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON + 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; + if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) { + Py_DECREF(descr); + return -1; + } + Py_DECREF(descr); + changed = 1; + } +#endif + } + memb++; + } + if (changed) + PyType_Modified(type); + } +#endif + return 0; +} +#endif + +/* FetchSharedCythonModule */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void) { + return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME); +} + +/* FetchCommonType */ +static int __Pyx_VerifyCachedType(PyObject *cached_type, + const char *name, + Py_ssize_t basicsize, + Py_ssize_t expected_basicsize) { + if (!PyType_Check(cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", name); + return -1; + } + if (basicsize != expected_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + name); + return -1; + } + return 0; +} +#if !CYTHON_USE_TYPE_SPECS +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { + PyObject* abi_module; + const char* object_name; + PyTypeObject *cached_type = NULL; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) return NULL; + object_name = strrchr(type->tp_name, '.'); + object_name = object_name ? object_name+1 : type->tp_name; + cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name); + if (cached_type) { + if (__Pyx_VerifyCachedType( + (PyObject *)cached_type, + object_name, + cached_type->tp_basicsize, + type->tp_basicsize) < 0) { + goto bad; + } + goto done; + } + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + if (PyType_Ready(type) < 0) goto bad; + if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0) + goto bad; + Py_INCREF(type); + cached_type = type; +done: + Py_DECREF(abi_module); + return cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} +#else +static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *abi_module, *cached_type = NULL; + const char* object_name = strrchr(spec->name, '.'); + object_name = object_name ? object_name+1 : spec->name; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) return NULL; + cached_type = PyObject_GetAttrString(abi_module, object_name); + if (cached_type) { + Py_ssize_t basicsize; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_basicsize; + py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); + if (unlikely(!py_basicsize)) goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; +#else + basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1; +#endif + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + basicsize, + spec->basicsize) < 0) { + goto bad; + } + goto done; + } + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + CYTHON_UNUSED_VAR(module); + cached_type = __Pyx_PyType_FromModuleAndSpec(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; + if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad; +done: + Py_DECREF(abi_module); + assert(cached_type == NULL || PyType_Check(cached_type)); + return (PyTypeObject *) cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} +#endif + +/* PyVectorcallFastCallDict */ +#if CYTHON_METH_FASTCALL +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; + Py_ssize_t nkw = PyDict_GET_SIZE(kw); + 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 &= Py_TYPE(key)->tp_flags; + Py_INCREF(key); + Py_INCREF(value); + PyTuple_SET_ITEM(kwnames, i, key); + 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) +{ + if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) { + return vc(func, args, nargs, NULL); + } + return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); +} +#endif + +/* CythonFunctionShared */ +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { + 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; +} +#else +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { + 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(__pyx_CyFunctionObject *op, void *closure) +{ + CYTHON_UNUSED_VAR(closure); + 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) { +#if PY_MAJOR_VERSION >= 3 + op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); +#else + op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); +#endif + 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 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_Py_XDECREF_SET(op->func_doc, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(op->func_name == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_name = PyObject_GetAttrString(op->func, "__name__"); +#elif PY_MAJOR_VERSION >= 3 + op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); +#else + op->func_name = PyString_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 int +__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) +#else + if (unlikely(value == NULL || !PyString_Check(value))) +#endif + { + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_name, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + Py_INCREF(op->func_qualname); + return op->func_qualname; +} +static int +__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) +#else + if (unlikely(value == NULL || !PyString_Check(value))) +#endif + { + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_qualname, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(op->func_dict == NULL)) { + op->func_dict = PyDict_New(); + if (unlikely(op->func_dict == NULL)) + return NULL; + } + Py_INCREF(op->func_dict); + return op->func_dict; +} +static int +__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, 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_Py_XDECREF_SET(op->func_dict, value); + 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_Py_XDECREF_SET(op->defaults_tuple, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->defaults_tuple; + CYTHON_UNUSED_VAR(context); + 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 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_Py_XDECREF_SET(op->defaults_kwdict, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->defaults_kwdict; + CYTHON_UNUSED_VAR(context); + 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; } - -/* --- 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; +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_Py_XDECREF_SET(op->func_annotations, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->func_annotations; + CYTHON_UNUSED_VAR(context); + 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_is_coroutine(__pyx_CyFunctionObject *op, void *context) { + int is_coroutine; + CYTHON_UNUSED_VAR(context); + if (op->func_is_coroutine) { + return __Pyx_NewRef(op->func_is_coroutine); + } + is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; +#if PY_VERSION_HEX >= 0x03050000 + if (is_coroutine) { + PyObject *module, *fromlist, *marker = __pyx_n_s_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 - -/* 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)); + module = PyImport_ImportModuleLevelObject(__pyx_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0); + Py_DECREF(fromlist); + if (unlikely(!module)) goto ignore; + op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker); + Py_DECREF(module); + if (likely(op->func_is_coroutine)) { + return __Pyx_NewRef(op->func_is_coroutine); + } +ignore: + PyErr_Clear(); + } #endif - return PyObject_GetAttr(obj, attr_name); + op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine); + return __Pyx_NewRef(op->func_is_coroutine); +} +#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[] = { + {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, + {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {(char *) "_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 - -/* GetBuiltinName */ -static PyObject *__Pyx_GetBuiltinName(PyObject *name) { - PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); - if (unlikely(!result)) { - PyErr_Format(PyExc_NameError, + {0, 0, 0, 0, 0} +}; +static PyMemberDef __pyx_CyFunction_members[] = { +#if !CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, +#endif +#if CYTHON_USE_TYPE_SPECS + {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, +#if CYTHON_METH_FASTCALL +#if CYTHON_BACKPORT_VECTORCALL + {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, +#else +#if !CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, +#endif +#endif +#endif +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, +#else + {(char *) "__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) +{ + CYTHON_UNUSED_VAR(args); #if PY_MAJOR_VERSION >= 3 - "name '%U' is not defined", name); + Py_INCREF(m->func_qualname); + return m->func_qualname; #else - "name '%.200s' is not defined", PyString_AS_STRING(name)); + return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name); #endif - } - return result; } - -/* RaiseArgTupleInvalid */ -static void __Pyx_RaiseArgtupleInvalid( - const char* func_name, - int exact, - Py_ssize_t num_min, - Py_ssize_t num_max, - Py_ssize_t num_found) -{ - Py_ssize_t num_expected; - const char *more_or_less; - if (num_found < num_min) { - num_expected = num_min; - more_or_less = "at least"; - } else { - num_expected = num_max; - more_or_less = "at most"; - } - if (exact) { - more_or_less = "exactly"; +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} +}; +#if PY_VERSION_HEX < 0x030500A0 || 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_pyobjects = 0; + op->defaults_size = 0; + 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; } - 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); +#endif + return (PyObject *) op; } - -/* KeywordStringCheck */ -static int __Pyx_CheckKeywordStrings( - PyObject *kwdict, - const char* function_name, - int kw_allowed) +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); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_XDECREF(pydefaults[i]); + PyObject_Free(m->defaults); + m->defaults = NULL; + } return 0; } - -/* 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; - } - *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; - } -#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; +static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) +{ + 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); + Py_VISIT(m->func_name); + Py_VISIT(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + Py_VISIT(m->func_code); +#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); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_VISIT(pydefaults[i]); } + return 0; } -static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno) { - PyCodeObject *py_code = 0; +static PyObject* +__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) +{ #if PY_MAJOR_VERSION >= 3 - py_code = PyCode_NewEmpty(srcfile, funcname, firstlineno); - if (likely(py_code)) { - py_code->co_flags |= CO_OPTIMIZED | CO_NEWLOCALS; + return PyUnicode_FromFormat("", + op->func_qualname, (void *)op); +#else + return PyString_FromFormat("", + PyString_AsString(op->func_qualname), (void *)op); +#endif +} +static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *f = ((__pyx_CyFunctionObject*)func)->func; + PyObject *py_name = NULL; + 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*)meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_MACROS + 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); +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, + "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, size); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); +#endif + return NULL; + } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_MACROS + 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; + } +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, + "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, size); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); +#endif + return NULL; + } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + return NULL; } +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments", + py_name); + Py_DECREF(py_name); #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); + PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", + f->m_ml->ml_name); #endif - return py_code; + 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 + 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 + __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); + if (vc) { +#if CYTHON_ASSUME_SAFE_MACROS + 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_MACROS + argc = PyTuple_GET_SIZE(args); #else - if (unlikely(PyErr_Occurred())) { - if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { - PyErr_Clear(); - return 0; - } 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); +#if PY_MAJOR_VERSION > 2 + PyErr_Format(PyExc_TypeError, + "unbound method %.200S() needs an argument", + cyfunc->func_qualname); +#else + PyErr_SetString(PyExc_TypeError, + "unbound method needs an argument"); +#endif + return NULL; + } + result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); + Py_DECREF(new_args); + } else { + result = __Pyx_CyFunction_Call(func, args, kw); + } + return result; +} +#if CYTHON_METH_FASTCALL +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)) { + PyErr_Format(PyExc_TypeError, "%.200s() needs an argument", + ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); return -1; } + ret = 1; } - return 0; -#endif + if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); + return -1; + } + return ret; } - -/* 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) { +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: return NULL; } - fastlocals = __Pyx_PyFrame_GetLocalsplus(f); - for (i = 0; i < na; i++) { - Py_INCREF(*args); - fastlocals[i] = *args++; + if (unlikely(nargs != 0)) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + def->ml_name, nargs); + return NULL; } - result = PyEval_EvalFrameEx(f,0); - ++tstate->recursion_depth; - Py_DECREF(f); - --tstate->recursion_depth; - return result; + return def->ml_meth(self, NULL); } -#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")) { +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: 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 (unlikely(nargs != 1)) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + def->ml_name, nargs); + return NULL; } - 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; + return def->ml_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; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; } - else { - kwtuple = NULL; - k = NULL; + return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_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; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; + 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; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; } - closure = PyFunction_GET_CLOSURE(func); -#if PY_MAJOR_VERSION >= 3 - kwdefs = PyFunction_GET_KW_DEFAULTS(func); + return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames); +} +#endif +#if CYTHON_USE_TYPE_SPECS +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 (argdefs != NULL) { - d = &PyTuple_GET_ITEM(argdefs, 0); - nd = Py_SIZE(argdefs); - } - else { - d = NULL; - nd = 0; - } -#if PY_MAJOR_VERSION >= 3 - result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, kwdefs, closure); +#if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL) + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + __pyx_CyFunctionType_slots +}; #else - result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, closure); +static PyTypeObject __pyx_CyFunctionType_type = { + PyVarObject_HEAD_INIT(0, 0) + __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, + (destructor) __Pyx_CyFunction_dealloc, +#if !CYTHON_METH_FASTCALL + 0, +#elif CYTHON_BACKPORT_VECTORCALL + (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall), +#else + offsetof(PyCFunctionObject, vectorcall), #endif - Py_XDECREF(kwtuple); -done: - Py_LeaveRecursiveCall(); - return result; -} + 0, + 0, +#if PY_MAJOR_VERSION < 3 + 0, +#else + 0, +#endif + (reprfunc) __Pyx_CyFunction_repr, + 0, + 0, + 0, + 0, + __Pyx_CyFunction_CallAsMethod, + 0, + 0, + 0, + 0, +#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR + Py_TPFLAGS_METHOD_DESCRIPTOR | +#endif +#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + 0, + (traverseproc) __Pyx_CyFunction_traverse, + (inquiry) __Pyx_CyFunction_clear, + 0, +#if PY_VERSION_HEX < 0x030500A0 + offsetof(__pyx_CyFunctionObject, func_weakreflist), +#else + offsetof(PyCFunctionObject, m_weakreflist), +#endif + 0, + 0, + __pyx_CyFunction_methods, + __pyx_CyFunction_members, + __pyx_CyFunction_getsets, + 0, + 0, + __Pyx_PyMethod_New, + 0, + offsetof(__pyx_CyFunctionObject, func_dict), + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX >= 0x030400a1 + 0, +#endif +#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, +#endif +#if __PYX_NEED_TP_PRINT_SLOT + 0, +#endif +#if PY_VERSION_HEX >= 0x030C0000 + 0, +#endif +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, +#endif +}; #endif +static int __pyx_CyFunction_init(PyObject *module) { +#if CYTHON_USE_TYPE_SPECS + __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL); +#else + CYTHON_UNUSED_VAR(module); + __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); #endif + if (unlikely(__pyx_CyFunctionType == NULL)) { + return -1; + } + return 0; +} +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults = PyObject_Malloc(size); + if (unlikely(!m->defaults)) + return PyErr_NoMemory(); + memset(m->defaults, 0, size); + m->defaults_pyobjects = pyobjects; + m->defaults_size = size; + 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_CyFunctionType), + ml, flags, qualname, closure, module, globals, code + ); + if (likely(op)) { + PyObject_GC_Track(op); + } + return op; +} /* 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 PY_MAJOR_VERSION < 3 if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + #endif result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { @@ -23200,763 +35479,1019 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg } #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"); - } +/* UnpackUnboundCMethod */ +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; } -#endif - -/* PyObjectCallNoArg */ +static PyMethodDef __Pyx_UnboundCMethod_Def = { + "CythonUnboundCMethod", + __PYX_REINTERPRET_FUNCION(PyCFunction, __Pyx_SelflessCall), + METH_VARARGS | METH_KEYWORDS, + NULL +}; +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 -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { -#if CYTHON_FAST_PYCALL - if (PyFunction_Check(func)) { - return __Pyx_PyFunction_FastCall(func, NULL, 0); - } + #if PY_MAJOR_VERSION >= 3 + if (likely(__Pyx_TypeCheck(method, &PyMethodDescr_Type))) + #else + if (likely(!__Pyx_CyOrPyCFunction_Check(method))) + #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); + } else #endif -#ifdef __Pyx_CyFunction_USED - if (likely(PyCFunction_Check(func) || __Pyx_CyFunction_Check(func))) +#if CYTHON_COMPILING_IN_PYPY #else - if (likely(PyCFunction_Check(func))) + if (PyCFunction_Check(method)) #endif { - if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { - return __Pyx_PyObject_CallMethO(func, NULL); + 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); + target->method = unbound_method; } } - 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); - } else { - return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); + 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); + #endif + } else if ((PY_VERSION_HEX >= 0x030700A0) && flag == (METH_FASTCALL | METH_KEYWORDS)) { + return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, &arg, 1, NULL); + } } + return __Pyx__CallUnboundCMethod1(cfunc, self, arg); } #endif - -/* PyObjectCallOneArg */ +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 -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); + 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); + } +#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; } -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); - } + +/* KeywordStringCheck */ +static int __Pyx_CheckKeywordStrings( + PyObject *kw, + const char* function_name, + int kw_allowed) +{ + PyObject* key = 0; + Py_ssize_t pos = 0; +#if CYTHON_COMPILING_IN_PYPY + if (!kw_allowed && PyDict_Next(kw, &pos, &key, 0)) + goto invalid_keyword; + return 1; +#else + if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) { + Py_ssize_t kwsize; +#if CYTHON_ASSUME_SAFE_MACROS + kwsize = PyTuple_GET_SIZE(kw); +#else + kwsize = PyTuple_Size(kw); + if (kwsize < 0) return 0; #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); + if (unlikely(kwsize == 0)) + return 1; + if (!kw_allowed) { +#if CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kw, 0); +#else + key = PyTuple_GetItem(kw, pos); + if (!key) return 0; #endif + goto invalid_keyword; } - } - return __Pyx__PyObject_CallOneArg(func, arg); -} +#if PY_VERSION_HEX < 0x03090000 + for (pos = 0; pos < kwsize; pos++) { +#if CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kw, pos); #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; -} + key = PyTuple_GetItem(kw, pos); + if (!key) return 0; +#endif + if (unlikely(!PyUnicode_Check(key))) + goto invalid_keyword_type; + } +#endif + return 1; + } + while (PyDict_Next(kw, &pos, &key, 0)) { + #if PY_MAJOR_VERSION < 3 + if (unlikely(!PyString_Check(key))) + #endif + if (unlikely(!PyUnicode_Check(key))) + goto invalid_keyword_type; + } + 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: + #if PY_MAJOR_VERSION < 3 + PyErr_Format(PyExc_TypeError, + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif + return 0; +} -/* 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; +/* RaiseException */ +#if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + __Pyx_PyThreadState_declare + CYTHON_UNUSED_VAR(cause); + 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 (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) { - return 0; + 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; + } } - 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 + __Pyx_PyThreadState_assign + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} #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; - } 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; +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; + } } } - } - 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; + 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; + } } - 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; + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; } - if (descr != NULL) { - *method = descr; - return 0; + 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_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 - return 0; + 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 - 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; - } + 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 - *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; } - if (unlikely(!method)) goto bad; - result = __Pyx_PyObject_CallNoArg(method); - Py_DECREF(method); bad: - return result; -} - -/* RaiseNeedMoreValuesToUnpack */ -static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { - PyErr_Format(PyExc_ValueError, - "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", - index, (index == 1) ? "" : "s"); -} - -/* RaiseTooManyValuesToUnpack */ -static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { - PyErr_Format(PyExc_ValueError, - "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); -} - -/* UnpackItemEndCheck */ -static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { - if (unlikely(retval)) { - Py_DECREF(retval); - __Pyx_RaiseTooManyValuesError(expected); - return -1; - } else { - return __Pyx_IterFinish(); - } - return 0; -} - -/* RaiseNoneIterError */ -static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); -} - -/* UnpackTupleError */ -static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) { - if (t == Py_None) { - __Pyx_RaiseNoneNotIterableError(); - } else if (PyTuple_GET_SIZE(t) < index) { - __Pyx_RaiseNeedMoreValuesError(PyTuple_GET_SIZE(t)); - } else { - __Pyx_RaiseTooManyValuesError(index); - } + Py_XDECREF(owned_instance); + return; } - -/* UnpackTuple2 */ -static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( - PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int decref_tuple) { - PyObject *value1 = NULL, *value2 = NULL; -#if CYTHON_COMPILING_IN_PYPY - value1 = PySequence_ITEM(tuple, 0); if (unlikely(!value1)) goto bad; - value2 = PySequence_ITEM(tuple, 1); if (unlikely(!value2)) goto bad; -#else - value1 = PyTuple_GET_ITEM(tuple, 0); Py_INCREF(value1); - value2 = PyTuple_GET_ITEM(tuple, 1); Py_INCREF(value2); #endif - if (decref_tuple) { - Py_DECREF(tuple); + +/* 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; } - *pvalue1 = value1; - *pvalue2 = value2; - return 0; -#if CYTHON_COMPILING_IN_PYPY -bad: - Py_XDECREF(value1); - Py_XDECREF(value2); - if (decref_tuple) { Py_XDECREF(tuple); } - return -1; -#endif -} -static int __Pyx_unpack_tuple2_generic(PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, - int has_known_size, int decref_tuple) { - Py_ssize_t index; - PyObject *value1 = NULL, *value2 = NULL, *iter = NULL; - iternextfunc iternext; - iter = PyObject_GetIter(tuple); - if (unlikely(!iter)) goto bad; - if (decref_tuple) { Py_DECREF(tuple); tuple = NULL; } - iternext = Py_TYPE(iter)->tp_iternext; - value1 = iternext(iter); if (unlikely(!value1)) { index = 0; goto unpacking_failed; } - value2 = iternext(iter); if (unlikely(!value2)) { index = 1; goto unpacking_failed; } - if (!has_known_size && unlikely(__Pyx_IternextUnpackEndCheck(iternext(iter), 2))) goto bad; - Py_DECREF(iter); - *pvalue1 = value1; - *pvalue2 = value2; return 0; -unpacking_failed: - if (!has_known_size && __Pyx_IterFinish() == 0) - __Pyx_RaiseNeedMoreValuesError(index); -bad: - Py_XDECREF(iter); - Py_XDECREF(value1); - Py_XDECREF(value2); - if (decref_tuple) { Py_XDECREF(tuple); } - return -1; } -/* dict_iter */ -static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_dict, PyObject* method_name, - Py_ssize_t* p_orig_length, int* p_source_is_dict) { - is_dict = is_dict || likely(PyDict_CheckExact(iterable)); - *p_source_is_dict = is_dict; - if (is_dict) { -#if !CYTHON_COMPILING_IN_PYPY - *p_orig_length = PyDict_Size(iterable); - Py_INCREF(iterable); - return iterable; -#elif PY_MAJOR_VERSION >= 3 - static PyObject *py_items = NULL, *py_keys = NULL, *py_values = NULL; - PyObject **pp = NULL; - if (method_name) { - const char *name = PyUnicode_AsUTF8(method_name); - if (strcmp(name, "iteritems") == 0) pp = &py_items; - else if (strcmp(name, "iterkeys") == 0) pp = &py_keys; - else if (strcmp(name, "itervalues") == 0) pp = &py_values; - if (pp) { - if (!*pp) { - *pp = PyUnicode_FromString(name + 4); - if (!*pp) - return NULL; - } - method_name = *pp; - } - } -#endif +/* PyFunctionFastCall */ +#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL +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; } - *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; + fastlocals = __Pyx_PyFrame_GetLocalsplus(f); + for (i = 0; i < na; i++) { + Py_INCREF(*args); + fastlocals[i] = *args++; } - return PyObject_GetIter(iterable); + result = PyEval_EvalFrameEx(f,0); + ++tstate->recursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; + return result; } -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; +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_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) { + return NULL; + } + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) { + return NULL; + } + #endif + 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; } - if (unlikely(!PyDict_Next(iter_obj, ppos, &key, &value))) { - return 0; + 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 (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; - } + } + if (kwargs != NULL) { + Py_ssize_t pos, i; + kwtuple = PyTuple_New(2 * nk); + if (kwtuple == NULL) { + result = NULL; + goto done; } - 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(); + 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; } - 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; + else { + kwtuple = NULL; + k = NULL; } - return 1; + closure = PyFunction_GET_CLOSURE(func); +#if PY_MAJOR_VERSION >= 3 + kwdefs = PyFunction_GET_KW_DEFAULTS(func); +#endif + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } +#if PY_MAJOR_VERSION >= 3 + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, (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; } +#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); - } +/* 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 PY_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(function)) { - PyObject *args[2] = {arg1, arg2}; - return __Pyx_PyCFunction_FastCall(function, args, 2); + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); } - #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 -/* 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; - } +/* PyObjectFastCall */ +#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API +static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **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 +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **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]); } - 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; + #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); } } - __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 PY_VERSION_HEX >= 0x030700A1 + if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) { + return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL); } - 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; + #endif + #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 + #if PY_VERSION_HEX < 0x03090000 + vectorcallfunc f = _PyVectorcall_Function(func); + #else + vectorcallfunc f = PyVectorcall_Function(func); + #endif + if (f) { + return f(func, args, (size_t)nargs, NULL); } - 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; - } - } + #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, (size_t)nargs, NULL); } - 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 (nargs == 0) { + return __Pyx_PyObject_Call(func, __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 +} + +/* 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)) +#elif PY_MAJOR_VERSION >= 3 + #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 +#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; + } 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; } } - } 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; + 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; } - PyException_SetCause(value, fixed_cause); + Py_DECREF(dict); } - 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); + 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_GetName(tp); + PyErr_Format(PyExc_AttributeError, +#if PY_MAJOR_VERSION >= 3 + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, name); #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); - } + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", + type_name, PyString_AS_STRING(name)); +#endif + __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) { + 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: - Py_XDECREF(owned_instance); - return; + return result; } -#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); - } - } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { - return (equals == Py_NE); - } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { - return (equals == Py_NE); +/* 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 if (PyTuple_GET_SIZE(t) < index) { + __Pyx_RaiseNeedMoreValuesError(PyTuple_GET_SIZE(t)); } 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; + __Pyx_RaiseTooManyValuesError(index); } -#endif } -/* UnicodeEquals */ -static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { +/* 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 - return PyObject_RichCompareBool(s1, s2, equals); + value1 = PySequence_ITEM(tuple, 0); if (unlikely(!value1)) goto bad; + value2 = PySequence_ITEM(tuple, 1); if (unlikely(!value2)) goto bad; #else -#if PY_MAJOR_VERSION < 3 - PyObject* owned_ref = NULL; + value1 = PyTuple_GET_ITEM(tuple, 0); Py_INCREF(value1); + value2 = PyTuple_GET_ITEM(tuple, 1); Py_INCREF(value2); #endif - int s1_is_unicode, s2_is_unicode; - if (s1 == s2) { - goto return_eq; + if (decref_tuple) { + Py_DECREF(tuple); } - 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); + *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 = __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 && PY_MAJOR_VERSION >= 3 +#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; +#elif PY_MAJOR_VERSION >= 3 + static PyObject *py_items = NULL, *py_keys = NULL, *py_values = NULL; + PyObject **pp = NULL; + if (method_name) { + const char *name = PyUnicode_AsUTF8(method_name); + if (strcmp(name, "iteritems") == 0) pp = &py_items; + else if (strcmp(name, "iterkeys") == 0) pp = &py_keys; + else if (strcmp(name, "itervalues") == 0) pp = &py_values; + if (pp) { + if (!*pp) { + *pp = PyUnicode_FromString(name + 4); + if (!*pp) + return NULL; + } + method_name = *pp; + } + } +#endif } + *p_orig_length = 0; + if (method_name) { + PyObject* iter; + iterable = __Pyx_PyObject_CallMethod0(iterable, method_name); + if (!iterable) + return NULL; +#if !CYTHON_COMPILING_IN_PYPY + if (PyTuple_CheckExact(iterable) || PyList_CheckExact(iterable)) + return iterable; #endif - 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)) + 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; - 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; + 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 - 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); + { + next_item = PyIter_Next(iter_obj); + if (unlikely(!next_item)) { + return __Pyx_IterFinish(); } - } 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) + } + 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; - result = __Pyx_PyObject_IsTrue(py_result); - Py_DECREF(py_result); - return result; + } else if (pkey) { + *pkey = next_item; + } else { + *pvalue = next_item; } -return_eq: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - return (equals == Py_EQ); -return_ne: + return 1; +} + +/* PyObjectFormatAndDecref */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f) { + if (unlikely(!s)) return NULL; + if (likely(PyUnicode_CheckExact(s))) return s; #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); + if (likely(PyString_CheckExact(s))) { + PyObject *result = PyUnicode_FromEncodedObject(s, NULL, "strict"); + Py_DECREF(s); + return result; + } #endif - return (equals == Py_NE); + 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* value_tuple, 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; + CYTHON_MAYBE_UNUSED_VAR(max_char); +#if CYTHON_PEP393_ENABLED + 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); +#else + result_uval = PyUnicode_FromUnicode(NULL, result_ulength); + if (unlikely(!result_uval)) return NULL; + result_ukind = sizeof(Py_UNICODE); + kind_shift = (result_ukind == 4) ? 2 : result_ukind - 1; + result_udata = PyUnicode_AS_UNICODE(result_uval); +#endif + assert(kind_shift == 2 || kind_shift == 1 || kind_shift == 0); + char_pos = 0; + for (i=0; i < value_count; i++) { + int ukind; + Py_ssize_t ulength; + void *udata; + PyObject *uval = PyTuple_GET_ITEM(value_tuple, i); + if (unlikely(__Pyx_PyUnicode_READY(uval))) + goto bad; + ulength = __Pyx_PyUnicode_GET_LENGTH(uval); + 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 (!CYTHON_PEP393_ENABLED || 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 && PY_VERSION_HEX >= 0x030300F0 || 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 + CYTHON_UNUSED_VAR(max_char); + CYTHON_UNUSED_VAR(result_ulength); + CYTHON_UNUSED_VAR(value_count); + return PyUnicode_Join(__pyx_empty_unicode, value_tuple); #endif } @@ -23995,7 +36530,7 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) { PyObject *result; #if !CYTHON_AVOID_BORROWED_REFS -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && PY_VERSION_HEX < 0x030d0000 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)) { @@ -24003,6 +36538,14 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) } else if (unlikely(PyErr_Occurred())) { return NULL; } +#elif CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(!__pyx_m)) { + return NULL; + } + result = PyObject_GetAttr(__pyx_m, name); + if (likely(result)) { + return result; + } #else result = PyDict_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) @@ -24021,26 +36564,6 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) 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))) - #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); - } -#endif - return 0; -} - /* CallUnboundCMethod0 */ static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) { PyObject *args, *result = NULL; @@ -24068,194 +36591,189 @@ static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d) { return PyDict_Items(d); } -/* None */ +/* RaiseUnboundLocalError */ +static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) { + PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); +} + +/* RaiseClosureNameError */ static CYTHON_INLINE void __Pyx_RaiseClosureNameError(const char *varname) { PyErr_Format(PyExc_NameError, "free variable '%s' referenced before assignment in enclosing scope", varname); } -/* 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); -} +/* 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 - -/* 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; - } + 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 >= 0x030C00A6 + local_value = tstate->current_exception; + tstate->current_exception = 0; + if (likely(local_value)) { + local_type = (PyObject*) Py_TYPE(local_value); + Py_INCREF(local_type); + local_tb = PyException_GetTraceback(local_value); + } + #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 +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); +#endif + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE && PY_VERSION_HEX >= 0x030C00A6 + if (unlikely(tstate->current_exception)) +#elif CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) +#else + 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 + 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 } - 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); + 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); +#else + PyErr_SetExcInfo(local_type, local_value, local_tb); +#endif + return 0; bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); 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; +/* pep479 */ +static void __Pyx_Generator_Replace_StopIteration(int in_async_gen) { + PyObject *exc, *val, *tb, *cur_exc; + __Pyx_PyThreadState_declare + #ifdef __Pyx_StopAsyncIteration_USED + int is_async_stopiteration = 0; + #endif + CYTHON_MAYBE_UNUSED_VAR(in_async_gen); + cur_exc = PyErr_Occurred(); + if (likely(!__Pyx_PyErr_GivenExceptionMatches(cur_exc, PyExc_StopIteration))) { + #ifdef __Pyx_StopAsyncIteration_USED + if (in_async_gen && unlikely(__Pyx_PyErr_GivenExceptionMatches(cur_exc, __Pyx_PyExc_StopAsyncIteration))) { + is_async_stopiteration = 1; + } else #endif + return; } - else { - if (likely(__Pyx_TypeCheck(obj, type))) return 1; - } - PyErr_Format(PyExc_TypeError, - "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", - name, type->tp_name, Py_TYPE(obj)->tp_name); - return 0; + __Pyx_PyThreadState_assign + __Pyx_GetException(&exc, &val, &tb); + Py_XDECREF(exc); + Py_XDECREF(val); + Py_XDECREF(tb); + PyErr_SetString(PyExc_RuntimeError, + #ifdef __Pyx_StopAsyncIteration_USED + is_async_stopiteration ? "async generator raised StopAsyncIteration" : + in_async_gen ? "async generator raised StopIteration" : + #endif + "generator raised StopIteration"); } -/* 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); + +/* PyObjectCallMethod1 */ +#if !(CYTHON_VECTORCALL && __PYX_LIMITED_VERSION_HEX >= 0x030C00A2) +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 >= 0x030C00A2 + 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; + } + if (unlikely(!method)) return NULL; + return __Pyx__PyObject_CallMethod1(method, arg); +#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))) +/* StringJoin */ +static CYTHON_INLINE PyObject* __Pyx_PyBytes_Join(PyObject* sep, PyObject* values) { + (void) __Pyx_PyObject_CallMethod1; +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION < 3 + return _PyString_Join(sep, values); +#elif CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 + return _PyBytes_Join(sep, values); #else - if (likely(PyString_Check(n))) -#endif - return __Pyx_PyObject_GetAttrStr(o, n); + return __Pyx_PyObject_CallMethod1(sep, __pyx_n_s_join, values); #endif - return PyObject_GetAttr(o, n); } /* GetAttr3 */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 static PyObject *__Pyx_GetAttr3Default(PyObject *d) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign @@ -24265,15 +36783,277 @@ static PyObject *__Pyx_GetAttr3Default(PyObject *d) { Py_INCREF(d); return d; } +#endif static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { - PyObject *r = __Pyx_GetAttr(o, n); + PyObject *r; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 + int res = PyObject_GetOptionalAttr(o, n, &r); + return (res != 0) ? r : __Pyx_NewRef(d); +#else + #if CYTHON_USE_TYPE_SLOTS + if (likely(PyString_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 +} + +/* RaiseUnexpectedTypeError */ +static int +__Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj) +{ + __Pyx_TypeName obj_type_name = __Pyx_PyType_GetName(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; +} + +/* bytes_tailmatch */ +static int __Pyx_PyBytes_SingleTailmatch(PyObject* self, PyObject* arg, + Py_ssize_t start, Py_ssize_t end, int direction) { + const char* self_ptr = PyBytes_AS_STRING(self); + Py_ssize_t self_len = PyBytes_GET_SIZE(self); + const char* sub_ptr; + Py_ssize_t sub_len; + int retval; + Py_buffer view; + view.obj = NULL; + if ( PyBytes_Check(arg) ) { + sub_ptr = PyBytes_AS_STRING(arg); + sub_len = PyBytes_GET_SIZE(arg); + } +#if PY_MAJOR_VERSION < 3 + else if ( PyUnicode_Check(arg) ) { + return (int) PyUnicode_Tailmatch(self, arg, start, end, direction); + } +#endif + else { + if (unlikely(PyObject_GetBuffer(self, &view, PyBUF_SIMPLE) == -1)) + return -1; + sub_ptr = (const char*) view.buf; + sub_len = view.len; + } + if (end > self_len) + end = self_len; + else if (end < 0) + end += self_len; + if (end < 0) + end = 0; + if (start < 0) + start += self_len; + if (start < 0) + start = 0; + if (direction > 0) { + if (end-sub_len > start) + start = end - sub_len; + } + if (start + sub_len <= end) + retval = !memcmp(self_ptr+start, sub_ptr, (size_t)sub_len); + else + retval = 0; + if (view.obj) + PyBuffer_Release(&view); + return retval; +} +static int __Pyx_PyBytes_TailmatchTuple(PyObject* self, PyObject* substrings, + Py_ssize_t start, Py_ssize_t end, int direction) { + Py_ssize_t i, count = PyTuple_GET_SIZE(substrings); + for (i = 0; i < count; i++) { + int result; +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + result = __Pyx_PyBytes_SingleTailmatch(self, PyTuple_GET_ITEM(substrings, i), + start, end, direction); +#else + PyObject* sub = PySequence_ITEM(substrings, i); + if (unlikely(!sub)) return -1; + result = __Pyx_PyBytes_SingleTailmatch(self, sub, start, end, direction); + Py_DECREF(sub); +#endif + if (result) { + return result; + } + } + return 0; +} +static int __Pyx_PyBytes_Tailmatch(PyObject* self, PyObject* substr, + Py_ssize_t start, Py_ssize_t end, int direction) { + if (unlikely(PyTuple_Check(substr))) { + return __Pyx_PyBytes_TailmatchTuple(self, substr, start, end, direction); + } + return __Pyx_PyBytes_SingleTailmatch(self, substr, start, end, direction); +} + +/* 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 = PyTuple_GET_SIZE(substrings); + 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 = 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); +} + +/* str_tailmatch */ +static CYTHON_INLINE int __Pyx_PyStr_Tailmatch(PyObject* self, PyObject* arg, Py_ssize_t start, + Py_ssize_t end, int direction) +{ + if (PY_MAJOR_VERSION < 3) + return __Pyx_PyBytes_Tailmatch(self, arg, start, end, direction); + else + return __Pyx_PyUnicode_Tailmatch(self, arg, start, end, direction); +} + +/* 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_GetName(Py_TYPE(obj)); + type_name = __Pyx_PyType_GetName(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; +} + +/* Import */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *module = 0; + PyObject *empty_dict = 0; + PyObject *empty_list = 0; + #if PY_MAJOR_VERSION < 3 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (unlikely(!py_import)) + goto bad; + if (!from_list) { + empty_list = PyList_New(0); + if (unlikely(!empty_list)) + goto bad; + from_list = empty_list; + } + #endif + empty_dict = PyDict_New(); + if (unlikely(!empty_dict)) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if (strchr(__Pyx_MODULE_NAME, '.') != NULL) { + module = PyImport_ImportModuleLevelObject( + name, __pyx_d, empty_dict, from_list, 1); + if (unlikely(!module)) { + if (unlikely(!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 (unlikely(!py_level)) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, __pyx_d, empty_dict, from_list, py_level, (PyObject *)NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, __pyx_d, empty_dict, from_list, level); + #endif + } + } +bad: + Py_XDECREF(empty_dict); + Py_XDECREF(empty_list); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_import); + #endif + 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)) { + 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_kp_u__6); + if (unlikely(!module_dot)) { goto modbad; } + full_name = PyUnicode_Concat(module_dot, name); + if (unlikely(!full_name)) { goto modbad; } + #if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) + { + 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, + #if PY_MAJOR_VERSION < 3 + "cannot import name %.230s", PyString_AS_STRING(name)); + #else + "cannot import name %S", name); + #endif + } + 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; @@ -24334,10 +37114,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 = PyInt_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,126 +37134,45 @@ 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)); } -/* 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); -} -#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 - } +/* 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_n_s_append, x); + if (unlikely(!retval)) + return -1; + Py_DECREF(retval); } -bad: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(py_import); - #endif - Py_XDECREF(empty_list); - Py_XDECREF(empty_dict); - return module; + return 0; } -/* 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 - } - return value; +/* 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); } /* HasAttr */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { PyObject *r; if (unlikely(!__Pyx_PyBaseString_Check(n))) { @@ -24474,7 +37181,7 @@ static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { return -1; } r = __Pyx_GetAttr(o, n); - if (unlikely(!r)) { + if (!r) { PyErr_Clear(); return 0; } else { @@ -24482,18 +37189,188 @@ static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { return 1; } } +#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_MACROS + n = PyTuple_GET_SIZE(bases); +#else + n = PyTuple_Size(bases); + if (n < 0) return -1; +#endif + for (i = 1; i < n; i++) + { +#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 + PyTypeObject *b; +#if PY_MAJOR_VERSION < 3 + if (PyClass_Check(b0)) + { + PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class", + PyString_AS_STRING(((PyClassObject*)b0)->cl_name)); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } +#endif + b = (PyTypeObject*) b0; + if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) + { + __Pyx_TypeName b_name = __Pyx_PyType_GetName(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 || CYTHON_COMPILING_IN_PYPY + 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_GetName(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 || CYTHON_COMPILING_IN_PYPY) + 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 */ +static int __Pyx_PyType_Ready(PyTypeObject *t) { +#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || 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; + 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 PY_VERSION_HEX >= 0x03050000 && !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 PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) + gc = PyImport_GetModule(__pyx_kp_u_gc); + #endif + if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc); + if (unlikely(!gc)) return -1; + py_status = __Pyx_PyObject_CallMethod0(gc, __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_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 PY_VERSION_HEX >= 0x03050000 && !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_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 +} /* PyObject_GenericGetAttrNoDict */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { + __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp); PyErr_Format(PyExc_AttributeError, #if PY_MAJOR_VERSION >= 3 - "'%.50s' object has no attribute '%U'", - tp->tp_name, attr_name); + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, attr_name); #else - "'%.50s' object has no attribute '%.400s'", - tp->tp_name, PyString_AS_STRING(attr_name)); + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", + type_name, PyString_AS_STRING(attr_name)); #endif + __Pyx_DECREF_TypeName(type_name); return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { @@ -24524,10 +37401,11 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj #endif /* SetupReduce */ +#if !CYTHON_COMPILING_IN_LIMITED_API 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_n_s_name_2); if (likely(name_attr)) { ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); } else { @@ -24543,53 +37421,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 + getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate); +#else + getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate); + if (!getstate && PyErr_Occurred()) { + goto __PYX_BAD; + } +#endif + if (getstate) { #if CYTHON_USE_PYTYPE_LOOKUP - if (_PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate)) goto GOOD; + object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate); #else - if (PyObject_HasAttr(type_obj, __pyx_n_s_getstate)) goto GOOD; + object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_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_n_s_reduce_ex); if (!object_reduce_ex) goto BAD; + object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; #else - object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto BAD; + object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; #endif - reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto BAD; + reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_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_n_s_reduce); if (!object_reduce) goto BAD; + object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; #else - object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto BAD; + object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; #endif - reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto BAD; + reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_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_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython); + if (likely(reduce_cython)) { + ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_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_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; + setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); + if (likely(setstate_cython)) { + ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_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_GetName((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); @@ -24598,18 +37509,21 @@ static int __Pyx_setup_reduce(PyObject* type_obj) { Py_XDECREF(setstate_cython); return ret; } +#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) +#ifndef __PYX_HAVE_RT_ImportType_3_0_10 +#define __PYX_HAVE_RT_ImportType_3_0_10 +static PyTypeObject *__Pyx_ImportType_3_0_10(PyObject *module, const char *module_name, const char *class_name, + size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_10 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,8 +37534,9 @@ 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 py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); if (!py_basicsize) @@ -24631,22 +37546,38 @@ 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_0_10 && + ((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) { + else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_0_10 && (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", @@ -24661,16 +37592,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_n_s_pyx_vtable); +#else + PyObject *ob = PyObject_GetItem(type->tp_dict, __pyx_n_s_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); @@ -24753,6 +37684,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif + CYTHON_MAYBE_UNUSED_VAR(tstate); if (unlikely(!__pyx_cython_runtime)) { return c_line; } @@ -24766,7 +37698,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { } 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_cython_runtime, __pyx_n_s_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; Py_DECREF(use_cline_obj); @@ -24777,7 +37709,7 @@ 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_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); } else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { c_line = 0; @@ -24788,6 +37720,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { #endif /* CodeObjectCache */ +#if !CYTHON_COMPILING_IN_LIMITED_API static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { @@ -24851,7 +37784,7 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { if (__pyx_code_cache.count == __pyx_code_cache.max_count) { int new_max = __pyx_code_cache.max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( - __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); + __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } @@ -24866,44 +37799,136 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { __pyx_code_cache.count++; Py_INCREF(code_object); } +#endif /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API + #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; + result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict); + Py_DECREF(replace); + return result; + } + PyErr_Clear(); + #if __PYX_LIMITED_VERSION_HEX < 0x030780000 + { + PyObject *compiled = NULL, *result = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL; + compiled = Py_CompileString( + "out = type(code)(\n" + " code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n" + " code.co_flags, code.co_code, code.co_consts, code.co_names,\n" + " code.co_varnames, code.co_filename, co_name, co_firstlineno,\n" + " code.co_lnotab)\n", "", Py_file_input); + if (!compiled) return NULL; + result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict); + Py_DECREF(compiled); + if (!result) PyErr_Print(); + Py_DECREF(result); + result = PyDict_GetItemString(scratch_dict, "out"); + if (result) Py_INCREF(result); + return result; + } + #else + return NULL; + #endif +} +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 = 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; + 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; + PyCodeObject *py_code = NULL; + PyObject *py_funcname = NULL; #if PY_MAJOR_VERSION < 3 + PyObject *py_srcfile = NULL; py_srcfile = PyString_FromString(filename); - #else - py_srcfile = PyUnicode_FromString(filename); - #endif if (!py_srcfile) goto bad; + #endif if (c_line) { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + if (!py_funcname) goto bad; #else py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + if (!py_funcname) goto bad; + funcname = PyUnicode_AsUTF8(py_funcname); + if (!funcname) goto bad; #endif } else { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromString(funcname); - #else - py_funcname = PyUnicode_FromString(funcname); + if (!py_funcname) goto bad; #endif } - if (!py_funcname) goto bad; + #if PY_MAJOR_VERSION < 3 py_code = __Pyx_PyCode_New( 0, 0, 0, 0, 0, + 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ @@ -24916,11 +37941,16 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( __pyx_empty_bytes /*PyObject *lnotab*/ ); Py_DECREF(py_srcfile); - Py_DECREF(py_funcname); + #else + py_code = PyCode_NewEmpty(filename, funcname, py_line); + #endif + Py_XDECREF(py_funcname); return py_code; bad: - Py_XDECREF(py_srcfile); Py_XDECREF(py_funcname); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_srcfile); + #endif return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, @@ -24928,14 +37958,24 @@ 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( @@ -24951,37 +37991,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,24 +38016,31 @@ 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_PyInt_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)) { + if (sizeof(int) < sizeof(long)) { return PyInt_FromLong((long) value); - } else if (sizeof(long) <= sizeof(unsigned long)) { + } 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)) { + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { - if (sizeof(long) <= sizeof(long)) { + if (sizeof(int) <= sizeof(long)) { return PyInt_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 } @@ -25031,18 +38048,51 @@ 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; - return _PyLong_FromByteArray(bytes, sizeof(long), +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 + return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = 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; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + 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; +#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(int) < sizeof(long)) { + if ((sizeof(int) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -25056,40 +38106,45 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (int) 0; - case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) - case 2: - if (8 * sizeof(int) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { - return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + 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)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; - case 3: - if (8 * sizeof(int) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { - return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; - case 4: - if (8 * sizeof(int) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { - return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -25102,109 +38157,181 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { goto raise_neg_overflow; } #endif - if (sizeof(int) <= sizeof(unsigned long)) { + 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)) { + } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (int) 0; - case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) - case -2: - if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + 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)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 2: - if (8 * sizeof(int) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case -3: - if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case -3: + if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 3: - if (8 * sizeof(int) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case -4: - if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case -4: + if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 4: - if (8 * sizeof(int) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { - return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; + break; + } } #endif - if (sizeof(int) <= sizeof(long)) { + 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)) { + } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { -#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) - PyErr_SetString(PyExc_RuntimeError, - "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); -#else int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if 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; - int ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (int) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (int) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (int) -1; + } else { + stepval = __Pyx_NewRef(v); + } + 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; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((int) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + 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 CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + 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 Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (int) -1; } } else { @@ -25227,11 +38354,18 @@ 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; +#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 PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { - if (sizeof(long) < sizeof(long)) { + if ((sizeof(long) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -25245,40 +38379,45 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (long) 0; - case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) - case 2: - if (8 * sizeof(long) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { - return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + 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)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; - case 3: - if (8 * sizeof(long) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { - return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; - case 4: - if (8 * sizeof(long) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { - return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -25291,134 +38430,286 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { goto raise_neg_overflow; } #endif - if (sizeof(long) <= sizeof(unsigned long)) { + 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)) { + } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (long) 0; - case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) - case -2: - if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + 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)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 2: - if (8 * sizeof(long) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case -3: - if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case -3: + if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 3: - if (8 * sizeof(long) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case -4: - if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case -4: + if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 4: - if (8 * sizeof(long) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; + break; + } } #endif - if (sizeof(long) <= sizeof(long)) { + 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)) { + } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { -#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) - PyErr_SetString(PyExc_RuntimeError, - "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); -#else long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if 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; - int ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (long) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (long) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (long) -1; + } else { + stepval = __Pyx_NewRef(v); + } + 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; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((long) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + 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 CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + 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 Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (long) -1; } - } else { - long val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (long) -1; - val = __Pyx_PyInt_As_long(tmp); - Py_DECREF(tmp); - return val; + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +/* CIntToPy */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_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); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } } -raise_overflow: - PyErr_SetString(PyExc_OverflowError, - "value too large to convert to long"); - return (long) -1; -raise_neg_overflow: - PyErr_SetString(PyExc_OverflowError, - "can't convert negative value to long"); - return (long) -1; + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = 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; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif + } +} + +/* FormatTypeName */ +#if CYTHON_COMPILING_IN_LIMITED_API +static __Pyx_TypeName +__Pyx_PyType_GetName(PyTypeObject* tp) +{ + PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_n_s_name_2); + if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) { + PyErr_Clear(); + Py_XDECREF(name); + name = __Pyx_NewRef(__pyx_n_s__48); + } + return name; } +#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,6 +38730,22 @@ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { } return __Pyx_InBases(a, b); } +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); +} #if PY_MAJOR_VERSION == 2 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { PyObject *exception, *value, *tb; @@ -25463,11 +38770,11 @@ static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc } #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) { @@ -25514,52 +38821,13 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj } #endif -/* FetchCommonType */ -static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { - PyObject* fake_module; - PyTypeObject* cached_type = NULL; - fake_module = PyImport_AddModule((char*) "_cython_" CYTHON_ABI); - if (!fake_module) return NULL; - Py_INCREF(fake_module); - cached_type = (PyTypeObject*) PyObject_GetAttrString(fake_module, type->tp_name); - if (cached_type) { - if (!PyType_Check((PyObject*)cached_type)) { - PyErr_Format(PyExc_TypeError, - "Shared Cython type %.200s is not a type object", - type->tp_name); - goto bad; - } - if (cached_type->tp_basicsize != type->tp_basicsize) { - PyErr_Format(PyExc_TypeError, - "Shared Cython type %.200s has the wrong size, try recompiling", - type->tp_name); - goto bad; - } - } else { - if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; - PyErr_Clear(); - if (PyType_Ready(type) < 0) goto bad; - if (PyObject_SetAttrString(fake_module, type->tp_name, (PyObject*) type) < 0) - goto bad; - Py_INCREF(type); - cached_type = type; - } -done: - Py_DECREF(fake_module); - return cached_type; -bad: - Py_XDECREF(cached_type); - cached_type = NULL; - goto done; -} - /* 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 +38839,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 +38899,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 +38907,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 +38934,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; @@ -25644,31 +38957,19 @@ static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, } #endif -/* PyObjectCallMethod1 */ -static PyObject* __Pyx__PyObject_CallMethod1(PyObject* method, PyObject* arg) { - PyObject *result = __Pyx_PyObject_CallOneArg(method, arg); - Py_DECREF(method); - return result; -} -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; - } - if (unlikely(!method)) return NULL; - return __Pyx__PyObject_CallMethod1(method, arg); -} - /* CoroutineBase */ -#include #include +#if PY_VERSION_HEX >= 0x030b00a6 + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif #define __Pyx_Coroutine_Undelegate(gen) Py_CLEAR((gen)->yieldfrom) -static int __Pyx_PyGen__FetchStopIterationValue(CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject **pvalue) { +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); @@ -25683,7 +38984,7 @@ static int __Pyx_PyGen__FetchStopIterationValue(CYTHON_UNUSED PyThreadState *__p 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))) { value = ((PyStopIterationObject *)ev)->value; Py_INCREF(value); Py_DECREF(ev); @@ -25747,6 +39048,9 @@ static int __Pyx_PyGen__FetchStopIterationValue(CYTHON_UNUSED PyThreadState *__p } 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 +39061,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)) { @@ -25776,8 +39082,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) { +static void __Pyx__Coroutine_NotStartedError(PyObject *gen) { const char *msg; + CYTHON_MAYBE_UNUSED_VAR(gen); if ((0)) { #ifdef __Pyx_Coroutine_USED } else if (__Pyx_Coroutine_Check(gen)) { @@ -25793,7 +39100,9 @@ static void __Pyx__Coroutine_NotStartedError(CYTHON_UNUSED PyObject *gen) { 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"); @@ -25830,15 +39139,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_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 } @@ -25854,7 +39178,7 @@ PyObject *__Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value, i } #endif self->is_running = 1; - retval = self->body((PyObject *) self, tstate, value); + retval = self->body(self, tstate, value); self->is_running = 0; #if CYTHON_USE_EXC_INFO_STACK exc_state = &self->gi_exc_state; @@ -25865,18 +39189,29 @@ PyObject *__Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value, i return retval; } 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_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); -#endif + #if PY_VERSION_HEX >= 0x030B00a4 + Py_DECREF(exc_tb); + #endif } +#endif } static CYTHON_INLINE -PyObject *__Pyx_Coroutine_MethodReturn(CYTHON_UNUSED PyObject* gen, PyObject *retval) { +PyObject *__Pyx_Coroutine_MethodReturn(PyObject* gen, PyObject *retval) { + CYTHON_MAYBE_UNUSED_VAR(gen); if (unlikely(!retval)) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign @@ -25891,6 +39226,43 @@ PyObject *__Pyx_Coroutine_MethodReturn(CYTHON_UNUSED PyObject* gen, PyObject *re } return retval; } +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03030000 && (defined(__linux__) || PY_VERSION_HEX >= 0x030600B3) +static CYTHON_INLINE +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 result; +#endif +} +#endif static CYTHON_INLINE PyObject *__Pyx_Coroutine_FinishDelegation(__pyx_CoroutineObject *gen) { PyObject *ret; @@ -25927,17 +39299,17 @@ static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value) { #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, 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 { if (value == Py_None) - ret = Py_TYPE(yf)->tp_iternext(yf); + ret = __Pyx_PyObject_GetIterNextFunc(yf)(yf); else ret = __Pyx_PyObject_CallMethod1(yf, __pyx_n_s_send, value); } @@ -25984,16 +39356,15 @@ static int __Pyx_Coroutine_CloseIter(__pyx_CoroutineObject *gen, PyObject *yf) { { PyObject *meth; gen->is_running = 1; - meth = __Pyx_PyObject_GetAttrStr(yf, __pyx_n_s_close); + meth = __Pyx_PyObject_GetAttrStrNoError(yf, __pyx_n_s_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) + if (unlikely(!retval)) err = -1; } gen->is_running = 0; @@ -26016,7 +39387,7 @@ static PyObject *__Pyx_Generator_Next(PyObject *self) { #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); + ret = __Pyx_PyGen_Send((PyGenObject*)yf, NULL); } else #endif #ifdef __Pyx_Coroutine_USED @@ -26024,7 +39395,7 @@ static PyObject *__Pyx_Generator_Next(PyObject *self) { ret = __Pyx_Coroutine_Send(yf, Py_None); } else #endif - ret = Py_TYPE(yf)->tp_iternext(yf); + ret = __Pyx_PyObject_GetIterNextFunc(yf)(yf); gen->is_running = 0; if (likely(ret)) { return ret; @@ -26033,7 +39404,8 @@ static PyObject *__Pyx_Generator_Next(PyObject *self) { } return __Pyx_Coroutine_SendEx(gen, Py_None, 0); } -static PyObject *__Pyx_Coroutine_Close_Method(PyObject *self, CYTHON_UNUSED PyObject *arg) { +static PyObject *__Pyx_Coroutine_Close_Method(PyObject *self, PyObject *arg) { + CYTHON_UNUSED_VAR(arg); return __Pyx_Coroutine_Close(self); } static PyObject *__Pyx_Coroutine_Close(PyObject *self) { @@ -26114,22 +39486,22 @@ 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_n_s_throw); if (unlikely(!meth)) { Py_DECREF(yf); - if (!PyErr_ExceptionMatches(PyExc_AttributeError)) { + if (unlikely(PyErr_Occurred())) { gen->is_running = 0; 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); } @@ -26148,14 +39520,18 @@ 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, (char *)"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) { @@ -26176,6 +39552,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); @@ -26189,10 +39566,10 @@ static void __Pyx_Coroutine_dealloc(PyObject *self) { if (gen->resume_label >= 0) { PyObject_GC_Track(self); #if PY_VERSION_HEX >= 0x030400a1 && CYTHON_USE_TP_FINALIZE - if (PyObject_CallFinalizerFromDealloc(self)) + if (unlikely(PyObject_CallFinalizerFromDealloc(self))) #else Py_TYPE(gen)->tp_del(self); - if (self->ob_refcnt > 0) + if (unlikely(Py_REFCNT(self) > 0)) #endif { return; @@ -26208,7 +39585,7 @@ static void __Pyx_Coroutine_dealloc(PyObject *self) { } #endif __Pyx_Coroutine_clear(self); - PyObject_GC_Del(gen); + __Pyx_PyHeapTypeObject_GC_Del(gen); } static void __Pyx_Coroutine_del(PyObject *self) { PyObject *error_type, *error_value, *error_traceback; @@ -26219,7 +39596,7 @@ static void __Pyx_Coroutine_del(PyObject *self) { } #if !CYTHON_USE_TP_FINALIZE assert(self->ob_refcnt == 0); - self->ob_refcnt = 1; + __Pyx_SET_REFCNT(self, 1); #endif __Pyx_PyThreadState_assign __Pyx_ErrFetch(&error_type, &error_value, &error_traceback); @@ -26286,17 +39663,17 @@ static void __Pyx_Coroutine_del(PyObject *self) { } __Pyx_ErrRestore(error_type, error_value, error_traceback); #if !CYTHON_USE_TP_FINALIZE - assert(self->ob_refcnt > 0); - if (--self->ob_refcnt == 0) { + assert(Py_REFCNT(self) > 0); + if (likely(--self->ob_refcnt == 0)) { return; } { - Py_ssize_t refcnt = self->ob_refcnt; + Py_ssize_t refcnt = Py_REFCNT(self); _Py_NewReference(self); - self->ob_refcnt = refcnt; + __Pyx_SET_REFCNT(self, refcnt); } #if CYTHON_COMPILING_IN_CPYTHON - assert(PyType_IS_GC(self->ob_type) && + assert(PyType_IS_GC(Py_TYPE(self)) && _Py_AS_GC(self)->gc.gc_refs != _PyGC_REFS_UNTRACKED); _Py_DEC_REFTOTAL; #endif @@ -26307,17 +39684,18 @@ static void __Pyx_Coroutine_del(PyObject *self) { #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; + CYTHON_UNUSED_VAR(context); #if PY_MAJOR_VERSION >= 3 if (unlikely(value == NULL || !PyUnicode_Check(value))) #else @@ -26328,24 +39706,23 @@ __Pyx_Coroutine_set_name(__pyx_CoroutineObject *self, PyObject *value, CYTHON_UN "__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; + CYTHON_UNUSED_VAR(context); #if PY_MAJOR_VERSION >= 3 if (unlikely(value == NULL || !PyUnicode_Check(value))) #else @@ -26356,12 +39733,32 @@ __Pyx_Coroutine_set_qualname(__pyx_CoroutineObject *self, PyObject *value, CYTHO "__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, void *context) +{ + PyObject *frame = self->gi_frame; + CYTHON_UNUSED_VAR(context); + if (!frame) { + if (unlikely(!self->gi_code)) { + Py_RETURN_NONE; + } + frame = (PyObject *) PyFrame_New( + PyThreadState_Get(), /*PyThreadState *tstate,*/ + (PyCodeObject*) self->gi_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (unlikely(!frame)) + return NULL; + self->gi_frame = frame; + } + Py_INCREF(frame); + return frame; +} 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 +39777,13 @@ static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit( gen->resume_label = 0; gen->classobj = NULL; gen->yieldfrom = NULL; + #if PY_VERSION_HEX >= 0x030B00a4 + 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,6 +39796,7 @@ 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; } @@ -26426,7 +39828,7 @@ static int __Pyx_patch_abc(void) { if (CYTHON_REGISTER_ABCS && !abc_patched) { PyObject *module; module = PyImport_ImportModule((PY_MAJOR_VERSION >= 3) ? "collections.abc" : "collections"); - if (!module) { + if (unlikely(!module)) { PyErr_WriteUnraisable(NULL); if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, ((PY_MAJOR_VERSION >= 3) ? @@ -26471,6 +39873,10 @@ static PyMemberDef __pyx_Generator_memberlist[] = { {(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}, + {(char *) "__module__", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_modulename), 0, 0}, +#if CYTHON_USE_TYPE_SPECS + {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CoroutineObject, gi_weakreflist), READONLY, 0}, +#endif {0, 0, 0, 0, 0} }; static PyGetSetDef __pyx_Generator_getsets[] = { @@ -26478,11 +39884,36 @@ static PyGetSetDef __pyx_Generator_getsets[] = { (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}, + {(char *) "gi_frame", (getter)__Pyx_Coroutine_get_frame, NULL, + (char*) PyDoc_STR("Frame of the generator"), 0}, {0, 0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +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 *) __Pyx_PyObject_GenericGetAttrNoDict}, +#if CYTHON_USE_TP_FINALIZE + {Py_tp_finalize, (void *)__Pyx_Coroutine_del}, +#endif + {0, 0}, +}; +static PyType_Spec __pyx_GeneratorType_spec = { + __PYX_TYPE_MODULE_PREFIX "generator", + sizeof(__pyx_CoroutineObject), + 0, + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE, + __pyx_GeneratorType_slots +}; +#else static PyTypeObject __pyx_GeneratorType_type = { PyVarObject_HEAD_INIT(0, 0) - "generator", + __PYX_TYPE_MODULE_PREFIX "generator", sizeof(__pyx_CoroutineObject), 0, (destructor) __Pyx_Coroutine_dealloc, @@ -26537,17 +39968,29 @@ static PyTypeObject __pyx_GeneratorType_type = { #elif PY_VERSION_HEX >= 0x030400a1 0, #endif -#if PY_VERSION_HEX >= 0x030800b1 +#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, +#endif +#if __PYX_NEED_TP_PRINT_SLOT + 0, +#endif +#if PY_VERSION_HEX >= 0x030C0000 0, #endif -#if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, #endif }; -static int __pyx_Generator_init(void) { +#endif +static int __pyx_Generator_init(PyObject *module) { +#if CYTHON_USE_TYPE_SPECS + __pyx_GeneratorType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_GeneratorType_spec, NULL); +#else + CYTHON_UNUSED_VAR(module); __pyx_GeneratorType_type.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; __pyx_GeneratorType_type.tp_iter = PyObject_SelfIter; __pyx_GeneratorType = __Pyx_FetchCommonType(&__pyx_GeneratorType_type); +#endif if (unlikely(!__pyx_GeneratorType)) { return -1; } @@ -26555,19 +39998,50 @@ static int __pyx_Generator_init(void) { } /* 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 unsigned long __Pyx_get_runtime_version(void) { +#if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4 + return Py_Version & ~0xFFUL; +#else + 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; + } + return version; +#endif +} +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 */ @@ -26589,11 +40063,7 @@ static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *s 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,10 +40077,70 @@ static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *s return -1; } +/* FunctionImport */ +#ifndef __PYX_HAVE_RT_ImportFunction_3_0_10 +#define __PYX_HAVE_RT_ImportFunction_3_0_10 +static int __Pyx_ImportFunction_3_0_10(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__"); + if (!d) + goto bad; + cobj = PyDict_GetItemString(d, funcname); + 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); + return 0; +bad: + Py_XDECREF(d); + return -1; +} +#endif + /* InitStrings */ +#if PY_MAJOR_VERSION >= 3 +static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) { + if (t.is_unicode | t.is_str) { + if (t.intern) { + *str = PyUnicode_InternFromString(t.s); + } else if (t.encoding) { + *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL); + } else { + *str = PyUnicode_FromStringAndSize(t.s, t.n - 1); + } + } else { + *str = PyBytes_FromStringAndSize(t.s, t.n - 1); + } + if (!*str) + return -1; + if (PyObject_Hash(*str) == -1) + return -1; + return 0; +} +#endif static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { - #if PY_MAJOR_VERSION < 3 + #if PY_MAJOR_VERSION >= 3 + __Pyx_InitString(*t, t->p); + #else if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { @@ -26618,30 +40148,34 @@ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } - #else - if (t->is_unicode | t->is_str) { - if (t->intern) { - *t->p = PyUnicode_InternFromString(t->s); - } else if (t->encoding) { - *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); - } else { - *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); - } - } else { - *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); - } - #endif if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) return -1; + #endif ++t; } 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; @@ -26696,7 +40230,7 @@ static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif -#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) +#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); @@ -26725,22 +40259,26 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { return retval; } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { + __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result)); #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, - "__int__ returned non-int (type %.200s). " - "The ability to return an instance of a strict subclass of int " - "is deprecated, and may be removed in a future version of Python.", - Py_TYPE(result)->tp_name)) { + "__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); + "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")", + type_name, type_name, result_type_name); + __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } @@ -26806,13 +40344,11 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* 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) { @@ -26855,6 +40391,23 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { 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); +#if PY_MAJOR_VERSION < 3 + } else if (likely(PyInt_CheckExact(o))) { + return PyInt_AS_LONG(o); +#endif + } else { + Py_ssize_t ival; + PyObject *x; + x = PyNumber_Index(o); + if (!x) return -1; + ival = PyInt_AsLong(x); + Py_DECREF(x); + return ival; + } +} static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); } @@ -26863,4 +40416,12 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { } +/* #### 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..617934d0 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 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..70d9391c 100644 --- a/src/hunter/_tracer.c +++ b/src/hunter/_tracer.c @@ -1,20 +1,74 @@ -/* Generated by Cython 0.29.14 */ +/* Generated by Cython 3.0.10 */ +/* BEGIN: Cython Metadata +{ + "distutils": { + "depends": [ + "src/hunter/vendor/_compat.h" + ], + "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 */ +#if defined(CYTHON_LIMITED_API) && 0 + #ifndef Py_LIMITED_API + #if CYTHON_LIMITED_API+0 > 0x03030000 + #define Py_LIMITED_API CYTHON_LIMITED_API + #else + #define Py_LIMITED_API 0x03030000 + #endif + #endif +#endif + #include "Python.h" + + #if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyFloat_FromString(obj) PyFloat_FromString(obj) + #else + #define __Pyx_PyFloat_FromString(obj) PyFloat_FromString(obj, NULL) + #endif + + + #if PY_MAJOR_VERSION <= 2 + #define PyDict_GetItemWithError _PyDict_GetItemWithError + #endif + + + #if (PY_VERSION_HEX < 0x030700b1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030600)) && !defined(PyContextVar_Get) + #define PyContextVar_Get(var, d, v) ((d) ? ((void)(var), Py_INCREF(d), (v)[0] = (d), 0) : ((v)[0] = NULL, 0) ) + #endif + #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 < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.7+ or Python 3.3+. #else -#define CYTHON_ABI "0_29_14" -#define CYTHON_HEX_VERSION 0x001D0EF0 +#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API +#define __PYX_EXTRA_ABI_MODULE_NAME "limited" +#else +#define __PYX_EXTRA_ABI_MODULE_NAME "" +#endif +#define CYTHON_ABI "3_0_10" __PYX_EXTRA_ABI_MODULE_NAME +#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI +#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." +#define CYTHON_HEX_VERSION 0x03000AF0 #define CYTHON_FUTURE_DIVISION 1 #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 +87,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,12 +95,19 @@ #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_NOGIL 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 @@ -73,27 +132,176 @@ #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 (PY_MAJOR_VERSION >= 3) + #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_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 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) + #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 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_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 (PY_MAJOR_VERSION >= 3) + #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_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00) + #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 +#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_NOGIL 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_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 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 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_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 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 1 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #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 +#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL) #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 1 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif + #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 + #ifndef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #ifndef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS @@ -101,8 +309,6 @@ #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif @@ -114,27 +320,48 @@ #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 1 + #endif #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 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 1 + #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 1 + #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 + #endif #else #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 1 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif - #if PY_VERSION_HEX < 0x02070000 - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #ifndef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 @@ -143,10 +370,7 @@ #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif - #if PY_VERSION_HEX < 0x02070000 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #ifndef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS @@ -155,7 +379,7 @@ #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif - #if PY_VERSION_HEX < 0x030300F0 + #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #elif !defined(CYTHON_USE_UNICODE_WRITER) @@ -173,27 +397,63 @@ #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif + #ifndef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6) + #endif + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1) + #endif #ifndef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 1 #endif - #ifndef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif - #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) + #if PY_VERSION_HEX < 0x03050000 + #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 - #ifndef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 #endif - #ifndef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) + #if PY_VERSION_HEX < 0x030400a1 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #elif !defined(CYTHON_USE_TP_FINALIZE) + #define CYTHON_USE_TP_FINALIZE 1 + #endif + #if PY_VERSION_HEX < 0x030600B1 + #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) + #endif + #if PY_VERSION_HEX < 0x030700A3 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #elif !defined(CYTHON_USE_EXC_INFO_STACK) + #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 1 #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif +#if !defined(CYTHON_VECTORCALL) +#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) +#endif +#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) #if CYTHON_USE_PYLONG_INTERNALS - #include "longintrepr.h" + #if PY_MAJOR_VERSION < 3 + #include "longintrepr.h" + #endif #undef SHIFT #undef BASE #undef MASK @@ -218,6 +478,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,13 +502,16 @@ # 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 # define CYTHON_NCP_UNUSED @@ -245,28 +519,59 @@ # 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 __int8 uint8_t; - typedef unsigned __int32 uint32_t; + 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,13 +581,26 @@ #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 +#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)) #ifndef CYTHON_INLINE #if defined(__clang__) @@ -298,26 +616,145 @@ #endif #endif -#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) - #define Py_OptimizeFlag 0 -#endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type + #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) #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) + #define __Pyx_DefaultClassType PyType_Type +#if CYTHON_COMPILING_IN_LIMITED_API + static CYTHON_INLINE 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, "iiiiiOOOOOOiOO", 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, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else { + if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); + } + end: + Py_XDECREF(code_type); + Py_XDECREF(exception_table); + Py_XDECREF(types_module); + if (type) { + PyErr_Restore(type, value, traceback); + } + return result; + } + #ifndef CO_OPTIMIZED + #define CO_OPTIMIZED 0x0001 + #endif + #ifndef CO_NEWLOCALS + #define CO_NEWLOCALS 0x0002 + #endif + #ifndef CO_VARARGS + #define CO_VARARGS 0x0004 + #endif + #ifndef CO_VARKEYWORDS + #define CO_VARKEYWORDS 0x0008 + #endif + #ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x0200 + #endif + #ifndef CO_GENERATOR + #define CO_GENERATOR 0x0020 + #endif + #ifndef CO_COROUTINE + #define CO_COROUTINE 0x0080 + #endif +#elif PY_VERSION_HEX >= 0x030B0000 + static CYTHON_INLINE 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; + PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0); + if (!empty_bytes) return NULL; + 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, empty_bytes); + Py_DECREF(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, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + #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 - #define __Pyx_DefaultClassType PyType_Type +#endif +#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 CO_COROUTINE + #define CO_COROUTINE 0x80 +#endif +#ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x200 #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 @@ -331,6 +768,12 @@ #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 @@ -342,34 +785,89 @@ 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_MAJOR_VERSION >= 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) { +#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 < 0x030900B1 + #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_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_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 +#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() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 @@ -377,6 +875,22 @@ #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif +#if CYTHON_COMPILING_IN_LIMITED_API +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; +} +#endif +#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) +#else + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) +#endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 @@ -407,7 +921,29 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { return PyThread_get_key_value(*key); } #endif -#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) +#if PY_MAJOR_VERSION < 3 + #if CYTHON_COMPILING_IN_PYPY + #if PYPY_VERSION_NUM < 0x07030600 + #if defined(__cplusplus) && __cplusplus >= 201402L + [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]] + #elif defined(__GNUC__) || defined(__clang__) + __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))) + #elif defined(_MSC_VER) + __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")) + #endif + static CYTHON_INLINE int PyGILState_Check(void) { + return 0; + } + #else // PYPY_VERSION_NUM < 0x07030600 + #endif // PYPY_VERSION_NUM < 0x07030600 + #else + static CYTHON_INLINE int PyGILState_Check(void) { + PyThreadState * tstate = _PyThreadState_Current; + return tstate && (tstate == PyGILState_GetThisThreadState()); + } + #endif +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() @@ -419,23 +955,92 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS -#define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && 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 PY_MAJOR_VERSION >= 3 && (!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) + #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext) +#else + #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) + #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) + #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v) +#else + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v) +#endif +#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) +#if CYTHON_COMPILING_IN_LIMITED_API + #define CYTHON_PEP393_ENABLED 1 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u) + #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)) +#elif 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))) + #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_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) - #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_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))) + #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 #else #define CYTHON_PEP393_ENABLED 0 #define PyUnicode_1BYTE_KIND 1 @@ -444,11 +1049,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #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_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((int)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_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY @@ -459,14 +1064,20 @@ 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) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500) + #undef 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)) @@ -484,8 +1095,10 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define PyString_Type PyUnicode_Type #define PyString_Check PyUnicode_Check #define PyString_CheckExact PyUnicode_CheckExact +#ifndef PyObject_Unicode #define PyObject_Unicode PyObject_Str #endif +#endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) @@ -493,19 +1106,59 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif +#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_PySequence_ListKeepNew(obj) PySequence_List(obj) +#endif #ifndef PySet_CheckExact - #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) + #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type) +#endif +#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_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_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) + #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) #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_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) + #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) +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 + #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 __Pyx_Py3Int_Check(op) PyLong_Check(op) + #define __Pyx_Py3Int_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong @@ -517,6 +1170,9 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long +#else + #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op)) + #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op)) #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject @@ -529,15 +1185,10 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #if PY_VERSION_HEX < 0x030200A4 typedef long Py_hash_t; #define __Pyx_PyInt_FromHash_t PyInt_FromLong - #define __Pyx_PyInt_AsHash_t PyInt_AsLong + #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t #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) + #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t #endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 @@ -557,8 +1208,10 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { } __Pyx_PyAsyncMethodsStruct; #endif -#if defined(WIN32) || defined(MS_WINDOWS) - #define _USE_MATH_DEFINES +#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) + #if !defined(_USE_MATH_DEFINES) + #define _USE_MATH_DEFINES + #endif #endif #include #ifdef NAN @@ -576,13 +1229,21 @@ static CYTHON_INLINE float __PYX_NAN() { #define __Pyx_truncl truncl #endif - +#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; } #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 + { __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,8 +1256,9 @@ static CYTHON_INLINE float __PYX_NAN() { /* Early includes */ #include #include -#include "frameobject.h" +#include "vendor/_compat.h" #include "pystate.h" +#include #include "pythread.h" #ifdef _OPENMP #include @@ -646,9 +1308,10 @@ 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 @@ -666,9 +1329,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_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) @@ -676,13 +1339,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #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) @@ -694,6 +1351,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); (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 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)) #else @@ -705,8 +1363,54 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); #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 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 PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +#include static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; @@ -727,7 +1431,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { - ascii_chars[c] = c; + ascii_chars[c] = (char) c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); @@ -757,6 +1461,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #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 +#include static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; @@ -792,29 +1497,43 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } +#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 * __pyx_cfilenm = __FILE__; static const char *__pyx_filename; +/* #### Code section: filename_table ### */ static const char *__pyx_f[] = { "src/hunter/_tracer.pyx", - "stringsource", + "", + ".tox/cythonize/lib64/python3.11/site-packages/Cython/Includes/cpython/contextvars.pxd", "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.11/site-packages/Cython/Includes/cpython/type.pxd", + ".tox/cythonize/lib64/python3.11/site-packages/Cython/Includes/cpython/bool.pxd", + ".tox/cythonize/lib64/python3.11/site-packages/Cython/Includes/cpython/complex.pxd", "src/hunter/_event.pxd", "src/hunter/_predicates.pxd", }; +/* #### Code section: utility_code_proto_before_types ### */ +/* ForceInitThreads.proto */ +#ifndef __PYX_FORCE_INIT_THREADS + #define __PYX_FORCE_INIT_THREADS 0 +#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() + +/* #### Code section: numeric_typedefs ### */ +/* #### Code section: complex_type_declarations ### */ +/* #### Code section: type_declarations ### */ /*--- Type declarations ---*/ struct __pyx_obj_6hunter_6_event_Event; @@ -824,9 +1543,36 @@ 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; +struct __pyx_opt_args_7cpython_11contextvars_get_value; +struct __pyx_opt_args_7cpython_11contextvars_get_value_no_default; + +/* "cpython/contextvars.pxd":112 + * + * + * cdef inline object get_value(var, default_value=None): # <<<<<<<<<<<<<< + * """Return a new reference to the value of the context variable, + * or the default value of the context variable, + */ +struct __pyx_opt_args_7cpython_11contextvars_get_value { + int __pyx_n; + PyObject *default_value; +}; + +/* "cpython/contextvars.pxd":129 + * + * + * cdef inline object get_value_no_default(var, default_value=None): # <<<<<<<<<<<<<< + * """Return a new reference to the value of the context variable, + * or the provided default value if no such value was found. + */ +struct __pyx_opt_args_7cpython_11contextvars_get_value_no_default { + int __pyx_n; + PyObject *default_value; +}; -/* "_event.pxd":11 +/* "_event.pxd":13 * * @cython.final * cdef class Event: # <<<<<<<<<<<<<< @@ -843,6 +1589,7 @@ struct __pyx_obj_6hunter_6_event_Event { int calls; int threading_support; int detached; + PyObject *builtin; PyObject *_code; PyObject *_filename; PyObject *_fullsource; @@ -857,6 +1604,7 @@ struct __pyx_obj_6hunter_6_event_Event { PyObject *_thread; PyObject *_threadidn; PyObject *_threadname; + PyObject *_instruction; }; @@ -882,7 +1630,7 @@ struct __pyx_obj_6hunter_11_predicates_Query { }; -/* "_predicates.pxd":22 +/* "_predicates.pxd":23 * * @cython.final * cdef class And: # <<<<<<<<<<<<<< @@ -895,7 +1643,7 @@ struct __pyx_obj_6hunter_11_predicates_And { }; -/* "_predicates.pxd":27 +/* "_predicates.pxd":29 * * @cython.final * cdef class Or: # <<<<<<<<<<<<<< @@ -908,7 +1656,7 @@ struct __pyx_obj_6hunter_11_predicates_Or { }; -/* "_predicates.pxd":32 +/* "_predicates.pxd":35 * * @cython.final * cdef class Not: # <<<<<<<<<<<<<< @@ -921,7 +1669,7 @@ struct __pyx_obj_6hunter_11_predicates_Not { }; -/* "_predicates.pxd":37 +/* "_predicates.pxd":41 * * @cython.final * cdef class When: # <<<<<<<<<<<<<< @@ -935,7 +1683,7 @@ struct __pyx_obj_6hunter_11_predicates_When { }; -/* "_predicates.pxd":43 +/* "_predicates.pxd":48 * * @cython.final * cdef class From: # <<<<<<<<<<<<<< @@ -952,7 +1700,28 @@ struct __pyx_obj_6hunter_11_predicates_From { }; -/* "hunter/_tracer.pxd":28 +/* "_predicates.pxd":58 + * + * @cython.final + * cdef class Backlog: # <<<<<<<<<<<<<< + * cdef: + * readonly object condition + */ +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":36 * * @cython.final * cdef class Tracer: # <<<<<<<<<<<<<< @@ -964,6 +1733,7 @@ struct __pyx_obj_6hunter_7_tracer_Tracer { PyObject *handler; PyObject *previous; PyObject *threading_support; + int profiling_mode; int depth; int calls; PyObject *__weakref__; @@ -973,7 +1743,7 @@ struct __pyx_obj_6hunter_7_tracer_Tracer { -/* "_event.pxd":11 +/* "_event.pxd":13 * * @cython.final * cdef class Event: # <<<<<<<<<<<<<< @@ -982,9 +1752,22 @@ struct __pyx_obj_6hunter_7_tracer_Tracer { */ 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,11 +1776,11 @@ 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; @@ -1007,28 +1790,40 @@ static struct __pyx_vtabstruct_6hunter_6_event_Event *__pyx_vtabptr_6hunter_6_ev #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);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)) + #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext() #endif + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ + } #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 +1834,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 +1849,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 +1884,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,9 +1900,22 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* PyObjectGetAttrStrNoError.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + /* Profile.proto */ #ifndef CYTHON_PROFILE -#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_PYSTON +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY #define CYTHON_PROFILE 0 #else #define CYTHON_PROFILE 1 @@ -1124,6 +1941,12 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #include "compile.h" #include "frameobject.h" #include "traceback.h" +#if PY_VERSION_HEX >= 0x030b00a6 + #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) @@ -1132,11 +1955,51 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #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; + static PyCodeObject *__pyx_frame_code = NULL;\ + CYTHON_FRAME_MODIFIER PyFrameObject *__pyx_frame = NULL;\ + int __Pyx_use_tracing = 0; #define __Pyx_TraceFrameInit(codeobj)\ - if (codeobj) __pyx_frame_code = (PyCodeObject*) codeobj; + if (codeobj) __pyx_frame_code = (PyCodeObject*) codeobj; +#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 #ifdef WITH_THREAD #define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error)\ if (nogil) {\ @@ -1144,8 +2007,7 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject 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))) {\ + if (__Pyx_IsTracing(tstate, 1, 1)) {\ __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ }\ PyGILState_Release(state);\ @@ -1153,8 +2015,7 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject }\ } else {\ PyThreadState* tstate = PyThreadState_GET();\ - if (unlikely(tstate->use_tracing) && !tstate->tracing &&\ - (tstate->c_profilefunc || (CYTHON_TRACE && tstate->c_tracefunc))) {\ + if (__Pyx_IsTracing(tstate, 1, 1)) {\ __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ }\ @@ -1162,8 +2023,7 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #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))) {\ + if (__Pyx_IsTracing(tstate, 1, 1)) {\ __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ }\ @@ -1172,10 +2032,8 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #define __Pyx_TraceException()\ 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;\ + if (__Pyx_IsTracing(tstate, 0, 1)) {\ + __Pyx_EnterTracing(tstate);\ PyObject *exc_info = __Pyx_GetExceptionTuple(tstate);\ if (exc_info) {\ if (CYTHON_TRACE && tstate->c_tracefunc)\ @@ -1185,22 +2043,19 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject tstate->c_profileobj, __pyx_frame, PyTrace_EXCEPTION, exc_info);\ Py_DECREF(exc_info);\ }\ - tstate->use_tracing = 1;\ - tstate->tracing--;\ + __Pyx_LeaveTracing(tstate);\ }\ } static void __Pyx_call_return_trace_func(PyThreadState *tstate, PyFrameObject *frame, PyObject *result) { 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--; + __Pyx_LeaveTracing(tstate); __Pyx_ErrRestoreInState(tstate, type, value, traceback); } #ifdef WITH_THREAD @@ -1211,14 +2066,14 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject PyThreadState *tstate;\ PyGILState_STATE state = PyGILState_Ensure();\ tstate = __Pyx_PyThreadState_Current;\ - if (tstate->use_tracing) {\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ }\ PyGILState_Release(state);\ }\ } else {\ PyThreadState* tstate = __Pyx_PyThreadState_Current;\ - if (tstate->use_tracing) {\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ }\ }\ @@ -1227,7 +2082,7 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #define __Pyx_TraceReturn(result, nogil)\ if (likely(!__Pyx_use_tracing)); else {\ PyThreadState* tstate = __Pyx_PyThreadState_Current;\ - if (tstate->use_tracing) {\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ }\ } @@ -1247,11 +2102,9 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject PyObject *type, *value, *traceback; __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); __Pyx_PyFrame_SetLineNumber(frame, lineno); - tstate->tracing++; - tstate->use_tracing = 0; + __Pyx_EnterTracing(tstate); ret = tstate->c_tracefunc(tstate->c_traceobj, frame, PyTrace_LINE, NULL); - tstate->use_tracing = 1; - tstate->tracing--; + __Pyx_LeaveTracing(tstate); if (likely(!ret)) { __Pyx_ErrRestoreInState(tstate, type, value, traceback); } else { @@ -1268,17 +2121,17 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject if (CYTHON_TRACE_NOGIL) {\ int ret = 0;\ PyThreadState *tstate;\ - PyGILState_STATE state = PyGILState_Ensure();\ + PyGILState_STATE state = __Pyx_PyGILState_Ensure();\ tstate = __Pyx_PyThreadState_Current;\ - if (unlikely(tstate->use_tracing && tstate->c_tracefunc && __pyx_frame->f_trace)) {\ + if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && __pyx_frame->f_trace) {\ ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ }\ - PyGILState_Release(state);\ + __Pyx_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)) {\ + if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && __pyx_frame->f_trace) {\ int ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ if (unlikely(ret)) goto_error;\ }\ @@ -1288,7 +2141,7 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #define __Pyx_TraceLine(lineno, 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)) {\ + if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && __pyx_frame->f_trace) {\ int ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ if (unlikely(ret)) goto_error;\ }\ @@ -1298,27 +2151,14 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #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); +/* 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) PyObject_DelAttr(o,n) +#define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v) +#endif /* PyObjectCall.proto */ #if CYTHON_COMPILING_IN_CPYTHON @@ -1328,7 +2168,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg #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 @@ -1343,14 +2183,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 +2219,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))) ?\ (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) @@ -1408,18 +2240,28 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); /* PyFunctionFastCall.proto */ #if CYTHON_FAST_PYCALL +#if !CYTHON_VECTORCALL #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); -#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 +#if !CYTHON_VECTORCALL +#if PY_VERSION_HEX >= 0x03080000 + #include "frameobject.h" +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif + #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()\ @@ -1428,31 +2270,17 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, #define __Pyx_PyFrame_GetLocalsplus(frame)\ (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) #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 - -/* PyObjectCall2Args.proto */ -static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); +#endif /* PyObjectCallMethO.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif -/* PyObjectCallOneArg.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); - -/* 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 +/* 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 **args, size_t nargs, PyObject *kwargs); /* SwapException.proto */ #if CYTHON_FAST_THREAD_STATE @@ -1462,12 +2290,77 @@ static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject * static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); #endif +/* TupleAndListFromArray.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); +static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); +#endif + +/* 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_Arg_VARARGS(args, i) PySequence_GetItem(args, i) +#elif CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i) +#else + #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i) +#endif +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg) + #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg) +#else + #define __Pyx_Arg_NewRef_VARARGS(arg) arg + #define __Pyx_Arg_XDECREF_VARARGS(arg) +#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_Arg_FASTCALL(args, i) args[i] + #define __Pyx_NumKwargs_FASTCALL(kwds) 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_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); + #else + #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) + #endif + #define __Pyx_Arg_NewRef_FASTCALL(arg) arg /* no-op, __Pyx_Arg_FASTCALL is direct and this needs + to have the same reference counting */ + #define __Pyx_Arg_XDECREF_FASTCALL(arg) +#else + #define __Pyx_Arg_FASTCALL __Pyx_Arg_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 + #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg) + #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start) +#else +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) +#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 int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ - PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues, + PyObject **argnames[], + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name); /* RaiseArgTupleInvalid.proto */ @@ -1479,35 +2372,29 @@ static void __Pyx_WriteUnraisable(const char *name, int clineno, int lineno, const char *filename, int full_traceback, int nogil); +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* 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); + /* ExtTypeTest.proto */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); -/* UnpackUnboundCMethod.proto */ -typedef struct { - PyObject *type; - PyObject **method_name; - PyCFunction func; - PyObject *method; - int flag; -} __Pyx_CachedCFunction; - -/* CallUnboundCMethod1.proto */ -static PyObject* __Pyx__CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg); -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg); +/* DictGetItem.proto */ +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); +#define __Pyx_PyObject_Dict_GetItem(obj, name)\ + (likely(PyDict_CheckExact(obj)) ?\ + __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name)) #else -#define __Pyx_CallUnboundCMethod1(cfunc, self, arg) __Pyx__CallUnboundCMethod1(cfunc, self, arg) +#define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) +#define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) #endif -/* 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 @@ -1515,26 +2402,59 @@ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int #define __Pyx_PyString_Equals __Pyx_PyBytes_Equals #endif -/* GetAttr.proto */ -static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); - /* GetAttr3.proto */ static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); +/* KeywordStringCheck.proto */ +static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed); + /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); /* 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_0_10 +#define __PYX_HAVE_RT_ImportType_proto_3_0_10 +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L +#include +#endif +#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L +#define __PYX_GET_STRUCT_ALIGNMENT_3_0_10(s) alignof(s) +#else +#define __PYX_GET_STRUCT_ALIGNMENT_3_0_10(s) sizeof(void*) +#endif +enum __Pyx_ImportType_CheckSize_3_0_10 { + __Pyx_ImportType_CheckSize_Error_3_0_10 = 0, + __Pyx_ImportType_CheckSize_Warn_3_0_10 = 1, + __Pyx_ImportType_CheckSize_Ignore_3_0_10 = 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_0_10(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_10 check_size); #endif +/* IncludeStructmemberH.proto */ +#include + +/* FixUpExtensionType.proto */ +#if CYTHON_USE_TYPE_SPECS +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); +#endif + +/* 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); + /* 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); @@ -1543,14 +2463,162 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj #endif /* SetupReduce.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API static int __Pyx_setup_reduce(PyObject* type_obj); +#endif /* 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); +/* ImportDottedModule.proto */ +static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple); +#if PY_MAJOR_VERSION >= 3 +static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple); +#endif + +/* FetchSharedCythonModule.proto */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void); + +/* FetchCommonType.proto */ +#if !CYTHON_USE_TYPE_SPECS +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); +#else +static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases); +#endif + +/* PyMethodNew.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + PyObject *typesModule=NULL, *methodType=NULL, *result=NULL; + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + typesModule = PyImport_ImportModule("types"); + if (!typesModule) return NULL; + methodType = PyObject_GetAttrString(typesModule, "MethodType"); + Py_DECREF(typesModule); + if (!methodType) return NULL; + result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL); + Py_DECREF(methodType); + return result; +} +#elif PY_MAJOR_VERSION >= 3 +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); +} +#else + #define __Pyx_PyMethod_New PyMethod_New +#endif + +/* PyVectorcallFastCallDict.proto */ +#if CYTHON_METH_FASTCALL +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 + __pyx_vectorcallfunc func_vectorcall; +#endif +#if PY_VERSION_HEX < 0x030500A0 || 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 + void *defaults; + int defaults_pyobjects; + size_t defaults_size; + 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_CyFunctionType) +#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type) +#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_CyFunctionType) +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc); +#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 void *__Pyx_CyFunction_InitDefaults(PyObject *m, + size_t size, + int pyobjects); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, + PyObject *tuple); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, + PyObject *dict); +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, + PyObject *dict); +static int __pyx_CyFunction_init(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 +#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) @@ -1559,6 +2627,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API typedef struct { PyCodeObject* code_object; int code_line; @@ -1572,17 +2641,36 @@ 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); +#endif /* 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); /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); +/* FormatTypeName.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%U" +static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp); +#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) +#else +typedef const char *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%.200s" +#define __Pyx_PyType_GetName(tp) ((tp)->tp_name) +#define __Pyx_DECREF_TypeName(obj) +#endif + /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); @@ -1592,162 +2680,177 @@ static CYTHON_INLINE long __Pyx_PyInt_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)) #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) /* CheckBinaryVersion.proto */ -static int __Pyx_check_binary_version(void); +static unsigned long __Pyx_get_runtime_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); +static int __Pyx_ImportFunction_3_0_10(PyObject *module, const char *funcname, void (**f)(void), const char *sig); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); +/* #### Code section: module_declarations ### */ +static CYTHON_INLINE double __pyx_f_7cpython_7complex_7complex_4real_real(PyComplexObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE double __pyx_f_7cpython_7complex_7complex_4imag_imag(PyComplexObject *__pyx_v_self); /* proto*/ + +/* Module declarations from "cython" */ -/* Module declarations from 'cython' */ +/* Module declarations from "libc.string" */ -/* Module declarations from 'libc.string' */ +/* Module declarations from "libc.stdio" */ -/* Module declarations from 'libc.stdio' */ +/* Module declarations from "__builtin__" */ -/* Module declarations from '__builtin__' */ +/* Module declarations from "cpython.type" */ -/* Module declarations from 'cpython.type' */ -static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; +/* Module declarations from "cpython.version" */ -/* Module declarations from 'cpython.version' */ +/* Module declarations from "cpython.ref" */ -/* Module declarations from 'cpython.ref' */ +/* Module declarations from "cpython.exc" */ -/* Module declarations from 'cpython.exc' */ +/* Module declarations from "cpython.module" */ -/* Module declarations from 'cpython.module' */ +/* Module declarations from "cpython.mem" */ -/* Module declarations from 'cpython.mem' */ +/* Module declarations from "cpython.tuple" */ -/* Module declarations from 'cpython.tuple' */ +/* Module declarations from "cpython.list" */ -/* Module declarations from 'cpython.list' */ +/* Module declarations from "cpython.sequence" */ -/* Module declarations from 'cpython.sequence' */ +/* Module declarations from "cpython.mapping" */ -/* Module declarations from 'cpython.mapping' */ +/* Module declarations from "cpython.iterator" */ -/* Module declarations from 'cpython.iterator' */ +/* Module declarations from "cpython.number" */ -/* Module declarations from 'cpython.number' */ +/* Module declarations from "cpython.int" */ -/* Module declarations from 'cpython.int' */ +/* Module declarations from "__builtin__" */ -/* Module declarations from '__builtin__' */ +/* Module declarations from "cpython.bool" */ -/* Module declarations from 'cpython.bool' */ -static PyTypeObject *__pyx_ptype_7cpython_4bool_bool = 0; +/* Module declarations from "cpython.long" */ -/* Module declarations from 'cpython.long' */ +/* Module declarations from "cpython.float" */ -/* Module declarations from 'cpython.float' */ +/* Module declarations from "__builtin__" */ -/* Module declarations from '__builtin__' */ +/* Module declarations from "cpython.complex" */ -/* Module declarations from 'cpython.complex' */ -static PyTypeObject *__pyx_ptype_7cpython_7complex_complex = 0; +/* Module declarations from "cpython.string" */ -/* Module declarations from 'cpython.string' */ +/* Module declarations from "libc.stddef" */ -/* Module declarations from 'cpython.unicode' */ +/* Module declarations from "cpython.unicode" */ -/* Module declarations from 'cpython.dict' */ +/* Module declarations from "cpython.pyport" */ -/* Module declarations from 'cpython.instance' */ +/* Module declarations from "cpython.dict" */ -/* Module declarations from 'cpython.function' */ +/* Module declarations from "cpython.instance" */ -/* Module declarations from 'cpython.method' */ +/* Module declarations from "cpython.function" */ -/* Module declarations from 'cpython.weakref' */ +/* Module declarations from "cpython.method" */ -/* Module declarations from 'cpython.getargs' */ +/* Module declarations from "cpython.weakref" */ -/* Module declarations from 'cpython.pythread' */ +/* Module declarations from "cpython.getargs" */ -/* Module declarations from 'cpython.cobject' */ +/* Module declarations from "cpython.pythread" */ -/* Module declarations from 'cpython.oldbuffer' */ +/* Module declarations from "cpython.cobject" */ -/* Module declarations from 'cpython.set' */ +/* Module declarations from "cpython.oldbuffer" */ -/* Module declarations from 'cpython.buffer' */ +/* Module declarations from "cpython.set" */ -/* Module declarations from 'cpython.bytes' */ +/* Module declarations from "cpython.buffer" */ -/* Module declarations from 'cpython.pycapsule' */ +/* Module declarations from "cpython.bytes" */ -/* Module declarations from 'cpython' */ +/* Module declarations from "cpython.pycapsule" */ -/* Module declarations from 'cpython.object' */ +/* Module declarations from "cpython.contextvars" */ -/* Module declarations from 'cpython.pystate' */ +/* Module declarations from "cpython" */ -/* Module declarations from 'types' */ +/* Module declarations from "cpython.object" */ -/* Module declarations from 'hunter._event' */ -static PyTypeObject *__pyx_ptype_6hunter_6_event_Event = 0; +/* Module declarations from "cpython.pystate" */ -/* 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; +/* Module declarations from "types" */ + +/* Module declarations from "hunter._event" */ + +/* 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 '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*/ +/* Module declarations from "hunter._tracer" */ +static PyObject *__pyx_v_6hunter_7_tracer_KIND_INTS = 0; +static CYTHON_INLINE int __pyx_f_6hunter_7_tracer_trace_func(struct __pyx_obj_6hunter_7_tracer_Tracer *, 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; -/* Implementation of 'hunter._tracer' */ +/* Implementation of "hunter._tracer" */ +/* #### Code section: global_var ### */ static PyObject *__pyx_builtin_id; static PyObject *__pyx_builtin_TypeError; +/* #### Code section: string_decls ### */ static const char __pyx_k_[] = ""; +static const char __pyx_k__8[] = "*"; +static const char __pyx_k_gc[] = "gc"; static const char __pyx_k_id[] = "id"; +static const char __pyx_k__14[] = "?"; static const char __pyx_k_all[] = "__all__"; static const char __pyx_k_arg[] = "arg"; 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_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_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_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_enable[] = "enable"; static const char __pyx_k_exc_tb[] = "exc_tb"; -static const char __pyx_k_format[] = "format"; static const char __pyx_k_hunter[] = "hunter"; static const char __pyx_k_import[] = "__import__"; static const char __pyx_k_reduce[] = "__reduce__"; static const char __pyx_k_return[] = "return"; +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_c_return[] = "c_return"; @@ -1758,71 +2861,41 @@ static const char __pyx_k_setstate[] = "__setstate__"; static const char __pyx_k_settrace[] = "settrace"; 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_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_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_Tracer___reduce_cython[] = "Tracer.__reduce_cython__"; +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_x_t[] = ""; -static const char __pyx_k_Disabling_tracer_because_handler[] = "Disabling tracer because handler {} failed ({!r}).\n\n"; +static const char __pyx_k_Disabling_tracer_because_handler[] = "Disabling tracer because handler %r failed (%r) at %r.\n\n"; static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__"; -static PyObject *__pyx_kp_s_; -static PyObject *__pyx_kp_s_Disabling_tracer_because_handler; -static PyObject *__pyx_n_s_Tracer; -static PyObject *__pyx_n_s_TypeError; -static PyObject *__pyx_n_s_all; -static PyObject *__pyx_n_s_arg; -static PyObject *__pyx_n_s_c_call; -static PyObject *__pyx_n_s_c_exception; -static PyObject *__pyx_n_s_c_return; -static PyObject *__pyx_n_s_call; -static PyObject *__pyx_n_s_cline_in_traceback; -static PyObject *__pyx_n_s_default_stream; -static PyObject *__pyx_n_s_exc_tb; -static PyObject *__pyx_n_s_exc_type; -static PyObject *__pyx_n_s_exc_val; -static PyObject *__pyx_n_s_exception; -static PyObject *__pyx_n_s_file; -static PyObject *__pyx_n_s_format; -static PyObject *__pyx_n_s_frame; -static PyObject *__pyx_n_s_getstate; -static PyObject *__pyx_kp_s_handler; -static PyObject *__pyx_n_s_hunter; -static PyObject *__pyx_kp_s_hunter__tracer_Tracer_at_0x_x_t; -static PyObject *__pyx_n_s_id; -static PyObject *__pyx_n_s_import; -static PyObject *__pyx_n_s_index; -static PyObject *__pyx_n_s_kind; -static PyObject *__pyx_n_s_line; -static PyObject *__pyx_n_s_main; -static PyObject *__pyx_n_s_name; -static PyObject *__pyx_kp_s_no_default___reduce___due_to_non; -static PyObject *__pyx_kp_s_previous; -static PyObject *__pyx_n_s_print_exc; -static PyObject *__pyx_n_s_pyx_vtable; -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_return; -static PyObject *__pyx_n_s_setstate; -static PyObject *__pyx_n_s_setstate_cython; -static PyObject *__pyx_n_s_settrace; -static PyObject *__pyx_n_s_stop; -static PyObject *__pyx_kp_s_stopped; -static PyObject *__pyx_n_s_test; -static PyObject *__pyx_n_s_threading; -static PyObject *__pyx_n_s_threading_support; -static PyObject *__pyx_n_s_trace_hook; -static PyObject *__pyx_n_s_traceback; -static PyObject *__pyx_n_s_write; -static int __pyx_pf_6hunter_7_tracer_6Tracer___cinit__(struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self, PyObject *__pyx_v_threading_support); /* proto */ +/* #### Code section: decls ### */ +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); /* proto */ static void __pyx_pf_6hunter_7_tracer_6Tracer_2__dealloc__(struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_4__repr__(struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self); /* proto */ 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); /* proto */ @@ -1833,539 +2906,1618 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_14__exit__(struct __pyx_obj_6 static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_7handler___get__(struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_8previous___get__(struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_17threading_support___get__(struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_14profiling_mode___get__(struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_5depth___get__(struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_5calls___get__(struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_19_threading_previous___get__(struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_16__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6hunter_7_tracer_Tracer *__pyx_v_self); /* proto */ 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); /* proto */ static PyObject *__pyx_tp_new_6hunter_7_tracer_Tracer(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static __Pyx_CachedCFunction __pyx_umethod_PyTuple_Type_index = {0, &__pyx_n_s_index, 0, 0, 0}; -static PyObject *__pyx_tuple__2; -static PyObject *__pyx_tuple__3; -static PyObject *__pyx_tuple__4; -static PyObject *__pyx_tuple__5; -/* Late includes */ - -/* "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) { - 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_RefNannyDeclarations - int __pyx_t_1; - 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; - int __pyx_t_9; - PyObject *__pyx_t_10 = NULL; - PyObject *__pyx_t_11 = NULL; - PyObject *__pyx_t_12 = NULL; - PyObject *__pyx_t_13 = NULL; - PyObject *__pyx_t_14 = NULL; - PyObject *__pyx_t_15 = NULL; - int __pyx_t_16; - char const *__pyx_t_17; - 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; - PyObject *__pyx_t_23 = NULL; - __Pyx_RefNannySetupContext("trace_func", 0); - __Pyx_TraceCall("trace_func", __pyx_f[0], 24, 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) { - - /* "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 +/* #### Code section: late_includes ### */ +/* #### Code section: module_state ### */ +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 + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + PyTypeObject *__pyx_ptype_7cpython_4type_type; + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + PyTypeObject *__pyx_ptype_7cpython_4bool_bool; + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + PyTypeObject *__pyx_ptype_7cpython_7complex_complex; + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + PyTypeObject *__pyx_ptype_6hunter_6_event_Event; + #if CYTHON_USE_MODULE_STATE + #endif + 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; + #if CYTHON_USE_MODULE_STATE + PyObject *__pyx_type_6hunter_7_tracer_Tracer; + #endif + PyTypeObject *__pyx_ptype_6hunter_7_tracer_FrameType; + PyTypeObject *__pyx_ptype_6hunter_7_tracer_CodeType; + PyTypeObject *__pyx_ptype_6hunter_7_tracer_Tracer; + PyObject *__pyx_kp_s_; + PyObject *__pyx_kp_s_Disabling_tracer_because_handler; + PyObject *__pyx_n_s_Tracer; + PyObject *__pyx_n_s_Tracer___enter; + PyObject *__pyx_n_s_Tracer___exit; + PyObject *__pyx_n_s_Tracer___reduce_cython; + PyObject *__pyx_n_s_Tracer___setstate_cython; + PyObject *__pyx_n_s_Tracer_stop; + PyObject *__pyx_n_s_Tracer_trace; + PyObject *__pyx_n_s_TypeError; + PyObject *__pyx_n_s__14; + PyObject *__pyx_n_s__8; + PyObject *__pyx_n_s_all; + PyObject *__pyx_n_s_arg; + PyObject *__pyx_n_s_asyncio_coroutines; + PyObject *__pyx_n_s_c_call; + PyObject *__pyx_n_s_c_exception; + PyObject *__pyx_n_s_c_return; + PyObject *__pyx_n_s_call; + PyObject *__pyx_n_s_cline_in_traceback; + PyObject *__pyx_n_s_default_stream; + PyObject *__pyx_kp_u_disable; + PyObject *__pyx_kp_u_enable; + PyObject *__pyx_n_s_enter; + PyObject *__pyx_n_s_exc_tb; + PyObject *__pyx_n_s_exc_type; + PyObject *__pyx_n_s_exc_val; + PyObject *__pyx_n_s_exception; + PyObject *__pyx_n_s_exit; + PyObject *__pyx_n_s_f_trace; + PyObject *__pyx_n_s_file; + PyObject *__pyx_n_s_frame; + PyObject *__pyx_kp_u_gc; + PyObject *__pyx_n_s_getstate; + PyObject *__pyx_kp_s_handler; + PyObject *__pyx_n_s_hunter; + PyObject *__pyx_n_s_hunter__tracer; + PyObject *__pyx_kp_s_hunter__tracer_Tracer_at_0x_x_t; + PyObject *__pyx_n_s_id; + PyObject *__pyx_n_s_import; + PyObject *__pyx_n_s_initializing; + PyObject *__pyx_n_s_is_coroutine; + PyObject *__pyx_kp_u_isenabled; + PyObject *__pyx_n_s_kind; + PyObject *__pyx_n_s_line; + PyObject *__pyx_n_s_main; + PyObject *__pyx_n_s_name; + PyObject *__pyx_kp_s_no_default___reduce___due_to_non; + PyObject *__pyx_n_s_predicate; + PyObject *__pyx_kp_s_previous; + PyObject *__pyx_n_s_print_exc; + PyObject *__pyx_n_s_profile_hook; + PyObject *__pyx_n_s_profiling_mode; + PyObject *__pyx_n_s_pyx_state; + PyObject *__pyx_n_s_pyx_vtable; + PyObject *__pyx_n_s_reduce; + PyObject *__pyx_n_s_reduce_cython; + PyObject *__pyx_n_s_reduce_ex; + PyObject *__pyx_n_s_return; + PyObject *__pyx_n_s_self; + PyObject *__pyx_n_s_setprofile; + PyObject *__pyx_n_s_setstate; + PyObject *__pyx_n_s_setstate_cython; + PyObject *__pyx_n_s_settrace; + PyObject *__pyx_n_s_spec; + PyObject *__pyx_kp_s_src_hunter__tracer_pyx; + PyObject *__pyx_n_s_state; + PyObject *__pyx_n_s_stop; + PyObject *__pyx_kp_s_stopped; + PyObject *__pyx_kp_s_stringsource; + PyObject *__pyx_n_s_test; + PyObject *__pyx_n_s_threading; + PyObject *__pyx_n_s_threading_support; + PyObject *__pyx_n_s_trace; + PyObject *__pyx_n_s_trace_hook; + PyObject *__pyx_n_s_traceback; + PyObject *__pyx_n_s_write; + 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; + PyObject *__pyx_tuple__9; + PyObject *__pyx_tuple__10; + PyObject *__pyx_tuple__11; + PyObject *__pyx_tuple__12; + PyObject *__pyx_tuple__13; + PyObject *__pyx_codeobj__2; + PyObject *__pyx_codeobj__3; + PyObject *__pyx_codeobj__4; + PyObject *__pyx_codeobj__5; + PyObject *__pyx_codeobj__6; + PyObject *__pyx_codeobj__7; +} __pyx_mstate; + +#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(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o)) + +#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef))) + +#define __pyx_m (PyState_FindModule(&__pyx_moduledef)) +#else +static __pyx_mstate __pyx_mstate_global_static = +#ifdef __cplusplus + {}; +#else + {0}; +#endif +static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static; +#endif +/* #### Code section: module_state_clear ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_clear(PyObject *m) { + __pyx_mstate *clear_module_state = __pyx_mstate(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 + Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_4type_type); + Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_4bool_bool); + Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_7complex_complex); + 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_FrameType); + 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); + Py_CLEAR(clear_module_state->__pyx_kp_s_); + Py_CLEAR(clear_module_state->__pyx_kp_s_Disabling_tracer_because_handler); + Py_CLEAR(clear_module_state->__pyx_n_s_Tracer); + Py_CLEAR(clear_module_state->__pyx_n_s_Tracer___enter); + Py_CLEAR(clear_module_state->__pyx_n_s_Tracer___exit); + Py_CLEAR(clear_module_state->__pyx_n_s_Tracer___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Tracer___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Tracer_stop); + Py_CLEAR(clear_module_state->__pyx_n_s_Tracer_trace); + Py_CLEAR(clear_module_state->__pyx_n_s_TypeError); + Py_CLEAR(clear_module_state->__pyx_n_s__14); + Py_CLEAR(clear_module_state->__pyx_n_s__8); + Py_CLEAR(clear_module_state->__pyx_n_s_all); + Py_CLEAR(clear_module_state->__pyx_n_s_arg); + Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines); + Py_CLEAR(clear_module_state->__pyx_n_s_c_call); + Py_CLEAR(clear_module_state->__pyx_n_s_c_exception); + Py_CLEAR(clear_module_state->__pyx_n_s_c_return); + Py_CLEAR(clear_module_state->__pyx_n_s_call); + Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback); + Py_CLEAR(clear_module_state->__pyx_n_s_default_stream); + Py_CLEAR(clear_module_state->__pyx_kp_u_disable); + Py_CLEAR(clear_module_state->__pyx_kp_u_enable); + Py_CLEAR(clear_module_state->__pyx_n_s_enter); + Py_CLEAR(clear_module_state->__pyx_n_s_exc_tb); + Py_CLEAR(clear_module_state->__pyx_n_s_exc_type); + Py_CLEAR(clear_module_state->__pyx_n_s_exc_val); + Py_CLEAR(clear_module_state->__pyx_n_s_exception); + Py_CLEAR(clear_module_state->__pyx_n_s_exit); + Py_CLEAR(clear_module_state->__pyx_n_s_f_trace); + Py_CLEAR(clear_module_state->__pyx_n_s_file); + Py_CLEAR(clear_module_state->__pyx_n_s_frame); + Py_CLEAR(clear_module_state->__pyx_kp_u_gc); + Py_CLEAR(clear_module_state->__pyx_n_s_getstate); + Py_CLEAR(clear_module_state->__pyx_kp_s_handler); + Py_CLEAR(clear_module_state->__pyx_n_s_hunter); + Py_CLEAR(clear_module_state->__pyx_n_s_hunter__tracer); + Py_CLEAR(clear_module_state->__pyx_kp_s_hunter__tracer_Tracer_at_0x_x_t); + Py_CLEAR(clear_module_state->__pyx_n_s_id); + Py_CLEAR(clear_module_state->__pyx_n_s_import); + Py_CLEAR(clear_module_state->__pyx_n_s_initializing); + Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine); + Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled); + Py_CLEAR(clear_module_state->__pyx_n_s_kind); + Py_CLEAR(clear_module_state->__pyx_n_s_line); + Py_CLEAR(clear_module_state->__pyx_n_s_main); + Py_CLEAR(clear_module_state->__pyx_n_s_name); + Py_CLEAR(clear_module_state->__pyx_kp_s_no_default___reduce___due_to_non); + Py_CLEAR(clear_module_state->__pyx_n_s_predicate); + Py_CLEAR(clear_module_state->__pyx_kp_s_previous); + Py_CLEAR(clear_module_state->__pyx_n_s_print_exc); + Py_CLEAR(clear_module_state->__pyx_n_s_profile_hook); + Py_CLEAR(clear_module_state->__pyx_n_s_profiling_mode); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_vtable); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex); + Py_CLEAR(clear_module_state->__pyx_n_s_return); + Py_CLEAR(clear_module_state->__pyx_n_s_self); + Py_CLEAR(clear_module_state->__pyx_n_s_setprofile); + Py_CLEAR(clear_module_state->__pyx_n_s_setstate); + Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_settrace); + Py_CLEAR(clear_module_state->__pyx_n_s_spec); + Py_CLEAR(clear_module_state->__pyx_kp_s_src_hunter__tracer_pyx); + Py_CLEAR(clear_module_state->__pyx_n_s_state); + Py_CLEAR(clear_module_state->__pyx_n_s_stop); + Py_CLEAR(clear_module_state->__pyx_kp_s_stopped); + Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource); + Py_CLEAR(clear_module_state->__pyx_n_s_test); + Py_CLEAR(clear_module_state->__pyx_n_s_threading); + Py_CLEAR(clear_module_state->__pyx_n_s_threading_support); + Py_CLEAR(clear_module_state->__pyx_n_s_trace); + Py_CLEAR(clear_module_state->__pyx_n_s_trace_hook); + Py_CLEAR(clear_module_state->__pyx_n_s_traceback); + Py_CLEAR(clear_module_state->__pyx_n_s_write); + 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); + Py_CLEAR(clear_module_state->__pyx_tuple__9); + Py_CLEAR(clear_module_state->__pyx_tuple__10); + Py_CLEAR(clear_module_state->__pyx_tuple__11); + Py_CLEAR(clear_module_state->__pyx_tuple__12); + Py_CLEAR(clear_module_state->__pyx_tuple__13); + Py_CLEAR(clear_module_state->__pyx_codeobj__2); + Py_CLEAR(clear_module_state->__pyx_codeobj__3); + Py_CLEAR(clear_module_state->__pyx_codeobj__4); + Py_CLEAR(clear_module_state->__pyx_codeobj__5); + Py_CLEAR(clear_module_state->__pyx_codeobj__6); + Py_CLEAR(clear_module_state->__pyx_codeobj__7); + return 0; +} +#endif +/* #### Code section: module_state_traverse ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { + __pyx_mstate *traverse_module_state = __pyx_mstate(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); + Py_VISIT(traverse_module_state->__pyx_empty_tuple); + Py_VISIT(traverse_module_state->__pyx_empty_bytes); + Py_VISIT(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_7cpython_4bool_bool); + Py_VISIT(traverse_module_state->__pyx_ptype_7cpython_7complex_complex); + 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_FrameType); + 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); + Py_VISIT(traverse_module_state->__pyx_kp_s_); + Py_VISIT(traverse_module_state->__pyx_kp_s_Disabling_tracer_because_handler); + Py_VISIT(traverse_module_state->__pyx_n_s_Tracer); + Py_VISIT(traverse_module_state->__pyx_n_s_Tracer___enter); + Py_VISIT(traverse_module_state->__pyx_n_s_Tracer___exit); + Py_VISIT(traverse_module_state->__pyx_n_s_Tracer___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Tracer___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Tracer_stop); + Py_VISIT(traverse_module_state->__pyx_n_s_Tracer_trace); + Py_VISIT(traverse_module_state->__pyx_n_s_TypeError); + Py_VISIT(traverse_module_state->__pyx_n_s__14); + Py_VISIT(traverse_module_state->__pyx_n_s__8); + Py_VISIT(traverse_module_state->__pyx_n_s_all); + Py_VISIT(traverse_module_state->__pyx_n_s_arg); + Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines); + Py_VISIT(traverse_module_state->__pyx_n_s_c_call); + Py_VISIT(traverse_module_state->__pyx_n_s_c_exception); + Py_VISIT(traverse_module_state->__pyx_n_s_c_return); + Py_VISIT(traverse_module_state->__pyx_n_s_call); + Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback); + Py_VISIT(traverse_module_state->__pyx_n_s_default_stream); + Py_VISIT(traverse_module_state->__pyx_kp_u_disable); + Py_VISIT(traverse_module_state->__pyx_kp_u_enable); + Py_VISIT(traverse_module_state->__pyx_n_s_enter); + Py_VISIT(traverse_module_state->__pyx_n_s_exc_tb); + Py_VISIT(traverse_module_state->__pyx_n_s_exc_type); + Py_VISIT(traverse_module_state->__pyx_n_s_exc_val); + Py_VISIT(traverse_module_state->__pyx_n_s_exception); + Py_VISIT(traverse_module_state->__pyx_n_s_exit); + Py_VISIT(traverse_module_state->__pyx_n_s_f_trace); + Py_VISIT(traverse_module_state->__pyx_n_s_file); + Py_VISIT(traverse_module_state->__pyx_n_s_frame); + Py_VISIT(traverse_module_state->__pyx_kp_u_gc); + Py_VISIT(traverse_module_state->__pyx_n_s_getstate); + Py_VISIT(traverse_module_state->__pyx_kp_s_handler); + Py_VISIT(traverse_module_state->__pyx_n_s_hunter); + Py_VISIT(traverse_module_state->__pyx_n_s_hunter__tracer); + Py_VISIT(traverse_module_state->__pyx_kp_s_hunter__tracer_Tracer_at_0x_x_t); + Py_VISIT(traverse_module_state->__pyx_n_s_id); + Py_VISIT(traverse_module_state->__pyx_n_s_import); + Py_VISIT(traverse_module_state->__pyx_n_s_initializing); + Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine); + Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled); + Py_VISIT(traverse_module_state->__pyx_n_s_kind); + Py_VISIT(traverse_module_state->__pyx_n_s_line); + Py_VISIT(traverse_module_state->__pyx_n_s_main); + Py_VISIT(traverse_module_state->__pyx_n_s_name); + Py_VISIT(traverse_module_state->__pyx_kp_s_no_default___reduce___due_to_non); + Py_VISIT(traverse_module_state->__pyx_n_s_predicate); + Py_VISIT(traverse_module_state->__pyx_kp_s_previous); + Py_VISIT(traverse_module_state->__pyx_n_s_print_exc); + Py_VISIT(traverse_module_state->__pyx_n_s_profile_hook); + Py_VISIT(traverse_module_state->__pyx_n_s_profiling_mode); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_vtable); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex); + Py_VISIT(traverse_module_state->__pyx_n_s_return); + Py_VISIT(traverse_module_state->__pyx_n_s_self); + Py_VISIT(traverse_module_state->__pyx_n_s_setprofile); + Py_VISIT(traverse_module_state->__pyx_n_s_setstate); + Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_settrace); + Py_VISIT(traverse_module_state->__pyx_n_s_spec); + Py_VISIT(traverse_module_state->__pyx_kp_s_src_hunter__tracer_pyx); + Py_VISIT(traverse_module_state->__pyx_n_s_state); + Py_VISIT(traverse_module_state->__pyx_n_s_stop); + Py_VISIT(traverse_module_state->__pyx_kp_s_stopped); + Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource); + Py_VISIT(traverse_module_state->__pyx_n_s_test); + Py_VISIT(traverse_module_state->__pyx_n_s_threading); + Py_VISIT(traverse_module_state->__pyx_n_s_threading_support); + Py_VISIT(traverse_module_state->__pyx_n_s_trace); + Py_VISIT(traverse_module_state->__pyx_n_s_trace_hook); + Py_VISIT(traverse_module_state->__pyx_n_s_traceback); + Py_VISIT(traverse_module_state->__pyx_n_s_write); + Py_VISIT(traverse_module_state->__pyx_int_0); + Py_VISIT(traverse_module_state->__pyx_int_1); + Py_VISIT(traverse_module_state->__pyx_int_2); + Py_VISIT(traverse_module_state->__pyx_int_3); + Py_VISIT(traverse_module_state->__pyx_int_4); + Py_VISIT(traverse_module_state->__pyx_int_5); + Py_VISIT(traverse_module_state->__pyx_int_6); + Py_VISIT(traverse_module_state->__pyx_tuple__9); + Py_VISIT(traverse_module_state->__pyx_tuple__10); + Py_VISIT(traverse_module_state->__pyx_tuple__11); + Py_VISIT(traverse_module_state->__pyx_tuple__12); + Py_VISIT(traverse_module_state->__pyx_tuple__13); + Py_VISIT(traverse_module_state->__pyx_codeobj__2); + Py_VISIT(traverse_module_state->__pyx_codeobj__3); + Py_VISIT(traverse_module_state->__pyx_codeobj__4); + Py_VISIT(traverse_module_state->__pyx_codeobj__5); + Py_VISIT(traverse_module_state->__pyx_codeobj__6); + Py_VISIT(traverse_module_state->__pyx_codeobj__7); + return 0; +} +#endif +/* #### Code section: module_state_defines ### */ +#define __pyx_d __pyx_mstate_global->__pyx_d +#define __pyx_b __pyx_mstate_global->__pyx_b +#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime +#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple +#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes +#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode +#ifdef __Pyx_CyFunction_USED +#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType +#endif +#ifdef __Pyx_FusedFunction_USED +#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType +#endif +#ifdef __Pyx_Generator_USED +#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType +#endif +#ifdef __Pyx_IterableCoroutine_USED +#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#define __pyx_ptype_7cpython_4type_type __pyx_mstate_global->__pyx_ptype_7cpython_4type_type +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#define __pyx_ptype_7cpython_4bool_bool __pyx_mstate_global->__pyx_ptype_7cpython_4bool_bool +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#define __pyx_ptype_7cpython_7complex_complex __pyx_mstate_global->__pyx_ptype_7cpython_7complex_complex +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#define __pyx_ptype_6hunter_6_event_Event __pyx_mstate_global->__pyx_ptype_6hunter_6_event_Event +#if CYTHON_USE_MODULE_STATE +#endif +#define __pyx_ptype_6hunter_11_predicates_Query __pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Query +#define __pyx_ptype_6hunter_11_predicates_And __pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_And +#define __pyx_ptype_6hunter_11_predicates_Or __pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Or +#define __pyx_ptype_6hunter_11_predicates_Not __pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Not +#define __pyx_ptype_6hunter_11_predicates_When __pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_When +#define __pyx_ptype_6hunter_11_predicates_From __pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_From +#define __pyx_ptype_6hunter_11_predicates_Backlog __pyx_mstate_global->__pyx_ptype_6hunter_11_predicates_Backlog +#if CYTHON_USE_MODULE_STATE +#define __pyx_type_6hunter_7_tracer_Tracer __pyx_mstate_global->__pyx_type_6hunter_7_tracer_Tracer +#endif +#define __pyx_ptype_6hunter_7_tracer_FrameType __pyx_mstate_global->__pyx_ptype_6hunter_7_tracer_FrameType +#define __pyx_ptype_6hunter_7_tracer_CodeType __pyx_mstate_global->__pyx_ptype_6hunter_7_tracer_CodeType +#define __pyx_ptype_6hunter_7_tracer_Tracer __pyx_mstate_global->__pyx_ptype_6hunter_7_tracer_Tracer +#define __pyx_kp_s_ __pyx_mstate_global->__pyx_kp_s_ +#define __pyx_kp_s_Disabling_tracer_because_handler __pyx_mstate_global->__pyx_kp_s_Disabling_tracer_because_handler +#define __pyx_n_s_Tracer __pyx_mstate_global->__pyx_n_s_Tracer +#define __pyx_n_s_Tracer___enter __pyx_mstate_global->__pyx_n_s_Tracer___enter +#define __pyx_n_s_Tracer___exit __pyx_mstate_global->__pyx_n_s_Tracer___exit +#define __pyx_n_s_Tracer___reduce_cython __pyx_mstate_global->__pyx_n_s_Tracer___reduce_cython +#define __pyx_n_s_Tracer___setstate_cython __pyx_mstate_global->__pyx_n_s_Tracer___setstate_cython +#define __pyx_n_s_Tracer_stop __pyx_mstate_global->__pyx_n_s_Tracer_stop +#define __pyx_n_s_Tracer_trace __pyx_mstate_global->__pyx_n_s_Tracer_trace +#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError +#define __pyx_n_s__14 __pyx_mstate_global->__pyx_n_s__14 +#define __pyx_n_s__8 __pyx_mstate_global->__pyx_n_s__8 +#define __pyx_n_s_all __pyx_mstate_global->__pyx_n_s_all +#define __pyx_n_s_arg __pyx_mstate_global->__pyx_n_s_arg +#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines +#define __pyx_n_s_c_call __pyx_mstate_global->__pyx_n_s_c_call +#define __pyx_n_s_c_exception __pyx_mstate_global->__pyx_n_s_c_exception +#define __pyx_n_s_c_return __pyx_mstate_global->__pyx_n_s_c_return +#define __pyx_n_s_call __pyx_mstate_global->__pyx_n_s_call +#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback +#define __pyx_n_s_default_stream __pyx_mstate_global->__pyx_n_s_default_stream +#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable +#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable +#define __pyx_n_s_enter __pyx_mstate_global->__pyx_n_s_enter +#define __pyx_n_s_exc_tb __pyx_mstate_global->__pyx_n_s_exc_tb +#define __pyx_n_s_exc_type __pyx_mstate_global->__pyx_n_s_exc_type +#define __pyx_n_s_exc_val __pyx_mstate_global->__pyx_n_s_exc_val +#define __pyx_n_s_exception __pyx_mstate_global->__pyx_n_s_exception +#define __pyx_n_s_exit __pyx_mstate_global->__pyx_n_s_exit +#define __pyx_n_s_f_trace __pyx_mstate_global->__pyx_n_s_f_trace +#define __pyx_n_s_file __pyx_mstate_global->__pyx_n_s_file +#define __pyx_n_s_frame __pyx_mstate_global->__pyx_n_s_frame +#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc +#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate +#define __pyx_kp_s_handler __pyx_mstate_global->__pyx_kp_s_handler +#define __pyx_n_s_hunter __pyx_mstate_global->__pyx_n_s_hunter +#define __pyx_n_s_hunter__tracer __pyx_mstate_global->__pyx_n_s_hunter__tracer +#define __pyx_kp_s_hunter__tracer_Tracer_at_0x_x_t __pyx_mstate_global->__pyx_kp_s_hunter__tracer_Tracer_at_0x_x_t +#define __pyx_n_s_id __pyx_mstate_global->__pyx_n_s_id +#define __pyx_n_s_import __pyx_mstate_global->__pyx_n_s_import +#define __pyx_n_s_initializing __pyx_mstate_global->__pyx_n_s_initializing +#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine +#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled +#define __pyx_n_s_kind __pyx_mstate_global->__pyx_n_s_kind +#define __pyx_n_s_line __pyx_mstate_global->__pyx_n_s_line +#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main +#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name +#define __pyx_kp_s_no_default___reduce___due_to_non __pyx_mstate_global->__pyx_kp_s_no_default___reduce___due_to_non +#define __pyx_n_s_predicate __pyx_mstate_global->__pyx_n_s_predicate +#define __pyx_kp_s_previous __pyx_mstate_global->__pyx_kp_s_previous +#define __pyx_n_s_print_exc __pyx_mstate_global->__pyx_n_s_print_exc +#define __pyx_n_s_profile_hook __pyx_mstate_global->__pyx_n_s_profile_hook +#define __pyx_n_s_profiling_mode __pyx_mstate_global->__pyx_n_s_profiling_mode +#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state +#define __pyx_n_s_pyx_vtable __pyx_mstate_global->__pyx_n_s_pyx_vtable +#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce +#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython +#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex +#define __pyx_n_s_return __pyx_mstate_global->__pyx_n_s_return +#define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self +#define __pyx_n_s_setprofile __pyx_mstate_global->__pyx_n_s_setprofile +#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate +#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython +#define __pyx_n_s_settrace __pyx_mstate_global->__pyx_n_s_settrace +#define __pyx_n_s_spec __pyx_mstate_global->__pyx_n_s_spec +#define __pyx_kp_s_src_hunter__tracer_pyx __pyx_mstate_global->__pyx_kp_s_src_hunter__tracer_pyx +#define __pyx_n_s_state __pyx_mstate_global->__pyx_n_s_state +#define __pyx_n_s_stop __pyx_mstate_global->__pyx_n_s_stop +#define __pyx_kp_s_stopped __pyx_mstate_global->__pyx_kp_s_stopped +#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource +#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test +#define __pyx_n_s_threading __pyx_mstate_global->__pyx_n_s_threading +#define __pyx_n_s_threading_support __pyx_mstate_global->__pyx_n_s_threading_support +#define __pyx_n_s_trace __pyx_mstate_global->__pyx_n_s_trace +#define __pyx_n_s_trace_hook __pyx_mstate_global->__pyx_n_s_trace_hook +#define __pyx_n_s_traceback __pyx_mstate_global->__pyx_n_s_traceback +#define __pyx_n_s_write __pyx_mstate_global->__pyx_n_s_write +#define __pyx_int_0 __pyx_mstate_global->__pyx_int_0 +#define __pyx_int_1 __pyx_mstate_global->__pyx_int_1 +#define __pyx_int_2 __pyx_mstate_global->__pyx_int_2 +#define __pyx_int_3 __pyx_mstate_global->__pyx_int_3 +#define __pyx_int_4 __pyx_mstate_global->__pyx_int_4 +#define __pyx_int_5 __pyx_mstate_global->__pyx_int_5 +#define __pyx_int_6 __pyx_mstate_global->__pyx_int_6 +#define __pyx_tuple__9 __pyx_mstate_global->__pyx_tuple__9 +#define __pyx_tuple__10 __pyx_mstate_global->__pyx_tuple__10 +#define __pyx_tuple__11 __pyx_mstate_global->__pyx_tuple__11 +#define __pyx_tuple__12 __pyx_mstate_global->__pyx_tuple__12 +#define __pyx_tuple__13 __pyx_mstate_global->__pyx_tuple__13 +#define __pyx_codeobj__2 __pyx_mstate_global->__pyx_codeobj__2 +#define __pyx_codeobj__3 __pyx_mstate_global->__pyx_codeobj__3 +#define __pyx_codeobj__4 __pyx_mstate_global->__pyx_codeobj__4 +#define __pyx_codeobj__5 __pyx_mstate_global->__pyx_codeobj__5 +#define __pyx_codeobj__6 __pyx_mstate_global->__pyx_codeobj__6 +#define __pyx_codeobj__7 __pyx_mstate_global->__pyx_codeobj__7 +/* #### Code section: module_code ### */ + +/* "cpython/complex.pxd":19 + * + * @property + * cdef inline double real(self) noexcept: # <<<<<<<<<<<<<< + * return self.cval.real * */ - __Pyx_TraceLine(27,0,__PYX_ERR(0, 27, __pyx_L1_error)) - Py_INCREF(((PyObject *)__pyx_v_self)); - /* "hunter/_tracer.pyx":28 - * Py_CLEAR(frame.f_trace) - * Py_INCREF(self) - * frame.f_trace = self # <<<<<<<<<<<<<< +static CYTHON_INLINE double __pyx_f_7cpython_7complex_7complex_4real_real(PyComplexObject *__pyx_v_self) { + double __pyx_r; + + /* "cpython/complex.pxd":20 + * @property + * cdef inline double real(self) noexcept: + * return self.cval.real # <<<<<<<<<<<<<< * - * handler = self.handler + * @property */ - __Pyx_TraceLine(28,0,__PYX_ERR(0, 28, __pyx_L1_error)) - __pyx_v_frame->f_trace = ((PyObject *)__pyx_v_self); + __pyx_r = __pyx_v_self->cval.real; + goto __pyx_L0; - /* "hunter/_tracer.pyx":25 + /* "cpython/complex.pxd":19 + * + * @property + * cdef inline double real(self) noexcept: # <<<<<<<<<<<<<< + * return self.cval.real * - * 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) */ - } - /* "hunter/_tracer.pyx":30 - * frame.f_trace = self + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "cpython/complex.pxd":23 * - * handler = self.handler # <<<<<<<<<<<<<< + * @property + * cdef inline double imag(self) noexcept: # <<<<<<<<<<<<<< + * return self.cval.imag * - * 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; - /* "hunter/_tracer.pyx":32 - * handler = self.handler - * - * if kind == 3 and self.depth > 0: # <<<<<<<<<<<<<< - * self.depth -= 1 +static CYTHON_INLINE double __pyx_f_7cpython_7complex_7complex_4imag_imag(PyComplexObject *__pyx_v_self) { + double __pyx_r; + + /* "cpython/complex.pxd":24 + * @property + * cdef inline double imag(self) noexcept: + * return self.cval.imag # <<<<<<<<<<<<<< * + * # PyTypeObject PyComplex_Type */ - __Pyx_TraceLine(32,0,__PYX_ERR(0, 32, __pyx_L1_error)) - __pyx_t_3 = ((__pyx_v_kind == 3) != 0); - if (__pyx_t_3) { - } else { - __pyx_t_1 = __pyx_t_3; - goto __pyx_L5_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_r = __pyx_v_self->cval.imag; + goto __pyx_L0; - /* "hunter/_tracer.pyx":33 + /* "cpython/complex.pxd":23 * - * if kind == 3 and self.depth > 0: - * self.depth -= 1 # <<<<<<<<<<<<<< + * @property + * cdef inline double imag(self) noexcept: # <<<<<<<<<<<<<< + * return self.cval.imag * - * 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)) - __pyx_v_self->depth = (__pyx_v_self->depth - 1); - /* "hunter/_tracer.pyx":32 - * handler = self.handler + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "cpython/contextvars.pxd":112 * - * if kind == 3 and self.depth > 0: # <<<<<<<<<<<<<< - * self.depth -= 1 * + * cdef inline object get_value(var, default_value=None): # <<<<<<<<<<<<<< + * """Return a new reference to the value of the context variable, + * or the default value of the context variable, */ + +static CYTHON_INLINE PyObject *__pyx_f_7cpython_11contextvars_get_value(PyObject *__pyx_v_var, struct __pyx_opt_args_7cpython_11contextvars_get_value *__pyx_optional_args) { + PyObject *__pyx_v_default_value = ((PyObject *)Py_None); + PyObject *__pyx_v_value; + PyObject *__pyx_v_pyvalue = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_value", 1); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_default_value = __pyx_optional_args->default_value; + } } - /* "hunter/_tracer.pyx":35 - * self.depth -= 1 - * - * cdef Event event = Event(frame, KIND_NAMES[kind], None if arg is NULL else arg, self) # <<<<<<<<<<<<<< - * - * try: + /* "cpython/contextvars.pxd":117 + * or None if no such value or default was found. + * """ + * cdef PyObject *value = NULL # <<<<<<<<<<<<<< + * PyContextVar_Get(var, NULL, &value) + * if value is NULL: */ - __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_v_value = NULL; + + /* "cpython/contextvars.pxd":118 + * """ + * cdef PyObject *value = NULL + * PyContextVar_Get(var, NULL, &value) # <<<<<<<<<<<<<< + * if value is NULL: + * # context variable does not have a default + */ + __pyx_t_1 = PyContextVar_Get(__pyx_v_var, NULL, (&__pyx_v_value)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(2, 118, __pyx_L1_error) + + /* "cpython/contextvars.pxd":119 + * cdef PyObject *value = NULL + * PyContextVar_Get(var, NULL, &value) + * if value is NULL: # <<<<<<<<<<<<<< + * # context variable does not have a default + * pyvalue = default_value + */ + __pyx_t_2 = (__pyx_v_value == NULL); + if (__pyx_t_2) { + + /* "cpython/contextvars.pxd":121 + * if value is NULL: + * # context variable does not have a default + * pyvalue = default_value # <<<<<<<<<<<<<< + * else: + * # value or default value of context variable + */ + __Pyx_INCREF(__pyx_v_default_value); + __pyx_v_pyvalue = __pyx_v_default_value; + + /* "cpython/contextvars.pxd":119 + * cdef PyObject *value = NULL + * PyContextVar_Get(var, NULL, &value) + * if value is NULL: # <<<<<<<<<<<<<< + * # context variable does not have a default + * pyvalue = default_value + */ + goto __pyx_L3; } - __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)) { - __Pyx_INCREF(Py_None); - __pyx_t_4 = Py_None; - } else { - __Pyx_INCREF(((PyObject *)__pyx_v_arg)); - __pyx_t_4 = ((PyObject *)__pyx_v_arg); + + /* "cpython/contextvars.pxd":124 + * else: + * # value or default value of context variable + * pyvalue = value # <<<<<<<<<<<<<< + * Py_XDECREF(value) # PyContextVar_Get() returned an owned reference as 'PyObject*' + * return pyvalue + */ + /*else*/ { + __pyx_t_3 = ((PyObject *)__pyx_v_value); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_pyvalue = __pyx_t_3; + __pyx_t_3 = 0; + + /* "cpython/contextvars.pxd":125 + * # value or default value of context variable + * pyvalue = value + * Py_XDECREF(value) # PyContextVar_Get() returned an owned reference as 'PyObject*' # <<<<<<<<<<<<<< + * return pyvalue + * + */ + Py_XDECREF(__pyx_v_value); } - __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_L3:; - /* "hunter/_tracer.pyx":37 - * cdef Event event = Event(frame, KIND_NAMES[kind], None if arg is NULL else arg, self) + /* "cpython/contextvars.pxd":126 + * pyvalue = value + * Py_XDECREF(value) # PyContextVar_Get() returned an owned reference as 'PyObject*' + * return pyvalue # <<<<<<<<<<<<<< + * * - * try: # <<<<<<<<<<<<<< - * fast_call(handler, event) - * except Exception as exc: */ - __Pyx_TraceLine(37,0,__PYX_ERR(0, 37, __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); - /*try:*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_pyvalue); + __pyx_r = __pyx_v_pyvalue; + goto __pyx_L0; - /* "hunter/_tracer.pyx":38 + /* "cpython/contextvars.pxd":112 * - * try: - * fast_call(handler, event) # <<<<<<<<<<<<<< - * except Exception as exc: - * traceback.print_exc(file=hunter._default_stream) + * + * cdef inline object get_value(var, default_value=None): # <<<<<<<<<<<<<< + * """Return a new reference to the value of the context variable, + * or the default value of the context variable, */ - __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; - /* "hunter/_tracer.pyx":37 - * cdef Event event = Event(frame, KIND_NAMES[kind], None if arg is NULL else arg, self) + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("cpython.contextvars.get_value", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_pyvalue); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cpython/contextvars.pxd":129 * - * try: # <<<<<<<<<<<<<< - * fast_call(handler, event) - * except Exception as exc: + * + * cdef inline object get_value_no_default(var, default_value=None): # <<<<<<<<<<<<<< + * """Return a new reference to the value of the context variable, + * or the provided default value if no such value was found. */ - } - __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; - /* "hunter/_tracer.pyx":39 - * try: - * fast_call(handler, event) +static CYTHON_INLINE PyObject *__pyx_f_7cpython_11contextvars_get_value_no_default(PyObject *__pyx_v_var, struct __pyx_opt_args_7cpython_11contextvars_get_value_no_default *__pyx_optional_args) { + PyObject *__pyx_v_default_value = ((PyObject *)Py_None); + PyObject *__pyx_v_value; + PyObject *__pyx_v_pyvalue = NULL; + PyObject *__pyx_r = NULL; + __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_RefNannySetupContext("get_value_no_default", 1); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_default_value = __pyx_optional_args->default_value; + } + } + + /* "cpython/contextvars.pxd":135 + * Ignores the default value of the context variable, if any. + * """ + * cdef PyObject *value = NULL # <<<<<<<<<<<<<< + * PyContextVar_Get(var, default_value, &value) + * # value of context variable or 'default_value' + */ + __pyx_v_value = NULL; + + /* "cpython/contextvars.pxd":136 + * """ + * cdef PyObject *value = NULL + * PyContextVar_Get(var, default_value, &value) # <<<<<<<<<<<<<< + * # value of context variable or 'default_value' + * pyvalue = value + */ + __pyx_t_1 = PyContextVar_Get(__pyx_v_var, ((PyObject *)__pyx_v_default_value), (&__pyx_v_value)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(2, 136, __pyx_L1_error) + + /* "cpython/contextvars.pxd":138 + * PyContextVar_Get(var, default_value, &value) + * # value of context variable or 'default_value' + * pyvalue = value # <<<<<<<<<<<<<< + * Py_XDECREF(value) # PyContextVar_Get() returned an owned reference as 'PyObject*' + * return pyvalue + */ + __pyx_t_2 = ((PyObject *)__pyx_v_value); + __Pyx_INCREF(__pyx_t_2); + __pyx_v_pyvalue = __pyx_t_2; + __pyx_t_2 = 0; + + /* "cpython/contextvars.pxd":139 + * # value of context variable or 'default_value' + * pyvalue = value + * Py_XDECREF(value) # PyContextVar_Get() returned an owned reference as 'PyObject*' # <<<<<<<<<<<<<< + * return pyvalue + */ + Py_XDECREF(__pyx_v_value); + + /* "cpython/contextvars.pxd":140 + * pyvalue = value + * Py_XDECREF(value) # PyContextVar_Get() returned an owned reference as 'PyObject*' + * return pyvalue # <<<<<<<<<<<<<< + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_pyvalue); + __pyx_r = __pyx_v_pyvalue; + goto __pyx_L0; + + /* "cpython/contextvars.pxd":129 + * + * + * cdef inline object get_value_no_default(var, default_value=None): # <<<<<<<<<<<<<< + * """Return a new reference to the value of the context variable, + * or the provided default value if no such value was found. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("cpython.contextvars.get_value_no_default", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_pyvalue); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/_tracer.pyx":25 + * } + * + * cdef inline int trace_func(Tracer self, FrameType frame, int kind, PyObject* arg) except -1: # <<<<<<<<<<<<<< + * if frame.f_trace is not self: + * frame.f_trace = self + */ + +static CYTHON_INLINE 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) { + 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_RefNannyDeclarations + 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_11 = NULL; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + int __pyx_t_14; + 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; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("trace_func", 1); + __Pyx_TraceCall("trace_func", __pyx_f[0], 25, 0, __PYX_ERR(0, 25, __pyx_L1_error)); + + /* "hunter/_tracer.pyx":26 + * + * cdef inline int trace_func(Tracer self, FrameType frame, int kind, PyObject* arg) except -1: + * if frame.f_trace is not self: # <<<<<<<<<<<<<< + * frame.f_trace = self + * + */ + __Pyx_TraceLine(26,0,__PYX_ERR(0, 26, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_frame), __pyx_n_s_f_trace); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__pyx_t_1 != ((PyObject *)__pyx_v_self)); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "hunter/_tracer.pyx":27 + * cdef inline int trace_func(Tracer self, FrameType frame, int kind, PyObject* arg) except -1: + * if frame.f_trace is not self: + * frame.f_trace = self # <<<<<<<<<<<<<< + * + * handler = self.handler + */ + __Pyx_TraceLine(27,0,__PYX_ERR(0, 27, __pyx_L1_error)) + if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_frame), __pyx_n_s_f_trace, ((PyObject *)__pyx_v_self)) < 0) __PYX_ERR(0, 27, __pyx_L1_error) + + /* "hunter/_tracer.pyx":26 + * + * cdef inline int trace_func(Tracer self, FrameType frame, int kind, PyObject* arg) except -1: + * if frame.f_trace is not self: # <<<<<<<<<<<<<< + * frame.f_trace = self + * + */ + } + + /* "hunter/_tracer.pyx":29 + * frame.f_trace = self + * + * handler = self.handler # <<<<<<<<<<<<<< + * + * if handler is None: # the tracer was stopped + */ + __Pyx_TraceLine(29,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,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,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,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_L5; + } + + /* "hunter/_tracer.pyx":36 + * PyEval_SetProfile(NULL, NULL) + * else: + * PyEval_SetTrace(NULL, NULL) # <<<<<<<<<<<<<< + * return 0 + * + */ + __Pyx_TraceLine(36,0,__PYX_ERR(0, 36, __pyx_L1_error)) + /*else*/ { + PyEval_SetTrace(NULL, NULL); + } + __pyx_L5:; + + /* "hunter/_tracer.pyx":37 + * else: + * PyEval_SetTrace(NULL, NULL) + * return 0 # <<<<<<<<<<<<<< + * + * if kind == 3 and self.depth > 0: + */ + __Pyx_TraceLine(37,0,__PYX_ERR(0, 37, __pyx_L1_error)) + __pyx_r = 0; + goto __pyx_L0; + + /* "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(39,0,__PYX_ERR(0, 39, __pyx_L1_error)) + __pyx_t_3 = (__pyx_v_kind == 3); + if (__pyx_t_3) { + } else { + __pyx_t_2 = __pyx_t_3; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_3 = (__pyx_v_self->depth > 0); + __pyx_t_2 = __pyx_t_3; + __pyx_L7_bool_binop_done:; + if (__pyx_t_2) { + + /* "hunter/_tracer.pyx":40 + * + * if kind == 3 and self.depth > 0: + * self.depth -= 1 # <<<<<<<<<<<<<< + * + * cdef Event event = Event(frame, kind, None if arg is NULL else arg, self) + */ + __Pyx_TraceLine(40,0,__PYX_ERR(0, 40, __pyx_L1_error)) + __pyx_v_self->depth = (__pyx_v_self->depth - 1); + + /* "hunter/_tracer.pyx":39 + * return 0 + * + * if kind == 3 and self.depth > 0: # <<<<<<<<<<<<<< + * self.depth -= 1 + * + */ + } + + /* "hunter/_tracer.pyx":42 + * self.depth -= 1 + * + * cdef Event event = Event(frame, kind, None if arg is NULL else arg, self) # <<<<<<<<<<<<<< + * + * try: + */ + __Pyx_TraceLine(42,0,__PYX_ERR(0, 42, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_kind); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__pyx_v_arg == NULL); + if (__pyx_t_2) { + __Pyx_INCREF(Py_None); + __pyx_t_4 = Py_None; + } else { + __Pyx_INCREF(((PyObject *)__pyx_v_arg)); + __pyx_t_4 = ((PyObject *)__pyx_v_arg); + } + __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF((PyObject *)__pyx_v_frame); + __Pyx_GIVEREF((PyObject *)__pyx_v_frame); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, ((PyObject *)__pyx_v_frame))) __PYX_ERR(0, 42, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1)) __PYX_ERR(0, 42, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_4)) __PYX_ERR(0, 42, __pyx_L1_error); + __Pyx_INCREF((PyObject *)__pyx_v_self); + __Pyx_GIVEREF((PyObject *)__pyx_v_self); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 3, ((PyObject *)__pyx_v_self))) __PYX_ERR(0, 42, __pyx_L1_error); + __pyx_t_1 = 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, 42, __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; + + /* "hunter/_tracer.pyx":44 + * cdef Event event = Event(frame, kind, None if arg is NULL else arg, self) + * + * try: # <<<<<<<<<<<<<< + * fast_call(handler, event) + * except Exception as exc: + */ + __Pyx_TraceLine(44,0,__PYX_ERR(0, 44, __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); + /*try:*/ { + + /* "hunter/_tracer.pyx":45 + * + * try: + * fast_call(handler, event) # <<<<<<<<<<<<<< + * except Exception as exc: + * traceback.print_exc(file=hunter._default_stream) + */ + __Pyx_TraceLine(45,0,__PYX_ERR(0, 45, __pyx_L9_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, 45, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "hunter/_tracer.pyx":44 + * cdef Event event = Event(frame, kind, None if arg is NULL else arg, self) + * + * try: # <<<<<<<<<<<<<< + * fast_call(handler, event) + * except Exception as exc: + */ + } + __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_L14_try_end; + __pyx_L9_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; + + /* "hunter/_tracer.pyx":46 + * 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( + * hunter._default_stream.write('Disabling tracer because handler %r failed (%r) at %r.\n\n' % ( */ - __Pyx_TraceLine(39,0,__PYX_ERR(0, 39, __pyx_L9_except_error)) + __Pyx_TraceLine(46,0,__PYX_ERR(0, 46, __pyx_L11_except_error)) __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_9) { __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); + if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_5, &__pyx_t_1) < 0) __PYX_ERR(0, 46, __pyx_L11_except_error) + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_v_exc = __pyx_t_5; /*try:*/ { - /* "hunter/_tracer.pyx":40 + /* "hunter/_tracer.pyx":47 * 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)) */ - __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_TraceLine(47,0,__PYX_ERR(0, 47, __pyx_L20_error)) + __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_traceback); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 47, __pyx_L20_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_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_print_exc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 47, __pyx_L20_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_t_10 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 47, __pyx_L20_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_GetModuleGlobalName(__pyx_t_12, __pyx_n_s_hunter); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 47, __pyx_L20_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_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_n_s_default_stream); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 47, __pyx_L20_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) + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_file, __pyx_t_13) < 0) __PYX_ERR(0, 47, __pyx_L20_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_t_13 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_empty_tuple, __pyx_t_10); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 47, __pyx_L20_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/_tracer.pyx":48 * 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_TraceLine(48,0,__PYX_ERR(0, 48, __pyx_L20_error)) + __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_hunter); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 48, __pyx_L20_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_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_default_stream); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 48, __pyx_L20_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_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_write); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 48, __pyx_L20_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 + /* "hunter/_tracer.pyx":49 * 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_TraceLine(49,0,__PYX_ERR(0, 49, __pyx_L20_error)) + __pyx_t_11 = PyTuple_New(3); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 49, __pyx_L20_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_INCREF(__pyx_v_handler); + __Pyx_GIVEREF(__pyx_v_handler); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_v_handler)) __PYX_ERR(0, 49, __pyx_L20_error); + __Pyx_INCREF(__pyx_v_exc); + __Pyx_GIVEREF(__pyx_v_exc); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_v_exc)) __PYX_ERR(0, 49, __pyx_L20_error); + __Pyx_INCREF((PyObject *)__pyx_v_event); + __Pyx_GIVEREF((PyObject *)__pyx_v_event); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_11, 2, ((PyObject *)__pyx_v_event))) __PYX_ERR(0, 49, __pyx_L20_error); + + /* "hunter/_tracer.pyx":48 + * 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(48,0,__PYX_ERR(0, 48, __pyx_L20_error)) + __pyx_t_12 = __Pyx_PyString_Format(__pyx_kp_s_Disabling_tracer_because_handler, __pyx_t_11); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 48, __pyx_L20_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_11 = 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); + #if CYTHON_UNPACK_METHODS + if (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_12, function); + __Pyx_DECREF_SET(__pyx_t_10, 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_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); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + PyObject *__pyx_callargs[2] = {__pyx_t_11, __pyx_t_12}; + __pyx_t_13 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+1-__pyx_t_9, 1+__pyx_t_9); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 48, __pyx_L20_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } - __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + + /* "hunter/_tracer.pyx":50 + * hunter._default_stream.write('Disabling tracer because handler %r failed (%r) at %r.\n\n' % ( + * handler, exc, event)) + * self.stop() # <<<<<<<<<<<<<< + * return 0 + * + */ + __Pyx_TraceLine(50,0,__PYX_ERR(0, 50, __pyx_L20_error)) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_stop); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 50, __pyx_L20_error) + __Pyx_GOTREF(__pyx_t_10); __pyx_t_12 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_10))) { + __pyx_t_9 = 0; + #if CYTHON_UNPACK_METHODS + if (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_9 = 1; } } - __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; + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, NULL}; + __pyx_t_13 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+1-__pyx_t_9, 0+__pyx_t_9); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 50, __pyx_L20_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)) - * self.stop() # <<<<<<<<<<<<<< - * return 0 + /* "hunter/_tracer.pyx":51 + * handler, exc, event)) + * self.stop() + * return 0 # <<<<<<<<<<<<<< * + * if kind == 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_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; - - /* "hunter/_tracer.pyx":44 - * handler, exc)) - * self.stop() - * return 0 # <<<<<<<<<<<<<< - * - * if kind == 0: - */ - __Pyx_TraceLine(44,0,__PYX_ERR(0, 44, __pyx_L18_error)) + __Pyx_TraceLine(51,0,__PYX_ERR(0, 51, __pyx_L20_error)) __pyx_r = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - goto __pyx_L17_return; + goto __pyx_L19_return; } - /* "hunter/_tracer.pyx":39 + /* "hunter/_tracer.pyx":46 * 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( + * hunter._default_stream.write('Disabling tracer because handler %r failed (%r) at %r.\n\n' % ( */ - __Pyx_TraceLine(39,0,__PYX_ERR(0, 39, __pyx_L18_error)) + __Pyx_TraceLine(46,0,__PYX_ERR(0, 46, __pyx_L20_error)) /*finally:*/ { - __pyx_L18_error:; + __pyx_L20_error:; /*exception exit:*/{ __Pyx_PyThreadState_declare __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_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_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_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); + if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_19, &__pyx_t_20, &__pyx_t_21); + if ((PY_MAJOR_VERSION < 3) || 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_XGOTREF(__pyx_t_23); - __pyx_t_9 = __pyx_lineno; __pyx_t_16 = __pyx_clineno; __pyx_t_17 = __pyx_filename; + __pyx_t_9 = __pyx_lineno; __pyx_t_14 = __pyx_clineno; __pyx_t_15 = __pyx_filename; { - __Pyx_DECREF(__pyx_v_exc); - __pyx_v_exc = NULL; + __Pyx_DECREF(__pyx_v_exc); __pyx_v_exc = 0; } if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_19); + __Pyx_XGIVEREF(__pyx_t_20); __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_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_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_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_9; __pyx_clineno = __pyx_t_14; __pyx_filename = __pyx_t_15; + goto __pyx_L11_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_L19_return: { + __pyx_t_14 = __pyx_r; + __Pyx_DECREF(__pyx_v_exc); __pyx_v_exc = 0; + __pyx_r = __pyx_t_14; + goto __pyx_L12_except_return; } } } - goto __pyx_L9_except_error; - __pyx_L9_except_error:; + goto __pyx_L11_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":44 + * cdef Event event = Event(frame, kind, None if arg is NULL else arg, self) * * try: # <<<<<<<<<<<<<< * fast_call(handler, event) * except Exception as exc: */ + __pyx_L11_except_error:; __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); goto __pyx_L1_error; - __pyx_L10_except_return:; + __pyx_L12_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); goto __pyx_L0; - __pyx_L12_try_end:; + __pyx_L14_try_end:; } - /* "hunter/_tracer.pyx":46 + /* "hunter/_tracer.pyx":53 * 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(53,0,__PYX_ERR(0, 53, __pyx_L1_error)) + __pyx_t_2 = (__pyx_v_kind == 0); + if (__pyx_t_2) { - /* "hunter/_tracer.pyx":47 + /* "hunter/_tracer.pyx":54 * * if kind == 0: * self.depth += 1 # <<<<<<<<<<<<<< * self.calls += 1 * */ - __Pyx_TraceLine(47,0,__PYX_ERR(0, 47, __pyx_L1_error)) + __Pyx_TraceLine(54,0,__PYX_ERR(0, 54, __pyx_L1_error)) __pyx_v_self->depth = (__pyx_v_self->depth + 1); - /* "hunter/_tracer.pyx":48 + /* "hunter/_tracer.pyx":55 * if kind == 0: * self.depth += 1 * self.calls += 1 # <<<<<<<<<<<<<< * * */ - __Pyx_TraceLine(48,0,__PYX_ERR(0, 48, __pyx_L1_error)) + __Pyx_TraceLine(55,0,__PYX_ERR(0, 55, __pyx_L1_error)) __pyx_v_self->calls = (__pyx_v_self->calls + 1); - /* "hunter/_tracer.pyx":46 + /* "hunter/_tracer.pyx":53 * return 0 * * if kind == 0: # <<<<<<<<<<<<<< @@ -2374,27 +4526,25 @@ static int __pyx_f_6hunter_7_tracer_trace_func(struct __pyx_obj_6hunter_7_tracer */ } - /* "hunter/_tracer.pyx":24 - * + /* "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) + * cdef inline int trace_func(Tracer self, FrameType frame, int kind, PyObject* arg) except -1: # <<<<<<<<<<<<<< + * if frame.f_trace is not self: + * frame.f_trace = self */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __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_15); __Pyx_AddTraceback("hunter._tracer.trace_func", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; @@ -2406,10 +4556,10 @@ static int __pyx_f_6hunter_7_tracer_trace_func(struct __pyx_obj_6hunter_7_tracer 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 */ @@ -2418,155 +4568,210 @@ static int __pyx_f_6hunter_7_tracer_trace_func(struct __pyx_obj_6hunter_7_tracer 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_MACROS + __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)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_threading_support,&__pyx_n_s_profiling_mode,0}; + values[0] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)Py_None)); + values[1] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)Py_False)); + if (__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); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { 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--; } + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_threading_support); + if (value) { values[0] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 59, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_profiling_mode); + if (value) { values[1] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 59, __pyx_L3_error) } } 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 (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(0, 59, __pyx_L3_error) } } 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_Arg_VARARGS(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } } __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:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(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 */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(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_RefNannyDeclarations - __Pyx_RefNannySetupContext("__cinit__", 0); - __Pyx_TraceCall("__cinit__", __pyx_f[0], 52, 0, __PYX_ERR(0, 52, __pyx_L1_error)); + int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__cinit__", 1); + __Pyx_TraceCall("__cinit__", __pyx_f[0], 59, 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,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,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,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 + * self.profiling_mode = profiling_mode */ - __Pyx_TraceLine(56,0,__PYX_ERR(0, 56, __pyx_L1_error)) + __Pyx_TraceLine(63,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,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,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,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,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 */ @@ -2583,19 +4788,21 @@ static int __pyx_pf_6hunter_7_tracer_6Tracer___cinit__(struct __pyx_obj_6hunter_ 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 */ @@ -2610,72 +4817,83 @@ static void __pyx_pf_6hunter_7_tracer_6Tracer_2__dealloc__(struct __pyx_obj_6hun PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; - __Pyx_RefNannySetupContext("__dealloc__", 0); - __Pyx_TraceCall("__dealloc__", __pyx_f[0], 61, 0, __PYX_ERR(0, 61, __pyx_L1_error)); + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__dealloc__", 1); + __Pyx_TraceCall("__dealloc__", __pyx_f[0], 69, 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,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,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_TraceLine(72,0,__PYX_ERR(0, 72, __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, 72, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (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_t_5 = 1; } } - __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; + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 72, __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 */ @@ -2690,7 +4908,7 @@ static void __pyx_pf_6hunter_7_tracer_6Tracer_2__dealloc__(struct __pyx_obj_6hun __Pyx_RefNannyFinishContext(); } -/* "hunter/_tracer.pyx":66 +/* "hunter/_tracer.pyx":74 * self.stop() * * def __repr__(self): # <<<<<<<<<<<<<< @@ -2701,9 +4919,11 @@ static void __pyx_pf_6hunter_7_tracer_6Tracer_2__dealloc__(struct __pyx_obj_6hun /* 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 */ @@ -2723,40 +4943,43 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_4__repr__(struct __pyx_obj_6h PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; - __Pyx_RefNannySetupContext("__repr__", 0); - __Pyx_TraceCall("__repr__", __pyx_f[0], 66, 0, __PYX_ERR(0, 66, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__repr__", 1); + __Pyx_TraceCall("__repr__", __pyx_f[0], 74, 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,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,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); - /* "hunter/_tracer.pyx":70 + /* "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_TraceLine(78,0,__PYX_ERR(0, 78, __pyx_L1_error)) __pyx_t_3 = (__pyx_v_self->handler == Py_None); - if ((__pyx_t_3 != 0)) { + if (__pyx_t_3) { __Pyx_INCREF(__pyx_kp_s_stopped); __pyx_t_2 = __pyx_kp_s_stopped; } else { @@ -2764,38 +4987,38 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_4__repr__(struct __pyx_obj_6h __pyx_t_2 = __pyx_kp_s_handler; } - /* "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_TraceLine(79,0,__PYX_ERR(0, 79, __pyx_L1_error)) __pyx_t_3 = (__pyx_v_self->handler == Py_None); - if ((__pyx_t_3 != 0)) { + if (__pyx_t_3) { __Pyx_INCREF(__pyx_kp_s_); __pyx_t_4 = __pyx_kp_s_; } 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_t_6 = PyObject_Repr(__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 79, __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; } - /* "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_TraceLine(80,0,__PYX_ERR(0, 80, __pyx_L1_error)) __pyx_t_3 = (__pyx_v_self->previous == Py_None); - if ((__pyx_t_3 != 0)) { + if (__pyx_t_3) { __Pyx_INCREF(__pyx_kp_s_); __pyx_t_6 = __pyx_kp_s_; } else { @@ -2803,73 +5026,73 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_4__repr__(struct __pyx_obj_6h __pyx_t_6 = __pyx_kp_s_previous; } - /* "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_TraceLine(81,0,__PYX_ERR(0, 81, __pyx_L1_error)) __pyx_t_3 = (__pyx_v_self->previous == Py_None); - if ((__pyx_t_3 != 0)) { + if (__pyx_t_3) { __Pyx_INCREF(__pyx_kp_s_); __pyx_t_5 = __pyx_kp_s_; } 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_t_8 = PyObject_Repr(__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 81, __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; } - /* "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_8 = PyTuple_New(6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 68, __pyx_L1_error) + __Pyx_TraceLine(76,0,__PYX_ERR(0, 76, __pyx_L1_error)) + __pyx_t_8 = PyTuple_New(6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 76, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_1)) __PYX_ERR(0, 76, __pyx_L1_error); __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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_v_self->threading_support)) __PYX_ERR(0, 76, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_2)) __PYX_ERR(0, 76, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_8, 3, __pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 3, __pyx_t_4)) __PYX_ERR(0, 76, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_8, 4, __pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 4, __pyx_t_6)) __PYX_ERR(0, 76, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_5); - PyTuple_SET_ITEM(__pyx_t_8, 5, __pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 5, __pyx_t_5)) __PYX_ERR(0, 76, __pyx_L1_error); __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_5 = 0; - /* "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_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_TraceLine(75,0,__PYX_ERR(0, 75, __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, 75, __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; goto __pyx_L0; - /* "hunter/_tracer.pyx":66 + /* "hunter/_tracer.pyx":74 * self.stop() * * def __repr__(self): # <<<<<<<<<<<<<< @@ -2895,12 +5118,12 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_4__repr__(struct __pyx_obj_6h 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 */ @@ -2909,68 +5132,110 @@ 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_MACROS + __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)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_frame,&__pyx_n_s_kind,&__pyx_n_s_arg,0}; + if (__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); + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_frame)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_frame)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 84, __pyx_L3_error) 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--; + if (likely((values[1] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_kind)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 84, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("__call__", 1, 3, 3, 1); __PYX_ERR(0, 76, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__call__", 1, 3, 3, 1); __PYX_ERR(0, 84, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_arg)) != 0)) kw_args--; + if (likely((values[2] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_arg)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 84, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("__call__", 1, 3, 3, 2); __PYX_ERR(0, 76, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__call__", 1, 3, 3, 2); __PYX_ERR(0, 84, __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 (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__call__") < 0)) __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_Arg_VARARGS(__pyx_args, 0); + values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); + values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); } __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:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(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), (&PyString_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; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2983,73 +5248,80 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_6__call__(struct __pyx_obj_6h int __pyx_t_2; int __pyx_t_3; int __pyx_t_4; - __Pyx_RefNannySetupContext("__call__", 0); - __Pyx_TraceCall("__call__", __pyx_f[0], 76, 0, __PYX_ERR(0, 76, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__call__", 1); + __Pyx_TraceCall("__call__", __pyx_f[0], 84, 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) + * 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(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) + __Pyx_TraceLine(85,0,__PYX_ERR(0, 85, __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, 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_PyInt_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) + __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, 85, __pyx_L1_error) - /* "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) + __Pyx_TraceLine(86,0,__PYX_ERR(0, 86, __pyx_L1_error)) + __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_v_kind, __pyx_int_0, Py_EQ)); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 86, __pyx_L1_error) if (__pyx_t_4) { - /* "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)) + __Pyx_TraceLine(87,0,__PYX_ERR(0, 87, __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) + /* "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,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); 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 */ @@ -3064,23 +5336,106 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_6__call__(struct __pyx_obj_6h 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*)(__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_MACROS + __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 **__pyx_pyargnames[] = {&__pyx_n_s_predicate,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_predicate)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 90, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "trace") < 0)) __PYX_ERR(0, 90, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __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:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(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 */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3092,227 +5447,429 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_8trace(struct __pyx_obj_6hunt __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; + int __pyx_t_6; Py_tracefunc __pyx_t_7; - __Pyx_RefNannySetupContext("trace", 0); - __Pyx_TraceCall("trace", __pyx_f[0], 82, 0, __PYX_ERR(0, 82, __pyx_L1_error)); - - /* "hunter/_tracer.pyx":83 + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__2) + __Pyx_RefNannySetupContext("trace", 1); + __Pyx_TraceCall("trace", __pyx_f[0], 90, 0, __PYX_ERR(0, 90, __pyx_L1_error)); + + /* "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) + * cdef PyThreadState *state = PyThreadState_Get() + * */ - __Pyx_TraceLine(84,0,__PYX_ERR(0, 84, __pyx_L1_error)) + __Pyx_TraceLine(91,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) + * cdef PyThreadState *state = PyThreadState_Get() # <<<<<<<<<<<<<< + * + * if self.profiling_mode: */ - __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) { + __Pyx_TraceLine(92,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,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 + /* "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(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); - } + __Pyx_TraceLine(95,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_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; + __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":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":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,0,__PYX_ERR(0, 96, __pyx_L1_error)) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_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_n_s_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":88 - * self._threading_previous = getattr(threading, '_trace_hook', None) - * threading.settrace(self) - * if state.c_traceobj is NULL: # <<<<<<<<<<<<<< - * self.previous = None - * self._previousfunc = NULL + /* "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(88,0,__PYX_ERR(0, 88, __pyx_L1_error)) - __pyx_t_1 = ((__pyx_v_state->c_traceobj == NULL) != 0); - if (__pyx_t_1) { + __Pyx_TraceLine(97,0,__PYX_ERR(0, 97, __pyx_L1_error)) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_threading); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_setprofile); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, ((PyObject *)__pyx_v_self)}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "hunter/_tracer.pyx":89 - * threading.settrace(self) - * if state.c_traceobj is NULL: - * self.previous = None # <<<<<<<<<<<<<< - * self._previousfunc = NULL - * else: + /* "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(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 # <<<<<<<<<<<<<< - * else: - * self.previous = (state.c_traceobj) + } + + /* "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(90,0,__PYX_ERR(0, 90, __pyx_L1_error)) - __pyx_v_self->_previousfunc = NULL; + __Pyx_TraceLine(98,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 + /* "hunter/_tracer.pyx":99 + * threading.setprofile(self) + * if state.c_profileobj is NULL: + * self.previous = None # <<<<<<<<<<<<<< + * self._previousfunc = NULL + * else: */ - goto __pyx_L6; - } + __Pyx_TraceLine(99,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":92 - * self._previousfunc = NULL - * else: - * self.previous = (state.c_traceobj) # <<<<<<<<<<<<<< - * self._previousfunc = state.c_tracefunc - * PyEval_SetTrace( trace_func, self) + /* "hunter/_tracer.pyx":100 + * if state.c_profileobj is NULL: + * self.previous = None + * self._previousfunc = NULL # <<<<<<<<<<<<<< + * else: + * self.previous = (state.c_profileobj) */ - __Pyx_TraceLine(92,0,__PYX_ERR(0, 92, __pyx_L1_error)) + __Pyx_TraceLine(100,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":102 + * self._previousfunc = NULL + * else: + * self.previous = (state.c_profileobj) # <<<<<<<<<<<<<< + * self._previousfunc = state.c_profilefunc + * PyEval_SetProfile( trace_func, self) + */ + __Pyx_TraceLine(102,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(103,0,__PYX_ERR(0, 103, __pyx_L1_error)) + __pyx_t_7 = __pyx_v_state->c_profilefunc; + __pyx_v_self->_previousfunc = __pyx_t_7; + } + __pyx_L7:; + + /* "hunter/_tracer.pyx":104 + * self.previous = (state.c_profileobj) + * self._previousfunc = state.c_profilefunc + * PyEval_SetProfile( trace_func, self) # <<<<<<<<<<<<<< + * else: + * if self.threading_support is None or self.threading_support: + */ + __Pyx_TraceLine(104,0,__PYX_ERR(0, 104, __pyx_L1_error)) + PyEval_SetProfile(((Py_tracefunc)__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":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) + */ + __Pyx_TraceLine(106,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; + __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,0,__PYX_ERR(0, 107, __pyx_L1_error)) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_threading); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 107, __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, 107, __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":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,0,__PYX_ERR(0, 108, __pyx_L1_error)) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_threading); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_settrace); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(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_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, ((PyObject *)__pyx_v_self)}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + 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_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "hunter/_tracer.pyx":93 + /* "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) + * 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,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,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,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,0,__PYX_ERR(0, 113, __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":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,0,__PYX_ERR(0, 114, __pyx_L1_error)) + __pyx_t_7 = __pyx_v_state->c_tracefunc; + __pyx_v_self->_previousfunc = __pyx_t_7; + } + __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,0,__PYX_ERR(0, 115, __pyx_L1_error)) + PyEval_SetTrace(((Py_tracefunc)__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,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); 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_AddTraceback("hunter._tracer.Tracer.trace", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -3322,20 +5879,48 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_8trace(struct __pyx_obj_6hunt 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*)(__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_MACROS + __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;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "stop", 0))) return NULL; __pyx_r = __pyx_pf_6hunter_7_tracer_6Tracer_10stop(((struct __pyx_obj_6hunter_7_tracer_Tracer *)__pyx_v_self)); /* function exit code */ @@ -3349,196 +5934,379 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_10stop(struct __pyx_obj_6hunt __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; - __Pyx_RefNannySetupContext("stop", 0); - __Pyx_TraceCall("stop", __pyx_f[0], 97, 0, __PYX_ERR(0, 97, __pyx_L1_error)); - - /* "hunter/_tracer.pyx":98 + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__3) + __Pyx_RefNannySetupContext("stop", 1); + __Pyx_TraceCall("stop", __pyx_f[0], 118, 0, __PYX_ERR(0, 118, __pyx_L1_error)); + + /* "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: */ - __Pyx_TraceLine(98,0,__PYX_ERR(0, 98, __pyx_L1_error)) + __Pyx_TraceLine(119,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) - * else: + * if self.profiling_mode: # <<<<<<<<<<<<<< + * if self.previous is None: + * PyEval_SetProfile(NULL, NULL) */ - __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(120,0,__PYX_ERR(0, 120, __pyx_L1_error)) + if (__pyx_v_self->profiling_mode) { - /* "hunter/_tracer.pyx":100 + /* "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,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,0,__PYX_ERR(0, 122, __pyx_L1_error)) + PyEval_SetProfile(NULL, NULL); + + /* "hunter/_tracer.pyx":121 * 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: + */ + 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,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,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,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,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: - * PyEval_SetTrace(self._previousfunc, self.previous) */ - __Pyx_TraceLine(100,0,__PYX_ERR(0, 100, __pyx_L1_error)) - PyEval_SetTrace(NULL, NULL); + __Pyx_TraceLine(128,0,__PYX_ERR(0, 128, __pyx_L1_error)) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_threading); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_setprofile); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (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; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_self->_threading_previous}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "hunter/_tracer.pyx":99 + /* "hunter/_tracer.pyx":129 + * if self.threading_support is None or self.threading_support: + * threading.setprofile(self._threading_previous) + * self._threading_previous = None # <<<<<<<<<<<<<< + * else: + * if self.previous is None: + */ + __Pyx_TraceLine(129,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":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 + * if self.previous is None: # <<<<<<<<<<<<<< + * PyEval_SetTrace(NULL, NULL) + * else: */ - __Pyx_TraceLine(102,0,__PYX_ERR(0, 102, __pyx_L1_error)) + __Pyx_TraceLine(131,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: + * if self.previous is None: + * PyEval_SetTrace(NULL, NULL) # <<<<<<<<<<<<<< + * else: + * PyEval_SetTrace(self._previousfunc, self.previous) */ - __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; + __Pyx_TraceLine(132,0,__PYX_ERR(0, 132, __pyx_L1_error)) + PyEval_SetTrace(NULL, NULL); - /* "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) + /* "hunter/_tracer.pyx":131 + * self._threading_previous = None + * else: + * if self.previous is None: # <<<<<<<<<<<<<< + * PyEval_SetTrace(NULL, NULL) + * else: */ - __Pyx_TraceLine(104,0,__PYX_ERR(0, 104, __pyx_L1_error)) - __pyx_v_self->_previousfunc = NULL; + goto __pyx_L9; + } - /* "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 + /* "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(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) { - - /* "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 + __Pyx_TraceLine(134,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,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,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,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,0,__PYX_ERR(0, 138, __pyx_L1_error)) + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_threading); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_settrace); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (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_6 = 1; + } } - } - __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_5, __pyx_v_self->_threading_previous}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__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_4); __pyx_t_4 = 0; + } + __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,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); 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_AddTraceback("hunter._tracer.Tracer.stop", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -3548,8 +6316,8 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_10stop(struct __pyx_obj_6hunt return __pyx_r; } -/* "hunter/_tracer.pyx":109 - * self._threading_previous = None +/* "hunter/_tracer.pyx":141 + * self._threading_previous = None * * def __enter__(self): # <<<<<<<<<<<<<< * return self @@ -3557,11 +6325,39 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_10stop(struct __pyx_obj_6hunt */ /* 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*)(__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_MACROS + __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;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__enter__", 0))) 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 */ @@ -3573,24 +6369,28 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_12__enter__(struct __pyx_obj_ PyObject *__pyx_r = NULL; __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__enter__", 0); - __Pyx_TraceCall("__enter__", __pyx_f[0], 109, 0, __PYX_ERR(0, 109, __pyx_L1_error)); - - /* "hunter/_tracer.pyx":110 + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__4) + __Pyx_RefNannySetupContext("__enter__", 1); + __Pyx_TraceCall("__enter__", __pyx_f[0], 141, 0, __PYX_ERR(0, 141, __pyx_L1_error)); + + /* "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,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); goto __pyx_L0; - /* "hunter/_tracer.pyx":109 - * self._threading_previous = None + /* "hunter/_tracer.pyx":141 + * self._threading_previous = None * * def __enter__(self): # <<<<<<<<<<<<<< * return self @@ -3608,7 +6408,7 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_12__enter__(struct __pyx_obj_ return __pyx_r; } -/* "hunter/_tracer.pyx":112 +/* "hunter/_tracer.pyx":144 * return self * * def __exit__(self, exc_type, exc_val, exc_tb): # <<<<<<<<<<<<<< @@ -3616,66 +6416,114 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_12__enter__(struct __pyx_obj_ */ /* 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*)(__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_MACROS + __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)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_exc_type,&__pyx_n_s_exc_val,&__pyx_n_s_exc_tb,0}; + if (__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); + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_exc_type)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_exc_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 144, __pyx_L3_error) 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--; + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_exc_val)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 144, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("__exit__", 1, 3, 3, 1); __PYX_ERR(0, 112, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__exit__", 1, 3, 3, 1); __PYX_ERR(0, 144, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_exc_tb)) != 0)) kw_args--; + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_exc_tb)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 144, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("__exit__", 1, 3, 3, 2); __PYX_ERR(0, 112, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__exit__", 1, 3, 3, 2); __PYX_ERR(0, 144, __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 (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__exit__") < 0)) __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_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); } __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:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("hunter._tracer.Tracer.__exit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -3683,6 +6531,12 @@ 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 */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3694,35 +6548,47 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_14__exit__(struct __pyx_obj_6 PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; - __Pyx_RefNannySetupContext("__exit__", 0); - __Pyx_TraceCall("__exit__", __pyx_f[0], 112, 0, __PYX_ERR(0, 112, __pyx_L1_error)); - - /* "hunter/_tracer.pyx":113 + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__5) + __Pyx_RefNannySetupContext("__exit__", 1); + __Pyx_TraceCall("__exit__", __pyx_f[0], 144, 0, __PYX_ERR(0, 144, __pyx_L1_error)); + + /* "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_TraceLine(145,0,__PYX_ERR(0, 145, __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, 145, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (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_t_4 = 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; + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 145, __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): # <<<<<<<<<<<<<< @@ -3745,7 +6611,7 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_14__exit__(struct __pyx_obj_6 return __pyx_r; } -/* "hunter/_tracer.pxd":30 +/* "hunter/_tracer.pxd":38 * cdef class Tracer: * cdef: * readonly object handler # <<<<<<<<<<<<<< @@ -3756,9 +6622,11 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_14__exit__(struct __pyx_obj_6 /* 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 */ @@ -3770,8 +6638,11 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_7handler___get__(struct __pyx PyObject *__pyx_r = NULL; __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[2], 30, 0, __PYX_ERR(2, 30, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[3], 38, 0, __PYX_ERR(3, 38, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->handler); __pyx_r = __pyx_v_self->handler; @@ -3788,20 +6659,22 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_7handler___get__(struct __pyx return __pyx_r; } -/* "hunter/_tracer.pxd":31 +/* "hunter/_tracer.pxd":39 * 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 */ @@ -3813,8 +6686,11 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_8previous___get__(struct __py PyObject *__pyx_r = NULL; __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[2], 31, 0, __PYX_ERR(2, 31, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[3], 39, 0, __PYX_ERR(3, 39, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->previous); __pyx_r = __pyx_v_self->previous; @@ -3831,20 +6707,22 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_8previous___get__(struct __py return __pyx_r; } -/* "hunter/_tracer.pxd":32 +/* "hunter/_tracer.pxd":40 * 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 */ @@ -3856,8 +6734,11 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_17threading_support___get__(s PyObject *__pyx_r = NULL; __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[2], 32, 0, __PYX_ERR(2, 32, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[3], 40, 0, __PYX_ERR(3, 40, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->threading_support); __pyx_r = __pyx_v_self->threading_support; @@ -3874,36 +6755,41 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_17threading_support___get__(s return __pyx_r; } -/* "hunter/_tracer.pxd":33 +/* "hunter/_tracer.pxd":41 * 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_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[2], 33, 0, __PYX_ERR(2, 33, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[3], 41, 0, __PYX_ERR(3, 41, __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(3, 41, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -3912,7 +6798,7 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_5depth___get__(struct __pyx_o /* 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_AddTraceback("hunter._tracer.Tracer.profiling_mode.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -3921,36 +6807,93 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_5depth___get__(struct __pyx_o return __pyx_r; } -/* "hunter/_tracer.pxd":34 +/* "hunter/_tracer.pxd":42 * 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_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[3], 42, 0, __PYX_ERR(3, 42, __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(3, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("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_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/_tracer.pxd":43 + * 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) { + 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_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_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[2], 34, 0, __PYX_ERR(2, 34, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[3], 43, 0, __PYX_ERR(3, 43, __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_PyInt_From_int(__pyx_v_self->calls); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 43, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -3968,7 +6911,7 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_5calls___get__(struct __pyx_o return __pyx_r; } -/* "hunter/_tracer.pxd":38 +/* "hunter/_tracer.pxd":47 * object __weakref__ * * readonly object _threading_previous # <<<<<<<<<<<<<< @@ -3978,9 +6921,11 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_5calls___get__(struct __pyx_o /* 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 */ @@ -3992,8 +6937,11 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_19_threading_previous___get__ PyObject *__pyx_r = NULL; __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); - __Pyx_TraceCall("__get__", __pyx_f[2], 38, 0, __PYX_ERR(2, 38, __pyx_L1_error)); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_TraceCall("__get__", __pyx_f[3], 47, 0, __PYX_ERR(3, 47, __pyx_L1_error)); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->_threading_previous); __pyx_r = __pyx_v_self->_threading_previous; @@ -4012,16 +6960,44 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_19_threading_previous___get__ /* "(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*)(__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_MACROS + __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;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) 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 */ @@ -4033,32 +7009,31 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_16__reduce_cython__(CYTHON_UN PyObject *__pyx_r = NULL; __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__reduce_cython__", 0); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__6) + __Pyx_RefNannySetupContext("__reduce_cython__", 1); __Pyx_TraceCall("__reduce_cython__", __pyx_f[1], 1, 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__") + * 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; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_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_AddTraceback("hunter._tracer.Tracer.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -4069,20 +7044,103 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_16__reduce_cython__(CYTHON_UN /* "(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*)(__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_MACROS + __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 **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __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:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(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 */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -4091,32 +7149,31 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_18__setstate_cython__(CYTHON_ PyObject *__pyx_r = NULL; __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__setstate_cython__", 0); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__7) + __Pyx_RefNannySetupContext("__setstate_cython__", 1); __Pyx_TraceCall("__setstate_cython__", __pyx_f[1], 3, 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__") # <<<<<<<<<<<<<< + * 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; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_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_AddTraceback("hunter._tracer.Tracer.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -4128,8 +7185,13 @@ static PyObject *__pyx_pf_6hunter_7_tracer_6Tracer_18__setstate_cython__(CYTHON_ 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,20 +7207,27 @@ 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 || CYTHON_COMPILING_IN_PYPY (*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) { @@ -4209,6 +7278,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); } @@ -4221,13 +7294,18 @@ static PyObject *__pyx_getprop_6hunter_7_tracer_6Tracer__threading_previous(PyOb return __pyx_pw_6hunter_7_tracer_6Tracer_19_threading_previous_1__get__(o); } +static PyObject *__pyx_specialmethod___pyx_pw_6hunter_7_tracer_6Tracer_5__repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + return __pyx_pw_6hunter_7_tracer_6Tracer_5__repr__(self); +} + 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}, + {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_pw_6hunter_7_tracer_6Tracer_5__repr__, METH_NOARGS|METH_COEXIST, 0}, + {"trace", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_7_tracer_6Tracer_9trace, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"stop", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_7_tracer_6Tracer_11stop, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__enter__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_7_tracer_6Tracer_13__enter__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__exit__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_7_tracer_6Tracer_15__exit__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_7_tracer_6Tracer_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_7_tracer_6Tracer_19__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {0, 0, 0, 0} }; @@ -4235,15 +7313,36 @@ 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 *)"profiling_mode", __pyx_getprop_6hunter_7_tracer_6Tracer_profiling_mode, 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}, {0, 0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +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}, + {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*/ @@ -4286,7 +7385,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*/ @@ -4300,51 +7401,30 @@ static PyTypeObject __pyx_type_6hunter_7_tracer_Tracer = { 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 + #endif + #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 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} }; - -#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 */ - #endif - __pyx_methods /* m_methods */, - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_moduledef_slots, /* m_slots */ - #else - NULL, /* m_reload */ - #endif - NULL, /* m_traverse */ - NULL, /* m_clear */ - NULL /* m_free */ -}; -#endif #ifndef CYTHON_SMALL_CODE #if defined(__clang__) #define CYTHON_SMALL_CODE @@ -4354,125 +7434,204 @@ static struct PyModuleDef __pyx_moduledef = { #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} -}; +/* #### Code section: pystring_table ### */ + +static int __Pyx_CreateStringTabAndInitStrings(void) { + __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_Tracer___enter, __pyx_k_Tracer___enter, sizeof(__pyx_k_Tracer___enter), 0, 0, 1, 1}, + {&__pyx_n_s_Tracer___exit, __pyx_k_Tracer___exit, sizeof(__pyx_k_Tracer___exit), 0, 0, 1, 1}, + {&__pyx_n_s_Tracer___reduce_cython, __pyx_k_Tracer___reduce_cython, sizeof(__pyx_k_Tracer___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Tracer___setstate_cython, __pyx_k_Tracer___setstate_cython, sizeof(__pyx_k_Tracer___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Tracer_stop, __pyx_k_Tracer_stop, sizeof(__pyx_k_Tracer_stop), 0, 0, 1, 1}, + {&__pyx_n_s_Tracer_trace, __pyx_k_Tracer_trace, sizeof(__pyx_k_Tracer_trace), 0, 0, 1, 1}, + {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, + {&__pyx_n_s__14, __pyx_k__14, sizeof(__pyx_k__14), 0, 0, 1, 1}, + {&__pyx_n_s__8, __pyx_k__8, sizeof(__pyx_k__8), 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_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 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_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0}, + {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0}, + {&__pyx_n_s_enter, __pyx_k_enter, sizeof(__pyx_k_enter), 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_exit, __pyx_k_exit, sizeof(__pyx_k_exit), 0, 0, 1, 1}, + {&__pyx_n_s_f_trace, __pyx_k_f_trace, sizeof(__pyx_k_f_trace), 0, 0, 1, 1}, + {&__pyx_n_s_file, __pyx_k_file, sizeof(__pyx_k_file), 0, 0, 1, 1}, + {&__pyx_n_s_frame, __pyx_k_frame, sizeof(__pyx_k_frame), 0, 0, 1, 1}, + {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0}, + {&__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_n_s_hunter__tracer, __pyx_k_hunter__tracer, sizeof(__pyx_k_hunter__tracer), 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_initializing, __pyx_k_initializing, sizeof(__pyx_k_initializing), 0, 0, 1, 1}, + {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1}, + {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0}, + {&__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_n_s_predicate, __pyx_k_predicate, sizeof(__pyx_k_predicate), 0, 0, 1, 1}, + {&__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_profile_hook, __pyx_k_profile_hook, sizeof(__pyx_k_profile_hook), 0, 0, 1, 1}, + {&__pyx_n_s_profiling_mode, __pyx_k_profiling_mode, sizeof(__pyx_k_profiling_mode), 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_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_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, + {&__pyx_n_s_setprofile, __pyx_k_setprofile, sizeof(__pyx_k_setprofile), 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_spec, __pyx_k_spec, sizeof(__pyx_k_spec), 0, 0, 1, 1}, + {&__pyx_kp_s_src_hunter__tracer_pyx, __pyx_k_src_hunter__tracer_pyx, sizeof(__pyx_k_src_hunter__tracer_pyx), 0, 0, 1, 0}, + {&__pyx_n_s_state, __pyx_k_state, sizeof(__pyx_k_state), 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_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 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, __pyx_k_trace, sizeof(__pyx_k_trace), 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} + }; + return __Pyx_InitStrings(__pyx_string_tab); +} +/* #### Code section: cached_builtins ### */ 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_id = __Pyx_GetBuiltinName(__pyx_n_s_id); if (!__pyx_builtin_id) __PYX_ERR(0, 76, __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; } +/* #### Code section: cached_constants ### */ 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__") + /* "hunter/_tracer.pyx":13 + * import hunter + * + * __all__ = 'Tracer', # <<<<<<<<<<<<<< + * + * cdef dict KIND_INTS = { */ - __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); + __pyx_tuple__9 = PyTuple_Pack(1, __pyx_n_s_Tracer); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__9); + __Pyx_GIVEREF(__pyx_tuple__9); - /* "(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__") # <<<<<<<<<<<<<< + /* "hunter/_tracer.pyx":90 + * return self + * + * def trace(self, predicate): # <<<<<<<<<<<<<< + * self.handler = predicate + * cdef PyThreadState *state = PyThreadState_Get() */ - __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); + __pyx_tuple__10 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_predicate, __pyx_n_s_state); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + __pyx_codeobj__2 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_hunter__tracer_pyx, __pyx_n_s_trace, 90, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__2)) __PYX_ERR(0, 90, __pyx_L1_error) - /* "hunter/_tracer.pyx":19 - * import hunter - * - * __all__ = 'Tracer', # <<<<<<<<<<<<<< + /* "hunter/_tracer.pyx":118 + * return self * - * cdef tuple KIND_NAMES = ('call', 'exception', 'line', 'return', 'c_call', 'c_exception', 'c_return') + * def stop(self): # <<<<<<<<<<<<<< + * if self.handler is not None: + * if self.profiling_mode: */ - __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); + __pyx_tuple__11 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 118, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__11); + __Pyx_GIVEREF(__pyx_tuple__11); + __pyx_codeobj__3 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 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__tracer_pyx, __pyx_n_s_stop, 118, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__3)) __PYX_ERR(0, 118, __pyx_L1_error) - /* "hunter/_tracer.pyx":21 - * __all__ = 'Tracer', + /* "hunter/_tracer.pyx":141 + * self._threading_previous = None * - * cdef tuple KIND_NAMES = ('call', 'exception', 'line', 'return', 'c_call', 'c_exception', 'c_return') # <<<<<<<<<<<<<< + * def __enter__(self): # <<<<<<<<<<<<<< + * return self * + */ + __pyx_codeobj__4 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 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__tracer_pyx, __pyx_n_s_enter, 141, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__4)) __PYX_ERR(0, 141, __pyx_L1_error) + + /* "hunter/_tracer.pyx":144 + * return self * + * def __exit__(self, exc_type, exc_val, exc_tb): # <<<<<<<<<<<<<< + * self.stop() + */ + __pyx_tuple__12 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_exc_type, __pyx_n_s_exc_val, __pyx_n_s_exc_tb); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__12); + __Pyx_GIVEREF(__pyx_tuple__12); + __pyx_codeobj__5 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 4, 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_src_hunter__tracer_pyx, __pyx_n_s_exit, 144, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__5)) __PYX_ERR(0, 144, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__6 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 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_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__6)) __PYX_ERR(1, 1, __pyx_L1_error) + + /* "(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_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_tuple__13 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_pyx_state); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__13); + __Pyx_GIVEREF(__pyx_tuple__13); + __pyx_codeobj__7 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__7)) __PYX_ERR(1, 3, __pyx_L1_error) __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); +/* #### Code section: init_constants ### */ + +static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) { + if (__Pyx_CreateStringTabAndInitStrings() < 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_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_4 = PyInt_FromLong(4); if (unlikely(!__pyx_int_4)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_5 = PyInt_FromLong(5); if (unlikely(!__pyx_int_5)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_6 = PyInt_FromLong(6); if (unlikely(!__pyx_int_6)) __PYX_ERR(0, 1, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } +/* #### Code section: init_globals ### */ + +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { + return 0; +} +/* #### Code section: init_module ### */ static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ @@ -4486,7 +7645,7 @@ static int __Pyx_modinit_global_init_code(void) { __Pyx_RefNannyDeclarations __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; } @@ -4510,25 +7669,39 @@ static int __Pyx_modinit_function_export_code(void) { static int __Pyx_modinit_type_init_code(void) { __Pyx_RefNannyDeclarations 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(3, 19, __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; - } - 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_FrameType = __Pyx_ImportType_3_0_10(__pyx_t_1, "types", "FrameType", sizeof(PyFrameObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyFrameObject),__Pyx_ImportType_CheckSize_Ignore_3_0_10); if (!__pyx_ptype_6hunter_7_tracer_FrameType) __PYX_ERR(3, 19, __pyx_L1_error) + __pyx_ptype_6hunter_7_tracer_CodeType = __Pyx_ImportType_3_0_10(__pyx_t_1, "types", "CodeType", sizeof(PyCodeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyCodeObject),__Pyx_ImportType_CheckSize_Ignore_3_0_10); if (!__pyx_ptype_6hunter_7_tracer_CodeType) __PYX_ERR(3, 22, __pyx_L1_error) + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_6hunter_7_tracer_Tracer = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6hunter_7_tracer_Tracer_spec, NULL); if (unlikely(!__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_ptype_6hunter_7_tracer_Tracer) < 0) __PYX_ERR(0, 58, __pyx_L1_error) + #else __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_ptype_6hunter_7_tracer_Tracer) < 0) __PYX_ERR(0, 58, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_6hunter_7_tracer_Tracer->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_6hunter_7_tracer_Tracer->tp_dictoffset && __pyx_ptype_6hunter_7_tracer_Tracer->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_6hunter_7_tracer_Tracer->tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Tracer, (PyObject *) __pyx_ptype_6hunter_7_tracer_Tracer) < 0) __PYX_ERR(0, 58, __pyx_L1_error) + if (__pyx_ptype_6hunter_7_tracer_Tracer->tp_weaklistoffset == 0) __pyx_ptype_6hunter_7_tracer_Tracer->tp_weaklistoffset = offsetof(struct __pyx_obj_6hunter_7_tracer_Tracer, __weakref__); + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_6hunter_7_tracer_Tracer) < 0) __PYX_ERR(0, 58, __pyx_L1_error) + #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; @@ -4541,49 +7714,45 @@ static int __Pyx_modinit_type_init_code(void) { static int __Pyx_modinit_type_import_code(void) { __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = 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(4, 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_ptype_7cpython_4type_type = __Pyx_ImportType_3_0_10(__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_0_10(PyTypeObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyTypeObject), #else - sizeof(PyHeapTypeObject), + sizeof(PyHeapTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyHeapTypeObject), #endif - __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(3, 9, __pyx_L1_error) + __Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(4, 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_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 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_ptype_7cpython_4bool_bool = __Pyx_ImportType_3_0_10(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "bool", sizeof(PyBoolObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyBoolObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_7cpython_4bool_bool) __PYX_ERR(5, 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_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 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_ptype_7cpython_7complex_complex = __Pyx_ImportType_3_0_10(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "complex", sizeof(PyComplexObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyComplexObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_7cpython_7complex_complex) __PYX_ERR(6, 15, __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("hunter._event"); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 13, __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_ptype_6hunter_6_event_Event = __Pyx_ImportType_3_0_10(__pyx_t_1, "hunter._event", "Event", sizeof(struct __pyx_obj_6hunter_6_event_Event), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_6hunter_6_event_Event),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_6hunter_6_event_Event) __PYX_ERR(7, 13, __pyx_L1_error) + __pyx_vtabptr_6hunter_6_event_Event = (struct __pyx_vtabstruct_6hunter_6_event_Event*)__Pyx_GetVtable(__pyx_ptype_6hunter_6_event_Event); if (unlikely(!__pyx_vtabptr_6hunter_6_event_Event)) __PYX_ERR(7, 13, __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_t_1 = PyImport_ImportModule("hunter._predicates"); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 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_ptype_6hunter_11_predicates_Query = __Pyx_ImportType_3_0_10(__pyx_t_1, "hunter._predicates", "Query", sizeof(struct __pyx_obj_6hunter_11_predicates_Query), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_6hunter_11_predicates_Query),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_6hunter_11_predicates_Query) __PYX_ERR(8, 8, __pyx_L1_error) + __pyx_ptype_6hunter_11_predicates_And = __Pyx_ImportType_3_0_10(__pyx_t_1, "hunter._predicates", "And", sizeof(struct __pyx_obj_6hunter_11_predicates_And), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_6hunter_11_predicates_And),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_6hunter_11_predicates_And) __PYX_ERR(8, 23, __pyx_L1_error) + __pyx_ptype_6hunter_11_predicates_Or = __Pyx_ImportType_3_0_10(__pyx_t_1, "hunter._predicates", "Or", sizeof(struct __pyx_obj_6hunter_11_predicates_Or), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_6hunter_11_predicates_Or),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_6hunter_11_predicates_Or) __PYX_ERR(8, 29, __pyx_L1_error) + __pyx_ptype_6hunter_11_predicates_Not = __Pyx_ImportType_3_0_10(__pyx_t_1, "hunter._predicates", "Not", sizeof(struct __pyx_obj_6hunter_11_predicates_Not), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_6hunter_11_predicates_Not),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_6hunter_11_predicates_Not) __PYX_ERR(8, 35, __pyx_L1_error) + __pyx_ptype_6hunter_11_predicates_When = __Pyx_ImportType_3_0_10(__pyx_t_1, "hunter._predicates", "When", sizeof(struct __pyx_obj_6hunter_11_predicates_When), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_6hunter_11_predicates_When),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_6hunter_11_predicates_When) __PYX_ERR(8, 41, __pyx_L1_error) + __pyx_ptype_6hunter_11_predicates_From = __Pyx_ImportType_3_0_10(__pyx_t_1, "hunter._predicates", "From", sizeof(struct __pyx_obj_6hunter_11_predicates_From), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_6hunter_11_predicates_From),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_6hunter_11_predicates_From) __PYX_ERR(8, 48, __pyx_L1_error) + __pyx_ptype_6hunter_11_predicates_Backlog = __Pyx_ImportType_3_0_10(__pyx_t_1, "hunter._predicates", "Backlog", sizeof(struct __pyx_obj_6hunter_11_predicates_Backlog), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_6hunter_11_predicates_Backlog),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_6hunter_11_predicates_Backlog) __PYX_ERR(8, 58, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; @@ -4604,11 +7773,15 @@ static int __Pyx_modinit_variable_import_code(void) { static int __Pyx_modinit_function_import_code(void) { __Pyx_RefNannyDeclarations 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_0_10(__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:; @@ -4618,17 +7791,68 @@ static int __Pyx_modinit_function_import_code(void) { } -#if PY_MAJOR_VERSION < 3 -#ifdef CYTHON_NO_PYINIT_EXPORT -#define __Pyx_PyMODINIT_FUNC void -#else +#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 + +#ifdef __cplusplus +namespace { + struct PyModuleDef __pyx_moduledef = + #else + static struct PyModuleDef __pyx_moduledef = + #endif + { + PyModuleDef_HEAD_INIT, + "_tracer", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #elif CYTHON_USE_MODULE_STATE + sizeof(__pyx_mstate), /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + #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 +#endif + +#ifndef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#elif PY_MAJOR_VERSION < 3 +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" void +#else +#define __Pyx_PyMODINIT_FUNC void #endif #else -#ifdef CYTHON_NO_PYINIT_EXPORT -#define __Pyx_PyMODINIT_FUNC PyObject * +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * #else -#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#define __Pyx_PyMODINIT_FUNC PyObject * #endif #endif @@ -4666,12 +7890,21 @@ 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) { +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none) +#else +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 +{ PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { if (allow_none || value != Py_None) { +#if CYTHON_COMPILING_IN_LIMITED_API + result = PyModule_AddObject(module, to_name, value); +#else result = PyDict_SetItemString(moddict, to_name, value); +#endif } Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { @@ -4681,8 +7914,9 @@ 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 (__Pyx_check_single_interpreter()) return NULL; if (__pyx_m) @@ -4692,8 +7926,12 @@ static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNU module = PyModule_NewObject(modname); Py_DECREF(modname); if (unlikely(!module)) goto bad; +#if CYTHON_COMPILING_IN_LIMITED_API + moddict = module; +#else moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; +#endif 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; @@ -4709,8 +7947,16 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec__tracer(PyObject *__pyx_pyinit_mod #endif #endif { + int stringtab_initialized = 0; + #if CYTHON_USE_MODULE_STATE + int pystate_addmodule_run = 0; + #endif __Pyx_TraceDeclarations 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) { @@ -4721,6 +7967,33 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec__tracer(PyObject *__pyx_pyinit_mod #elif PY_MAJOR_VERSION >= 3 if (__pyx_m) return __Pyx_NewRef(__pyx_m); #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); + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #elif CYTHON_USE_MODULE_STATE + __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + { + int add_module_result = PyState_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 = PyModule_Create(&__pyx_moduledef); + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #endif + CYTHON_UNUSED_VAR(__pyx_t_1); + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { @@ -4731,7 +8004,7 @@ if (!__Pyx_RefNanny) { } #endif __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit__tracer(void)", 0); - if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + 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 @@ -4739,50 +8012,31 @@ if (!__Pyx_RefNanny) { __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) + 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) + if (__pyx_AsyncGen_init(__pyx_m) < 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_StopAsyncIteration_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? */ + #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS 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_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + stringtab_initialized = 1; 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) @@ -4794,22 +8048,22 @@ if (!__Pyx_RefNanny) { { 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() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Constants init code ---*/ - if (__Pyx_InitCachedConstants() < 0) goto __pyx_L1_error; + if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Global type/function init code ---*/ (void)__Pyx_modinit_global_init_code(); (void)__Pyx_modinit_variable_export_code(); (void)__Pyx_modinit_function_export_code(); - if (unlikely(__Pyx_modinit_type_init_code() != 0)) goto __pyx_L1_error; - if (unlikely(__Pyx_modinit_type_import_code() != 0)) goto __pyx_L1_error; + if (unlikely((__Pyx_modinit_type_init_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_type_import_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error) (void)__Pyx_modinit_variable_import_code(); - if (unlikely(__Pyx_modinit_function_import_code() != 0)) goto __pyx_L1_error; + if (unlikely((__Pyx_modinit_function_import_code() < 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) @@ -4823,10 +8077,10 @@ if (!__Pyx_RefNanny) { * */ __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_t_2 = __Pyx_ImportDottedModule(__pyx_n_s_threading, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_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 @@ -4836,56 +8090,143 @@ if (!__Pyx_RefNanny) { * 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; + __pyx_t_2 = __Pyx_ImportDottedModule(__pyx_n_s_traceback, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_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":11 + * 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(11,0,__PYX_ERR(0, 11, __pyx_L1_error)) + __pyx_t_2 = __Pyx_ImportDottedModule(__pyx_n_s_hunter, NULL); 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_hunter, __pyx_t_2) < 0) __PYX_ERR(0, 11, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "hunter/_tracer.pyx":19 + /* "hunter/_tracer.pyx":13 * import hunter * * __all__ = 'Tracer', # <<<<<<<<<<<<<< * - * cdef tuple KIND_NAMES = ('call', 'exception', 'line', 'return', 'c_call', 'c_exception', 'c_return') + * cdef dict KIND_INTS = { */ - __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) + __Pyx_TraceLine(13,0,__PYX_ERR(0, 13, __pyx_L1_error)) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_all, __pyx_tuple__9) < 0) __PYX_ERR(0, 13, __pyx_L1_error) - /* "hunter/_tracer.pyx":21 - * __all__ = 'Tracer', + /* "hunter/_tracer.pyx":16 + * + * cdef dict KIND_INTS = { + * 'call': 0, # <<<<<<<<<<<<<< + * 'exception': 1, + * 'line': 2, + */ + __Pyx_TraceLine(16,0,__PYX_ERR(0, 16, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_call, __pyx_int_0) < 0) __PYX_ERR(0, 16, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_exception, __pyx_int_1) < 0) __PYX_ERR(0, 16, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_line, __pyx_int_2) < 0) __PYX_ERR(0, 16, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_return, __pyx_int_3) < 0) __PYX_ERR(0, 16, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_c_call, __pyx_int_4) < 0) __PYX_ERR(0, 16, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_c_exception, __pyx_int_5) < 0) __PYX_ERR(0, 16, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_c_return, __pyx_int_6) < 0) __PYX_ERR(0, 16, __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":25 + * } * - * cdef tuple KIND_NAMES = ('call', 'exception', 'line', 'return', 'c_call', 'c_exception', 'c_return') # <<<<<<<<<<<<<< + * cdef inline int trace_func(Tracer self, FrameType frame, int kind, PyObject* arg) except -1: # <<<<<<<<<<<<<< + * if frame.f_trace is not self: + * frame.f_trace = self + */ + __Pyx_TraceLine(25,0,__PYX_ERR(0, 25, __pyx_L1_error)) + + + /* "hunter/_tracer.pyx":90 + * return self * + * def trace(self, predicate): # <<<<<<<<<<<<<< + * self.handler = predicate + * cdef PyThreadState *state = PyThreadState_Get() + */ + __Pyx_TraceLine(90,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_n_s_Tracer_trace, NULL, __pyx_n_s_hunter__tracer, __pyx_d, ((PyObject *)__pyx_codeobj__2)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6hunter_7_tracer_Tracer, __pyx_n_s_trace, __pyx_t_2) < 0) __PYX_ERR(0, 90, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_6hunter_7_tracer_Tracer); + + /* "hunter/_tracer.pyx":118 + * return self * + * def stop(self): # <<<<<<<<<<<<<< + * if self.handler is not None: + * if self.profiling_mode: */ - __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); + __Pyx_TraceLine(118,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_n_s_Tracer_stop, NULL, __pyx_n_s_hunter__tracer, __pyx_d, ((PyObject *)__pyx_codeobj__3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 118, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6hunter_7_tracer_Tracer, __pyx_n_s_stop, __pyx_t_2) < 0) __PYX_ERR(0, 118, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_6hunter_7_tracer_Tracer); - /* "hunter/_tracer.pyx":24 + /* "hunter/_tracer.pyx":141 + * self._threading_previous = None + * + * def __enter__(self): # <<<<<<<<<<<<<< + * return self * + */ + __Pyx_TraceLine(141,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_n_s_Tracer___enter, NULL, __pyx_n_s_hunter__tracer, __pyx_d, ((PyObject *)__pyx_codeobj__4)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6hunter_7_tracer_Tracer, __pyx_n_s_enter, __pyx_t_2) < 0) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_6hunter_7_tracer_Tracer); + + /* "hunter/_tracer.pyx":144 + * 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) + * def __exit__(self, exc_type, exc_val, exc_tb): # <<<<<<<<<<<<<< + * self.stop() + */ + __Pyx_TraceLine(144,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_n_s_Tracer___exit, NULL, __pyx_n_s_hunter__tracer, __pyx_d, ((PyObject *)__pyx_codeobj__5)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6hunter_7_tracer_Tracer, __pyx_n_s_exit, __pyx_t_2) < 0) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_6hunter_7_tracer_Tracer); + + /* "(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(24,0,__PYX_ERR(0, 24, __pyx_L1_error)) + __Pyx_TraceLine(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_n_s_Tracer___reduce_cython, NULL, __pyx_n_s_hunter__tracer, __pyx_d, ((PyObject *)__pyx_codeobj__6)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_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,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_n_s_Tracer___setstate_cython, NULL, __pyx_n_s_hunter__tracer, __pyx_d, ((PyObject *)__pyx_codeobj__7)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_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 # <<<<<<<<<<<<<< @@ -4893,22 +8234,32 @@ if (!__Pyx_RefNanny) { * 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_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_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_TraceReturn(Py_None, 0); /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); if (__pyx_m) { - if (__pyx_d) { + if (__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"); } @@ -4922,6 +8273,22 @@ if (!__Pyx_RefNanny) { return; #endif } +/* #### 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 +8308,67 @@ 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)); +/* 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= 3 - "name '%U' is not defined", name); +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) { + int result; + PyObject *exc_type; +#if PY_VERSION_HEX >= 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,16 +8379,93 @@ 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); +#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 + +/* PyObjectGetAttrStrNoError */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 +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 >= 0x030d00A1 + (void) PyObject_GetOptionalAttr(obj, attr_name, &result); + return result; +#else +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 + 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_b, name); + if (unlikely(!result) && !PyErr_Occurred()) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); #endif + } + return result; +} /* Profile */ #if CYTHON_PROFILE @@ -5024,10 +8498,9 @@ static int __Pyx_TraceSetupAndCall(PyCodeObject** code, (*frame)->f_tstate = tstate; #endif } - __Pyx_PyFrame_SetLineNumber(*frame, firstlineno); + __Pyx_PyFrame_SetLineNumber(*frame, firstlineno); retval = 1; - tstate->tracing++; - tstate->use_tracing = 0; + __Pyx_EnterTracing(tstate); __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); #if CYTHON_TRACE if (tstate->c_tracefunc) @@ -5035,12 +8508,10 @@ static int __Pyx_TraceSetupAndCall(PyCodeObject** code, 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--; + __Pyx_LeaveTracing(tstate); if (retval) { __Pyx_ErrRestoreInState(tstate, type, value, traceback); - return tstate->use_tracing && retval; + return __Pyx_IsTracing(tstate, 0, 0) && retval; } else { Py_XDECREF(type); Py_XDECREF(value); @@ -5086,102 +8557,34 @@ static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const cha } #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; -} -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); - } - 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)); -#else - return PySequence_GetItem(o, i); +/* 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); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_setattr)) + return tp->tp_setattr(obj, PyString_AS_STRING(attr_name), value); #endif + return PyObject_SetAttr(obj, attr_name, value); } -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; - } - } - 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(); - } - } - return m->sq_item(o, i); - } - } -#else - if (is_list || PySequence_Check(o)) { - return PySequence_GetItem(o, i); - } #endif - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); -} /* 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 PY_MAJOR_VERSION < 3 if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + #endif result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { @@ -5194,12 +8597,12 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg #endif /* 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; @@ -5211,21 +8614,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; @@ -5246,55 +8674,43 @@ static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); + #endif } #endif -/* PyErrExceptionMatches */ +/* GetException */ #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= 0x030C00A6 + local_value = tstate->current_exception; + tstate->current_exception = 0; + if (likely(local_value)) { + local_type = (PyObject*) Py_TYPE(local_value); + Py_INCREF(local_type); + local_tb = PyException_GetTraceback(local_value); } - 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 - -/* 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, *local_value, *local_tb; -#if CYTHON_FAST_THREAD_STATE - PyObject *tmp_type, *tmp_value, *tmp_tb; + #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 #else PyErr_Fetch(&local_type, &local_value, &local_tb); #endif PyErr_NormalizeException(&local_type, &local_value, &local_tb); -#if CYTHON_FAST_THREAD_STATE +#if CYTHON_FAST_THREAD_STATE && PY_VERSION_HEX >= 0x030C00A6 + if (unlikely(tstate->current_exception)) +#elif CYTHON_FAST_THREAD_STATE if (unlikely(tstate->curexc_type)) #else if (unlikely(PyErr_Occurred())) @@ -5316,12 +8732,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; @@ -5383,7 +8808,7 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) { PyObject *result; #if !CYTHON_AVOID_BORROWED_REFS -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && PY_VERSION_HEX < 0x030d0000 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)) { @@ -5391,6 +8816,14 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) } else if (unlikely(PyErr_Occurred())) { return NULL; } +#elif CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(!__pyx_m)) { + return NULL; + } + result = PyObject_GetAttr(__pyx_m, name); + if (likely(result)) { + return result; + } #else result = PyDict_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) @@ -5410,7 +8843,7 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) } /* PyFunctionFastCall */ -#if CYTHON_FAST_PYCALL +#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, PyObject *globals) { PyFrameObject *f; @@ -5439,7 +8872,6 @@ static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args --tstate->recursion_depth; 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); @@ -5455,9 +8887,15 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, PyObject *result; assert(kwargs == NULL || PyDict_Check(kwargs)); nk = kwargs ? PyDict_Size(kwargs) : 0; - if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { + #if PY_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) { + return NULL; + } + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) { return NULL; } + #endif if ( #if PY_MAJOR_VERSION >= 3 co->co_kwonlyargcount == 0 && @@ -5526,69 +8964,21 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, 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: - 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); + cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); + self = __Pyx_CyOrPyCFunction_GET_SELF(func); + #if PY_MAJOR_VERSION < 3 if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + #endif result = cfunc(self, arg); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { @@ -5600,73 +8990,108 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject } #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); +/* PyObjectFastCall */ +#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API +static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **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; } -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); +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **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); } } - 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 PY_VERSION_HEX >= 0x030700A1 + if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) { + return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL); + } + #endif + #endif + #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { - return __Pyx_PyFunction_FastCall(func, NULL, 0); + return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs); } -#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); + #endif + #endif + if (kwargs == NULL) { + #if CYTHON_VECTORCALL + #if PY_VERSION_HEX < 0x03090000 + vectorcallfunc f = _PyVectorcall_Function(func); + #else + vectorcallfunc f = PyVectorcall_Function(func); + #endif + if (f) { + return f(func, args, (size_t)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, (size_t)nargs, NULL); } + #endif + } + if (nargs == 0) { + return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs); } - return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); + #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 } -#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 +9099,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,278 +9122,46 @@ 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 +/* TupleAndListFromArray */ +#if 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); + } } - -/* ParseKeywords */ -static int __Pyx_ParseOptionalKeywords( - PyObject *kwds, - PyObject **argnames[], - PyObject *kwds2, - PyObject *values[], - Py_ssize_t num_pos_args, - const char* function_name) +static CYTHON_INLINE PyObject * +__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) { - 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; + PyObject *res; + if (n <= 0) { + Py_INCREF(__pyx_empty_tuple); + return __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; } - -/* 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 CYTHON_INLINE PyObject * +__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n) { - 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"; + PyObject *res; + if (n <= 0) { + return PyList_New(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); + res = PyList_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n); + return res; } - -/* 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) { - 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 - __Pyx_PyThreadState_assign - __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); - if (full_traceback) { - Py_XINCREF(old_exc); - Py_XINCREF(old_val); - Py_XINCREF(old_tb); - __Pyx_ErrRestore(old_exc, old_val, old_tb); - PyErr_PrintEx(1); - } - #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); - } else { - 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; - } - 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; -} - -/* 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); - } -#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); - } - } - return __Pyx__CallUnboundCMethod1(cfunc, self, arg); -} -#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); - } -#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; -} /* 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 return PyObject_RichCompareBool(s1, s2, equals); #else if (s1 == s2) { @@ -5986,7 +9179,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,7 +9208,7 @@ 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 return PyObject_RichCompareBool(s1, s2, equals); #else #if PY_MAJOR_VERSION < 3 @@ -6115,85 +9308,519 @@ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int #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); +/* fastcall */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) +{ + Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames); + for (i = 0; i < n; i++) + { + if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i]; + } + for (i = 0; i < n; i++) + { + int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ); + if (unlikely(eq != 0)) { + if (unlikely(eq < 0)) return NULL; + return kwvalues[i]; + } + } + return NULL; } - -/* GetAttr3 */ -static PyObject *__Pyx_GetAttr3Default(PyObject *d) { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 +CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { + Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames); + PyObject *dict; + dict = PyDict_New(); + if (unlikely(!dict)) return NULL; - __Pyx_PyErr_Clear(); - Py_INCREF(d); - return d; + for (i=0; i= 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 } -/* 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; +/* ParseKeywords */ +static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject *const *kwvalues, + 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; + int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds)); + while (1) { + Py_XDECREF(key); key = NULL; + Py_XDECREF(value); value = NULL; + if (kwds_is_tuple) { + Py_ssize_t size; +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(kwds); +#else + size = PyTuple_Size(kwds); + if (size < 0) goto bad; +#endif + if (pos >= size) break; +#if CYTHON_AVOID_BORROWED_REFS + key = __Pyx_PySequence_ITEM(kwds, pos); + if (!key) goto bad; +#elif CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kwds, pos); +#else + key = PyTuple_GetItem(kwds, pos); + if (!key) goto bad; +#endif + value = kwvalues[pos]; + pos++; } - } - if (PyType_Check(type)) { -#if CYTHON_COMPILING_IN_PYPY - if (!value) { - Py_INCREF(Py_None); - value = Py_None; + else + { + if (!PyDict_Next(kwds, &pos, &key, &value)) break; +#if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(key); +#endif } + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; +#if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(value); + Py_DECREF(key); #endif - PyErr_NormalizeException(&type, &value, &tb); - } else { - if (value) { - PyErr_SetString(PyExc_TypeError, - "instance exception may not have a separate value"); - goto raise_error; + key = NULL; + value = NULL; + continue; } - 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_AVOID_BORROWED_REFS + Py_INCREF(key); +#endif + Py_INCREF(value); + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (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; +#if CYTHON_AVOID_BORROWED_REFS + value = NULL; +#endif + 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 = ( + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key) + ); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; +#if CYTHON_AVOID_BORROWED_REFS + value = NULL; +#endif + 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 + (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(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; } } - __Pyx_PyThreadState_assign - __Pyx_ErrRestore(type, value, tb); - return; -raise_error: + Py_XDECREF(key); Py_XDECREF(value); - Py_XDECREF(type); - Py_XDECREF(tb); - return; + 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: + #if PY_MAJOR_VERSION < 3 + PyErr_Format(PyExc_TypeError, + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + Py_XDECREF(key); + Py_XDECREF(value); + 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, 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(); + else state = (PyGILState_STATE)0; +#endif + 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) { + Py_XINCREF(old_exc); + Py_XINCREF(old_val); + Py_XINCREF(old_tb); + __Pyx_ErrRestore(old_exc, old_val, old_tb); + PyErr_PrintEx(1); + } + #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); + } else { + PyErr_WriteUnraisable(ctx); + Py_DECREF(ctx); + } +#ifdef WITH_THREAD + if (nogil) + PyGILState_Release(state); +#endif +} + +/* 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); +} + +/* ArgTypeTest */ +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +{ + __Pyx_TypeName type_name; + __Pyx_TypeName obj_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; + } + type_name = __Pyx_PyType_GetName(type); + obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME + ", got " __Pyx_FMT_TYPENAME ")", name, type_name, obj_type_name); + __Pyx_DECREF_TypeName(type_name); + __Pyx_DECREF_TypeName(obj_type_name); + return 0; +} + +/* 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_GetName(Py_TYPE(obj)); + type_name = __Pyx_PyType_GetName(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; +} + +/* DictGetItem */ +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { + PyObject *value; + value = PyDict_GetItemWithError(d, key); + if (unlikely(!value)) { + if (!PyErr_Occurred()) { + 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 NULL; + } + Py_INCREF(value); + return value; +} +#endif + +/* GetAttr3 */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 +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 >= 0x030d00A1 + int res = PyObject_GetOptionalAttr(o, n, &r); + return (res != 0) ? r : __Pyx_NewRef(d); +#else + #if CYTHON_USE_TYPE_SLOTS + if (likely(PyString_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 +} + +/* KeywordStringCheck */ +static int __Pyx_CheckKeywordStrings( + PyObject *kw, + const char* function_name, + int kw_allowed) +{ + PyObject* key = 0; + Py_ssize_t pos = 0; +#if CYTHON_COMPILING_IN_PYPY + if (!kw_allowed && PyDict_Next(kw, &pos, &key, 0)) + goto invalid_keyword; + return 1; +#else + if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) { + Py_ssize_t kwsize; +#if CYTHON_ASSUME_SAFE_MACROS + kwsize = PyTuple_GET_SIZE(kw); +#else + kwsize = PyTuple_Size(kw); + if (kwsize < 0) return 0; +#endif + if (unlikely(kwsize == 0)) + return 1; + if (!kw_allowed) { +#if CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kw, 0); +#else + key = PyTuple_GetItem(kw, pos); + if (!key) return 0; +#endif + goto invalid_keyword; + } +#if PY_VERSION_HEX < 0x03090000 + for (pos = 0; pos < kwsize; pos++) { +#if CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kw, pos); +#else + key = PyTuple_GetItem(kw, pos); + if (!key) return 0; +#endif + if (unlikely(!PyUnicode_Check(key))) + goto invalid_keyword_type; + } +#endif + return 1; + } + while (PyDict_Next(kw, &pos, &key, 0)) { + #if PY_MAJOR_VERSION < 3 + if (unlikely(!PyString_Check(key))) + #endif + if (unlikely(!PyUnicode_Check(key))) + goto invalid_keyword_type; + } + 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: + #if PY_MAJOR_VERSION < 3 + PyErr_Format(PyExc_TypeError, + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif + return 0; +} + +/* RaiseException */ +#if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + __Pyx_PyThreadState_declare + CYTHON_UNUSED_VAR(cause); + 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) { @@ -6280,13 +9907,9 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject } 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 + #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) { @@ -6294,274 +9917,1997 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject 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; +} +#endif + +/* TypeImport */ +#ifndef __PYX_HAVE_RT_ImportType_3_0_10 +#define __PYX_HAVE_RT_ImportType_3_0_10 +static PyTypeObject *__Pyx_ImportType_3_0_10(PyObject *module, const char *module_name, const char *class_name, + size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_10 check_size) +{ + PyObject *result = 0; + char warning[200]; + 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 + 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_0_10 && + ((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_0_10 && (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 (PyTypeObject *)result; +bad: + Py_XDECREF(result); + return NULL; +} +#endif + +/* FixUpExtensionType */ +#if CYTHON_USE_TYPE_SPECS +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) { +#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + CYTHON_UNUSED_VAR(spec); + CYTHON_UNUSED_VAR(type); +#else + const PyType_Slot *slot = spec->slots; + while (slot && slot->slot && slot->slot != Py_tp_members) + slot++; + if (slot && slot->slot == Py_tp_members) { + int changed = 0; +#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON) + const +#endif + PyMemberDef *memb = (PyMemberDef*) slot->pfunc; + while (memb && memb->name) { + if (memb->name[0] == '_' && memb->name[1] == '_') { +#if PY_VERSION_HEX < 0x030900b1 + 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 +#else + if ((0)); +#endif +#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON + 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; + if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) { + Py_DECREF(descr); + return -1; + } + Py_DECREF(descr); + changed = 1; + } +#endif + } + memb++; + } + if (changed) + PyType_Modified(type); + } +#endif + return 0; +} +#endif + +/* 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)) +#elif PY_MAJOR_VERSION >= 3 + #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 +#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; + } 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_GetName(tp); + PyErr_Format(PyExc_AttributeError, +#if PY_MAJOR_VERSION >= 3 + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, name); +#else + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", + type_name, PyString_AS_STRING(name)); +#endif + __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) { + 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; +} + +/* 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_MACROS + n = PyTuple_GET_SIZE(bases); +#else + n = PyTuple_Size(bases); + if (n < 0) return -1; +#endif + for (i = 1; i < n; i++) + { +#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 + PyTypeObject *b; +#if PY_MAJOR_VERSION < 3 + if (PyClass_Check(b0)) + { + PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class", + PyString_AS_STRING(((PyClassObject*)b0)->cl_name)); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } +#endif + b = (PyTypeObject*) b0; + if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) + { + __Pyx_TypeName b_name = __Pyx_PyType_GetName(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 || CYTHON_COMPILING_IN_PYPY + 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_GetName(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 || CYTHON_COMPILING_IN_PYPY) + 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 */ +static int __Pyx_PyType_Ready(PyTypeObject *t) { +#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || 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; + 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 PY_VERSION_HEX >= 0x03050000 && !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 PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) + gc = PyImport_GetModule(__pyx_kp_u_gc); + #endif + if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc); + if (unlikely(!gc)) return -1; + py_status = __Pyx_PyObject_CallMethod0(gc, __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_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 PY_VERSION_HEX >= 0x03050000 && !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_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 +} + +/* PyObject_GenericGetAttrNoDict */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { + __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp); + PyErr_Format(PyExc_AttributeError, +#if PY_MAJOR_VERSION >= 3 + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, attr_name); +#else + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", + type_name, PyString_AS_STRING(attr_name)); +#endif + __Pyx_DECREF_TypeName(type_name); + 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); + } + 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 descr; +} +#endif + +/* SetupReduce */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { + int ret; + PyObject *name_attr; + name_attr = __Pyx_PyObject_GetAttrStrNoError(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; +} +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_n_s_getstate); +#else + getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate); + if (!getstate && PyErr_Occurred()) { + goto __PYX_BAD; + } +#endif + if (getstate) { +#if CYTHON_USE_PYTYPE_LOOKUP + object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate); +#else + object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_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_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; +#else + object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; +#endif + reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_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_n_s_reduce); if (!object_reduce) goto __PYX_BAD; +#else + object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; +#endif + reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD; + if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { + reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython); + if (likely(reduce_cython)) { + ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_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_n_s_setstate); + if (!setstate) PyErr_Clear(); + if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { + setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); + if (likely(setstate_cython)) { + ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_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_GetName((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; +} +#endif + +/* GetVTable */ +static void* __Pyx_GetVtable(PyTypeObject *type) { + void* ptr; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *ob = PyObject_GetAttr((PyObject *)type, __pyx_n_s_pyx_vtable); +#else + PyObject *ob = PyObject_GetItem(type->tp_dict, __pyx_n_s_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; + #if PY_MAJOR_VERSION < 3 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (unlikely(!py_import)) + goto bad; + if (!from_list) { + empty_list = PyList_New(0); + if (unlikely(!empty_list)) + goto bad; + from_list = empty_list; + } + #endif + empty_dict = PyDict_New(); + if (unlikely(!empty_dict)) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if (strchr(__Pyx_MODULE_NAME, '.') != NULL) { + module = PyImport_ImportModuleLevelObject( + name, __pyx_d, empty_dict, from_list, 1); + if (unlikely(!module)) { + if (unlikely(!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 (unlikely(!py_level)) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, __pyx_d, empty_dict, from_list, py_level, (PyObject *)NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, __pyx_d, empty_dict, from_list, level); + #endif + } + } +bad: + Py_XDECREF(empty_dict); + Py_XDECREF(empty_list); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_import); + #endif + return module; +} + +/* ImportDottedModule */ +#if PY_MAJOR_VERSION >= 3 +static PyObject *__Pyx__ImportDottedModule_Error(PyObject *name, PyObject *parts_tuple, Py_ssize_t count) { + PyObject *partial_name = NULL, *slice = NULL, *sep = NULL; + if (unlikely(PyErr_Occurred())) { + PyErr_Clear(); + } + if (likely(PyTuple_GET_SIZE(parts_tuple) == 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( +#if PY_MAJOR_VERSION < 3 + PyExc_ImportError, + "No module named '%s'", PyString_AS_STRING(partial_name)); +#else +#if PY_VERSION_HEX >= 0x030600B1 + PyExc_ModuleNotFoundError, +#else + PyExc_ImportError, +#endif + "No module named '%U'", partial_name); +#endif +bad: + Py_XDECREF(sep); + Py_XDECREF(slice); + Py_XDECREF(partial_name); + return NULL; +} +#endif +#if PY_MAJOR_VERSION >= 3 +static PyObject *__Pyx__ImportDottedModule_Lookup(PyObject *name) { + PyObject *imported_module; +#if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) + 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; +} +#endif +#if PY_MAJOR_VERSION >= 3 +static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple) { + Py_ssize_t i, nparts; + nparts = PyTuple_GET_SIZE(parts_tuple); + 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 = PySequence_ITEM(parts_tuple, i); +#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; +} +#endif +static PyObject *__Pyx__ImportDottedModule(PyObject *name, PyObject *parts_tuple) { +#if PY_MAJOR_VERSION < 3 + PyObject *module, *from_list, *star = __pyx_n_s__8; + CYTHON_UNUSED_VAR(parts_tuple); + from_list = PyList_New(1); + if (unlikely(!from_list)) + return NULL; + Py_INCREF(star); + PyList_SET_ITEM(from_list, 0, star); + module = __Pyx_Import(name, from_list, 0); + Py_DECREF(from_list); + return module; +#else + 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); +#endif +} +static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030400B1 + PyObject *module = __Pyx__ImportDottedModule_Lookup(name); + if (likely(module)) { + PyObject *spec = __Pyx_PyObject_GetAttrStrNoError(module, __pyx_n_s_spec); + if (likely(spec)) { + PyObject *unsafe = __Pyx_PyObject_GetAttrStrNoError(spec, __pyx_n_s_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((char*) __PYX_ABI_MODULE_NAME); +} + +/* FetchCommonType */ +static int __Pyx_VerifyCachedType(PyObject *cached_type, + const char *name, + Py_ssize_t basicsize, + Py_ssize_t expected_basicsize) { + if (!PyType_Check(cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", name); + return -1; + } + if (basicsize != expected_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + name); + return -1; + } + return 0; +} +#if !CYTHON_USE_TYPE_SPECS +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { + PyObject* abi_module; + const char* object_name; + PyTypeObject *cached_type = NULL; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) return NULL; + object_name = strrchr(type->tp_name, '.'); + object_name = object_name ? object_name+1 : type->tp_name; + cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name); + if (cached_type) { + if (__Pyx_VerifyCachedType( + (PyObject *)cached_type, + object_name, + cached_type->tp_basicsize, + type->tp_basicsize) < 0) { + goto bad; + } + goto done; + } + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + if (PyType_Ready(type) < 0) goto bad; + if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0) + goto bad; + Py_INCREF(type); + cached_type = type; +done: + Py_DECREF(abi_module); + return cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} +#else +static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *abi_module, *cached_type = NULL; + const char* object_name = strrchr(spec->name, '.'); + object_name = object_name ? object_name+1 : spec->name; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) return NULL; + cached_type = PyObject_GetAttrString(abi_module, object_name); + if (cached_type) { + Py_ssize_t basicsize; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_basicsize; + py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); + if (unlikely(!py_basicsize)) goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; +#else + basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1; +#endif + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + basicsize, + spec->basicsize) < 0) { + goto bad; + } + goto done; + } + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + CYTHON_UNUSED_VAR(module); + cached_type = __Pyx_PyType_FromModuleAndSpec(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; + if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad; +done: + Py_DECREF(abi_module); + assert(cached_type == NULL || PyType_Check(cached_type)); + return (PyTypeObject *) cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} +#endif + +/* PyVectorcallFastCallDict */ +#if CYTHON_METH_FASTCALL +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; + Py_ssize_t nkw = PyDict_GET_SIZE(kw); + 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 &= Py_TYPE(key)->tp_flags; + Py_INCREF(key); + Py_INCREF(value); + PyTuple_SET_ITEM(kwnames, i, key); + 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) +{ + if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) { + return vc(func, args, nargs, NULL); + } + return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); +} +#endif + +/* CythonFunctionShared */ +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { + 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; +} +#else +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { + 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(__pyx_CyFunctionObject *op, void *closure) +{ + CYTHON_UNUSED_VAR(closure); + 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) { +#if PY_MAJOR_VERSION >= 3 + op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); +#else + op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); +#endif + 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 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_Py_XDECREF_SET(op->func_doc, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(op->func_name == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_name = PyObject_GetAttrString(op->func, "__name__"); +#elif PY_MAJOR_VERSION >= 3 + op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); +#else + op->func_name = PyString_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 int +__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) +#else + if (unlikely(value == NULL || !PyString_Check(value))) +#endif + { + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_name, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + Py_INCREF(op->func_qualname); + return op->func_qualname; +} +static int +__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) +#else + if (unlikely(value == NULL || !PyString_Check(value))) +#endif + { + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_qualname, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(op->func_dict == NULL)) { + op->func_dict = PyDict_New(); + if (unlikely(op->func_dict == NULL)) + return NULL; + } + Py_INCREF(op->func_dict); + return op->func_dict; +} +static int +__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, 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_Py_XDECREF_SET(op->func_dict, value); + 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_Py_XDECREF_SET(op->defaults_tuple, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->defaults_tuple; + CYTHON_UNUSED_VAR(context); + 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 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_Py_XDECREF_SET(op->defaults_kwdict, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->defaults_kwdict; + CYTHON_UNUSED_VAR(context); + 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 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_Py_XDECREF_SET(op->func_annotations, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->func_annotations; + CYTHON_UNUSED_VAR(context); + 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_is_coroutine(__pyx_CyFunctionObject *op, void *context) { + int is_coroutine; + CYTHON_UNUSED_VAR(context); + if (op->func_is_coroutine) { + return __Pyx_NewRef(op->func_is_coroutine); + } + is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; +#if PY_VERSION_HEX >= 0x03050000 + if (is_coroutine) { + PyObject *module, *fromlist, *marker = __pyx_n_s_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_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0); + Py_DECREF(fromlist); + if (unlikely(!module)) goto ignore; + op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker); + Py_DECREF(module); + if (likely(op->func_is_coroutine)) { + return __Pyx_NewRef(op->func_is_coroutine); + } +ignore: + PyErr_Clear(); + } +#endif + op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine); + return __Pyx_NewRef(op->func_is_coroutine); +} +#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[] = { + {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, + {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {(char *) "_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 + {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, +#endif +#if CYTHON_USE_TYPE_SPECS + {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, +#if CYTHON_METH_FASTCALL +#if CYTHON_BACKPORT_VECTORCALL + {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, +#else +#if !CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, +#endif +#endif +#endif +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, +#else + {(char *) "__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) +{ + CYTHON_UNUSED_VAR(args); +#if PY_MAJOR_VERSION >= 3 + Py_INCREF(m->func_qualname); + return m->func_qualname; +#else + return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name); +#endif +} +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} +}; +#if PY_VERSION_HEX < 0x030500A0 || 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_pyobjects = 0; + op->defaults_size = 0; + 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 + 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); + } +#endif +#endif + Py_CLEAR(m->defaults_tuple); + Py_CLEAR(m->defaults_kwdict); + Py_CLEAR(m->func_annotations); + Py_CLEAR(m->func_is_coroutine); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_XDECREF(pydefaults[i]); + PyObject_Free(m->defaults); + m->defaults = NULL; + } + return 0; +} +static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + if (__Pyx_CyFunction_weakreflist(m) != NULL) + PyObject_ClearWeakRefs((PyObject *) m); + __Pyx_CyFunction_clear(m); + __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) +{ + 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); + Py_VISIT(m->func_name); + Py_VISIT(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + Py_VISIT(m->func_code); +#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); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_VISIT(pydefaults[i]); + } + return 0; +} +static PyObject* +__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) +{ +#if PY_MAJOR_VERSION >= 3 + return PyUnicode_FromFormat("", + op->func_qualname, (void *)op); +#else + return PyString_FromFormat("", + PyString_AsString(op->func_qualname), (void *)op); +#endif +} +static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *f = ((__pyx_CyFunctionObject*)func)->func; + PyObject *py_name = NULL; + 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*)meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_MACROS + 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); +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, + "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, size); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); +#endif + return NULL; + } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_MACROS + 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; + } +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, + "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, size); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); #endif + return NULL; + } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + return NULL; } -bad: - Py_XDECREF(owned_instance); - return; +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments", + py_name); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", + f->m_ml->ml_name); +#endif + 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 + self = ((PyCFunctionObject*)func)->m_self; #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) -{ - PyObject *result = 0; - char warning[200]; - Py_ssize_t basicsize; -#ifdef Py_LIMITED_API - PyObject *py_basicsize; + 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 + __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); + if (vc) { +#if CYTHON_ASSUME_SAFE_MACROS + 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 - 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; +#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_MACROS + argc = PyTuple_GET_SIZE(args); #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; + argc = PyTuple_Size(args); + if (unlikely(!argc) < 0) 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; + 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); +#if PY_MAJOR_VERSION > 2 + PyErr_Format(PyExc_TypeError, + "unbound method %.200S() needs an argument", + cyfunc->func_qualname); +#else + PyErr_SetString(PyExc_TypeError, + "unbound method needs an argument"); +#endif + return NULL; + } + result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); + Py_DECREF(new_args); + } else { + result = __Pyx_CyFunction_Call(func, args, kw); } - 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 result; +} +#if CYTHON_METH_FASTCALL +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)) { + PyErr_Format(PyExc_TypeError, "%.200s() needs an argument", + ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); + return -1; + } + ret = 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; + if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); + return -1; } - return (PyTypeObject *)result; -bad: - Py_XDECREF(result); - return NULL; + return ret; } -#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 PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#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)); -#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); + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; } - assert(!tp->tp_dictoffset); - descr = _PyType_Lookup(tp, attr_name); - if (unlikely(!descr)) { - return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); + if (unlikely(nargs != 0)) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + def->ml_name, nargs); + 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; - } + return def->ml_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; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; } - return descr; + if (unlikely(nargs != 1)) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + def->ml_name, nargs); + return NULL; + } + return def->ml_meth(self, args[0]); } -#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; +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames); } -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_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; + PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc); +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; #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; + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames); +} +#endif +#if CYTHON_USE_TYPE_SPECS +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 (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL) + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + __pyx_CyFunctionType_slots +}; #else - object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto BAD; +static PyTypeObject __pyx_CyFunctionType_type = { + PyVarObject_HEAD_INIT(0, 0) + __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, + (destructor) __Pyx_CyFunction_dealloc, +#if !CYTHON_METH_FASTCALL + 0, +#elif CYTHON_BACKPORT_VECTORCALL + (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall), +#else + offsetof(PyCFunctionObject, vectorcall), #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; + 0, + 0, +#if PY_MAJOR_VERSION < 3 + 0, #else - object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto BAD; + 0, +#endif + (reprfunc) __Pyx_CyFunction_repr, + 0, + 0, + 0, + 0, + __Pyx_CyFunction_CallAsMethod, + 0, + 0, + 0, + 0, +#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR + Py_TPFLAGS_METHOD_DESCRIPTOR | +#endif +#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + 0, + (traverseproc) __Pyx_CyFunction_traverse, + (inquiry) __Pyx_CyFunction_clear, + 0, +#if PY_VERSION_HEX < 0x030500A0 + offsetof(__pyx_CyFunctionObject, func_weakreflist), +#else + offsetof(PyCFunctionObject, m_weakreflist), +#endif + 0, + 0, + __pyx_CyFunction_methods, + __pyx_CyFunction_members, + __pyx_CyFunction_getsets, + 0, + 0, + __Pyx_PyMethod_New, + 0, + offsetof(__pyx_CyFunctionObject, func_dict), + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX >= 0x030400a1 + 0, +#endif +#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, +#endif +#if __PYX_NEED_TP_PRINT_SLOT + 0, +#endif +#if PY_VERSION_HEX >= 0x030C0000 + 0, +#endif +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, #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; -} - -/* 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 int __pyx_CyFunction_init(PyObject *module) { +#if CYTHON_USE_TYPE_SPECS + __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL); #else - ptr = PyCObject_AsVoidPtr(ob); + CYTHON_UNUSED_VAR(module); + __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); #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; -} - -/* 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; + if (unlikely(__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 void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults = PyObject_Malloc(size); + if (unlikely(!m->defaults)) + return PyErr_NoMemory(); + memset(m->defaults, 0, size); + m->defaults_pyobjects = pyobjects; + m->defaults_size = size; + 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_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 */ @@ -6572,6 +11918,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif + CYTHON_MAYBE_UNUSED_VAR(tstate); if (unlikely(!__pyx_cython_runtime)) { return c_line; } @@ -6585,7 +11932,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { } 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_cython_runtime, __pyx_n_s_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; Py_DECREF(use_cline_obj); @@ -6596,7 +11943,7 @@ 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_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); } else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { c_line = 0; @@ -6607,6 +11954,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { #endif /* CodeObjectCache */ +#if !CYTHON_COMPILING_IN_LIMITED_API static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { @@ -6670,7 +12018,7 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { if (__pyx_code_cache.count == __pyx_code_cache.max_count) { int new_max = __pyx_code_cache.max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( - __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); + __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } @@ -6685,44 +12033,136 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { __pyx_code_cache.count++; Py_INCREF(code_object); } +#endif /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API + #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; + result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict); + Py_DECREF(replace); + return result; + } + PyErr_Clear(); + #if __PYX_LIMITED_VERSION_HEX < 0x030780000 + { + PyObject *compiled = NULL, *result = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL; + compiled = Py_CompileString( + "out = type(code)(\n" + " code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n" + " code.co_flags, code.co_code, code.co_consts, code.co_names,\n" + " code.co_varnames, code.co_filename, co_name, co_firstlineno,\n" + " code.co_lnotab)\n", "", Py_file_input); + if (!compiled) return NULL; + result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict); + Py_DECREF(compiled); + if (!result) PyErr_Print(); + Py_DECREF(result); + result = PyDict_GetItemString(scratch_dict, "out"); + if (result) Py_INCREF(result); + return result; + } + #else + return NULL; + #endif +} +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 = 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; + 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; + PyCodeObject *py_code = NULL; + PyObject *py_funcname = NULL; #if PY_MAJOR_VERSION < 3 + PyObject *py_srcfile = NULL; py_srcfile = PyString_FromString(filename); - #else - py_srcfile = PyUnicode_FromString(filename); - #endif if (!py_srcfile) goto bad; + #endif if (c_line) { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + if (!py_funcname) goto bad; #else py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + if (!py_funcname) goto bad; + funcname = PyUnicode_AsUTF8(py_funcname); + if (!funcname) goto bad; #endif } else { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromString(funcname); - #else - py_funcname = PyUnicode_FromString(funcname); + if (!py_funcname) goto bad; #endif } - if (!py_funcname) goto bad; + #if PY_MAJOR_VERSION < 3 py_code = __Pyx_PyCode_New( 0, 0, 0, 0, 0, + 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ @@ -6735,11 +12175,16 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( __pyx_empty_bytes /*PyObject *lnotab*/ ); Py_DECREF(py_srcfile); - Py_DECREF(py_funcname); + #else + py_code = PyCode_NewEmpty(filename, funcname, py_line); + #endif + Py_XDECREF(py_funcname); return py_code; bad: - Py_XDECREF(py_srcfile); Py_XDECREF(py_funcname); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_srcfile); + #endif return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, @@ -6747,14 +12192,24 @@ 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( @@ -6770,10 +12225,40 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, Py_XDECREF(py_code); Py_XDECREF(py_frame); } +#endif + +/* CIntFromPyVerify */ +#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { - const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; +#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(int) < sizeof(long)) { @@ -6797,40 +12282,51 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int 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 < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = 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; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif } } -/* CIntFromPyVerify */ -#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ - __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) -#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ - __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) -#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ - {\ - func_type value = func_value;\ - if (sizeof(target_type) < sizeof(func_type)) {\ - if (unlikely(value != (func_type) (target_type) value)) {\ - func_type zero = 0;\ - if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ - return (target_type) -1;\ - if (is_unsigned && unlikely(value < zero))\ - goto raise_neg_overflow;\ - else\ - goto raise_overflow;\ - }\ - }\ - return (target_type) value;\ - } - /* CIntFromPy */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { - const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; +#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(int) < sizeof(long)) { + if ((sizeof(int) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -6844,40 +12340,45 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (int) 0; - case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) - case 2: - if (8 * sizeof(int) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { - return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + 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)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; - case 3: - if (8 * sizeof(int) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { - return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; - case 4: - if (8 * sizeof(int) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { - return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -6890,109 +12391,181 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { goto raise_neg_overflow; } #endif - if (sizeof(int) <= sizeof(unsigned long)) { + 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)) { + } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (int) 0; - case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) - case -2: - if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + 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)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 2: - if (8 * sizeof(int) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case -3: - if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case -3: + if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 3: - if (8 * sizeof(int) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case -4: - if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case -4: + if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 4: - if (8 * sizeof(int) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { - return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; + break; + } } #endif - if (sizeof(int) <= sizeof(long)) { + 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)) { + } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { -#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) - PyErr_SetString(PyExc_RuntimeError, - "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); -#else int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if 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; - int ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (int) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (int) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (int) -1; + } else { + stepval = __Pyx_NewRef(v); + } + 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; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((int) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + 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 CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + 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 Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (int) -1; } } else { @@ -7013,9 +12586,32 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { return (int) -1; } +/* FormatTypeName */ +#if CYTHON_COMPILING_IN_LIMITED_API +static __Pyx_TypeName +__Pyx_PyType_GetName(PyTypeObject* tp) +{ + PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_n_s_name); + if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) { + PyErr_Clear(); + Py_XDECREF(name); + name = __Pyx_NewRef(__pyx_n_s__14); + } + return name; +} +#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; +#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)) { @@ -7039,18 +12635,51 @@ 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 < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = 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; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + 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; +#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 PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { - if (sizeof(long) < sizeof(long)) { + if ((sizeof(long) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -7064,40 +12693,45 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (long) 0; - case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) - case 2: - if (8 * sizeof(long) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { - return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + 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)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; - case 3: - if (8 * sizeof(long) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { - return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; - case 4: - if (8 * sizeof(long) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { - return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -7110,109 +12744,181 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { goto raise_neg_overflow; } #endif - if (sizeof(long) <= sizeof(unsigned long)) { + 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)) { + } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (long) 0; - case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) - case -2: - if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + 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)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 2: - if (8 * sizeof(long) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case -3: - if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case -3: + if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 3: - if (8 * sizeof(long) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case -4: - if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case -4: + if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 4: - if (8 * sizeof(long) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; + break; + } } #endif - if (sizeof(long) <= sizeof(long)) { + 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)) { + } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { -#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) - PyErr_SetString(PyExc_RuntimeError, - "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); -#else long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if 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; - int ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (long) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (long) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (long) -1; + } else { + stepval = __Pyx_NewRef(v); + } + 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; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((long) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + 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 CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + 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 Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (long) -1; } } else { @@ -7237,7 +12943,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,6 +12964,22 @@ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { } return __Pyx_InBases(a, b); } +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); +} #if PY_MAJOR_VERSION == 2 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { PyObject *exception, *value, *tb; @@ -7282,11 +13004,11 @@ static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc } #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) { @@ -7334,25 +13056,56 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj #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 unsigned long __Pyx_get_runtime_version(void) { +#if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4 + return Py_Version & ~0xFFUL; +#else + 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; + } + return version; +#endif +} +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_0_10 +#define __PYX_HAVE_RT_ImportFunction_3_0_10 +static int __Pyx_ImportFunction_3_0_10(PyObject *module, const char *funcname, void (**f)(void), const char *sig) { PyObject *d = 0; PyObject *cobj = 0; union { @@ -7369,7 +13122,6 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (** 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,21 +13129,6 @@ 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; @@ -7404,9 +13141,31 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (** #endif /* InitStrings */ +#if PY_MAJOR_VERSION >= 3 +static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) { + if (t.is_unicode | t.is_str) { + if (t.intern) { + *str = PyUnicode_InternFromString(t.s); + } else if (t.encoding) { + *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL); + } else { + *str = PyUnicode_FromStringAndSize(t.s, t.n - 1); + } + } else { + *str = PyBytes_FromStringAndSize(t.s, t.n - 1); + } + if (!*str) + return -1; + if (PyObject_Hash(*str) == -1) + return -1; + return 0; +} +#endif static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { - #if PY_MAJOR_VERSION < 3 + #if PY_MAJOR_VERSION >= 3 + __Pyx_InitString(*t, t->p); + #else if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { @@ -7414,30 +13173,34 @@ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } - #else - if (t->is_unicode | t->is_str) { - if (t->intern) { - *t->p = PyUnicode_InternFromString(t->s); - } else if (t->encoding) { - *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); - } else { - *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); - } - } else { - *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); - } - #endif if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) return -1; + #endif ++t; } 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; @@ -7492,7 +13255,7 @@ static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif -#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) +#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); @@ -7521,22 +13284,26 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { return retval; } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { + __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result)); #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, - "__int__ returned non-int (type %.200s). " - "The ability to return an instance of a strict subclass of int " - "is deprecated, and may be removed in a future version of Python.", - Py_TYPE(result)->tp_name)) { + "__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); + "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")", + type_name, type_name, result_type_name); + __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } @@ -7602,13 +13369,11 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* 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) { @@ -7651,6 +13416,23 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { 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); +#if PY_MAJOR_VERSION < 3 + } else if (likely(PyInt_CheckExact(o))) { + return PyInt_AS_LONG(o); +#endif + } else { + Py_ssize_t ival; + PyObject *x; + x = PyNumber_Index(o); + if (!x) return -1; + ival = PyInt_AsLong(x); + Py_DECREF(x); + return ival; + } +} static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); } @@ -7659,4 +13441,12 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { } +/* #### 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..91a16b56 100644 --- a/src/hunter/_tracer.pxd +++ b/src/hunter/_tracer.pxd @@ -1,28 +1,36 @@ # 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 +cdef extern from "vendor/_compat.h": + CodeType PyFrame_GetCode(FrameType) + int PyFrame_GetLasti(FrameType) + object PyCode_GetCode(CodeType) + object PyCode_GetVarnames(CodeType) + object PyFrame_GetGlobals(FrameType) + object PyFrame_GetLocals(FrameType) - ctypedef class types.CodeType[object PyCodeObject]: - cdef object co_filename - cdef int co_firstlineno +cdef extern from *: + void PyEval_SetTrace(Py_tracefunc, PyObject*) + void PyEval_SetProfile(Py_tracefunc, PyObject*) - 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 + ctypedef extern class types.FrameType[object PyFrameObject, check_size ignore]: + pass - 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 +38,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..9c2ca287 100644 --- a/src/hunter/_tracer.pyx +++ b/src/hunter/_tracer.pyx @@ -3,43 +3,50 @@ 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 ._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 dict KIND_INTS = { + 'call': 0, + 'exception': 1, + 'line': 2, + 'return': 3, + 'c_call': 4, + 'c_exception': 5, + 'c_return': 6, +} - -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 inline int trace_func(Tracer self, FrameType frame, int kind, PyObject* arg) except -1: + if frame.f_trace is not self: + frame.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) 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 @@ -49,18 +56,19 @@ cdef int trace_func(Tracer self, FrameType frame, int kind, PyObject *arg) excep 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 9e43aef5..1c339a73 100644 --- a/src/hunter/actions.py +++ b/src/hunter/actions.py @@ -1,13 +1,12 @@ -from __future__ import absolute_import - +# ruff: noqa: B008 import collections import opcode import os import threading 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 @@ -15,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', + 'Debugger', + 'Manhole', + 'CodePrinter', + 'CallPrinter', + '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 "" @@ -47,6 +51,7 @@ def __repr__(self): def __call__(self, **kwargs): from pdb import Pdb + return Pdb(**kwargs) @@ -60,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): """ @@ -87,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() @@ -102,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 @@ -110,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) @@ -146,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): @@ -163,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: @@ -192,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): """ @@ -243,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): """ @@ -257,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): """ @@ -271,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): """ @@ -290,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): """ @@ -328,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): @@ -416,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): """ @@ -437,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', @@ -511,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): """ @@ -535,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) @@ -585,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): @@ -599,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()): @@ -656,7 +717,8 @@ 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'] @@ -703,7 +765,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: @@ -728,25 +790,84 @@ 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 == RETURN_VALUE: 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 + + +class StackPrinter(ColorStreamAction): + """ + An action that prints a one-line stacktrace. + + Args: + depth (int): The maximum number of frames to show. + limit (int): The maximum number of components to show in path. Eg: ``limit=2`` means it will show 1 parent: ``foo/bar.py``. + stream (file-like): Stream to write to. Default: ``sys.stderr``. + filename_alignment (int): Default size for the filename column (files are right-aligned). Default: ``40``. + force_colors (bool): Force coloring. Default: ``False``. + repr_limit (bool): Limit length of ``repr()`` output. Default: ``512``. + repr_func (string or callable): Function to use instead of ``repr``. + If string must be one of 'repr' or 'safe_repr'. Default: ``'safe_repr'``. + """ + + def __init__(self, depth=15, limit=2, **options): + self.limit = limit + self.depth = depth + super().__init__(**options) + + def __call__(self, event): + """ + Handle event and print the stack. + """ + pid_prefix = self.pid_prefix() + thread_prefix = self.thread_prefix(event) + filename_prefix = self.filename_prefix(event).rstrip() + sep = os.path.sep + + if event.frame and event.frame.f_back: + template = '{{}}{{}}{{}}{{CONT}}:{{BRIGHT}}{{fore(BLUE)}}{} {{KIND}}<={{RESET}} {}'.format( + event.function, + ' {KIND}<={RESET} '.join( + '{}{{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, + ) + for frame in islice(frame_iterator(event.frame.f_back), self.depth) + ), + ) + else: + 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, + ) 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..17fcb0aa 100644 --- a/src/hunter/event.py +++ b/src/hunter/event.py @@ -1,26 +1,26 @@ -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 from .util import CYTHON_SUFFIX_RE from .util import LEADING_WHITESPACE_RE +from .util import MISSING from .util import cached_property from .util import get_func_in_mro 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 +34,36 @@ 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 + builtin = None + + def __init__( + self, + frame, + kind, + arg, + tracer=None, + depth=None, + calls=None, + threading_support=MISSING, + ): + if tracer is None: + if depth is None: + raise TypeError('Missing argument: depth (required because tracer was not given).') + if calls is None: + raise TypeError('Missing argument: calls (required because tracer was not given).') + if threading_support is MISSING: + raise TypeError('Missing argument: threading_support (required because tracer was not given).') + else: + depth = tracer.depth + calls = tracer.calls + threading_support = tracer.threading_support - def __init__(self, frame, kind, arg, tracer): #: The original Frame object. #: #: .. note:: @@ -49,8 +72,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 +91,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 +108,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 +159,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 +174,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 +185,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_lasti >= 0 and self.frame.f_code.co_code: + return self.frame.f_code.co_code[self.frame.f_lasti] + @cached_property def threadid(self): """ @@ -183,6 +230,9 @@ def locals(self): :type: dict """ + if self.builtin: + return {} + return self.frame.f_locals @cached_property @@ -192,6 +242,9 @@ def globals(self): :type: dict """ + if self.builtin: + return {} + return self.frame.f_globals @cached_property @@ -201,7 +254,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 +273,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 +307,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 +323,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 +396,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 +426,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..d140ca93 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) 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..d91a22e2 --- /dev/null +++ b/src/hunter/vendor/_compat.h @@ -0,0 +1,575 @@ +// 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/master/pythoncapi_compat.h +// +// SPDX-License-Identifier: 0BSD + +#ifndef PYTHONCAPI_COMPAT +#define PYTHONCAPI_COMPAT + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include "frameobject.h" // PyFrameObject, PyFrame_GetBack() + + +// Compatibility with Visual Studio 2013 and older which don't support +// the inline keyword in C (only in C++): use __inline instead. +#if (defined(_MSC_VER) && _MSC_VER < 1900 \ + && !defined(__cplusplus) && !defined(inline)) +# define PYCAPI_COMPAT_STATIC_INLINE(TYPE) static __inline TYPE +#else +# define PYCAPI_COMPAT_STATIC_INLINE(TYPE) static inline TYPE +#endif + + +#ifndef _Py_CAST +# define _Py_CAST(type, expr) ((type)(expr)) +#endif + +// On C++11 and newer, _Py_NULL is defined as nullptr on C++11, +// otherwise it is defined as NULL. +#ifndef _Py_NULL +# if 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 + + +// bpo-42262 added Py_NewRef() to Python 3.10.0a3 +#if PY_VERSION_HEX < 0x030A00A3 && !defined(Py_NewRef) +PYCAPI_COMPAT_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) +PYCAPI_COMPAT_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) +PYCAPI_COMPAT_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(Py_IsTrue) +# define Py_IsTrue(x) Py_Is(x, Py_True) +#endif +#if PY_VERSION_HEX < 0x030A00B1 && !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) +PYCAPI_COMPAT_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) +PYCAPI_COMPAT_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) +PYCAPI_COMPAT_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 + +PYCAPI_COMPAT_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) +PYCAPI_COMPAT_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) +PYCAPI_COMPAT_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) +PYCAPI_COMPAT_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) +PYCAPI_COMPAT_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) +PYCAPI_COMPAT_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) +PYCAPI_COMPAT_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) +PYCAPI_COMPAT_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_GetItem(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) +PYCAPI_COMPAT_STATIC_INLINE(PyObject*) +PyFrame_GetVarString(PyFrameObject *frame, const char *name) +{ + PyObject *name_obj, *value; + name_obj = PyUnicode_FromString(name); + 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) +PYCAPI_COMPAT_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) +PYCAPI_COMPAT_STATIC_INLINE(PyFrameObject*) +PyThreadState_GetFrame(PyThreadState *tstate) +{ + assert(tstate != _Py_NULL); + return _Py_CAST(PyFrameObject *, Py_XNewRef(tstate->frame)); +} +#endif + +#if !defined(PYPY_VERSION) +PYCAPI_COMPAT_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) +PYCAPI_COMPAT_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) +PYCAPI_COMPAT_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) +PYCAPI_COMPAT_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) +PYCAPI_COMPAT_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 +#if PY_VERSION_HEX < 0x030900A1 || defined(PYPY_VERSION) +PYCAPI_COMPAT_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 +#if PY_VERSION_HEX < 0x030900A4 || defined(PYPY_VERSION) +PYCAPI_COMPAT_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 +PYCAPI_COMPAT_STATIC_INLINE(int) +PyModule_AddObjectRef(PyObject *module, const char *name, PyObject *value) +{ + int res; + 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 +PYCAPI_COMPAT_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) +PYCAPI_COMPAT_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) +PYCAPI_COMPAT_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) +PYCAPI_COMPAT_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) +PYCAPI_COMPAT_STATIC_INLINE(int) +PyFloat_Pack2(double x, char *p, int le) +{ return _PyFloat_Pack2(x, (unsigned char*)p, le); } + +PYCAPI_COMPAT_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) +PYCAPI_COMPAT_STATIC_INLINE(int) +PyFloat_Pack4(double x, char *p, int le) +{ return _PyFloat_Pack4(x, (unsigned char*)p, le); } + +PYCAPI_COMPAT_STATIC_INLINE(int) +PyFloat_Pack8(double x, char *p, int le) +{ return _PyFloat_Pack8(x, (unsigned char*)p, le); } + +PYCAPI_COMPAT_STATIC_INLINE(double) +PyFloat_Unpack4(const char *p, int le) +{ return _PyFloat_Unpack4((const unsigned char *)p, le); } + +PYCAPI_COMPAT_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) +PYCAPI_COMPAT_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) +PYCAPI_COMPAT_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) +PYCAPI_COMPAT_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) +PYCAPI_COMPAT_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 + + +#ifdef __cplusplus +} +#endif +#endif // PYTHONCAPI_COMPAT diff --git a/src/hunter/vendor/_cymem/__init__.pxd b/src/hunter/vendor/_cymem/__init__.pxd new file mode 100644 index 00000000..e69de29b diff --git a/src/hunter/vendor/_cymem/__init__.py b/src/hunter/vendor/_cymem/__init__.py new file mode 100644 index 00000000..a5501448 --- /dev/null +++ b/src/hunter/vendor/_cymem/__init__.py @@ -0,0 +1 @@ +from .about import * diff --git a/src/hunter/vendor/_cymem/about.py b/src/hunter/vendor/_cymem/about.py new file mode 100644 index 00000000..7de9dc1c --- /dev/null +++ b/src/hunter/vendor/_cymem/about.py @@ -0,0 +1,7 @@ +__title__ = "cymem" +__version__ = "2.0.3" +__summary__ = "Manage calls to calloc/free through Cython" +__uri__ = "https://github.com/explosion/cymem" +__author__ = "Matthew Honnibal" +__email__ = "matt@explosion.ai" +__license__ = "MIT" diff --git a/src/hunter/vendor/_cymem/cymem.c b/src/hunter/vendor/_cymem/cymem.c new file mode 100644 index 00000000..0bfd6d2f --- /dev/null +++ b/src/hunter/vendor/_cymem/cymem.c @@ -0,0 +1,13142 @@ +/* Generated by Cython 3.0.10 */ + +/* BEGIN: Cython Metadata +{ + "distutils": { + "depends": [], + "include_dirs": [ + "src/hunter/vendor/_cymem" + ], + "name": "hunter.vendor._cymem.cymem", + "sources": [ + "src/hunter/vendor/_cymem/cymem.pyx" + ] + }, + "module_name": "hunter.vendor._cymem.cymem" +} +END: Cython Metadata */ + +#ifndef PY_SSIZE_T_CLEAN +#define PY_SSIZE_T_CLEAN +#endif /* PY_SSIZE_T_CLEAN */ +#if defined(CYTHON_LIMITED_API) && 0 + #ifndef Py_LIMITED_API + #if CYTHON_LIMITED_API+0 > 0x03030000 + #define Py_LIMITED_API CYTHON_LIMITED_API + #else + #define Py_LIMITED_API 0x03030000 + #endif + #endif +#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 < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.7+ or Python 3.3+. +#else +#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API +#define __PYX_EXTRA_ABI_MODULE_NAME "limited" +#else +#define __PYX_EXTRA_ABI_MODULE_NAME "" +#endif +#define CYTHON_ABI "3_0_10" __PYX_EXTRA_ABI_MODULE_NAME +#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI +#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." +#define CYTHON_HEX_VERSION 0x03000AF0 +#define CYTHON_FUTURE_DIVISION 1 +#include +#ifndef offsetof + #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#define __PYX_COMMA , +#ifndef HAVE_LONG_LONG + #define HAVE_LONG_LONG +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#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_NOGIL 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 + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_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 (PY_MAJOR_VERSION >= 3) + #endif + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 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 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 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_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 (PY_MAJOR_VERSION >= 3) + #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_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00) + #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 +#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_NOGIL 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_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 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 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_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 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 1 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #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 +#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 1 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #ifndef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #ifndef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 1 + #endif + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 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 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 1 + #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 1 + #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 + #endif +#else + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 1 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #ifndef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 1 + #endif + #if PY_MAJOR_VERSION < 3 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #ifndef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 1 + #endif + #ifndef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 1 + #endif + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #elif !defined(CYTHON_USE_UNICODE_WRITER) + #define CYTHON_USE_UNICODE_WRITER 1 + #endif + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #ifndef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 1 + #endif + #ifndef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6) + #endif + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1) + #endif + #ifndef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 1 + #endif + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #if PY_VERSION_HEX < 0x03050000 + #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 + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif + #if PY_VERSION_HEX < 0x030400a1 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #elif !defined(CYTHON_USE_TP_FINALIZE) + #define CYTHON_USE_TP_FINALIZE 1 + #endif + #if PY_VERSION_HEX < 0x030600B1 + #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) + #endif + #if PY_VERSION_HEX < 0x030700A3 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #elif !defined(CYTHON_USE_EXC_INFO_STACK) + #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 1 + #endif +#endif +#if !defined(CYTHON_FAST_PYCCALL) +#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) +#endif +#if !defined(CYTHON_VECTORCALL) +#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) +#endif +#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) +#if CYTHON_USE_PYLONG_INTERNALS + #if PY_MAJOR_VERSION < 3 + #include "longintrepr.h" + #endif + #undef SHIFT + #undef BASE + #undef MASK + #ifdef SIZEOF_VOID_P + enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; + #endif +#endif +#ifndef __has_attribute + #define __has_attribute(x) 0 +#endif +#ifndef __has_cpp_attribute + #define __has_cpp_attribute(x) 0 +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#ifndef CYTHON_UNUSED + #if defined(__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)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_UNUSED_VAR +# if defined(__cplusplus) + template void CYTHON_UNUSED_VAR( const T& ) { } +# else +# 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 +# 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 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 __int32 __pyx_uintptr_t; + #endif + #endif +#else + #include + typedef uintptr_t __pyx_uintptr_t; +#endif +#ifndef CYTHON_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 + #if __has_attribute(fallthrough) + #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) + #else + #define CYTHON_FALLTHROUGH + #endif + #endif + #if defined(__clang__) && defined(__apple_build_version__) + #if __apple_build_version__ < 7000000 + #undef CYTHON_FALLTHROUGH + #define CYTHON_FALLTHROUGH + #endif + #endif +#endif +#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)) + +#ifndef CYTHON_INLINE + #if defined(__clang__) + #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) + #elif defined(__GNUC__) + #define CYTHON_INLINE __inline__ + #elif defined(_MSC_VER) + #define CYTHON_INLINE __inline + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_INLINE inline + #else + #define CYTHON_INLINE + #endif +#endif + +#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_DefaultClassType PyClass_Type + #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) +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" + #define __Pyx_DefaultClassType PyType_Type +#if CYTHON_COMPILING_IN_LIMITED_API + static CYTHON_INLINE 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, "iiiiiOOOOOOiOO", 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, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else { + if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); + } + end: + Py_XDECREF(code_type); + Py_XDECREF(exception_table); + Py_XDECREF(types_module); + if (type) { + PyErr_Restore(type, value, traceback); + } + return result; + } + #ifndef CO_OPTIMIZED + #define CO_OPTIMIZED 0x0001 + #endif + #ifndef CO_NEWLOCALS + #define CO_NEWLOCALS 0x0002 + #endif + #ifndef CO_VARARGS + #define CO_VARARGS 0x0004 + #endif + #ifndef CO_VARKEYWORDS + #define CO_VARKEYWORDS 0x0008 + #endif + #ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x0200 + #endif + #ifndef CO_GENERATOR + #define CO_GENERATOR 0x0020 + #endif + #ifndef CO_COROUTINE + #define CO_COROUTINE 0x0080 + #endif +#elif PY_VERSION_HEX >= 0x030B0000 + static CYTHON_INLINE 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; + PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0); + if (!empty_bytes) return NULL; + 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, empty_bytes); + Py_DECREF(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 +#endif +#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 CO_COROUTINE + #define CO_COROUTINE 0x80 +#endif +#ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x200 +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#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 + #define METH_FASTCALL 0x80 + #endif + typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); + typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, + Py_ssize_t nargs, PyObject *kwnames); +#else + #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_MAJOR_VERSION >= 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) { +#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 +} +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) +#if __PYX_LIMITED_VERSION_HEX < 0x030900B1 + #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_LIMITED_API + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_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_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() +#elif PY_VERSION_HEX >= 0x03060000 + #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() +#elif PY_VERSION_HEX >= 0x03000000 + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#else + #define __Pyx_PyThreadState_Current _PyThreadState_Current +#endif +#if CYTHON_COMPILING_IN_LIMITED_API +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; +} +#endif +#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) +#else + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) +#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); +} +#endif +#if PY_MAJOR_VERSION < 3 + #if CYTHON_COMPILING_IN_PYPY + #if PYPY_VERSION_NUM < 0x07030600 + #if defined(__cplusplus) && __cplusplus >= 201402L + [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]] + #elif defined(__GNUC__) || defined(__clang__) + __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))) + #elif defined(_MSC_VER) + __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")) + #endif + static CYTHON_INLINE int PyGILState_Check(void) { + return 0; + } + #else // PYPY_VERSION_NUM < 0x07030600 + #endif // PYPY_VERSION_NUM < 0x07030600 + #else + static CYTHON_INLINE int PyGILState_Check(void) { + PyThreadState * tstate = _PyThreadState_Current; + return tstate && (tstate == PyGILState_GetThisThreadState()); + } + #endif +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized) +#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) +#else +#define __Pyx_PyDict_NewPresized(n) PyDict_New() +#endif +#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && 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 PY_MAJOR_VERSION >= 3 && (!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) + #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext) +#else + #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) + #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) + #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v) +#else + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v) +#endif +#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_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define CYTHON_PEP393_ENABLED 1 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u) + #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)) +#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #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_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) + #define __Pyx_PyUnicode_KIND(u) ((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, (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 +#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) ? 65535U : 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((int)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] = (Py_UNICODE) ch) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY + #if !defined(PyUnicode_DecodeUnicodeEscape) + #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) + #endif + #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500) + #undef 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) +#else + #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) +#endif +#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) + #define PyObject_ASCII(o) PyObject_Repr(o) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBaseString_Type PyUnicode_Type + #define PyStringObject PyUnicodeObject + #define PyString_Type PyUnicode_Type + #define PyString_Check PyUnicode_Check + #define PyString_CheckExact PyUnicode_CheckExact +#ifndef PyObject_Unicode + #define PyObject_Unicode PyObject_Str +#endif +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) +#endif +#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_PySequence_ListKeepNew(obj) PySequence_List(obj) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type) +#endif +#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_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_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) + #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) +#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_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) + #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) +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 + #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 __Pyx_Py3Int_Check(op) PyLong_Check(op) + #define __Pyx_Py3Int_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 +#else + #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op)) + #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op)) +#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 __Pyx_PyIndex_AsHash_t +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t +#endif +#if CYTHON_USE_ASYNC_SLOTS + #if PY_VERSION_HEX >= 0x030500B1 + #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods + #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) + #else + #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) + #endif +#else + #define __Pyx_PyType_AsAsync(obj) NULL +#endif +#ifndef __Pyx_PyAsyncMethodsStruct + typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; + } __Pyx_PyAsyncMethodsStruct; +#endif + +#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) + #if !defined(_USE_MATH_DEFINES) + #define _USE_MATH_DEFINES + #endif +#endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif +#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) +#define __Pyx_truncl trunc +#else +#define __Pyx_truncl truncl +#endif + +#define __PYX_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; } +#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 + #endif +#endif + +#define __PYX_HAVE__hunter__vendor___cymem__cymem +#define __PYX_HAVE_API__hunter__vendor___cymem__cymem +/* Early includes */ +#include +#include +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_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) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX))) ) +static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { + return (size_t) i < (size_t) limit; +} +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) + #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE 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); +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_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) +#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_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); +#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 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)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) +#else +#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) +#endif +#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 PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +#include +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] = (char) 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 +#include +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; +} +#endif +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ +static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } + +#if !CYTHON_USE_MODULE_STATE +static PyObject *__pyx_m = NULL; +#endif +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm = __FILE__; +static const char *__pyx_filename; + +/* #### Code section: filename_table ### */ + +static const char *__pyx_f[] = { + "", + "src/hunter/vendor/_cymem/cymem.pyx", + "src/hunter/vendor/_cymem/cymem.pxd", + ".tox/cythonize/lib64/python3.11/site-packages/Cython/Includes/cpython/type.pxd", +}; +/* #### Code section: utility_code_proto_before_types ### */ +/* ForceInitThreads.proto */ +#ifndef __PYX_FORCE_INIT_THREADS + #define __PYX_FORCE_INIT_THREADS 0 +#endif + +/* #### Code section: numeric_typedefs ### */ +/* #### Code section: complex_type_declarations ### */ +/* #### Code section: type_declarations ### */ + +/*--- Type declarations ---*/ +struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc; +struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree; +struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool; +struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address; + +/* "hunter/vendor/_cymem/cymem.pxd":2 + * # cython: language_level=3str + * ctypedef void* (*malloc_t)(size_t n) # <<<<<<<<<<<<<< + * ctypedef void (*free_t)(void *p) + * + */ +typedef void *(*__pyx_t_6hunter_6vendor_6_cymem_5cymem_malloc_t)(size_t); + +/* "hunter/vendor/_cymem/cymem.pxd":3 + * # cython: language_level=3str + * ctypedef void* (*malloc_t)(size_t n) + * ctypedef void (*free_t)(void *p) # <<<<<<<<<<<<<< + * + * cdef class PyMalloc: + */ +typedef void (*__pyx_t_6hunter_6vendor_6_cymem_5cymem_free_t)(void *); + +/* "hunter/vendor/_cymem/cymem.pxd":5 + * ctypedef void (*free_t)(void *p) + * + * cdef class PyMalloc: # <<<<<<<<<<<<<< + * cdef malloc_t malloc + * cdef void _set(self, malloc_t malloc) + */ +struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc { + PyObject_HEAD + struct __pyx_vtabstruct_6hunter_6vendor_6_cymem_5cymem_PyMalloc *__pyx_vtab; + __pyx_t_6hunter_6vendor_6_cymem_5cymem_malloc_t malloc; +}; + + +/* "hunter/vendor/_cymem/cymem.pxd":11 + * cdef PyMalloc WrapMalloc(malloc_t malloc) + * + * cdef class PyFree: # <<<<<<<<<<<<<< + * cdef free_t free + * cdef void _set(self, free_t free) + */ +struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree { + PyObject_HEAD + struct __pyx_vtabstruct_6hunter_6vendor_6_cymem_5cymem_PyFree *__pyx_vtab; + __pyx_t_6hunter_6vendor_6_cymem_5cymem_free_t free; +}; + + +/* "hunter/vendor/_cymem/cymem.pxd":17 + * cdef PyFree WrapFree(free_t free) + * + * cdef class Pool: # <<<<<<<<<<<<<< + * cdef readonly size_t size + * cdef readonly dict addresses + */ +struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool { + PyObject_HEAD + struct __pyx_vtabstruct_6hunter_6vendor_6_cymem_5cymem_Pool *__pyx_vtab; + size_t size; + PyObject *addresses; + PyObject *refs; + struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *pymalloc; + struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *pyfree; +}; + + +/* "hunter/vendor/_cymem/cymem.pxd":29 + * + * + * cdef class Address: # <<<<<<<<<<<<<< + * cdef void* ptr + * cdef readonly PyMalloc pymalloc + */ +struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address { + PyObject_HEAD + void *ptr; + struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *pymalloc; + struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *pyfree; +}; + + + +/* "hunter/vendor/_cymem/cymem.pyx":11 + * WARN_ZERO_ALLOC = False + * + * cdef class PyMalloc: # <<<<<<<<<<<<<< + * cdef void _set(self, malloc_t malloc): + * self.malloc = malloc + */ + +struct __pyx_vtabstruct_6hunter_6vendor_6_cymem_5cymem_PyMalloc { + void (*_set)(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *, __pyx_t_6hunter_6vendor_6_cymem_5cymem_malloc_t); +}; +static struct __pyx_vtabstruct_6hunter_6vendor_6_cymem_5cymem_PyMalloc *__pyx_vtabptr_6hunter_6vendor_6_cymem_5cymem_PyMalloc; + + +/* "hunter/vendor/_cymem/cymem.pyx":20 + * return o + * + * cdef class PyFree: # <<<<<<<<<<<<<< + * cdef void _set(self, free_t free): + * self.free = free + */ + +struct __pyx_vtabstruct_6hunter_6vendor_6_cymem_5cymem_PyFree { + void (*_set)(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *, __pyx_t_6hunter_6vendor_6_cymem_5cymem_free_t); +}; +static struct __pyx_vtabstruct_6hunter_6vendor_6_cymem_5cymem_PyFree *__pyx_vtabptr_6hunter_6vendor_6_cymem_5cymem_PyFree; + + +/* "hunter/vendor/_cymem/cymem.pyx":32 + * Default_Free = WrapFree(PyMem_Free) + * + * cdef class Pool: # <<<<<<<<<<<<<< + * """Track allocated memory addresses, and free them all when the Pool is + * garbage collected. This provides an easy way to avoid memory leaks, and + */ + +struct __pyx_vtabstruct_6hunter_6vendor_6_cymem_5cymem_Pool { + void *(*alloc)(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *, size_t, size_t); + void (*free)(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *, void *); + void *(*realloc)(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *, void *, size_t); +}; +static struct __pyx_vtabstruct_6hunter_6vendor_6_cymem_5cymem_Pool *__pyx_vtabptr_6hunter_6vendor_6_cymem_5cymem_Pool; +/* #### Code section: utility_code_proto ### */ + +/* --- Runtime support code (head) --- */ +/* Refnanny.proto */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + 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__));\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __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);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)) + #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext() +#endif + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ + } + #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); 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) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_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);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +/* 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 + +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#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() != NULL) +#define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() +#endif + +/* PyErrFetchRestore.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#if CYTHON_COMPILING_IN_CPYTHON && 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) +#endif +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* 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); +static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); +#endif + +/* 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_Arg_VARARGS(args, i) PySequence_GetItem(args, i) +#elif CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i) +#else + #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i) +#endif +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg) + #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg) +#else + #define __Pyx_Arg_NewRef_VARARGS(arg) arg + #define __Pyx_Arg_XDECREF_VARARGS(arg) +#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_Arg_FASTCALL(args, i) args[i] + #define __Pyx_NumKwargs_FASTCALL(kwds) 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_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); + #else + #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) + #endif + #define __Pyx_Arg_NewRef_FASTCALL(arg) arg /* no-op, __Pyx_Arg_FASTCALL is direct and this needs + to have the same reference counting */ + #define __Pyx_Arg_XDECREF_FASTCALL(arg) +#else + #define __Pyx_Arg_FASTCALL __Pyx_Arg_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 + #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg) + #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start) +#else +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) +#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); + +/* KeywordStringCheck.proto */ +static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed); + +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* RaiseDoubleKeywords.proto */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +/* ParseKeywords.proto */ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues, + PyObject **argnames[], + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, + const char* function_name); + +/* 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 **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" +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif + #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 **args, size_t nargs, PyObject *kwargs); + +/* PyObjectCallNoArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); + +/* 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); + +/* IterFinish.proto */ +static CYTHON_INLINE int __Pyx_IterFinish(void); + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* 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); + +/* RaiseNeedMoreValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); + +/* RaiseTooManyValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); + +/* UnpackItemEndCheck.proto */ +static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); + +/* RaiseNoneIterError.proto */ +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); + +/* UnpackTupleError.proto */ +static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index); + +/* UnpackTuple2.proto */ +#define __Pyx_unpack_tuple2(tuple, value1, value2, is_tuple, has_known_size, decref_tuple)\ + (likely(is_tuple || PyTuple_Check(tuple)) ?\ + (likely(has_known_size || PyTuple_GET_SIZE(tuple) == 2) ?\ + __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple) :\ + (__Pyx_UnpackTupleError(tuple, 2), -1)) :\ + __Pyx_unpack_tuple2_generic(tuple, value1, value2, has_known_size, decref_tuple)) +static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( + PyObject* tuple, PyObject** value1, PyObject** value2, int decref_tuple); +static int __Pyx_unpack_tuple2_generic( + PyObject* tuple, PyObject** value1, PyObject** value2, int has_known_size, int decref_tuple); + +/* dict_iter.proto */ +static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int is_dict, PyObject* method_name, + Py_ssize_t* p_orig_length, int* p_is_dict); +static CYTHON_INLINE int __Pyx_dict_iter_next(PyObject* dict_or_iter, Py_ssize_t orig_length, Py_ssize_t* ppos, + PyObject** pkey, PyObject** pvalue, PyObject** pitem, int is_dict); + +/* WriteUnraisableException.proto */ +static void __Pyx_WriteUnraisable(const char *name, int clineno, + int lineno, const char *filename, + int full_traceback, int nogil); + +/* 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_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) 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))) ?\ + (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_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 + +/* PyDictContains.proto */ +static CYTHON_INLINE int __Pyx_PyDict_ContainsTF(PyObject* item, PyObject* dict, int eq) { + int result = PyDict_Contains(dict, item); + return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); +} + +/* AssertionsEnabled.proto */ +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) + #define __Pyx_init_assertions_enabled() (0) + #define __pyx_assertions_enabled() (1) +#elif CYTHON_COMPILING_IN_LIMITED_API || (CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030C0000) + static int __pyx_assertions_enabled_flag; + #define __pyx_assertions_enabled() (__pyx_assertions_enabled_flag) + static int __Pyx_init_assertions_enabled(void) { + PyObject *builtins, *debug, *debug_str; + int flag; + builtins = PyEval_GetBuiltins(); + if (!builtins) goto bad; + debug_str = PyUnicode_FromStringAndSize("__debug__", 9); + if (!debug_str) goto bad; + debug = PyObject_GetItem(builtins, debug_str); + Py_DECREF(debug_str); + if (!debug) goto bad; + flag = PyObject_IsTrue(debug); + Py_DECREF(debug); + if (flag == -1) goto bad; + __pyx_assertions_enabled_flag = flag; + return 0; + bad: + __pyx_assertions_enabled_flag = 1; + return -1; + } +#else + #define __Pyx_init_assertions_enabled() (0) + #define __pyx_assertions_enabled() (!Py_OptimizeFlag) +#endif + +/* DictGetItem.proto */ +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); +#define __Pyx_PyObject_Dict_GetItem(obj, name)\ + (likely(PyDict_CheckExact(obj)) ?\ + __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name)) +#else +#define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) +#define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) +#endif + +/* py_dict_pop.proto */ +static CYTHON_INLINE PyObject *__Pyx_PyDict_Pop(PyObject *d, PyObject *key, PyObject *default_value); + +/* UnpackUnboundCMethod.proto */ +typedef struct { + PyObject *type; + PyObject **method_name; + PyCFunction func; + PyObject *method; + int flag; +} __Pyx_CachedCFunction; + +/* CallUnboundCMethod2.proto */ +static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2); +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030600B1 +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 + +/* CallUnboundCMethod1.proto */ +static PyObject* __Pyx__CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg); +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg); +#else +#define __Pyx_CallUnboundCMethod1(cfunc, self, arg) __Pyx__CallUnboundCMethod1(cfunc, self, arg) +#endif + +/* ListAppend.proto */ +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS +static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { + PyListObject* L = (PyListObject*) list; + Py_ssize_t len = Py_SIZE(list); + if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { + Py_INCREF(x); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 + L->ob_item[len] = x; + #else + PyList_SET_ITEM(list, len, x); + #endif + __Pyx_SET_SIZE(list, len + 1); + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_PyList_Append(L,x) PyList_Append(L,x) +#endif + +/* PySequenceMultiply.proto */ +#define __Pyx_PySequence_Multiply_Left(mul, seq) __Pyx_PySequence_Multiply(seq, mul) +static CYTHON_INLINE PyObject* __Pyx_PySequence_Multiply(PyObject *seq, Py_ssize_t mul); + +/* IncludeStructmemberH.proto */ +#include + +/* FixUpExtensionType.proto */ +#if CYTHON_USE_TYPE_SPECS +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); +#endif + +/* 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); + +/* 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 +#endif + +/* PyObject_GenericGetAttr.proto */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr +#endif + +/* SetVTable.proto */ +static int __Pyx_SetVtable(PyTypeObject* typeptr , void* vtable); + +/* GetVTable.proto */ +static void* __Pyx_GetVtable(PyTypeObject *type); + +/* MergeVTables.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_MergeVtables(PyTypeObject *type); +#endif + +/* SetupReduce.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_setup_reduce(PyObject* type_obj); +#endif + +/* TypeImport.proto */ +#ifndef __PYX_HAVE_RT_ImportType_proto_3_0_10 +#define __PYX_HAVE_RT_ImportType_proto_3_0_10 +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L +#include +#endif +#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L +#define __PYX_GET_STRUCT_ALIGNMENT_3_0_10(s) alignof(s) +#else +#define __PYX_GET_STRUCT_ALIGNMENT_3_0_10(s) sizeof(void*) +#endif +enum __Pyx_ImportType_CheckSize_3_0_10 { + __Pyx_ImportType_CheckSize_Error_3_0_10 = 0, + __Pyx_ImportType_CheckSize_Warn_3_0_10 = 1, + __Pyx_ImportType_CheckSize_Ignore_3_0_10 = 2 +}; +static PyTypeObject *__Pyx_ImportType_3_0_10(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_10 check_size); +#endif + +/* Import.proto */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +/* ImportDottedModule.proto */ +static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple); +#if PY_MAJOR_VERSION >= 3 +static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple); +#endif + +/* FetchSharedCythonModule.proto */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void); + +/* FetchCommonType.proto */ +#if !CYTHON_USE_TYPE_SPECS +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); +#else +static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases); +#endif + +/* PyMethodNew.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + PyObject *typesModule=NULL, *methodType=NULL, *result=NULL; + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + typesModule = PyImport_ImportModule("types"); + if (!typesModule) return NULL; + methodType = PyObject_GetAttrString(typesModule, "MethodType"); + Py_DECREF(typesModule); + if (!methodType) return NULL; + result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL); + Py_DECREF(methodType); + return result; +} +#elif PY_MAJOR_VERSION >= 3 +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); +} +#else + #define __Pyx_PyMethod_New PyMethod_New +#endif + +/* PyVectorcallFastCallDict.proto */ +#if CYTHON_METH_FASTCALL +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 + __pyx_vectorcallfunc func_vectorcall; +#endif +#if PY_VERSION_HEX < 0x030500A0 || 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 + void *defaults; + int defaults_pyobjects; + size_t defaults_size; + 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_CyFunctionType) +#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type) +#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_CyFunctionType) +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc); +#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 void *__Pyx_CyFunction_InitDefaults(PyObject *m, + size_t size, + int pyobjects); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, + PyObject *tuple); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, + PyObject *dict); +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, + PyObject *dict); +static int __pyx_CyFunction_init(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 +#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); + +/* ExtTypeTest.proto */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + +/* CLineInTraceback.proto */ +#ifdef CYTHON_CLINE_IN_TRACEBACK +#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) +#else +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); +#endif + +/* CodeObjectCache.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API +typedef struct { + PyCodeObject* code_object; + int code_line; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; +}; +static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static PyCodeObject *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); +#endif + +/* 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 size_t __Pyx_PyInt_As_size_t(PyObject *); + +/* FormatTypeName.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%U" +static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp); +#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) +#else +typedef const char *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%.200s" +#define __Pyx_PyType_GetName(tp) ((tp)->tp_name) +#define __Pyx_DECREF_TypeName(obj) +#endif + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + +/* FastTypeChecks.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +#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)) +#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) + +/* CheckBinaryVersion.proto */ +static unsigned long __Pyx_get_runtime_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); + +/* #### Code section: module_declarations ### */ +static void __pyx_f_6hunter_6vendor_6_cymem_5cymem_8PyMalloc__set(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *__pyx_v_self, __pyx_t_6hunter_6vendor_6_cymem_5cymem_malloc_t __pyx_v_malloc); /* proto*/ +static void __pyx_f_6hunter_6vendor_6_cymem_5cymem_6PyFree__set(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *__pyx_v_self, __pyx_t_6hunter_6vendor_6_cymem_5cymem_free_t __pyx_v_free); /* proto*/ +static void *__pyx_f_6hunter_6vendor_6_cymem_5cymem_4Pool_alloc(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *__pyx_v_self, size_t __pyx_v_number, size_t __pyx_v_elem_size); /* proto*/ +static void *__pyx_f_6hunter_6vendor_6_cymem_5cymem_4Pool_realloc(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *__pyx_v_self, void *__pyx_v_p, size_t __pyx_v_new_size); /* proto*/ +static void __pyx_f_6hunter_6vendor_6_cymem_5cymem_4Pool_free(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *__pyx_v_self, void *__pyx_v_p); /* proto*/ + +/* Module declarations from "cpython.mem" */ + +/* Module declarations from "libc.string" */ + +/* Module declarations from "libc.stdio" */ + +/* Module declarations from "__builtin__" */ + +/* Module declarations from "cpython.type" */ + +/* Module declarations from "cpython" */ + +/* Module declarations from "cpython.object" */ + +/* Module declarations from "cpython.ref" */ + +/* Module declarations from "hunter.vendor._cymem.cymem" */ +static struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *__pyx_f_6hunter_6vendor_6_cymem_5cymem_WrapMalloc(__pyx_t_6hunter_6vendor_6_cymem_5cymem_malloc_t); /*proto*/ +static struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *__pyx_f_6hunter_6vendor_6_cymem_5cymem_WrapFree(__pyx_t_6hunter_6vendor_6_cymem_5cymem_free_t); /*proto*/ +/* #### Code section: typeinfo ### */ +/* #### Code section: before_global_var ### */ +#define __Pyx_MODULE_NAME "hunter.vendor._cymem.cymem" +extern int __pyx_module_is_main_hunter__vendor___cymem__cymem; +int __pyx_module_is_main_hunter__vendor___cymem__cymem = 0; + +/* Implementation of "hunter.vendor._cymem.cymem" */ +/* #### Code section: global_var ### */ +static PyObject *__pyx_builtin_TypeError; +static PyObject *__pyx_builtin_MemoryError; +static PyObject *__pyx_builtin_ValueError; +static PyObject *__pyx_builtin_AssertionError; +/* #### Code section: string_decls ### */ +static const char __pyx_k__6[] = "*"; +static const char __pyx_k_gc[] = "gc"; +static const char __pyx_k__19[] = "?"; +static const char __pyx_k_pop[] = "pop"; +static const char __pyx_k_Pool[] = "Pool"; +static const char __pyx_k_main[] = "__main__"; +static const char __pyx_k_name[] = "__name__"; +static const char __pyx_k_self[] = "self"; +static const char __pyx_k_spec[] = "__spec__"; +static const char __pyx_k_test[] = "__test__"; +static const char __pyx_k_warn[] = "warn"; +static const char __pyx_k_PyFree[] = "PyFree"; +static const char __pyx_k_enable[] = "enable"; +static const char __pyx_k_import[] = "__import__"; +static const char __pyx_k_number[] = "number"; +static const char __pyx_k_py_ref[] = "py_ref"; +static const char __pyx_k_pyfree[] = "pyfree"; +static const char __pyx_k_reduce[] = "__reduce__"; +static const char __pyx_k_Address[] = "Address"; +static const char __pyx_k_disable[] = "disable"; +static const char __pyx_k_PyMalloc[] = "PyMalloc"; +static const char __pyx_k_getstate[] = "__getstate__"; +static const char __pyx_k_pymalloc[] = "pymalloc"; +static const char __pyx_k_setstate[] = "__setstate__"; +static const char __pyx_k_warnings[] = "warnings"; +static const char __pyx_k_TypeError[] = "TypeError"; +static const char __pyx_k_elem_size[] = "elem_size"; +static const char __pyx_k_isenabled[] = "isenabled"; +static const char __pyx_k_own_pyref[] = "own_pyref"; +static const char __pyx_k_pyx_state[] = "__pyx_state"; +static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; +static const char __pyx_k_ValueError[] = "ValueError"; +static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; +static const char __pyx_k_MemoryError[] = "MemoryError"; +static const char __pyx_k_Default_Free[] = "Default_Free"; +static const char __pyx_k_initializing[] = "_initializing"; +static const char __pyx_k_is_coroutine[] = "_is_coroutine"; +static const char __pyx_k_stringsource[] = ""; +static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; +static const char __pyx_k_AssertionError[] = "AssertionError"; +static const char __pyx_k_Default_Malloc[] = "Default_Malloc"; +static const char __pyx_k_Pool_own_pyref[] = "Pool.own_pyref"; +static const char __pyx_k_WARN_ZERO_ALLOC[] = "WARN_ZERO_ALLOC"; +static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; +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_Pool___reduce_cython[] = "Pool.__reduce_cython__"; +static const char __pyx_k_Allocating_zero_bytes[] = "Allocating zero bytes"; +static const char __pyx_k_Pool___setstate_cython[] = "Pool.__setstate_cython__"; +static const char __pyx_k_PyFree___reduce_cython[] = "PyFree.__reduce_cython__"; +static const char __pyx_k_Address___reduce_cython[] = "Address.__reduce_cython__"; +static const char __pyx_k_Error_assigning_d_bytes[] = "Error assigning %d bytes"; +static const char __pyx_k_PyFree___setstate_cython[] = "PyFree.__setstate_cython__"; +static const char __pyx_k_PyMalloc___reduce_cython[] = "PyMalloc.__reduce_cython__"; +static const char __pyx_k_Address___setstate_cython[] = "Address.__setstate_cython__"; +static const char __pyx_k_PyMalloc___setstate_cython[] = "PyMalloc.__setstate_cython__"; +static const char __pyx_k_hunter_vendor__cymem_cymem[] = "hunter.vendor._cymem.cymem"; +static const char __pyx_k_Realloc_requires_new_size_0[] = "Realloc requires new_size > 0"; +static const char __pyx_k_Error_reallocating_to_d_bytes[] = "Error reallocating to %d bytes"; +static const char __pyx_k_Pointer_d_not_found_in_Pool_s[] = "Pointer %d not found in Pool %s"; +static const char __pyx_k_self_malloc_cannot_be_converted[] = "self.malloc cannot be converted to a Python object for pickling"; +static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__"; +static const char __pyx_k_self_free_cannot_be_converted_to[] = "self.free cannot be converted to a Python object for pickling"; +static const char __pyx_k_src_hunter_vendor__cymem_cymem_p[] = "src/hunter/vendor/_cymem/cymem.pyx"; +/* #### Code section: decls ### */ +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_8PyMalloc___reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_8PyMalloc_2__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_6PyFree___reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_6PyFree_2__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_6hunter_6vendor_6_cymem_5cymem_4Pool___cinit__(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *__pyx_v_self, struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *__pyx_v_pymalloc, struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *__pyx_v_pyfree); /* proto */ +static void __pyx_pf_6hunter_6vendor_6_cymem_5cymem_4Pool_2__dealloc__(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_4Pool_4own_pyref(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *__pyx_v_self, PyObject *__pyx_v_py_ref); /* proto */ +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_4Pool_4size___get__(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_4Pool_9addresses___get__(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_4Pool_4refs___get__(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_4Pool_8pymalloc___get__(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_4Pool_6pyfree___get__(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_4Pool_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_4Pool_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_6hunter_6vendor_6_cymem_5cymem_7Address___cinit__(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *__pyx_v_self, CYTHON_UNUSED size_t __pyx_v_number, CYTHON_UNUSED size_t __pyx_v_elem_size, struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *__pyx_v_pymalloc, struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *__pyx_v_pyfree); /* proto */ +static int __pyx_pf_6hunter_6vendor_6_cymem_5cymem_7Address_2__init__(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *__pyx_v_self, size_t __pyx_v_number, size_t __pyx_v_elem_size); /* proto */ +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_7Address_4addr___get__(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *__pyx_v_self); /* proto */ +static void __pyx_pf_6hunter_6vendor_6_cymem_5cymem_7Address_4__dealloc__(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_7Address_8pymalloc___get__(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_7Address_6pyfree___get__(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_7Address_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_7Address_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_tp_new_6hunter_6vendor_6_cymem_5cymem_PyMalloc(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_6hunter_6vendor_6_cymem_5cymem_PyFree(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_6hunter_6vendor_6_cymem_5cymem_Pool(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_6hunter_6vendor_6_cymem_5cymem_Address(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_pop = {0, 0, 0, 0, 0}; +/* #### Code section: late_includes ### */ +/* #### Code section: module_state ### */ +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 + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + PyTypeObject *__pyx_ptype_7cpython_4type_type; + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + PyObject *__pyx_type_6hunter_6vendor_6_cymem_5cymem_PyMalloc; + PyObject *__pyx_type_6hunter_6vendor_6_cymem_5cymem_PyFree; + PyObject *__pyx_type_6hunter_6vendor_6_cymem_5cymem_Pool; + PyObject *__pyx_type_6hunter_6vendor_6_cymem_5cymem_Address; + #endif + PyTypeObject *__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyMalloc; + PyTypeObject *__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyFree; + PyTypeObject *__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Pool; + PyTypeObject *__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Address; + PyObject *__pyx_n_s_Address; + PyObject *__pyx_n_s_Address___reduce_cython; + PyObject *__pyx_n_s_Address___setstate_cython; + PyObject *__pyx_kp_s_Allocating_zero_bytes; + PyObject *__pyx_n_s_AssertionError; + PyObject *__pyx_n_s_Default_Free; + PyObject *__pyx_n_s_Default_Malloc; + PyObject *__pyx_kp_s_Error_assigning_d_bytes; + PyObject *__pyx_kp_s_Error_reallocating_to_d_bytes; + PyObject *__pyx_n_s_MemoryError; + PyObject *__pyx_kp_s_Pointer_d_not_found_in_Pool_s; + PyObject *__pyx_n_s_Pool; + PyObject *__pyx_n_s_Pool___reduce_cython; + PyObject *__pyx_n_s_Pool___setstate_cython; + PyObject *__pyx_n_s_Pool_own_pyref; + PyObject *__pyx_n_s_PyFree; + PyObject *__pyx_n_s_PyFree___reduce_cython; + PyObject *__pyx_n_s_PyFree___setstate_cython; + PyObject *__pyx_n_s_PyMalloc; + PyObject *__pyx_n_s_PyMalloc___reduce_cython; + PyObject *__pyx_n_s_PyMalloc___setstate_cython; + PyObject *__pyx_kp_s_Realloc_requires_new_size_0; + PyObject *__pyx_n_s_TypeError; + PyObject *__pyx_n_s_ValueError; + PyObject *__pyx_n_s_WARN_ZERO_ALLOC; + PyObject *__pyx_n_s__19; + PyObject *__pyx_n_s__6; + PyObject *__pyx_n_s_asyncio_coroutines; + PyObject *__pyx_n_s_cline_in_traceback; + PyObject *__pyx_kp_u_disable; + PyObject *__pyx_n_s_elem_size; + PyObject *__pyx_kp_u_enable; + PyObject *__pyx_kp_u_gc; + PyObject *__pyx_n_s_getstate; + PyObject *__pyx_n_s_hunter_vendor__cymem_cymem; + PyObject *__pyx_n_s_import; + PyObject *__pyx_n_s_initializing; + PyObject *__pyx_n_s_is_coroutine; + PyObject *__pyx_kp_u_isenabled; + PyObject *__pyx_n_s_main; + PyObject *__pyx_n_s_name; + PyObject *__pyx_kp_s_no_default___reduce___due_to_non; + PyObject *__pyx_n_s_number; + PyObject *__pyx_n_s_own_pyref; + PyObject *__pyx_n_s_pop; + PyObject *__pyx_n_s_py_ref; + PyObject *__pyx_n_s_pyfree; + PyObject *__pyx_n_s_pymalloc; + PyObject *__pyx_n_s_pyx_state; + PyObject *__pyx_n_s_pyx_vtable; + PyObject *__pyx_n_s_reduce; + PyObject *__pyx_n_s_reduce_cython; + PyObject *__pyx_n_s_reduce_ex; + PyObject *__pyx_n_s_self; + PyObject *__pyx_kp_s_self_free_cannot_be_converted_to; + PyObject *__pyx_kp_s_self_malloc_cannot_be_converted; + PyObject *__pyx_n_s_setstate; + PyObject *__pyx_n_s_setstate_cython; + PyObject *__pyx_n_s_spec; + PyObject *__pyx_kp_s_src_hunter_vendor__cymem_cymem_p; + PyObject *__pyx_kp_s_stringsource; + PyObject *__pyx_n_s_test; + PyObject *__pyx_n_s_warn; + PyObject *__pyx_n_s_warnings; + struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *__pyx_k_; + struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *__pyx_k__2; + struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *__pyx_k__4; + struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *__pyx_k__5; + PyObject *__pyx_tuple__3; + PyObject *__pyx_tuple__7; + PyObject *__pyx_tuple__9; + PyObject *__pyx_tuple__13; + PyObject *__pyx_codeobj__8; + PyObject *__pyx_codeobj__10; + PyObject *__pyx_codeobj__11; + PyObject *__pyx_codeobj__12; + PyObject *__pyx_codeobj__14; + PyObject *__pyx_codeobj__15; + PyObject *__pyx_codeobj__16; + PyObject *__pyx_codeobj__17; + PyObject *__pyx_codeobj__18; +} __pyx_mstate; + +#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(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o)) + +#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef))) + +#define __pyx_m (PyState_FindModule(&__pyx_moduledef)) +#else +static __pyx_mstate __pyx_mstate_global_static = +#ifdef __cplusplus + {}; +#else + {0}; +#endif +static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static; +#endif +/* #### Code section: module_state_clear ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_clear(PyObject *m) { + __pyx_mstate *clear_module_state = __pyx_mstate(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 + Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_4type_type); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyMalloc); + Py_CLEAR(clear_module_state->__pyx_type_6hunter_6vendor_6_cymem_5cymem_PyMalloc); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyFree); + Py_CLEAR(clear_module_state->__pyx_type_6hunter_6vendor_6_cymem_5cymem_PyFree); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Pool); + Py_CLEAR(clear_module_state->__pyx_type_6hunter_6vendor_6_cymem_5cymem_Pool); + Py_CLEAR(clear_module_state->__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Address); + Py_CLEAR(clear_module_state->__pyx_type_6hunter_6vendor_6_cymem_5cymem_Address); + Py_CLEAR(clear_module_state->__pyx_n_s_Address); + Py_CLEAR(clear_module_state->__pyx_n_s_Address___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Address___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_kp_s_Allocating_zero_bytes); + Py_CLEAR(clear_module_state->__pyx_n_s_AssertionError); + Py_CLEAR(clear_module_state->__pyx_n_s_Default_Free); + Py_CLEAR(clear_module_state->__pyx_n_s_Default_Malloc); + Py_CLEAR(clear_module_state->__pyx_kp_s_Error_assigning_d_bytes); + Py_CLEAR(clear_module_state->__pyx_kp_s_Error_reallocating_to_d_bytes); + Py_CLEAR(clear_module_state->__pyx_n_s_MemoryError); + Py_CLEAR(clear_module_state->__pyx_kp_s_Pointer_d_not_found_in_Pool_s); + Py_CLEAR(clear_module_state->__pyx_n_s_Pool); + Py_CLEAR(clear_module_state->__pyx_n_s_Pool___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Pool___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Pool_own_pyref); + Py_CLEAR(clear_module_state->__pyx_n_s_PyFree); + Py_CLEAR(clear_module_state->__pyx_n_s_PyFree___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_PyFree___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_PyMalloc); + Py_CLEAR(clear_module_state->__pyx_n_s_PyMalloc___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_PyMalloc___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_kp_s_Realloc_requires_new_size_0); + Py_CLEAR(clear_module_state->__pyx_n_s_TypeError); + Py_CLEAR(clear_module_state->__pyx_n_s_ValueError); + Py_CLEAR(clear_module_state->__pyx_n_s_WARN_ZERO_ALLOC); + Py_CLEAR(clear_module_state->__pyx_n_s__19); + Py_CLEAR(clear_module_state->__pyx_n_s__6); + Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines); + Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback); + Py_CLEAR(clear_module_state->__pyx_kp_u_disable); + Py_CLEAR(clear_module_state->__pyx_n_s_elem_size); + Py_CLEAR(clear_module_state->__pyx_kp_u_enable); + Py_CLEAR(clear_module_state->__pyx_kp_u_gc); + Py_CLEAR(clear_module_state->__pyx_n_s_getstate); + Py_CLEAR(clear_module_state->__pyx_n_s_hunter_vendor__cymem_cymem); + Py_CLEAR(clear_module_state->__pyx_n_s_import); + Py_CLEAR(clear_module_state->__pyx_n_s_initializing); + Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine); + Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled); + Py_CLEAR(clear_module_state->__pyx_n_s_main); + Py_CLEAR(clear_module_state->__pyx_n_s_name); + Py_CLEAR(clear_module_state->__pyx_kp_s_no_default___reduce___due_to_non); + Py_CLEAR(clear_module_state->__pyx_n_s_number); + Py_CLEAR(clear_module_state->__pyx_n_s_own_pyref); + Py_CLEAR(clear_module_state->__pyx_n_s_pop); + Py_CLEAR(clear_module_state->__pyx_n_s_py_ref); + Py_CLEAR(clear_module_state->__pyx_n_s_pyfree); + Py_CLEAR(clear_module_state->__pyx_n_s_pymalloc); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_vtable); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex); + Py_CLEAR(clear_module_state->__pyx_n_s_self); + Py_CLEAR(clear_module_state->__pyx_kp_s_self_free_cannot_be_converted_to); + Py_CLEAR(clear_module_state->__pyx_kp_s_self_malloc_cannot_be_converted); + Py_CLEAR(clear_module_state->__pyx_n_s_setstate); + Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_spec); + Py_CLEAR(clear_module_state->__pyx_kp_s_src_hunter_vendor__cymem_cymem_p); + Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource); + Py_CLEAR(clear_module_state->__pyx_n_s_test); + Py_CLEAR(clear_module_state->__pyx_n_s_warn); + Py_CLEAR(clear_module_state->__pyx_n_s_warnings); + Py_CLEAR(clear_module_state->__pyx_k_); + Py_CLEAR(clear_module_state->__pyx_k__2); + Py_CLEAR(clear_module_state->__pyx_k__4); + Py_CLEAR(clear_module_state->__pyx_k__5); + Py_CLEAR(clear_module_state->__pyx_tuple__3); + Py_CLEAR(clear_module_state->__pyx_tuple__7); + Py_CLEAR(clear_module_state->__pyx_tuple__9); + Py_CLEAR(clear_module_state->__pyx_tuple__13); + Py_CLEAR(clear_module_state->__pyx_codeobj__8); + Py_CLEAR(clear_module_state->__pyx_codeobj__10); + Py_CLEAR(clear_module_state->__pyx_codeobj__11); + Py_CLEAR(clear_module_state->__pyx_codeobj__12); + Py_CLEAR(clear_module_state->__pyx_codeobj__14); + Py_CLEAR(clear_module_state->__pyx_codeobj__15); + Py_CLEAR(clear_module_state->__pyx_codeobj__16); + Py_CLEAR(clear_module_state->__pyx_codeobj__17); + Py_CLEAR(clear_module_state->__pyx_codeobj__18); + return 0; +} +#endif +/* #### Code section: module_state_traverse ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { + __pyx_mstate *traverse_module_state = __pyx_mstate(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); + Py_VISIT(traverse_module_state->__pyx_empty_tuple); + Py_VISIT(traverse_module_state->__pyx_empty_bytes); + Py_VISIT(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_6vendor_6_cymem_5cymem_PyMalloc); + Py_VISIT(traverse_module_state->__pyx_type_6hunter_6vendor_6_cymem_5cymem_PyMalloc); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyFree); + Py_VISIT(traverse_module_state->__pyx_type_6hunter_6vendor_6_cymem_5cymem_PyFree); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Pool); + Py_VISIT(traverse_module_state->__pyx_type_6hunter_6vendor_6_cymem_5cymem_Pool); + Py_VISIT(traverse_module_state->__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Address); + Py_VISIT(traverse_module_state->__pyx_type_6hunter_6vendor_6_cymem_5cymem_Address); + Py_VISIT(traverse_module_state->__pyx_n_s_Address); + Py_VISIT(traverse_module_state->__pyx_n_s_Address___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Address___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_kp_s_Allocating_zero_bytes); + Py_VISIT(traverse_module_state->__pyx_n_s_AssertionError); + Py_VISIT(traverse_module_state->__pyx_n_s_Default_Free); + Py_VISIT(traverse_module_state->__pyx_n_s_Default_Malloc); + Py_VISIT(traverse_module_state->__pyx_kp_s_Error_assigning_d_bytes); + Py_VISIT(traverse_module_state->__pyx_kp_s_Error_reallocating_to_d_bytes); + Py_VISIT(traverse_module_state->__pyx_n_s_MemoryError); + Py_VISIT(traverse_module_state->__pyx_kp_s_Pointer_d_not_found_in_Pool_s); + Py_VISIT(traverse_module_state->__pyx_n_s_Pool); + Py_VISIT(traverse_module_state->__pyx_n_s_Pool___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Pool___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Pool_own_pyref); + Py_VISIT(traverse_module_state->__pyx_n_s_PyFree); + Py_VISIT(traverse_module_state->__pyx_n_s_PyFree___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_PyFree___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_PyMalloc); + Py_VISIT(traverse_module_state->__pyx_n_s_PyMalloc___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_PyMalloc___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_kp_s_Realloc_requires_new_size_0); + Py_VISIT(traverse_module_state->__pyx_n_s_TypeError); + Py_VISIT(traverse_module_state->__pyx_n_s_ValueError); + Py_VISIT(traverse_module_state->__pyx_n_s_WARN_ZERO_ALLOC); + Py_VISIT(traverse_module_state->__pyx_n_s__19); + Py_VISIT(traverse_module_state->__pyx_n_s__6); + Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines); + Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback); + Py_VISIT(traverse_module_state->__pyx_kp_u_disable); + Py_VISIT(traverse_module_state->__pyx_n_s_elem_size); + Py_VISIT(traverse_module_state->__pyx_kp_u_enable); + Py_VISIT(traverse_module_state->__pyx_kp_u_gc); + Py_VISIT(traverse_module_state->__pyx_n_s_getstate); + Py_VISIT(traverse_module_state->__pyx_n_s_hunter_vendor__cymem_cymem); + Py_VISIT(traverse_module_state->__pyx_n_s_import); + Py_VISIT(traverse_module_state->__pyx_n_s_initializing); + Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine); + Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled); + Py_VISIT(traverse_module_state->__pyx_n_s_main); + Py_VISIT(traverse_module_state->__pyx_n_s_name); + Py_VISIT(traverse_module_state->__pyx_kp_s_no_default___reduce___due_to_non); + Py_VISIT(traverse_module_state->__pyx_n_s_number); + Py_VISIT(traverse_module_state->__pyx_n_s_own_pyref); + Py_VISIT(traverse_module_state->__pyx_n_s_pop); + Py_VISIT(traverse_module_state->__pyx_n_s_py_ref); + Py_VISIT(traverse_module_state->__pyx_n_s_pyfree); + Py_VISIT(traverse_module_state->__pyx_n_s_pymalloc); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_vtable); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex); + Py_VISIT(traverse_module_state->__pyx_n_s_self); + Py_VISIT(traverse_module_state->__pyx_kp_s_self_free_cannot_be_converted_to); + Py_VISIT(traverse_module_state->__pyx_kp_s_self_malloc_cannot_be_converted); + Py_VISIT(traverse_module_state->__pyx_n_s_setstate); + Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_spec); + Py_VISIT(traverse_module_state->__pyx_kp_s_src_hunter_vendor__cymem_cymem_p); + Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource); + Py_VISIT(traverse_module_state->__pyx_n_s_test); + Py_VISIT(traverse_module_state->__pyx_n_s_warn); + Py_VISIT(traverse_module_state->__pyx_n_s_warnings); + Py_VISIT(traverse_module_state->__pyx_k_); + Py_VISIT(traverse_module_state->__pyx_k__2); + Py_VISIT(traverse_module_state->__pyx_k__4); + Py_VISIT(traverse_module_state->__pyx_k__5); + Py_VISIT(traverse_module_state->__pyx_tuple__3); + Py_VISIT(traverse_module_state->__pyx_tuple__7); + Py_VISIT(traverse_module_state->__pyx_tuple__9); + Py_VISIT(traverse_module_state->__pyx_tuple__13); + Py_VISIT(traverse_module_state->__pyx_codeobj__8); + Py_VISIT(traverse_module_state->__pyx_codeobj__10); + Py_VISIT(traverse_module_state->__pyx_codeobj__11); + Py_VISIT(traverse_module_state->__pyx_codeobj__12); + Py_VISIT(traverse_module_state->__pyx_codeobj__14); + Py_VISIT(traverse_module_state->__pyx_codeobj__15); + Py_VISIT(traverse_module_state->__pyx_codeobj__16); + Py_VISIT(traverse_module_state->__pyx_codeobj__17); + Py_VISIT(traverse_module_state->__pyx_codeobj__18); + return 0; +} +#endif +/* #### Code section: module_state_defines ### */ +#define __pyx_d __pyx_mstate_global->__pyx_d +#define __pyx_b __pyx_mstate_global->__pyx_b +#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime +#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple +#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes +#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode +#ifdef __Pyx_CyFunction_USED +#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType +#endif +#ifdef __Pyx_FusedFunction_USED +#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType +#endif +#ifdef __Pyx_Generator_USED +#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType +#endif +#ifdef __Pyx_IterableCoroutine_USED +#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#define __pyx_ptype_7cpython_4type_type __pyx_mstate_global->__pyx_ptype_7cpython_4type_type +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#define __pyx_type_6hunter_6vendor_6_cymem_5cymem_PyMalloc __pyx_mstate_global->__pyx_type_6hunter_6vendor_6_cymem_5cymem_PyMalloc +#define __pyx_type_6hunter_6vendor_6_cymem_5cymem_PyFree __pyx_mstate_global->__pyx_type_6hunter_6vendor_6_cymem_5cymem_PyFree +#define __pyx_type_6hunter_6vendor_6_cymem_5cymem_Pool __pyx_mstate_global->__pyx_type_6hunter_6vendor_6_cymem_5cymem_Pool +#define __pyx_type_6hunter_6vendor_6_cymem_5cymem_Address __pyx_mstate_global->__pyx_type_6hunter_6vendor_6_cymem_5cymem_Address +#endif +#define __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyMalloc __pyx_mstate_global->__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyMalloc +#define __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyFree __pyx_mstate_global->__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyFree +#define __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Pool __pyx_mstate_global->__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Pool +#define __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Address __pyx_mstate_global->__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Address +#define __pyx_n_s_Address __pyx_mstate_global->__pyx_n_s_Address +#define __pyx_n_s_Address___reduce_cython __pyx_mstate_global->__pyx_n_s_Address___reduce_cython +#define __pyx_n_s_Address___setstate_cython __pyx_mstate_global->__pyx_n_s_Address___setstate_cython +#define __pyx_kp_s_Allocating_zero_bytes __pyx_mstate_global->__pyx_kp_s_Allocating_zero_bytes +#define __pyx_n_s_AssertionError __pyx_mstate_global->__pyx_n_s_AssertionError +#define __pyx_n_s_Default_Free __pyx_mstate_global->__pyx_n_s_Default_Free +#define __pyx_n_s_Default_Malloc __pyx_mstate_global->__pyx_n_s_Default_Malloc +#define __pyx_kp_s_Error_assigning_d_bytes __pyx_mstate_global->__pyx_kp_s_Error_assigning_d_bytes +#define __pyx_kp_s_Error_reallocating_to_d_bytes __pyx_mstate_global->__pyx_kp_s_Error_reallocating_to_d_bytes +#define __pyx_n_s_MemoryError __pyx_mstate_global->__pyx_n_s_MemoryError +#define __pyx_kp_s_Pointer_d_not_found_in_Pool_s __pyx_mstate_global->__pyx_kp_s_Pointer_d_not_found_in_Pool_s +#define __pyx_n_s_Pool __pyx_mstate_global->__pyx_n_s_Pool +#define __pyx_n_s_Pool___reduce_cython __pyx_mstate_global->__pyx_n_s_Pool___reduce_cython +#define __pyx_n_s_Pool___setstate_cython __pyx_mstate_global->__pyx_n_s_Pool___setstate_cython +#define __pyx_n_s_Pool_own_pyref __pyx_mstate_global->__pyx_n_s_Pool_own_pyref +#define __pyx_n_s_PyFree __pyx_mstate_global->__pyx_n_s_PyFree +#define __pyx_n_s_PyFree___reduce_cython __pyx_mstate_global->__pyx_n_s_PyFree___reduce_cython +#define __pyx_n_s_PyFree___setstate_cython __pyx_mstate_global->__pyx_n_s_PyFree___setstate_cython +#define __pyx_n_s_PyMalloc __pyx_mstate_global->__pyx_n_s_PyMalloc +#define __pyx_n_s_PyMalloc___reduce_cython __pyx_mstate_global->__pyx_n_s_PyMalloc___reduce_cython +#define __pyx_n_s_PyMalloc___setstate_cython __pyx_mstate_global->__pyx_n_s_PyMalloc___setstate_cython +#define __pyx_kp_s_Realloc_requires_new_size_0 __pyx_mstate_global->__pyx_kp_s_Realloc_requires_new_size_0 +#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError +#define __pyx_n_s_ValueError __pyx_mstate_global->__pyx_n_s_ValueError +#define __pyx_n_s_WARN_ZERO_ALLOC __pyx_mstate_global->__pyx_n_s_WARN_ZERO_ALLOC +#define __pyx_n_s__19 __pyx_mstate_global->__pyx_n_s__19 +#define __pyx_n_s__6 __pyx_mstate_global->__pyx_n_s__6 +#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines +#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback +#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable +#define __pyx_n_s_elem_size __pyx_mstate_global->__pyx_n_s_elem_size +#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable +#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc +#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate +#define __pyx_n_s_hunter_vendor__cymem_cymem __pyx_mstate_global->__pyx_n_s_hunter_vendor__cymem_cymem +#define __pyx_n_s_import __pyx_mstate_global->__pyx_n_s_import +#define __pyx_n_s_initializing __pyx_mstate_global->__pyx_n_s_initializing +#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine +#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled +#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main +#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name +#define __pyx_kp_s_no_default___reduce___due_to_non __pyx_mstate_global->__pyx_kp_s_no_default___reduce___due_to_non +#define __pyx_n_s_number __pyx_mstate_global->__pyx_n_s_number +#define __pyx_n_s_own_pyref __pyx_mstate_global->__pyx_n_s_own_pyref +#define __pyx_n_s_pop __pyx_mstate_global->__pyx_n_s_pop +#define __pyx_n_s_py_ref __pyx_mstate_global->__pyx_n_s_py_ref +#define __pyx_n_s_pyfree __pyx_mstate_global->__pyx_n_s_pyfree +#define __pyx_n_s_pymalloc __pyx_mstate_global->__pyx_n_s_pymalloc +#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state +#define __pyx_n_s_pyx_vtable __pyx_mstate_global->__pyx_n_s_pyx_vtable +#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce +#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython +#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex +#define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self +#define __pyx_kp_s_self_free_cannot_be_converted_to __pyx_mstate_global->__pyx_kp_s_self_free_cannot_be_converted_to +#define __pyx_kp_s_self_malloc_cannot_be_converted __pyx_mstate_global->__pyx_kp_s_self_malloc_cannot_be_converted +#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate +#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython +#define __pyx_n_s_spec __pyx_mstate_global->__pyx_n_s_spec +#define __pyx_kp_s_src_hunter_vendor__cymem_cymem_p __pyx_mstate_global->__pyx_kp_s_src_hunter_vendor__cymem_cymem_p +#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource +#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test +#define __pyx_n_s_warn __pyx_mstate_global->__pyx_n_s_warn +#define __pyx_n_s_warnings __pyx_mstate_global->__pyx_n_s_warnings +#define __pyx_k_ __pyx_mstate_global->__pyx_k_ +#define __pyx_k__2 __pyx_mstate_global->__pyx_k__2 +#define __pyx_k__4 __pyx_mstate_global->__pyx_k__4 +#define __pyx_k__5 __pyx_mstate_global->__pyx_k__5 +#define __pyx_tuple__3 __pyx_mstate_global->__pyx_tuple__3 +#define __pyx_tuple__7 __pyx_mstate_global->__pyx_tuple__7 +#define __pyx_tuple__9 __pyx_mstate_global->__pyx_tuple__9 +#define __pyx_tuple__13 __pyx_mstate_global->__pyx_tuple__13 +#define __pyx_codeobj__8 __pyx_mstate_global->__pyx_codeobj__8 +#define __pyx_codeobj__10 __pyx_mstate_global->__pyx_codeobj__10 +#define __pyx_codeobj__11 __pyx_mstate_global->__pyx_codeobj__11 +#define __pyx_codeobj__12 __pyx_mstate_global->__pyx_codeobj__12 +#define __pyx_codeobj__14 __pyx_mstate_global->__pyx_codeobj__14 +#define __pyx_codeobj__15 __pyx_mstate_global->__pyx_codeobj__15 +#define __pyx_codeobj__16 __pyx_mstate_global->__pyx_codeobj__16 +#define __pyx_codeobj__17 __pyx_mstate_global->__pyx_codeobj__17 +#define __pyx_codeobj__18 __pyx_mstate_global->__pyx_codeobj__18 +/* #### Code section: module_code ### */ + +/* "hunter/vendor/_cymem/cymem.pyx":12 + * + * cdef class PyMalloc: + * cdef void _set(self, malloc_t malloc): # <<<<<<<<<<<<<< + * self.malloc = malloc + * + */ + +static void __pyx_f_6hunter_6vendor_6_cymem_5cymem_8PyMalloc__set(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *__pyx_v_self, __pyx_t_6hunter_6vendor_6_cymem_5cymem_malloc_t __pyx_v_malloc) { + + /* "hunter/vendor/_cymem/cymem.pyx":13 + * cdef class PyMalloc: + * cdef void _set(self, malloc_t malloc): + * self.malloc = malloc # <<<<<<<<<<<<<< + * + * cdef PyMalloc WrapMalloc(malloc_t malloc): + */ + __pyx_v_self->malloc = __pyx_v_malloc; + + /* "hunter/vendor/_cymem/cymem.pyx":12 + * + * cdef class PyMalloc: + * cdef void _set(self, malloc_t malloc): # <<<<<<<<<<<<<< + * self.malloc = malloc + * + */ + + /* function exit code */ +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.malloc cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_8PyMalloc_1__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*/ +PyDoc_STRVAR(__pyx_doc_6hunter_6vendor_6_cymem_5cymem_8PyMalloc___reduce_cython__, "PyMalloc.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_6hunter_6vendor_6_cymem_5cymem_8PyMalloc_1__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_6vendor_6_cymem_5cymem_8PyMalloc_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_6hunter_6vendor_6_cymem_5cymem_8PyMalloc___reduce_cython__}; +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_8PyMalloc_1__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_MACROS + __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;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_6hunter_6vendor_6_cymem_5cymem_8PyMalloc___reduce_cython__(((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_8PyMalloc___reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "self.malloc cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self.malloc cannot be converted to a Python object for pickling" + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_malloc_cannot_be_converted, 0, 0); + __PYX_ERR(0, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.malloc cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("hunter.vendor._cymem.cymem.PyMalloc.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.malloc cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.malloc cannot be converted to a Python object for pickling" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_8PyMalloc_3__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*/ +PyDoc_STRVAR(__pyx_doc_6hunter_6vendor_6_cymem_5cymem_8PyMalloc_2__setstate_cython__, "PyMalloc.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_6hunter_6vendor_6_cymem_5cymem_8PyMalloc_3__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_6vendor_6_cymem_5cymem_8PyMalloc_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_6hunter_6vendor_6_cymem_5cymem_8PyMalloc_2__setstate_cython__}; +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_8PyMalloc_3__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_MACROS + __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 **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __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(0, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("hunter.vendor._cymem.cymem.PyMalloc.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6hunter_6vendor_6_cymem_5cymem_8PyMalloc_2__setstate_cython__(((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_8PyMalloc_2__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":4 + * raise TypeError, "self.malloc cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self.malloc cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_malloc_cannot_be_converted, 0, 0); + __PYX_ERR(0, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.malloc cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.malloc cannot be converted to a Python object for pickling" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("hunter.vendor._cymem.cymem.PyMalloc.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/vendor/_cymem/cymem.pyx":15 + * self.malloc = malloc + * + * cdef PyMalloc WrapMalloc(malloc_t malloc): # <<<<<<<<<<<<<< + * cdef PyMalloc o = PyMalloc() + * o._set(malloc) + */ + +static struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *__pyx_f_6hunter_6vendor_6_cymem_5cymem_WrapMalloc(__pyx_t_6hunter_6vendor_6_cymem_5cymem_malloc_t __pyx_v_malloc) { + struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *__pyx_v_o = 0; + struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("WrapMalloc", 1); + + /* "hunter/vendor/_cymem/cymem.pyx":16 + * + * cdef PyMalloc WrapMalloc(malloc_t malloc): + * cdef PyMalloc o = PyMalloc() # <<<<<<<<<<<<<< + * o._set(malloc) + * return o + */ + __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyMalloc)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_o = ((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "hunter/vendor/_cymem/cymem.pyx":17 + * cdef PyMalloc WrapMalloc(malloc_t malloc): + * cdef PyMalloc o = PyMalloc() + * o._set(malloc) # <<<<<<<<<<<<<< + * return o + * + */ + ((struct __pyx_vtabstruct_6hunter_6vendor_6_cymem_5cymem_PyMalloc *)__pyx_v_o->__pyx_vtab)->_set(__pyx_v_o, __pyx_v_malloc); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 17, __pyx_L1_error) + + /* "hunter/vendor/_cymem/cymem.pyx":18 + * cdef PyMalloc o = PyMalloc() + * o._set(malloc) + * return o # <<<<<<<<<<<<<< + * + * cdef class PyFree: + */ + __Pyx_XDECREF((PyObject *)__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_o); + __pyx_r = __pyx_v_o; + goto __pyx_L0; + + /* "hunter/vendor/_cymem/cymem.pyx":15 + * self.malloc = malloc + * + * cdef PyMalloc WrapMalloc(malloc_t malloc): # <<<<<<<<<<<<<< + * cdef PyMalloc o = PyMalloc() + * o._set(malloc) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("hunter.vendor._cymem.cymem.WrapMalloc", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_o); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/vendor/_cymem/cymem.pyx":21 + * + * cdef class PyFree: + * cdef void _set(self, free_t free): # <<<<<<<<<<<<<< + * self.free = free + * + */ + +static void __pyx_f_6hunter_6vendor_6_cymem_5cymem_6PyFree__set(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *__pyx_v_self, __pyx_t_6hunter_6vendor_6_cymem_5cymem_free_t __pyx_v_free) { + + /* "hunter/vendor/_cymem/cymem.pyx":22 + * cdef class PyFree: + * cdef void _set(self, free_t free): + * self.free = free # <<<<<<<<<<<<<< + * + * cdef PyFree WrapFree(free_t free): + */ + __pyx_v_self->free = __pyx_v_free; + + /* "hunter/vendor/_cymem/cymem.pyx":21 + * + * cdef class PyFree: + * cdef void _set(self, free_t free): # <<<<<<<<<<<<<< + * self.free = free + * + */ + + /* function exit code */ +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.free cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_6PyFree_1__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*/ +PyDoc_STRVAR(__pyx_doc_6hunter_6vendor_6_cymem_5cymem_6PyFree___reduce_cython__, "PyFree.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_6hunter_6vendor_6_cymem_5cymem_6PyFree_1__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_6vendor_6_cymem_5cymem_6PyFree_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_6hunter_6vendor_6_cymem_5cymem_6PyFree___reduce_cython__}; +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_6PyFree_1__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_MACROS + __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;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_6hunter_6vendor_6_cymem_5cymem_6PyFree___reduce_cython__(((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_6PyFree___reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "self.free cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self.free cannot be converted to a Python object for pickling" + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_free_cannot_be_converted_to, 0, 0); + __PYX_ERR(0, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.free cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("hunter.vendor._cymem.cymem.PyFree.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.free cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.free cannot be converted to a Python object for pickling" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_6PyFree_3__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*/ +PyDoc_STRVAR(__pyx_doc_6hunter_6vendor_6_cymem_5cymem_6PyFree_2__setstate_cython__, "PyFree.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_6hunter_6vendor_6_cymem_5cymem_6PyFree_3__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_6vendor_6_cymem_5cymem_6PyFree_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_6hunter_6vendor_6_cymem_5cymem_6PyFree_2__setstate_cython__}; +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_6PyFree_3__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_MACROS + __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 **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __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(0, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("hunter.vendor._cymem.cymem.PyFree.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6hunter_6vendor_6_cymem_5cymem_6PyFree_2__setstate_cython__(((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_6PyFree_2__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":4 + * raise TypeError, "self.free cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self.free cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_free_cannot_be_converted_to, 0, 0); + __PYX_ERR(0, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.free cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.free cannot be converted to a Python object for pickling" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("hunter.vendor._cymem.cymem.PyFree.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/vendor/_cymem/cymem.pyx":24 + * self.free = free + * + * cdef PyFree WrapFree(free_t free): # <<<<<<<<<<<<<< + * cdef PyFree o = PyFree() + * o._set(free) + */ + +static struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *__pyx_f_6hunter_6vendor_6_cymem_5cymem_WrapFree(__pyx_t_6hunter_6vendor_6_cymem_5cymem_free_t __pyx_v_free) { + struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *__pyx_v_o = 0; + struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("WrapFree", 1); + + /* "hunter/vendor/_cymem/cymem.pyx":25 + * + * cdef PyFree WrapFree(free_t free): + * cdef PyFree o = PyFree() # <<<<<<<<<<<<<< + * o._set(free) + * return o + */ + __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyFree)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 25, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_o = ((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "hunter/vendor/_cymem/cymem.pyx":26 + * cdef PyFree WrapFree(free_t free): + * cdef PyFree o = PyFree() + * o._set(free) # <<<<<<<<<<<<<< + * return o + * + */ + ((struct __pyx_vtabstruct_6hunter_6vendor_6_cymem_5cymem_PyFree *)__pyx_v_o->__pyx_vtab)->_set(__pyx_v_o, __pyx_v_free); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 26, __pyx_L1_error) + + /* "hunter/vendor/_cymem/cymem.pyx":27 + * cdef PyFree o = PyFree() + * o._set(free) + * return o # <<<<<<<<<<<<<< + * + * Default_Malloc = WrapMalloc(PyMem_Malloc) + */ + __Pyx_XDECREF((PyObject *)__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_o); + __pyx_r = __pyx_v_o; + goto __pyx_L0; + + /* "hunter/vendor/_cymem/cymem.pyx":24 + * self.free = free + * + * cdef PyFree WrapFree(free_t free): # <<<<<<<<<<<<<< + * cdef PyFree o = PyFree() + * o._set(free) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("hunter.vendor._cymem.cymem.WrapFree", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_o); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/vendor/_cymem/cymem.pyx":49 + * """ + * + * def __cinit__(self, PyMalloc pymalloc=Default_Malloc, # <<<<<<<<<<<<<< + * PyFree pyfree=Default_Free): + * self.size = 0 + */ + +/* Python wrapper */ +static int __pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *__pyx_v_pymalloc = 0; + struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *__pyx_v_pyfree = 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_MACROS + __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 **__pyx_pyargnames[] = {&__pyx_n_s_pymalloc,&__pyx_n_s_pyfree,0}; + values[0] = __Pyx_Arg_NewRef_VARARGS((PyObject *)__pyx_k_); + values[1] = __Pyx_Arg_NewRef_VARARGS((PyObject *)__pyx_k__2); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pymalloc); + if (value) { values[0] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 49, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyfree); + if (value) { values[1] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 49, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(1, 49, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_pymalloc = ((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *)values[0]); + __pyx_v_pyfree = ((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *)values[1]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 0, 2, __pyx_nargs); __PYX_ERR(1, 49, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("hunter.vendor._cymem.cymem.Pool.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pymalloc), __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyMalloc, 1, "pymalloc", 0))) __PYX_ERR(1, 49, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pyfree), __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyFree, 1, "pyfree", 0))) __PYX_ERR(1, 50, __pyx_L1_error) + __pyx_r = __pyx_pf_6hunter_6vendor_6_cymem_5cymem_4Pool___cinit__(((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *)__pyx_v_self), __pyx_v_pymalloc, __pyx_v_pyfree); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6hunter_6vendor_6_cymem_5cymem_4Pool___cinit__(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *__pyx_v_self, struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *__pyx_v_pymalloc, struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *__pyx_v_pyfree) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__cinit__", 1); + + /* "hunter/vendor/_cymem/cymem.pyx":51 + * def __cinit__(self, PyMalloc pymalloc=Default_Malloc, + * PyFree pyfree=Default_Free): + * self.size = 0 # <<<<<<<<<<<<<< + * self.addresses = {} + * self.refs = [] + */ + __pyx_v_self->size = 0; + + /* "hunter/vendor/_cymem/cymem.pyx":52 + * PyFree pyfree=Default_Free): + * self.size = 0 + * self.addresses = {} # <<<<<<<<<<<<<< + * self.refs = [] + * self.pymalloc = pymalloc + */ + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->addresses); + __Pyx_DECREF(__pyx_v_self->addresses); + __pyx_v_self->addresses = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "hunter/vendor/_cymem/cymem.pyx":53 + * self.size = 0 + * self.addresses = {} + * self.refs = [] # <<<<<<<<<<<<<< + * self.pymalloc = pymalloc + * self.pyfree = pyfree + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->refs); + __Pyx_DECREF(__pyx_v_self->refs); + __pyx_v_self->refs = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "hunter/vendor/_cymem/cymem.pyx":54 + * self.addresses = {} + * self.refs = [] + * self.pymalloc = pymalloc # <<<<<<<<<<<<<< + * self.pyfree = pyfree + * + */ + __Pyx_INCREF((PyObject *)__pyx_v_pymalloc); + __Pyx_GIVEREF((PyObject *)__pyx_v_pymalloc); + __Pyx_GOTREF((PyObject *)__pyx_v_self->pymalloc); + __Pyx_DECREF((PyObject *)__pyx_v_self->pymalloc); + __pyx_v_self->pymalloc = __pyx_v_pymalloc; + + /* "hunter/vendor/_cymem/cymem.pyx":55 + * self.refs = [] + * self.pymalloc = pymalloc + * self.pyfree = pyfree # <<<<<<<<<<<<<< + * + * def __dealloc__(self): + */ + __Pyx_INCREF((PyObject *)__pyx_v_pyfree); + __Pyx_GIVEREF((PyObject *)__pyx_v_pyfree); + __Pyx_GOTREF((PyObject *)__pyx_v_self->pyfree); + __Pyx_DECREF((PyObject *)__pyx_v_self->pyfree); + __pyx_v_self->pyfree = __pyx_v_pyfree; + + /* "hunter/vendor/_cymem/cymem.pyx":49 + * """ + * + * def __cinit__(self, PyMalloc pymalloc=Default_Malloc, # <<<<<<<<<<<<<< + * PyFree pyfree=Default_Free): + * self.size = 0 + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("hunter.vendor._cymem.cymem.Pool.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/vendor/_cymem/cymem.pyx":57 + * self.pyfree = pyfree + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * cdef size_t addr + * if self.addresses is not None: + */ + +/* Python wrapper */ +static void __pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_3__dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_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_6vendor_6_cymem_5cymem_4Pool_2__dealloc__(((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_pf_6hunter_6vendor_6_cymem_5cymem_4Pool_2__dealloc__(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *__pyx_v_self) { + size_t __pyx_v_addr; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + Py_ssize_t __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + size_t __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__dealloc__", 1); + + /* "hunter/vendor/_cymem/cymem.pyx":59 + * def __dealloc__(self): + * cdef size_t addr + * if self.addresses is not None: # <<<<<<<<<<<<<< + * for addr in self.addresses: + * if addr != 0: + */ + __pyx_t_1 = (__pyx_v_self->addresses != ((PyObject*)Py_None)); + if (__pyx_t_1) { + + /* "hunter/vendor/_cymem/cymem.pyx":60 + * cdef size_t addr + * if self.addresses is not None: + * for addr in self.addresses: # <<<<<<<<<<<<<< + * if addr != 0: + * self.pyfree.free(addr) + */ + __pyx_t_3 = 0; + if (unlikely(__pyx_v_self->addresses == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(1, 60, __pyx_L1_error) + } + __pyx_t_6 = __Pyx_dict_iterator(__pyx_v_self->addresses, 1, ((PyObject *)NULL), (&__pyx_t_4), (&__pyx_t_5)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 60, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_2); + __pyx_t_2 = __pyx_t_6; + __pyx_t_6 = 0; + while (1) { + __pyx_t_7 = __Pyx_dict_iter_next(__pyx_t_2, __pyx_t_4, &__pyx_t_3, &__pyx_t_6, NULL, NULL, __pyx_t_5); + if (unlikely(__pyx_t_7 == 0)) break; + if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(1, 60, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyInt_As_size_t(__pyx_t_6); if (unlikely((__pyx_t_8 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 60, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_v_addr = __pyx_t_8; + + /* "hunter/vendor/_cymem/cymem.pyx":61 + * if self.addresses is not None: + * for addr in self.addresses: + * if addr != 0: # <<<<<<<<<<<<<< + * self.pyfree.free(addr) + * + */ + __pyx_t_1 = (__pyx_v_addr != 0); + if (__pyx_t_1) { + + /* "hunter/vendor/_cymem/cymem.pyx":62 + * for addr in self.addresses: + * if addr != 0: + * self.pyfree.free(addr) # <<<<<<<<<<<<<< + * + * cdef void* alloc(self, size_t number, size_t elem_size) except NULL: + */ + __pyx_v_self->pyfree->free(((void *)__pyx_v_addr)); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 62, __pyx_L1_error) + + /* "hunter/vendor/_cymem/cymem.pyx":61 + * if self.addresses is not None: + * for addr in self.addresses: + * if addr != 0: # <<<<<<<<<<<<<< + * self.pyfree.free(addr) + * + */ + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "hunter/vendor/_cymem/cymem.pyx":59 + * def __dealloc__(self): + * cdef size_t addr + * if self.addresses is not None: # <<<<<<<<<<<<<< + * for addr in self.addresses: + * if addr != 0: + */ + } + + /* "hunter/vendor/_cymem/cymem.pyx":57 + * self.pyfree = pyfree + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * cdef size_t addr + * if self.addresses is not None: + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_WriteUnraisable("hunter.vendor._cymem.cymem.Pool.__dealloc__", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "hunter/vendor/_cymem/cymem.pyx":64 + * self.pyfree.free(addr) + * + * cdef void* alloc(self, size_t number, size_t elem_size) except NULL: # <<<<<<<<<<<<<< + * """Allocate a 0-initialized number*elem_size-byte block of memory, and + * remember its address. The block will be freed when the Pool is garbage + */ + +static void *__pyx_f_6hunter_6vendor_6_cymem_5cymem_4Pool_alloc(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *__pyx_v_self, size_t __pyx_v_number, size_t __pyx_v_elem_size) { + void *__pyx_v_p; + void *__pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + void *__pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("alloc", 1); + + /* "hunter/vendor/_cymem/cymem.pyx":70 + * WARN_ZERO_ALLOC was set to True. + * """ + * if WARN_ZERO_ALLOC and (number == 0 or elem_size == 0): # <<<<<<<<<<<<<< + * warnings.warn("Allocating zero bytes") + * cdef void* p = self.pymalloc.malloc(number * elem_size) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_WARN_ZERO_ALLOC); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 70, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 70, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __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_v_number == 0); + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = (__pyx_v_elem_size == 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "hunter/vendor/_cymem/cymem.pyx":71 + * """ + * if WARN_ZERO_ALLOC and (number == 0 or elem_size == 0): + * warnings.warn("Allocating zero bytes") # <<<<<<<<<<<<<< + * cdef void* p = self.pymalloc.malloc(number * elem_size) + * if p == NULL: + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_warnings); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 71, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_warn); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 71, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (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; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_kp_s_Allocating_zero_bytes}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 71, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "hunter/vendor/_cymem/cymem.pyx":70 + * WARN_ZERO_ALLOC was set to True. + * """ + * if WARN_ZERO_ALLOC and (number == 0 or elem_size == 0): # <<<<<<<<<<<<<< + * warnings.warn("Allocating zero bytes") + * cdef void* p = self.pymalloc.malloc(number * elem_size) + */ + } + + /* "hunter/vendor/_cymem/cymem.pyx":72 + * if WARN_ZERO_ALLOC and (number == 0 or elem_size == 0): + * warnings.warn("Allocating zero bytes") + * cdef void* p = self.pymalloc.malloc(number * elem_size) # <<<<<<<<<<<<<< + * if p == NULL: + * raise MemoryError("Error assigning %d bytes" % (number * elem_size)) + */ + __pyx_t_7 = __pyx_v_self->pymalloc->malloc((__pyx_v_number * __pyx_v_elem_size)); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 72, __pyx_L1_error) + __pyx_v_p = __pyx_t_7; + + /* "hunter/vendor/_cymem/cymem.pyx":73 + * warnings.warn("Allocating zero bytes") + * cdef void* p = self.pymalloc.malloc(number * elem_size) + * if p == NULL: # <<<<<<<<<<<<<< + * raise MemoryError("Error assigning %d bytes" % (number * elem_size)) + * memset(p, 0, number * elem_size) + */ + __pyx_t_1 = (__pyx_v_p == NULL); + if (unlikely(__pyx_t_1)) { + + /* "hunter/vendor/_cymem/cymem.pyx":74 + * cdef void* p = self.pymalloc.malloc(number * elem_size) + * if p == NULL: + * raise MemoryError("Error assigning %d bytes" % (number * elem_size)) # <<<<<<<<<<<<<< + * memset(p, 0, number * elem_size) + * self.addresses[p] = number * elem_size + */ + __pyx_t_2 = __Pyx_PyInt_FromSize_t((__pyx_v_number * __pyx_v_elem_size)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 74, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Error_assigning_d_bytes, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 74, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_MemoryError, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 74, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(1, 74, __pyx_L1_error) + + /* "hunter/vendor/_cymem/cymem.pyx":73 + * warnings.warn("Allocating zero bytes") + * cdef void* p = self.pymalloc.malloc(number * elem_size) + * if p == NULL: # <<<<<<<<<<<<<< + * raise MemoryError("Error assigning %d bytes" % (number * elem_size)) + * memset(p, 0, number * elem_size) + */ + } + + /* "hunter/vendor/_cymem/cymem.pyx":75 + * if p == NULL: + * raise MemoryError("Error assigning %d bytes" % (number * elem_size)) + * memset(p, 0, number * elem_size) # <<<<<<<<<<<<<< + * self.addresses[p] = number * elem_size + * self.size += number * elem_size + */ + (void)(memset(__pyx_v_p, 0, (__pyx_v_number * __pyx_v_elem_size))); + + /* "hunter/vendor/_cymem/cymem.pyx":76 + * raise MemoryError("Error assigning %d bytes" % (number * elem_size)) + * memset(p, 0, number * elem_size) + * self.addresses[p] = number * elem_size # <<<<<<<<<<<<<< + * self.size += number * elem_size + * return p + */ + __pyx_t_2 = __Pyx_PyInt_FromSize_t((__pyx_v_number * __pyx_v_elem_size)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(__pyx_v_self->addresses == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 76, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_PyInt_FromSize_t(((size_t)__pyx_v_p)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely((PyDict_SetItem(__pyx_v_self->addresses, __pyx_t_5, __pyx_t_2) < 0))) __PYX_ERR(1, 76, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "hunter/vendor/_cymem/cymem.pyx":77 + * memset(p, 0, number * elem_size) + * self.addresses[p] = number * elem_size + * self.size += number * elem_size # <<<<<<<<<<<<<< + * return p + * + */ + __pyx_v_self->size = (__pyx_v_self->size + (__pyx_v_number * __pyx_v_elem_size)); + + /* "hunter/vendor/_cymem/cymem.pyx":78 + * self.addresses[p] = number * elem_size + * self.size += number * elem_size + * return p # <<<<<<<<<<<<<< + * + * cdef void* realloc(self, void* p, size_t new_size) except NULL: + */ + __pyx_r = __pyx_v_p; + goto __pyx_L0; + + /* "hunter/vendor/_cymem/cymem.pyx":64 + * self.pyfree.free(addr) + * + * cdef void* alloc(self, size_t number, size_t elem_size) except NULL: # <<<<<<<<<<<<<< + * """Allocate a 0-initialized number*elem_size-byte block of memory, and + * remember its address. The block will be freed when the Pool is garbage + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("hunter.vendor._cymem.cymem.Pool.alloc", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/vendor/_cymem/cymem.pyx":80 + * return p + * + * cdef void* realloc(self, void* p, size_t new_size) except NULL: # <<<<<<<<<<<<<< + * """Resizes the memory block pointed to by p to new_size bytes, returning + * a non-NULL pointer to the new block. new_size must be larger than the + */ + +static void *__pyx_f_6hunter_6vendor_6_cymem_5cymem_4Pool_realloc(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *__pyx_v_self, void *__pyx_v_p, size_t __pyx_v_new_size) { + void *__pyx_v_new_ptr; + void *__pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + void *__pyx_t_5; + size_t __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("realloc", 1); + + /* "hunter/vendor/_cymem/cymem.pyx":87 + * If p is not in the Pool or new_size is 0, a MemoryError is raised. + * """ + * if p not in self.addresses: # <<<<<<<<<<<<<< + * raise ValueError("Pointer %d not found in Pool %s" % (p, self.addresses)) + * if new_size == 0: + */ + __pyx_t_1 = __Pyx_PyInt_FromSize_t(((size_t)__pyx_v_p)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__pyx_v_self->addresses == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(1, 87, __pyx_L1_error) + } + __pyx_t_2 = (__Pyx_PyDict_ContainsTF(__pyx_t_1, __pyx_v_self->addresses, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 87, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(__pyx_t_2)) { + + /* "hunter/vendor/_cymem/cymem.pyx":88 + * """ + * if p not in self.addresses: + * raise ValueError("Pointer %d not found in Pool %s" % (p, self.addresses)) # <<<<<<<<<<<<<< + * if new_size == 0: + * raise ValueError("Realloc requires new_size > 0") + */ + __pyx_t_1 = __Pyx_PyInt_FromSize_t(((size_t)__pyx_v_p)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 88, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 88, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1)) __PYX_ERR(1, 88, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->addresses); + __Pyx_GIVEREF(__pyx_v_self->addresses); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_self->addresses)) __PYX_ERR(1, 88, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Pointer_d_not_found_in_Pool_s, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 88, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 88, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 88, __pyx_L1_error) + + /* "hunter/vendor/_cymem/cymem.pyx":87 + * If p is not in the Pool or new_size is 0, a MemoryError is raised. + * """ + * if p not in self.addresses: # <<<<<<<<<<<<<< + * raise ValueError("Pointer %d not found in Pool %s" % (p, self.addresses)) + * if new_size == 0: + */ + } + + /* "hunter/vendor/_cymem/cymem.pyx":89 + * if p not in self.addresses: + * raise ValueError("Pointer %d not found in Pool %s" % (p, self.addresses)) + * if new_size == 0: # <<<<<<<<<<<<<< + * raise ValueError("Realloc requires new_size > 0") + * assert new_size > self.addresses[p] + */ + __pyx_t_2 = (__pyx_v_new_size == 0); + if (unlikely(__pyx_t_2)) { + + /* "hunter/vendor/_cymem/cymem.pyx":90 + * raise ValueError("Pointer %d not found in Pool %s" % (p, self.addresses)) + * if new_size == 0: + * raise ValueError("Realloc requires new_size > 0") # <<<<<<<<<<<<<< + * assert new_size > self.addresses[p] + * cdef void* new_ptr = self.alloc(1, new_size) + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 90, __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(1, 90, __pyx_L1_error) + + /* "hunter/vendor/_cymem/cymem.pyx":89 + * if p not in self.addresses: + * raise ValueError("Pointer %d not found in Pool %s" % (p, self.addresses)) + * if new_size == 0: # <<<<<<<<<<<<<< + * raise ValueError("Realloc requires new_size > 0") + * assert new_size > self.addresses[p] + */ + } + + /* "hunter/vendor/_cymem/cymem.pyx":91 + * if new_size == 0: + * raise ValueError("Realloc requires new_size > 0") + * assert new_size > self.addresses[p] # <<<<<<<<<<<<<< + * cdef void* new_ptr = self.alloc(1, new_size) + * if new_ptr == NULL: + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_3 = __Pyx_PyInt_FromSize_t(__pyx_v_new_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 91, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (unlikely(__pyx_v_self->addresses == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 91, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_PyInt_FromSize_t(((size_t)__pyx_v_p)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 91, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyDict_GetItem(__pyx_v_self->addresses, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 91, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyObject_RichCompare(__pyx_t_3, __pyx_t_4, Py_GT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 91, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 91, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(1, 91, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(1, 91, __pyx_L1_error) + #endif + + /* "hunter/vendor/_cymem/cymem.pyx":92 + * raise ValueError("Realloc requires new_size > 0") + * assert new_size > self.addresses[p] + * cdef void* new_ptr = self.alloc(1, new_size) # <<<<<<<<<<<<<< + * if new_ptr == NULL: + * raise MemoryError("Error reallocating to %d bytes" % new_size) + */ + __pyx_t_5 = ((struct __pyx_vtabstruct_6hunter_6vendor_6_cymem_5cymem_Pool *)__pyx_v_self->__pyx_vtab)->alloc(__pyx_v_self, 1, __pyx_v_new_size); if (unlikely(__pyx_t_5 == ((void *)NULL))) __PYX_ERR(1, 92, __pyx_L1_error) + __pyx_v_new_ptr = __pyx_t_5; + + /* "hunter/vendor/_cymem/cymem.pyx":93 + * assert new_size > self.addresses[p] + * cdef void* new_ptr = self.alloc(1, new_size) + * if new_ptr == NULL: # <<<<<<<<<<<<<< + * raise MemoryError("Error reallocating to %d bytes" % new_size) + * memcpy(new_ptr, p, self.addresses[p]) + */ + __pyx_t_2 = (__pyx_v_new_ptr == NULL); + if (unlikely(__pyx_t_2)) { + + /* "hunter/vendor/_cymem/cymem.pyx":94 + * cdef void* new_ptr = self.alloc(1, new_size) + * if new_ptr == NULL: + * raise MemoryError("Error reallocating to %d bytes" % new_size) # <<<<<<<<<<<<<< + * memcpy(new_ptr, p, self.addresses[p]) + * self.free(p) + */ + __pyx_t_1 = __Pyx_PyInt_FromSize_t(__pyx_v_new_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Error_reallocating_to_d_bytes, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_MemoryError, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 94, __pyx_L1_error) + + /* "hunter/vendor/_cymem/cymem.pyx":93 + * assert new_size > self.addresses[p] + * cdef void* new_ptr = self.alloc(1, new_size) + * if new_ptr == NULL: # <<<<<<<<<<<<<< + * raise MemoryError("Error reallocating to %d bytes" % new_size) + * memcpy(new_ptr, p, self.addresses[p]) + */ + } + + /* "hunter/vendor/_cymem/cymem.pyx":95 + * if new_ptr == NULL: + * raise MemoryError("Error reallocating to %d bytes" % new_size) + * memcpy(new_ptr, p, self.addresses[p]) # <<<<<<<<<<<<<< + * self.free(p) + * self.addresses[new_ptr] = new_size + */ + if (unlikely(__pyx_v_self->addresses == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 95, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_PyInt_FromSize_t(((size_t)__pyx_v_p)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 95, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyDict_GetItem(__pyx_v_self->addresses, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 95, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_6 = __Pyx_PyInt_As_size_t(__pyx_t_4); if (unlikely((__pyx_t_6 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 95, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + (void)(memcpy(__pyx_v_new_ptr, __pyx_v_p, __pyx_t_6)); + + /* "hunter/vendor/_cymem/cymem.pyx":96 + * raise MemoryError("Error reallocating to %d bytes" % new_size) + * memcpy(new_ptr, p, self.addresses[p]) + * self.free(p) # <<<<<<<<<<<<<< + * self.addresses[new_ptr] = new_size + * return new_ptr + */ + ((struct __pyx_vtabstruct_6hunter_6vendor_6_cymem_5cymem_Pool *)__pyx_v_self->__pyx_vtab)->free(__pyx_v_self, __pyx_v_p); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 96, __pyx_L1_error) + + /* "hunter/vendor/_cymem/cymem.pyx":97 + * memcpy(new_ptr, p, self.addresses[p]) + * self.free(p) + * self.addresses[new_ptr] = new_size # <<<<<<<<<<<<<< + * return new_ptr + * + */ + __pyx_t_4 = __Pyx_PyInt_FromSize_t(__pyx_v_new_size); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (unlikely(__pyx_v_self->addresses == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 97, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_PyInt_FromSize_t(((size_t)__pyx_v_new_ptr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_self->addresses, __pyx_t_1, __pyx_t_4) < 0))) __PYX_ERR(1, 97, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "hunter/vendor/_cymem/cymem.pyx":98 + * self.free(p) + * self.addresses[new_ptr] = new_size + * return new_ptr # <<<<<<<<<<<<<< + * + * cdef void free(self, void* p) except *: + */ + __pyx_r = __pyx_v_new_ptr; + goto __pyx_L0; + + /* "hunter/vendor/_cymem/cymem.pyx":80 + * return p + * + * cdef void* realloc(self, void* p, size_t new_size) except NULL: # <<<<<<<<<<<<<< + * """Resizes the memory block pointed to by p to new_size bytes, returning + * a non-NULL pointer to the new block. new_size must be larger than the + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("hunter.vendor._cymem.cymem.Pool.realloc", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/vendor/_cymem/cymem.pyx":100 + * return new_ptr + * + * cdef void free(self, void* p) except *: # <<<<<<<<<<<<<< + * """Frees the memory block pointed to by p, which must have been returned + * by a previous call to Pool.alloc. You don't necessarily need to free + */ + +static void __pyx_f_6hunter_6vendor_6_cymem_5cymem_4Pool_free(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *__pyx_v_self, void *__pyx_v_p) { + __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_RefNannySetupContext("free", 1); + + /* "hunter/vendor/_cymem/cymem.pyx":108 + * If p is not in Pool.addresses, a KeyError is raised. + * """ + * self.size -= self.addresses.pop(p) # <<<<<<<<<<<<<< + * self.pyfree.free(p) + * + */ + __pyx_t_1 = __Pyx_PyInt_FromSize_t(__pyx_v_self->size); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__pyx_v_self->addresses == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "pop"); + __PYX_ERR(1, 108, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_PyInt_FromSize_t(((size_t)__pyx_v_p)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyDict_Pop(__pyx_v_self->addresses, __pyx_t_2, ((PyObject *)NULL)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyNumber_InPlaceSubtract(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 108, __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_t_4 = __Pyx_PyInt_As_size_t(__pyx_t_2); if (unlikely((__pyx_t_4 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 108, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_self->size = __pyx_t_4; + + /* "hunter/vendor/_cymem/cymem.pyx":109 + * """ + * self.size -= self.addresses.pop(p) + * self.pyfree.free(p) # <<<<<<<<<<<<<< + * + * def own_pyref(self, object py_ref): + */ + __pyx_v_self->pyfree->free(__pyx_v_p); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 109, __pyx_L1_error) + + /* "hunter/vendor/_cymem/cymem.pyx":100 + * return new_ptr + * + * cdef void free(self, void* p) except *: # <<<<<<<<<<<<<< + * """Frees the memory block pointed to by p, which must have been returned + * by a previous call to Pool.alloc. You don't necessarily need to free + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("hunter.vendor._cymem.cymem.Pool.free", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "hunter/vendor/_cymem/cymem.pyx":111 + * self.pyfree.free(p) + * + * def own_pyref(self, object py_ref): # <<<<<<<<<<<<<< + * self.refs.append(py_ref) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_5own_pyref(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*/ +PyDoc_STRVAR(__pyx_doc_6hunter_6vendor_6_cymem_5cymem_4Pool_4own_pyref, "Pool.own_pyref(self, py_ref)"); +static PyMethodDef __pyx_mdef_6hunter_6vendor_6_cymem_5cymem_4Pool_5own_pyref = {"own_pyref", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_5own_pyref, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_6hunter_6vendor_6_cymem_5cymem_4Pool_4own_pyref}; +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_5own_pyref(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_py_ref = 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("own_pyref (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __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 **__pyx_pyargnames[] = {&__pyx_n_s_py_ref,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_py_ref)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 111, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "own_pyref") < 0)) __PYX_ERR(1, 111, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_py_ref = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("own_pyref", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 111, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("hunter.vendor._cymem.cymem.Pool.own_pyref", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6hunter_6vendor_6_cymem_5cymem_4Pool_4own_pyref(((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *)__pyx_v_self), __pyx_v_py_ref); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_4Pool_4own_pyref(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *__pyx_v_self, PyObject *__pyx_v_py_ref) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("own_pyref", 1); + + /* "hunter/vendor/_cymem/cymem.pyx":112 + * + * def own_pyref(self, object py_ref): + * self.refs.append(py_ref) # <<<<<<<<<<<<<< + * + * + */ + if (unlikely(__pyx_v_self->refs == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "append"); + __PYX_ERR(1, 112, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_PyList_Append(__pyx_v_self->refs, __pyx_v_py_ref); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(1, 112, __pyx_L1_error) + + /* "hunter/vendor/_cymem/cymem.pyx":111 + * self.pyfree.free(p) + * + * def own_pyref(self, object py_ref): # <<<<<<<<<<<<<< + * self.refs.append(py_ref) + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("hunter.vendor._cymem.cymem.Pool.own_pyref", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/vendor/_cymem/cymem.pxd":18 + * + * cdef class Pool: + * cdef readonly size_t size # <<<<<<<<<<<<<< + * cdef readonly dict addresses + * cdef readonly list refs + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_4size_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_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_6vendor_6_cymem_5cymem_4Pool_4size___get__(((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_4Pool_4size___get__(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_FromSize_t(__pyx_v_self->size); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("hunter.vendor._cymem.cymem.Pool.size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/vendor/_cymem/cymem.pxd":19 + * cdef class Pool: + * cdef readonly size_t size + * cdef readonly dict addresses # <<<<<<<<<<<<<< + * cdef readonly list refs + * cdef readonly PyMalloc pymalloc + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_9addresses_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_9addresses_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_6vendor_6_cymem_5cymem_4Pool_9addresses___get__(((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_4Pool_9addresses___get__(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->addresses); + __pyx_r = __pyx_v_self->addresses; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/vendor/_cymem/cymem.pxd":20 + * cdef readonly size_t size + * cdef readonly dict addresses + * cdef readonly list refs # <<<<<<<<<<<<<< + * cdef readonly PyMalloc pymalloc + * cdef readonly PyFree pyfree + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_4refs_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_4refs_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_6vendor_6_cymem_5cymem_4Pool_4refs___get__(((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_4Pool_4refs___get__(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->refs); + __pyx_r = __pyx_v_self->refs; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/vendor/_cymem/cymem.pxd":21 + * cdef readonly dict addresses + * cdef readonly list refs + * cdef readonly PyMalloc pymalloc # <<<<<<<<<<<<<< + * cdef readonly PyFree pyfree + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_8pymalloc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_8pymalloc_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_6vendor_6_cymem_5cymem_4Pool_8pymalloc___get__(((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_4Pool_8pymalloc___get__(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_self->pymalloc); + __pyx_r = ((PyObject *)__pyx_v_self->pymalloc); + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/vendor/_cymem/cymem.pxd":22 + * cdef readonly list refs + * cdef readonly PyMalloc pymalloc + * cdef readonly PyFree pyfree # <<<<<<<<<<<<<< + * + * cdef void* alloc(self, size_t number, size_t size) except NULL + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_6pyfree_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_6pyfree_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_6vendor_6_cymem_5cymem_4Pool_6pyfree___get__(((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_4Pool_6pyfree___get__(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_self->pyfree); + __pyx_r = ((PyObject *)__pyx_v_self->pyfree); + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_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*/ +PyDoc_STRVAR(__pyx_doc_6hunter_6vendor_6_cymem_5cymem_4Pool_6__reduce_cython__, "Pool.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_6hunter_6vendor_6_cymem_5cymem_4Pool_7__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_6hunter_6vendor_6_cymem_5cymem_4Pool_6__reduce_cython__}; +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_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("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __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;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_6hunter_6vendor_6_cymem_5cymem_4Pool_6__reduce_cython__(((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_4Pool_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(0, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("hunter.vendor._cymem.cymem.Pool.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(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__" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_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*/ +PyDoc_STRVAR(__pyx_doc_6hunter_6vendor_6_cymem_5cymem_4Pool_8__setstate_cython__, "Pool.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_6hunter_6vendor_6_cymem_5cymem_4Pool_9__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_6hunter_6vendor_6_cymem_5cymem_4Pool_8__setstate_cython__}; +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_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_MACROS + __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 **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __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(0, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("hunter.vendor._cymem.cymem.Pool.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6hunter_6vendor_6_cymem_5cymem_4Pool_8__setstate_cython__(((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_4Pool_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(0, 4, __pyx_L1_error) + + /* "(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__" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("hunter.vendor._cymem.cymem.Pool.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/vendor/_cymem/cymem.pyx":133 + * pyfree (PyFree): The free to use (default uses PyMem_Free). + * """ + * def __cinit__(self, size_t number, size_t elem_size, # <<<<<<<<<<<<<< + * PyMalloc pymalloc=Default_Malloc, PyFree pyfree=Default_Free): + * self.ptr = NULL + */ + +/* Python wrapper */ +static int __pyx_pw_6hunter_6vendor_6_cymem_5cymem_7Address_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_6hunter_6vendor_6_cymem_5cymem_7Address_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED size_t __pyx_v_number; + CYTHON_UNUSED size_t __pyx_v_elem_size; + struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *__pyx_v_pymalloc = 0; + struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *__pyx_v_pyfree = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,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_MACROS + __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 **__pyx_pyargnames[] = {&__pyx_n_s_number,&__pyx_n_s_elem_size,&__pyx_n_s_pymalloc,&__pyx_n_s_pyfree,0}; + values[2] = __Pyx_Arg_NewRef_VARARGS((PyObject *)__pyx_k__4); + values[3] = __Pyx_Arg_NewRef_VARARGS((PyObject *)__pyx_k__5); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 4: values[3] = __Pyx_Arg_VARARGS(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_number)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 133, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_elem_size)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 133, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 4, 1); __PYX_ERR(1, 133, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pymalloc); + if (value) { values[2] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 133, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyfree); + if (value) { values[3] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 133, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(1, 133, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 4: values[3] = __Pyx_Arg_VARARGS(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); + values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_number = __Pyx_PyInt_As_size_t(values[0]); if (unlikely((__pyx_v_number == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 133, __pyx_L3_error) + __pyx_v_elem_size = __Pyx_PyInt_As_size_t(values[1]); if (unlikely((__pyx_v_elem_size == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 133, __pyx_L3_error) + __pyx_v_pymalloc = ((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *)values[2]); + __pyx_v_pyfree = ((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *)values[3]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 4, __pyx_nargs); __PYX_ERR(1, 133, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("hunter.vendor._cymem.cymem.Address.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pymalloc), __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyMalloc, 1, "pymalloc", 0))) __PYX_ERR(1, 134, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pyfree), __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyFree, 1, "pyfree", 0))) __PYX_ERR(1, 134, __pyx_L1_error) + __pyx_r = __pyx_pf_6hunter_6vendor_6_cymem_5cymem_7Address___cinit__(((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *)__pyx_v_self), __pyx_v_number, __pyx_v_elem_size, __pyx_v_pymalloc, __pyx_v_pyfree); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6hunter_6vendor_6_cymem_5cymem_7Address___cinit__(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *__pyx_v_self, CYTHON_UNUSED size_t __pyx_v_number, CYTHON_UNUSED size_t __pyx_v_elem_size, struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *__pyx_v_pymalloc, struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *__pyx_v_pyfree) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__", 1); + + /* "hunter/vendor/_cymem/cymem.pyx":135 + * def __cinit__(self, size_t number, size_t elem_size, + * PyMalloc pymalloc=Default_Malloc, PyFree pyfree=Default_Free): + * self.ptr = NULL # <<<<<<<<<<<<<< + * self.pymalloc = pymalloc + * self.pyfree = pyfree + */ + __pyx_v_self->ptr = NULL; + + /* "hunter/vendor/_cymem/cymem.pyx":136 + * PyMalloc pymalloc=Default_Malloc, PyFree pyfree=Default_Free): + * self.ptr = NULL + * self.pymalloc = pymalloc # <<<<<<<<<<<<<< + * self.pyfree = pyfree + * + */ + __Pyx_INCREF((PyObject *)__pyx_v_pymalloc); + __Pyx_GIVEREF((PyObject *)__pyx_v_pymalloc); + __Pyx_GOTREF((PyObject *)__pyx_v_self->pymalloc); + __Pyx_DECREF((PyObject *)__pyx_v_self->pymalloc); + __pyx_v_self->pymalloc = __pyx_v_pymalloc; + + /* "hunter/vendor/_cymem/cymem.pyx":137 + * self.ptr = NULL + * self.pymalloc = pymalloc + * self.pyfree = pyfree # <<<<<<<<<<<<<< + * + * def __init__(self, size_t number, size_t elem_size): + */ + __Pyx_INCREF((PyObject *)__pyx_v_pyfree); + __Pyx_GIVEREF((PyObject *)__pyx_v_pyfree); + __Pyx_GOTREF((PyObject *)__pyx_v_self->pyfree); + __Pyx_DECREF((PyObject *)__pyx_v_self->pyfree); + __pyx_v_self->pyfree = __pyx_v_pyfree; + + /* "hunter/vendor/_cymem/cymem.pyx":133 + * pyfree (PyFree): The free to use (default uses PyMem_Free). + * """ + * def __cinit__(self, size_t number, size_t elem_size, # <<<<<<<<<<<<<< + * PyMalloc pymalloc=Default_Malloc, PyFree pyfree=Default_Free): + * self.ptr = NULL + */ + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/vendor/_cymem/cymem.pyx":139 + * self.pyfree = pyfree + * + * def __init__(self, size_t number, size_t elem_size): # <<<<<<<<<<<<<< + * self.ptr = self.pymalloc.malloc(number * elem_size) + * if self.ptr == NULL: + */ + +/* Python wrapper */ +static int __pyx_pw_6hunter_6vendor_6_cymem_5cymem_7Address_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_6hunter_6vendor_6_cymem_5cymem_7Address_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + size_t __pyx_v_number; + size_t __pyx_v_elem_size; + 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_MACROS + __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 **__pyx_pyargnames[] = {&__pyx_n_s_number,&__pyx_n_s_elem_size,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_number)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 139, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_elem_size)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 139, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, 1); __PYX_ERR(1, 139, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(1, 139, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); + } + __pyx_v_number = __Pyx_PyInt_As_size_t(values[0]); if (unlikely((__pyx_v_number == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 139, __pyx_L3_error) + __pyx_v_elem_size = __Pyx_PyInt_As_size_t(values[1]); if (unlikely((__pyx_v_elem_size == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 139, __pyx_L3_error) + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, __pyx_nargs); __PYX_ERR(1, 139, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("hunter.vendor._cymem.cymem.Address.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6hunter_6vendor_6_cymem_5cymem_7Address_2__init__(((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *)__pyx_v_self), __pyx_v_number, __pyx_v_elem_size); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6hunter_6vendor_6_cymem_5cymem_7Address_2__init__(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *__pyx_v_self, size_t __pyx_v_number, size_t __pyx_v_elem_size) { + int __pyx_r; + __Pyx_RefNannyDeclarations + void *__pyx_t_1; + 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_RefNannySetupContext("__init__", 1); + + /* "hunter/vendor/_cymem/cymem.pyx":140 + * + * def __init__(self, size_t number, size_t elem_size): + * self.ptr = self.pymalloc.malloc(number * elem_size) # <<<<<<<<<<<<<< + * if self.ptr == NULL: + * raise MemoryError("Error assigning %d bytes" % number * elem_size) + */ + __pyx_t_1 = __pyx_v_self->pymalloc->malloc((__pyx_v_number * __pyx_v_elem_size)); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 140, __pyx_L1_error) + __pyx_v_self->ptr = __pyx_t_1; + + /* "hunter/vendor/_cymem/cymem.pyx":141 + * def __init__(self, size_t number, size_t elem_size): + * self.ptr = self.pymalloc.malloc(number * elem_size) + * if self.ptr == NULL: # <<<<<<<<<<<<<< + * raise MemoryError("Error assigning %d bytes" % number * elem_size) + * memset(self.ptr, 0, number * elem_size) + */ + __pyx_t_2 = (__pyx_v_self->ptr == NULL); + if (unlikely(__pyx_t_2)) { + + /* "hunter/vendor/_cymem/cymem.pyx":142 + * self.ptr = self.pymalloc.malloc(number * elem_size) + * if self.ptr == NULL: + * raise MemoryError("Error assigning %d bytes" % number * elem_size) # <<<<<<<<<<<<<< + * memset(self.ptr, 0, number * elem_size) + * + */ + __pyx_t_3 = __Pyx_PyInt_FromSize_t(__pyx_v_number); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Error_assigning_d_bytes, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PySequence_Multiply(__pyx_t_4, __pyx_v_elem_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_MemoryError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(1, 142, __pyx_L1_error) + + /* "hunter/vendor/_cymem/cymem.pyx":141 + * def __init__(self, size_t number, size_t elem_size): + * self.ptr = self.pymalloc.malloc(number * elem_size) + * if self.ptr == NULL: # <<<<<<<<<<<<<< + * raise MemoryError("Error assigning %d bytes" % number * elem_size) + * memset(self.ptr, 0, number * elem_size) + */ + } + + /* "hunter/vendor/_cymem/cymem.pyx":143 + * if self.ptr == NULL: + * raise MemoryError("Error assigning %d bytes" % number * elem_size) + * memset(self.ptr, 0, number * elem_size) # <<<<<<<<<<<<<< + * + * property addr: + */ + (void)(memset(__pyx_v_self->ptr, 0, (__pyx_v_number * __pyx_v_elem_size))); + + /* "hunter/vendor/_cymem/cymem.pyx":139 + * self.pyfree = pyfree + * + * def __init__(self, size_t number, size_t elem_size): # <<<<<<<<<<<<<< + * self.ptr = self.pymalloc.malloc(number * elem_size) + * if self.ptr == NULL: + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("hunter.vendor._cymem.cymem.Address.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/vendor/_cymem/cymem.pyx":146 + * + * property addr: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.ptr + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_7Address_4addr_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_7Address_4addr_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_6vendor_6_cymem_5cymem_7Address_4addr___get__(((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_7Address_4addr___get__(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "hunter/vendor/_cymem/cymem.pyx":147 + * property addr: + * def __get__(self): + * return self.ptr # <<<<<<<<<<<<<< + * + * def __dealloc__(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_FromSize_t(((size_t)__pyx_v_self->ptr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "hunter/vendor/_cymem/cymem.pyx":146 + * + * property addr: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.ptr + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("hunter.vendor._cymem.cymem.Address.addr.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/vendor/_cymem/cymem.pyx":149 + * return self.ptr + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * if self.ptr != NULL: + * self.pyfree.free(self.ptr) + */ + +/* Python wrapper */ +static void __pyx_pw_6hunter_6vendor_6_cymem_5cymem_7Address_5__dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_pw_6hunter_6vendor_6_cymem_5cymem_7Address_5__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_6vendor_6_cymem_5cymem_7Address_4__dealloc__(((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_pf_6hunter_6vendor_6_cymem_5cymem_7Address_4__dealloc__(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *__pyx_v_self) { + int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "hunter/vendor/_cymem/cymem.pyx":150 + * + * def __dealloc__(self): + * if self.ptr != NULL: # <<<<<<<<<<<<<< + * self.pyfree.free(self.ptr) + */ + __pyx_t_1 = (__pyx_v_self->ptr != NULL); + if (__pyx_t_1) { + + /* "hunter/vendor/_cymem/cymem.pyx":151 + * def __dealloc__(self): + * if self.ptr != NULL: + * self.pyfree.free(self.ptr) # <<<<<<<<<<<<<< + */ + __pyx_v_self->pyfree->free(__pyx_v_self->ptr); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 151, __pyx_L1_error) + + /* "hunter/vendor/_cymem/cymem.pyx":150 + * + * def __dealloc__(self): + * if self.ptr != NULL: # <<<<<<<<<<<<<< + * self.pyfree.free(self.ptr) + */ + } + + /* "hunter/vendor/_cymem/cymem.pyx":149 + * return self.ptr + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * if self.ptr != NULL: + * self.pyfree.free(self.ptr) + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_WriteUnraisable("hunter.vendor._cymem.cymem.Address.__dealloc__", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_L0:; +} + +/* "hunter/vendor/_cymem/cymem.pxd":31 + * cdef class Address: + * cdef void* ptr + * cdef readonly PyMalloc pymalloc # <<<<<<<<<<<<<< + * cdef readonly PyFree pyfree + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_7Address_8pymalloc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_7Address_8pymalloc_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_6vendor_6_cymem_5cymem_7Address_8pymalloc___get__(((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_7Address_8pymalloc___get__(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_self->pymalloc); + __pyx_r = ((PyObject *)__pyx_v_self->pymalloc); + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hunter/vendor/_cymem/cymem.pxd":32 + * cdef void* ptr + * cdef readonly PyMalloc pymalloc + * cdef readonly PyFree pyfree # <<<<<<<<<<<<<< + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_7Address_6pyfree_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_7Address_6pyfree_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_6vendor_6_cymem_5cymem_7Address_6pyfree___get__(((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_7Address_6pyfree___get__(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_self->pyfree); + __pyx_r = ((PyObject *)__pyx_v_self->pyfree); + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_7Address_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*/ +PyDoc_STRVAR(__pyx_doc_6hunter_6vendor_6_cymem_5cymem_7Address_6__reduce_cython__, "Address.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_6hunter_6vendor_6_cymem_5cymem_7Address_7__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_6vendor_6_cymem_5cymem_7Address_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_6hunter_6vendor_6_cymem_5cymem_7Address_6__reduce_cython__}; +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_7Address_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("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __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;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_6hunter_6vendor_6_cymem_5cymem_7Address_6__reduce_cython__(((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_7Address_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(0, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("hunter.vendor._cymem.cymem.Address.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(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__" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_7Address_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*/ +PyDoc_STRVAR(__pyx_doc_6hunter_6vendor_6_cymem_5cymem_7Address_8__setstate_cython__, "Address.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_6hunter_6vendor_6_cymem_5cymem_7Address_9__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_6vendor_6_cymem_5cymem_7Address_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_6hunter_6vendor_6_cymem_5cymem_7Address_8__setstate_cython__}; +static PyObject *__pyx_pw_6hunter_6vendor_6_cymem_5cymem_7Address_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_MACROS + __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 **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __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(0, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("hunter.vendor._cymem.cymem.Address.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6hunter_6vendor_6_cymem_5cymem_7Address_8__setstate_cython__(((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6hunter_6vendor_6_cymem_5cymem_7Address_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(0, 4, __pyx_L1_error) + + /* "(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__" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("hunter.vendor._cymem.cymem.Address.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static struct __pyx_vtabstruct_6hunter_6vendor_6_cymem_5cymem_PyMalloc __pyx_vtable_6hunter_6vendor_6_cymem_5cymem_PyMalloc; + +static PyObject *__pyx_tp_new_6hunter_6vendor_6_cymem_5cymem_PyMalloc(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *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 + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *)o); + p->__pyx_vtab = __pyx_vtabptr_6hunter_6vendor_6_cymem_5cymem_PyMalloc; + return o; +} + +static void __pyx_tp_dealloc_6hunter_6vendor_6_cymem_5cymem_PyMalloc(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_6hunter_6vendor_6_cymem_5cymem_PyMalloc) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*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 PyMethodDef __pyx_methods_6hunter_6vendor_6_cymem_5cymem_PyMalloc[] = { + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_6vendor_6_cymem_5cymem_8PyMalloc_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_6hunter_6vendor_6_cymem_5cymem_8PyMalloc___reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_6vendor_6_cymem_5cymem_8PyMalloc_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_6hunter_6vendor_6_cymem_5cymem_8PyMalloc_2__setstate_cython__}, + {0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_6hunter_6vendor_6_cymem_5cymem_PyMalloc_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_6hunter_6vendor_6_cymem_5cymem_PyMalloc}, + {Py_tp_methods, (void *)__pyx_methods_6hunter_6vendor_6_cymem_5cymem_PyMalloc}, + {Py_tp_new, (void *)__pyx_tp_new_6hunter_6vendor_6_cymem_5cymem_PyMalloc}, + {0, 0}, +}; +static PyType_Spec __pyx_type_6hunter_6vendor_6_cymem_5cymem_PyMalloc_spec = { + "hunter.vendor._cymem.cymem.PyMalloc", + sizeof(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_6hunter_6vendor_6_cymem_5cymem_PyMalloc_slots, +}; +#else + +static PyTypeObject __pyx_type_6hunter_6vendor_6_cymem_5cymem_PyMalloc = { + PyVarObject_HEAD_INIT(0, 0) + "hunter.vendor._cymem.cymem.""PyMalloc", /*tp_name*/ + sizeof(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6hunter_6vendor_6_cymem_5cymem_PyMalloc, /*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_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_6hunter_6vendor_6_cymem_5cymem_PyMalloc, /*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_6vendor_6_cymem_5cymem_PyMalloc, /*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 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #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 CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif +static struct __pyx_vtabstruct_6hunter_6vendor_6_cymem_5cymem_PyFree __pyx_vtable_6hunter_6vendor_6_cymem_5cymem_PyFree; + +static PyObject *__pyx_tp_new_6hunter_6vendor_6_cymem_5cymem_PyFree(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *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 + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *)o); + p->__pyx_vtab = __pyx_vtabptr_6hunter_6vendor_6_cymem_5cymem_PyFree; + return o; +} + +static void __pyx_tp_dealloc_6hunter_6vendor_6_cymem_5cymem_PyFree(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_6hunter_6vendor_6_cymem_5cymem_PyFree) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*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 PyMethodDef __pyx_methods_6hunter_6vendor_6_cymem_5cymem_PyFree[] = { + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_6vendor_6_cymem_5cymem_6PyFree_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_6hunter_6vendor_6_cymem_5cymem_6PyFree___reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_6vendor_6_cymem_5cymem_6PyFree_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_6hunter_6vendor_6_cymem_5cymem_6PyFree_2__setstate_cython__}, + {0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_6hunter_6vendor_6_cymem_5cymem_PyFree_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_6hunter_6vendor_6_cymem_5cymem_PyFree}, + {Py_tp_methods, (void *)__pyx_methods_6hunter_6vendor_6_cymem_5cymem_PyFree}, + {Py_tp_new, (void *)__pyx_tp_new_6hunter_6vendor_6_cymem_5cymem_PyFree}, + {0, 0}, +}; +static PyType_Spec __pyx_type_6hunter_6vendor_6_cymem_5cymem_PyFree_spec = { + "hunter.vendor._cymem.cymem.PyFree", + sizeof(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_6hunter_6vendor_6_cymem_5cymem_PyFree_slots, +}; +#else + +static PyTypeObject __pyx_type_6hunter_6vendor_6_cymem_5cymem_PyFree = { + PyVarObject_HEAD_INIT(0, 0) + "hunter.vendor._cymem.cymem.""PyFree", /*tp_name*/ + sizeof(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6hunter_6vendor_6_cymem_5cymem_PyFree, /*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_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_6hunter_6vendor_6_cymem_5cymem_PyFree, /*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_6vendor_6_cymem_5cymem_PyFree, /*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 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #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 CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif +static struct __pyx_vtabstruct_6hunter_6vendor_6_cymem_5cymem_Pool __pyx_vtable_6hunter_6vendor_6_cymem_5cymem_Pool; + +static PyObject *__pyx_tp_new_6hunter_6vendor_6_cymem_5cymem_Pool(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *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 + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *)o); + p->__pyx_vtab = __pyx_vtabptr_6hunter_6vendor_6_cymem_5cymem_Pool; + p->addresses = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->refs = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->pymalloc = ((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *)Py_None); Py_INCREF(Py_None); + p->pyfree = ((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *)Py_None); Py_INCREF(Py_None); + if (unlikely(__pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_1__cinit__(o, a, k) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_6hunter_6vendor_6_cymem_5cymem_Pool(PyObject *o) { + struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *p = (struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *)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_6vendor_6_cymem_5cymem_Pool) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); + __pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_3__dealloc__(o); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->addresses); + Py_CLEAR(p->refs); + Py_CLEAR(p->pymalloc); + Py_CLEAR(p->pyfree); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*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_6vendor_6_cymem_5cymem_Pool(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *p = (struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *)o; + if (p->addresses) { + e = (*v)(p->addresses, a); if (e) return e; + } + if (p->refs) { + e = (*v)(p->refs, a); if (e) return e; + } + if (p->pymalloc) { + e = (*v)(((PyObject *)p->pymalloc), a); if (e) return e; + } + if (p->pyfree) { + e = (*v)(((PyObject *)p->pyfree), a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_6hunter_6vendor_6_cymem_5cymem_Pool(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *p = (struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *)o; + tmp = ((PyObject*)p->addresses); + p->addresses = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->refs); + p->refs = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->pymalloc); + p->pymalloc = ((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->pyfree); + p->pyfree = ((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_6hunter_6vendor_6_cymem_5cymem_4Pool_size(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_4size_1__get__(o); +} + +static PyObject *__pyx_getprop_6hunter_6vendor_6_cymem_5cymem_4Pool_addresses(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_9addresses_1__get__(o); +} + +static PyObject *__pyx_getprop_6hunter_6vendor_6_cymem_5cymem_4Pool_refs(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_4refs_1__get__(o); +} + +static PyObject *__pyx_getprop_6hunter_6vendor_6_cymem_5cymem_4Pool_pymalloc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_8pymalloc_1__get__(o); +} + +static PyObject *__pyx_getprop_6hunter_6vendor_6_cymem_5cymem_4Pool_pyfree(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_6pyfree_1__get__(o); +} + +static PyMethodDef __pyx_methods_6hunter_6vendor_6_cymem_5cymem_Pool[] = { + {"own_pyref", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_5own_pyref, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_6hunter_6vendor_6_cymem_5cymem_4Pool_4own_pyref}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_6hunter_6vendor_6_cymem_5cymem_4Pool_6__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_6vendor_6_cymem_5cymem_4Pool_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_6hunter_6vendor_6_cymem_5cymem_4Pool_8__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_6hunter_6vendor_6_cymem_5cymem_Pool[] = { + {(char *)"size", __pyx_getprop_6hunter_6vendor_6_cymem_5cymem_4Pool_size, 0, (char *)0, 0}, + {(char *)"addresses", __pyx_getprop_6hunter_6vendor_6_cymem_5cymem_4Pool_addresses, 0, (char *)0, 0}, + {(char *)"refs", __pyx_getprop_6hunter_6vendor_6_cymem_5cymem_4Pool_refs, 0, (char *)0, 0}, + {(char *)"pymalloc", __pyx_getprop_6hunter_6vendor_6_cymem_5cymem_4Pool_pymalloc, 0, (char *)0, 0}, + {(char *)"pyfree", __pyx_getprop_6hunter_6vendor_6_cymem_5cymem_4Pool_pyfree, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_6hunter_6vendor_6_cymem_5cymem_Pool_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_6hunter_6vendor_6_cymem_5cymem_Pool}, + {Py_tp_doc, (void *)PyDoc_STR("Track allocated memory addresses, and free them all when the Pool is\n garbage collected. This provides an easy way to avoid memory leaks, and\n removes the need for deallocation functions for complicated structs.\n\n >>> from cymem.cymem cimport Pool\n >>> cdef Pool mem = Pool()\n >>> data1 = mem.alloc(10, sizeof(int))\n >>> data2 = mem.alloc(12, sizeof(float))\n\n Attributes:\n size (size_t): The current size (in bytes) allocated by the pool.\n addresses (dict): The currently allocated addresses and their sizes. Read-only.\n pymalloc (PyMalloc): The allocator to use (default uses PyMem_Malloc).\n pyfree (PyFree): The free to use (default uses PyMem_Free).\n ")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_6hunter_6vendor_6_cymem_5cymem_Pool}, + {Py_tp_clear, (void *)__pyx_tp_clear_6hunter_6vendor_6_cymem_5cymem_Pool}, + {Py_tp_methods, (void *)__pyx_methods_6hunter_6vendor_6_cymem_5cymem_Pool}, + {Py_tp_getset, (void *)__pyx_getsets_6hunter_6vendor_6_cymem_5cymem_Pool}, + {Py_tp_new, (void *)__pyx_tp_new_6hunter_6vendor_6_cymem_5cymem_Pool}, + {0, 0}, +}; +static PyType_Spec __pyx_type_6hunter_6vendor_6_cymem_5cymem_Pool_spec = { + "hunter.vendor._cymem.cymem.Pool", + sizeof(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_6hunter_6vendor_6_cymem_5cymem_Pool_slots, +}; +#else + +static PyTypeObject __pyx_type_6hunter_6vendor_6_cymem_5cymem_Pool = { + PyVarObject_HEAD_INIT(0, 0) + "hunter.vendor._cymem.cymem.""Pool", /*tp_name*/ + sizeof(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6hunter_6vendor_6_cymem_5cymem_Pool, /*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_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + PyDoc_STR("Track allocated memory addresses, and free them all when the Pool is\n garbage collected. This provides an easy way to avoid memory leaks, and\n removes the need for deallocation functions for complicated structs.\n\n >>> from cymem.cymem cimport Pool\n >>> cdef Pool mem = Pool()\n >>> data1 = mem.alloc(10, sizeof(int))\n >>> data2 = mem.alloc(12, sizeof(float))\n\n Attributes:\n size (size_t): The current size (in bytes) allocated by the pool.\n addresses (dict): The currently allocated addresses and their sizes. Read-only.\n pymalloc (PyMalloc): The allocator to use (default uses PyMem_Malloc).\n pyfree (PyFree): The free to use (default uses PyMem_Free).\n "), /*tp_doc*/ + __pyx_tp_traverse_6hunter_6vendor_6_cymem_5cymem_Pool, /*tp_traverse*/ + __pyx_tp_clear_6hunter_6vendor_6_cymem_5cymem_Pool, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_6hunter_6vendor_6_cymem_5cymem_Pool, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_6hunter_6vendor_6_cymem_5cymem_Pool, /*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_6vendor_6_cymem_5cymem_Pool, /*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 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #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 CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_6hunter_6vendor_6_cymem_5cymem_Address(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *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 + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *)o); + p->pymalloc = ((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *)Py_None); Py_INCREF(Py_None); + p->pyfree = ((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *)Py_None); Py_INCREF(Py_None); + if (unlikely(__pyx_pw_6hunter_6vendor_6_cymem_5cymem_7Address_1__cinit__(o, a, k) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_6hunter_6vendor_6_cymem_5cymem_Address(PyObject *o) { + struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *p = (struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *)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_6vendor_6_cymem_5cymem_Address) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); + __pyx_pw_6hunter_6vendor_6_cymem_5cymem_7Address_5__dealloc__(o); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->pymalloc); + Py_CLEAR(p->pyfree); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*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_6vendor_6_cymem_5cymem_Address(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *p = (struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *)o; + if (p->pymalloc) { + e = (*v)(((PyObject *)p->pymalloc), a); if (e) return e; + } + if (p->pyfree) { + e = (*v)(((PyObject *)p->pyfree), a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_6hunter_6vendor_6_cymem_5cymem_Address(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *p = (struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address *)o; + tmp = ((PyObject*)p->pymalloc); + p->pymalloc = ((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->pyfree); + p->pyfree = ((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_6hunter_6vendor_6_cymem_5cymem_7Address_addr(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_6vendor_6_cymem_5cymem_7Address_4addr_1__get__(o); +} + +static PyObject *__pyx_getprop_6hunter_6vendor_6_cymem_5cymem_7Address_pymalloc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_6vendor_6_cymem_5cymem_7Address_8pymalloc_1__get__(o); +} + +static PyObject *__pyx_getprop_6hunter_6vendor_6_cymem_5cymem_7Address_pyfree(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6hunter_6vendor_6_cymem_5cymem_7Address_6pyfree_1__get__(o); +} + +static PyMethodDef __pyx_methods_6hunter_6vendor_6_cymem_5cymem_Address[] = { + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_6vendor_6_cymem_5cymem_7Address_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_6hunter_6vendor_6_cymem_5cymem_7Address_6__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6hunter_6vendor_6_cymem_5cymem_7Address_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_6hunter_6vendor_6_cymem_5cymem_7Address_8__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_6hunter_6vendor_6_cymem_5cymem_Address[] = { + {(char *)"addr", __pyx_getprop_6hunter_6vendor_6_cymem_5cymem_7Address_addr, 0, (char *)0, 0}, + {(char *)"pymalloc", __pyx_getprop_6hunter_6vendor_6_cymem_5cymem_7Address_pymalloc, 0, (char *)0, 0}, + {(char *)"pyfree", __pyx_getprop_6hunter_6vendor_6_cymem_5cymem_7Address_pyfree, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_6hunter_6vendor_6_cymem_5cymem_Address_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_6hunter_6vendor_6_cymem_5cymem_Address}, + {Py_tp_doc, (void *)PyDoc_STR("Address(size_t number, size_t elem_size)\nA block of number * size-bytes of 0-initialized memory, tied to a Python\n ref-counted object. When the object is garbage collected, the memory is freed.\n\n >>> from cymem.cymem cimport Address\n >>> cdef Address address = Address(10, sizeof(double))\n >>> d10 = address.ptr\n\n Args:\n number (size_t): The number of elements in the memory block.\n elem_size (size_t): The size of each element.\n\n Attributes:\n ptr (void*): Pointer to the memory block.\n addr (size_t): Read-only size_t cast of the pointer.\n pymalloc (PyMalloc): The allocator to use (default uses PyMem_Malloc).\n pyfree (PyFree): The free to use (default uses PyMem_Free).\n ")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_6hunter_6vendor_6_cymem_5cymem_Address}, + {Py_tp_clear, (void *)__pyx_tp_clear_6hunter_6vendor_6_cymem_5cymem_Address}, + {Py_tp_methods, (void *)__pyx_methods_6hunter_6vendor_6_cymem_5cymem_Address}, + {Py_tp_getset, (void *)__pyx_getsets_6hunter_6vendor_6_cymem_5cymem_Address}, + {Py_tp_init, (void *)__pyx_pw_6hunter_6vendor_6_cymem_5cymem_7Address_3__init__}, + {Py_tp_new, (void *)__pyx_tp_new_6hunter_6vendor_6_cymem_5cymem_Address}, + {0, 0}, +}; +static PyType_Spec __pyx_type_6hunter_6vendor_6_cymem_5cymem_Address_spec = { + "hunter.vendor._cymem.cymem.Address", + sizeof(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_6hunter_6vendor_6_cymem_5cymem_Address_slots, +}; +#else + +static PyTypeObject __pyx_type_6hunter_6vendor_6_cymem_5cymem_Address = { + PyVarObject_HEAD_INIT(0, 0) + "hunter.vendor._cymem.cymem.""Address", /*tp_name*/ + sizeof(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Address), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6hunter_6vendor_6_cymem_5cymem_Address, /*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_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + PyDoc_STR("Address(size_t number, size_t elem_size)\nA block of number * size-bytes of 0-initialized memory, tied to a Python\n ref-counted object. When the object is garbage collected, the memory is freed.\n\n >>> from cymem.cymem cimport Address\n >>> cdef Address address = Address(10, sizeof(double))\n >>> d10 = address.ptr\n\n Args:\n number (size_t): The number of elements in the memory block.\n elem_size (size_t): The size of each element.\n\n Attributes:\n ptr (void*): Pointer to the memory block.\n addr (size_t): Read-only size_t cast of the pointer.\n pymalloc (PyMalloc): The allocator to use (default uses PyMem_Malloc).\n pyfree (PyFree): The free to use (default uses PyMem_Free).\n "), /*tp_doc*/ + __pyx_tp_traverse_6hunter_6vendor_6_cymem_5cymem_Address, /*tp_traverse*/ + __pyx_tp_clear_6hunter_6vendor_6_cymem_5cymem_Address, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_6hunter_6vendor_6_cymem_5cymem_Address, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_6hunter_6vendor_6_cymem_5cymem_Address, /*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_6vendor_6_cymem_5cymem_7Address_3__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6hunter_6vendor_6_cymem_5cymem_Address, /*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 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #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 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} +}; +#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 +/* #### Code section: pystring_table ### */ + +static int __Pyx_CreateStringTabAndInitStrings(void) { + __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s_Address, __pyx_k_Address, sizeof(__pyx_k_Address), 0, 0, 1, 1}, + {&__pyx_n_s_Address___reduce_cython, __pyx_k_Address___reduce_cython, sizeof(__pyx_k_Address___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Address___setstate_cython, __pyx_k_Address___setstate_cython, sizeof(__pyx_k_Address___setstate_cython), 0, 0, 1, 1}, + {&__pyx_kp_s_Allocating_zero_bytes, __pyx_k_Allocating_zero_bytes, sizeof(__pyx_k_Allocating_zero_bytes), 0, 0, 1, 0}, + {&__pyx_n_s_AssertionError, __pyx_k_AssertionError, sizeof(__pyx_k_AssertionError), 0, 0, 1, 1}, + {&__pyx_n_s_Default_Free, __pyx_k_Default_Free, sizeof(__pyx_k_Default_Free), 0, 0, 1, 1}, + {&__pyx_n_s_Default_Malloc, __pyx_k_Default_Malloc, sizeof(__pyx_k_Default_Malloc), 0, 0, 1, 1}, + {&__pyx_kp_s_Error_assigning_d_bytes, __pyx_k_Error_assigning_d_bytes, sizeof(__pyx_k_Error_assigning_d_bytes), 0, 0, 1, 0}, + {&__pyx_kp_s_Error_reallocating_to_d_bytes, __pyx_k_Error_reallocating_to_d_bytes, sizeof(__pyx_k_Error_reallocating_to_d_bytes), 0, 0, 1, 0}, + {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1}, + {&__pyx_kp_s_Pointer_d_not_found_in_Pool_s, __pyx_k_Pointer_d_not_found_in_Pool_s, sizeof(__pyx_k_Pointer_d_not_found_in_Pool_s), 0, 0, 1, 0}, + {&__pyx_n_s_Pool, __pyx_k_Pool, sizeof(__pyx_k_Pool), 0, 0, 1, 1}, + {&__pyx_n_s_Pool___reduce_cython, __pyx_k_Pool___reduce_cython, sizeof(__pyx_k_Pool___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Pool___setstate_cython, __pyx_k_Pool___setstate_cython, sizeof(__pyx_k_Pool___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Pool_own_pyref, __pyx_k_Pool_own_pyref, sizeof(__pyx_k_Pool_own_pyref), 0, 0, 1, 1}, + {&__pyx_n_s_PyFree, __pyx_k_PyFree, sizeof(__pyx_k_PyFree), 0, 0, 1, 1}, + {&__pyx_n_s_PyFree___reduce_cython, __pyx_k_PyFree___reduce_cython, sizeof(__pyx_k_PyFree___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_PyFree___setstate_cython, __pyx_k_PyFree___setstate_cython, sizeof(__pyx_k_PyFree___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_PyMalloc, __pyx_k_PyMalloc, sizeof(__pyx_k_PyMalloc), 0, 0, 1, 1}, + {&__pyx_n_s_PyMalloc___reduce_cython, __pyx_k_PyMalloc___reduce_cython, sizeof(__pyx_k_PyMalloc___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_PyMalloc___setstate_cython, __pyx_k_PyMalloc___setstate_cython, sizeof(__pyx_k_PyMalloc___setstate_cython), 0, 0, 1, 1}, + {&__pyx_kp_s_Realloc_requires_new_size_0, __pyx_k_Realloc_requires_new_size_0, sizeof(__pyx_k_Realloc_requires_new_size_0), 0, 0, 1, 0}, + {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_n_s_WARN_ZERO_ALLOC, __pyx_k_WARN_ZERO_ALLOC, sizeof(__pyx_k_WARN_ZERO_ALLOC), 0, 0, 1, 1}, + {&__pyx_n_s__19, __pyx_k__19, sizeof(__pyx_k__19), 0, 0, 1, 1}, + {&__pyx_n_s__6, __pyx_k__6, sizeof(__pyx_k__6), 0, 0, 1, 1}, + {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 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_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0}, + {&__pyx_n_s_elem_size, __pyx_k_elem_size, sizeof(__pyx_k_elem_size), 0, 0, 1, 1}, + {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0}, + {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0}, + {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, + {&__pyx_n_s_hunter_vendor__cymem_cymem, __pyx_k_hunter_vendor__cymem_cymem, sizeof(__pyx_k_hunter_vendor__cymem_cymem), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_initializing, __pyx_k_initializing, sizeof(__pyx_k_initializing), 0, 0, 1, 1}, + {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1}, + {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0}, + {&__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_n_s_number, __pyx_k_number, sizeof(__pyx_k_number), 0, 0, 1, 1}, + {&__pyx_n_s_own_pyref, __pyx_k_own_pyref, sizeof(__pyx_k_own_pyref), 0, 0, 1, 1}, + {&__pyx_n_s_pop, __pyx_k_pop, sizeof(__pyx_k_pop), 0, 0, 1, 1}, + {&__pyx_n_s_py_ref, __pyx_k_py_ref, sizeof(__pyx_k_py_ref), 0, 0, 1, 1}, + {&__pyx_n_s_pyfree, __pyx_k_pyfree, sizeof(__pyx_k_pyfree), 0, 0, 1, 1}, + {&__pyx_n_s_pymalloc, __pyx_k_pymalloc, sizeof(__pyx_k_pymalloc), 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_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_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, + {&__pyx_kp_s_self_free_cannot_be_converted_to, __pyx_k_self_free_cannot_be_converted_to, sizeof(__pyx_k_self_free_cannot_be_converted_to), 0, 0, 1, 0}, + {&__pyx_kp_s_self_malloc_cannot_be_converted, __pyx_k_self_malloc_cannot_be_converted, sizeof(__pyx_k_self_malloc_cannot_be_converted), 0, 0, 1, 0}, + {&__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_spec, __pyx_k_spec, sizeof(__pyx_k_spec), 0, 0, 1, 1}, + {&__pyx_kp_s_src_hunter_vendor__cymem_cymem_p, __pyx_k_src_hunter_vendor__cymem_cymem_p, sizeof(__pyx_k_src_hunter_vendor__cymem_cymem_p), 0, 0, 1, 0}, + {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_n_s_warn, __pyx_k_warn, sizeof(__pyx_k_warn), 0, 0, 1, 1}, + {&__pyx_n_s_warnings, __pyx_k_warnings, sizeof(__pyx_k_warnings), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} + }; + return __Pyx_InitStrings(__pyx_string_tab); +} +/* #### Code section: cached_builtins ### */ +static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 2, __pyx_L1_error) + __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(1, 74, __pyx_L1_error) + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 88, __pyx_L1_error) + __pyx_builtin_AssertionError = __Pyx_GetBuiltinName(__pyx_n_s_AssertionError); if (!__pyx_builtin_AssertionError) __PYX_ERR(1, 91, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: cached_constants ### */ + +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "hunter/vendor/_cymem/cymem.pyx":90 + * raise ValueError("Pointer %d not found in Pool %s" % (p, self.addresses)) + * if new_size == 0: + * raise ValueError("Realloc requires new_size > 0") # <<<<<<<<<<<<<< + * assert new_size > self.addresses[p] + * cdef void* new_ptr = self.alloc(1, new_size) + */ + __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_s_Realloc_requires_new_size_0); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.malloc cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_tuple__7 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__7); + __Pyx_GIVEREF(__pyx_tuple__7); + __pyx_codeobj__8 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__7, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__8)) __PYX_ERR(0, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.malloc cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.malloc cannot be converted to a Python object for pickling" + */ + __pyx_tuple__9 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_pyx_state); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__9); + __Pyx_GIVEREF(__pyx_tuple__9); + __pyx_codeobj__10 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__9, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__10)) __PYX_ERR(0, 3, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.free cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__11 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__7, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__11)) __PYX_ERR(0, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.free cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.free cannot be converted to a Python object for pickling" + */ + __pyx_codeobj__12 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__9, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__12)) __PYX_ERR(0, 3, __pyx_L1_error) + + /* "hunter/vendor/_cymem/cymem.pyx":111 + * self.pyfree.free(p) + * + * def own_pyref(self, object py_ref): # <<<<<<<<<<<<<< + * self.refs.append(py_ref) + * + */ + __pyx_tuple__13 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_py_ref); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(1, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__13); + __Pyx_GIVEREF(__pyx_tuple__13); + __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_hunter_vendor__cymem_cymem_p, __pyx_n_s_own_pyref, 111, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(1, 111, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__15 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__7, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__15)) __PYX_ERR(0, 1, __pyx_L1_error) + + /* "(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_codeobj__16 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__9, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__16)) __PYX_ERR(0, 3, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__17 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__7, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__17)) __PYX_ERR(0, 1, __pyx_L1_error) + + /* "(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_codeobj__18 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__9, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__18)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} +/* #### Code section: init_constants ### */ + +static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) { + __pyx_umethod_PyDict_Type_pop.type = (PyObject*)&PyDict_Type; + __pyx_umethod_PyDict_Type_pop.method_name = &__pyx_n_s_pop; + if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(1, 1, __pyx_L1_error); + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: init_globals ### */ + +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { + /* AssertionsEnabled.init */ + if (likely(__Pyx_init_assertions_enabled() == 0)); else + +if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L1_error) + + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: init_module ### */ + +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) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); + /*--- Global init code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); + /*--- Variable export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_export_code(void) { + __Pyx_RefNannyDeclarations + 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("WrapMalloc", (void (*)(void))__pyx_f_6hunter_6vendor_6_cymem_5cymem_WrapMalloc, "struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *(__pyx_t_6hunter_6vendor_6_cymem_5cymem_malloc_t)") < 0) __PYX_ERR(1, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("WrapFree", (void (*)(void))__pyx_f_6hunter_6vendor_6_cymem_5cymem_WrapFree, "struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *(__pyx_t_6hunter_6vendor_6_cymem_5cymem_free_t)") < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_type_init_code(void) { + __Pyx_RefNannyDeclarations + 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_vtabptr_6hunter_6vendor_6_cymem_5cymem_PyMalloc = &__pyx_vtable_6hunter_6vendor_6_cymem_5cymem_PyMalloc; + __pyx_vtable_6hunter_6vendor_6_cymem_5cymem_PyMalloc._set = (void (*)(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *, __pyx_t_6hunter_6vendor_6_cymem_5cymem_malloc_t))__pyx_f_6hunter_6vendor_6_cymem_5cymem_8PyMalloc__set; + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyMalloc = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6hunter_6vendor_6_cymem_5cymem_PyMalloc_spec, NULL); if (unlikely(!__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyMalloc)) __PYX_ERR(1, 11, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_6vendor_6_cymem_5cymem_PyMalloc_spec, __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyMalloc) < 0) __PYX_ERR(1, 11, __pyx_L1_error) + #else + __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyMalloc = &__pyx_type_6hunter_6vendor_6_cymem_5cymem_PyMalloc; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyMalloc) < 0) __PYX_ERR(1, 11, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyMalloc->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyMalloc->tp_dictoffset && __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyMalloc->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyMalloc->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (__Pyx_SetVtable(__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyMalloc, __pyx_vtabptr_6hunter_6vendor_6_cymem_5cymem_PyMalloc) < 0) __PYX_ERR(1, 11, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_MergeVtables(__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyMalloc) < 0) __PYX_ERR(1, 11, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PyMalloc, (PyObject *) __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyMalloc) < 0) __PYX_ERR(1, 11, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyMalloc) < 0) __PYX_ERR(1, 11, __pyx_L1_error) + #endif + __pyx_vtabptr_6hunter_6vendor_6_cymem_5cymem_PyFree = &__pyx_vtable_6hunter_6vendor_6_cymem_5cymem_PyFree; + __pyx_vtable_6hunter_6vendor_6_cymem_5cymem_PyFree._set = (void (*)(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *, __pyx_t_6hunter_6vendor_6_cymem_5cymem_free_t))__pyx_f_6hunter_6vendor_6_cymem_5cymem_6PyFree__set; + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyFree = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6hunter_6vendor_6_cymem_5cymem_PyFree_spec, NULL); if (unlikely(!__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyFree)) __PYX_ERR(1, 20, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_6vendor_6_cymem_5cymem_PyFree_spec, __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyFree) < 0) __PYX_ERR(1, 20, __pyx_L1_error) + #else + __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyFree = &__pyx_type_6hunter_6vendor_6_cymem_5cymem_PyFree; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyFree) < 0) __PYX_ERR(1, 20, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyFree->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyFree->tp_dictoffset && __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyFree->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyFree->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (__Pyx_SetVtable(__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyFree, __pyx_vtabptr_6hunter_6vendor_6_cymem_5cymem_PyFree) < 0) __PYX_ERR(1, 20, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_MergeVtables(__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyFree) < 0) __PYX_ERR(1, 20, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PyFree, (PyObject *) __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyFree) < 0) __PYX_ERR(1, 20, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyFree) < 0) __PYX_ERR(1, 20, __pyx_L1_error) + #endif + __pyx_vtabptr_6hunter_6vendor_6_cymem_5cymem_Pool = &__pyx_vtable_6hunter_6vendor_6_cymem_5cymem_Pool; + __pyx_vtable_6hunter_6vendor_6_cymem_5cymem_Pool.alloc = (void *(*)(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *, size_t, size_t))__pyx_f_6hunter_6vendor_6_cymem_5cymem_4Pool_alloc; + __pyx_vtable_6hunter_6vendor_6_cymem_5cymem_Pool.free = (void (*)(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *, void *))__pyx_f_6hunter_6vendor_6_cymem_5cymem_4Pool_free; + __pyx_vtable_6hunter_6vendor_6_cymem_5cymem_Pool.realloc = (void *(*)(struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_Pool *, void *, size_t))__pyx_f_6hunter_6vendor_6_cymem_5cymem_4Pool_realloc; + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Pool = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6hunter_6vendor_6_cymem_5cymem_Pool_spec, NULL); if (unlikely(!__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Pool)) __PYX_ERR(1, 32, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_6vendor_6_cymem_5cymem_Pool_spec, __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Pool) < 0) __PYX_ERR(1, 32, __pyx_L1_error) + #else + __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Pool = &__pyx_type_6hunter_6vendor_6_cymem_5cymem_Pool; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Pool) < 0) __PYX_ERR(1, 32, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Pool->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Pool->tp_dictoffset && __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Pool->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Pool->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (__Pyx_SetVtable(__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Pool, __pyx_vtabptr_6hunter_6vendor_6_cymem_5cymem_Pool) < 0) __PYX_ERR(1, 32, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_MergeVtables(__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Pool) < 0) __PYX_ERR(1, 32, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Pool, (PyObject *) __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Pool) < 0) __PYX_ERR(1, 32, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Pool) < 0) __PYX_ERR(1, 32, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Address = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6hunter_6vendor_6_cymem_5cymem_Address_spec, NULL); if (unlikely(!__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Address)) __PYX_ERR(1, 115, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6hunter_6vendor_6_cymem_5cymem_Address_spec, __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Address) < 0) __PYX_ERR(1, 115, __pyx_L1_error) + #else + __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Address = &__pyx_type_6hunter_6vendor_6_cymem_5cymem_Address; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Address) < 0) __PYX_ERR(1, 115, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Address->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Address->tp_dictoffset && __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Address->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Address->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Address, (PyObject *) __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Address) < 0) __PYX_ERR(1, 115, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Address) < 0) __PYX_ERR(1, 115, __pyx_L1_error) + #endif + __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; + 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_3_0_10(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyTypeObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyTypeObject), + #else + sizeof(PyHeapTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyHeapTypeObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(3, 9, __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; +} + +static int __Pyx_modinit_variable_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); + /*--- Variable import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); + /*--- Function import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + + +#if PY_MAJOR_VERSION >= 3 +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_cymem(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_cymem}, + {0, NULL} +}; +#endif + +#ifdef __cplusplus +namespace { + struct PyModuleDef __pyx_moduledef = + #else + static struct PyModuleDef __pyx_moduledef = + #endif + { + PyModuleDef_HEAD_INIT, + "cymem", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #elif CYTHON_USE_MODULE_STATE + sizeof(__pyx_mstate), /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + #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 +#endif + +#ifndef CYTHON_NO_PYINIT_EXPORT +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#elif PY_MAJOR_VERSION < 3 +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" void +#else +#define __Pyx_PyMODINIT_FUNC void +#endif +#else +#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 initcymem(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC initcymem(void) +#else +__Pyx_PyMODINIT_FUNC PyInit_cymem(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit_cymem(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; +} +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none) +#else +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 +{ + PyObject *value = PyObject_GetAttrString(spec, from_name); + int result = 0; + if (likely(value)) { + if (allow_none || value != Py_None) { +#if CYTHON_COMPILING_IN_LIMITED_API + result = PyModule_AddObject(module, to_name, value); +#else + result = PyDict_SetItemString(moddict, to_name, value); +#endif + } + 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 (__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; +#if CYTHON_COMPILING_IN_LIMITED_API + moddict = module; +#else + moddict = PyModule_GetDict(module); + if (unlikely(!moddict)) goto bad; +#endif + 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_cymem(PyObject *__pyx_pyinit_module) +#endif +#endif +{ + int stringtab_initialized = 0; + #if CYTHON_USE_MODULE_STATE + int pystate_addmodule_run = 0; + #endif + 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) { + if (__pyx_m == __pyx_pyinit_module) return 0; + PyErr_SetString(PyExc_RuntimeError, "Module 'cymem' 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 + /*--- 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("cymem", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + if (unlikely(!__pyx_m)) __PYX_ERR(1, 1, __pyx_L1_error) + #elif CYTHON_USE_MODULE_STATE + __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1, __pyx_L1_error) + { + int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef); + __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "cymem" pseudovariable */ + if (unlikely((add_module_result < 0))) __PYX_ERR(1, 1, __pyx_L1_error) + pystate_addmodule_run = 1; + } + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + if (unlikely(!__pyx_m)) __PYX_ERR(1, 1, __pyx_L1_error) + #endif + #endif + CYTHON_UNUSED_VAR(__pyx_t_1); + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(1, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(1, 1, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + #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_cymem(void)", 0); + if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(1, 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(1, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(1, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + PyEval_InitThreads(); + #endif + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitConstants() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + stringtab_initialized = 1; + if (__Pyx_InitGlobals() < 0) __PYX_ERR(1, 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(1, 1, __pyx_L1_error) + #endif + if (__pyx_module_is_main_hunter__vendor___cymem__cymem) { + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(1, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "hunter.vendor._cymem.cymem")) { + if (unlikely((PyDict_SetItemString(modules, "hunter.vendor._cymem.cymem", __pyx_m) < 0))) __PYX_ERR(1, 1, __pyx_L1_error) + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(1, 1, __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))) __PYX_ERR(1, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_type_init_code() < 0))) __PYX_ERR(1, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_type_import_code() < 0))) __PYX_ERR(1, 1, __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(1, 1, __pyx_L1_error) + #endif + + /* "hunter/vendor/_cymem/cymem.pyx":7 + * from libc.string cimport memset + * from libc.string cimport memcpy + * import warnings # <<<<<<<<<<<<<< + * + * WARN_ZERO_ALLOC = False + */ + __pyx_t_2 = __Pyx_ImportDottedModule(__pyx_n_s_warnings, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_warnings, __pyx_t_2) < 0) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "hunter/vendor/_cymem/cymem.pyx":9 + * import warnings + * + * WARN_ZERO_ALLOC = False # <<<<<<<<<<<<<< + * + * cdef class PyMalloc: + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_WARN_ZERO_ALLOC, Py_False) < 0) __PYX_ERR(1, 9, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.malloc cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_6vendor_6_cymem_5cymem_8PyMalloc_1__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PyMalloc___reduce_cython, NULL, __pyx_n_s_hunter_vendor__cymem_cymem, __pyx_d, ((PyObject *)__pyx_codeobj__8)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.malloc cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.malloc cannot be converted to a Python object for pickling" + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_6vendor_6_cymem_5cymem_8PyMalloc_3__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PyMalloc___setstate_cython, NULL, __pyx_n_s_hunter_vendor__cymem_cymem, __pyx_d, ((PyObject *)__pyx_codeobj__10)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.free cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_6vendor_6_cymem_5cymem_6PyFree_1__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PyFree___reduce_cython, NULL, __pyx_n_s_hunter_vendor__cymem_cymem, __pyx_d, ((PyObject *)__pyx_codeobj__11)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.free cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.free cannot be converted to a Python object for pickling" + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_6vendor_6_cymem_5cymem_6PyFree_3__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PyFree___setstate_cython, NULL, __pyx_n_s_hunter_vendor__cymem_cymem, __pyx_d, ((PyObject *)__pyx_codeobj__12)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "hunter/vendor/_cymem/cymem.pyx":29 + * return o + * + * Default_Malloc = WrapMalloc(PyMem_Malloc) # <<<<<<<<<<<<<< + * Default_Free = WrapFree(PyMem_Free) + * + */ + __pyx_t_2 = ((PyObject *)__pyx_f_6hunter_6vendor_6_cymem_5cymem_WrapMalloc(PyMem_Malloc)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Default_Malloc, __pyx_t_2) < 0) __PYX_ERR(1, 29, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "hunter/vendor/_cymem/cymem.pyx":30 + * + * Default_Malloc = WrapMalloc(PyMem_Malloc) + * Default_Free = WrapFree(PyMem_Free) # <<<<<<<<<<<<<< + * + * cdef class Pool: + */ + __pyx_t_2 = ((PyObject *)__pyx_f_6hunter_6vendor_6_cymem_5cymem_WrapFree(PyMem_Free)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 30, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Default_Free, __pyx_t_2) < 0) __PYX_ERR(1, 30, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "hunter/vendor/_cymem/cymem.pyx":49 + * """ + * + * def __cinit__(self, PyMalloc pymalloc=Default_Malloc, # <<<<<<<<<<<<<< + * PyFree pyfree=Default_Free): + * self.size = 0 + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_Default_Malloc); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyMalloc))))) __PYX_ERR(1, 49, __pyx_L1_error) + __pyx_k_ = ((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *)__pyx_t_2); + __Pyx_GIVEREF((PyObject *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "hunter/vendor/_cymem/cymem.pyx":50 + * + * def __cinit__(self, PyMalloc pymalloc=Default_Malloc, + * PyFree pyfree=Default_Free): # <<<<<<<<<<<<<< + * self.size = 0 + * self.addresses = {} + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_Default_Free); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyFree))))) __PYX_ERR(1, 50, __pyx_L1_error) + __pyx_k__2 = ((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *)__pyx_t_2); + __Pyx_GIVEREF((PyObject *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "hunter/vendor/_cymem/cymem.pyx":111 + * self.pyfree.free(p) + * + * def own_pyref(self, object py_ref): # <<<<<<<<<<<<<< + * self.refs.append(py_ref) + * + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_6vendor_6_cymem_5cymem_4Pool_5own_pyref, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Pool_own_pyref, NULL, __pyx_n_s_hunter_vendor__cymem_cymem, __pyx_d, ((PyObject *)__pyx_codeobj__14)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Pool, __pyx_n_s_own_pyref, __pyx_t_2) < 0) __PYX_ERR(1, 111, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_6hunter_6vendor_6_cymem_5cymem_Pool); + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_6vendor_6_cymem_5cymem_4Pool_7__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Pool___reduce_cython, NULL, __pyx_n_s_hunter_vendor__cymem_cymem, __pyx_d, ((PyObject *)__pyx_codeobj__15)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(0, 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_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_6vendor_6_cymem_5cymem_4Pool_9__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Pool___setstate_cython, NULL, __pyx_n_s_hunter_vendor__cymem_cymem, __pyx_d, ((PyObject *)__pyx_codeobj__16)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "hunter/vendor/_cymem/cymem.pyx":134 + * """ + * def __cinit__(self, size_t number, size_t elem_size, + * PyMalloc pymalloc=Default_Malloc, PyFree pyfree=Default_Free): # <<<<<<<<<<<<<< + * self.ptr = NULL + * self.pymalloc = pymalloc + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_Default_Malloc); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyMalloc))))) __PYX_ERR(1, 134, __pyx_L1_error) + __pyx_k__4 = ((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyMalloc *)__pyx_t_2); + __Pyx_GIVEREF((PyObject *)__pyx_t_2); + __pyx_t_2 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_Default_Free); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_6hunter_6vendor_6_cymem_5cymem_PyFree))))) __PYX_ERR(1, 134, __pyx_L1_error) + __pyx_k__5 = ((struct __pyx_obj_6hunter_6vendor_6_cymem_5cymem_PyFree *)__pyx_t_2); + __Pyx_GIVEREF((PyObject *)__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_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_6vendor_6_cymem_5cymem_7Address_7__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Address___reduce_cython, NULL, __pyx_n_s_hunter_vendor__cymem_cymem, __pyx_d, ((PyObject *)__pyx_codeobj__17)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(0, 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_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6hunter_6vendor_6_cymem_5cymem_7Address_9__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Address___setstate_cython, NULL, __pyx_n_s_hunter_vendor__cymem_cymem, __pyx_d, ((PyObject *)__pyx_codeobj__18)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "hunter/vendor/_cymem/cymem.pyx":1 + * # cython: embedsignature=True, language_level=3str # <<<<<<<<<<<<<< + * + * from cpython.mem cimport PyMem_Malloc, PyMem_Free + */ + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + if (__pyx_m) { + if (__pyx_d && stringtab_initialized) { + __Pyx_AddTraceback("init hunter.vendor._cymem.cymem", __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.vendor._cymem.cymem"); + } + __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 +} +/* #### 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); +#if PY_MAJOR_VERSION >= 3 + 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)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#endif + +/* PyObjectGetAttrStrNoError */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 +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 >= 0x030d00A1 + (void) PyObject_GetOptionalAttr(obj, attr_name, &result); + return result; +#else +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 + 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_b, name); + if (unlikely(!result) && !PyErr_Occurred()) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +/* TupleAndListFromArray */ +#if 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) { + Py_INCREF(__pyx_empty_tuple); + return __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 + 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 + 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; + 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; + } +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 +} + +/* fastcall */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) +{ + Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames); + for (i = 0; i < n; i++) + { + if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i]; + } + for (i = 0; i < n; i++) + { + int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), 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_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { + Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames); + PyObject *dict; + dict = PyDict_New(); + if (unlikely(!dict)) + return NULL; + for (i=0; i= 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; +} +#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 *const *kwvalues, + 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; + int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds)); + while (1) { + Py_XDECREF(key); key = NULL; + Py_XDECREF(value); value = NULL; + if (kwds_is_tuple) { + Py_ssize_t size; +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(kwds); +#else + size = PyTuple_Size(kwds); + if (size < 0) goto bad; +#endif + if (pos >= size) break; +#if CYTHON_AVOID_BORROWED_REFS + key = __Pyx_PySequence_ITEM(kwds, pos); + if (!key) goto bad; +#elif CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kwds, pos); +#else + key = PyTuple_GetItem(kwds, pos); + if (!key) goto bad; +#endif + value = kwvalues[pos]; + pos++; + } + else + { + if (!PyDict_Next(kwds, &pos, &key, &value)) break; +#if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(key); +#endif + } + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; +#if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(value); + Py_DECREF(key); +#endif + key = NULL; + value = NULL; + continue; + } +#if !CYTHON_AVOID_BORROWED_REFS + Py_INCREF(key); +#endif + Py_INCREF(value); + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (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; +#if CYTHON_AVOID_BORROWED_REFS + value = NULL; +#endif + 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 = ( + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key) + ); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; +#if CYTHON_AVOID_BORROWED_REFS + value = NULL; +#endif + 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 + (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(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; + } + } + Py_XDECREF(key); + Py_XDECREF(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: + #if PY_MAJOR_VERSION < 3 + PyErr_Format(PyExc_TypeError, + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + Py_XDECREF(key); + Py_XDECREF(value); + return -1; +} + +/* PyFunctionFastCall */ +#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL +static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, + PyObject *globals) { + PyFrameObject *f; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject **fastlocals; + Py_ssize_t i; + PyObject *result; + assert(globals != NULL); + /* XXX Perhaps we should create a specialized + PyFrame_New() that doesn't take locals, but does + take builtins without sanity checking them. + */ + assert(tstate != NULL); + f = PyFrame_New(tstate, co, globals, NULL); + if (f == NULL) { + return NULL; + } + fastlocals = __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; + return result; +} +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_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) { + return NULL; + } + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) { + return NULL; + } + #endif + if ( +#if PY_MAJOR_VERSION >= 3 + co->co_kwonlyargcount == 0 && +#endif + likely(kwargs == NULL || nk == 0) && + co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { + if (argdefs == NULL && co->co_argcount == nargs) { + result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); + goto done; + } + else if (nargs == 0 && argdefs != NULL + && co->co_argcount == Py_SIZE(argdefs)) { + /* function called with no arguments, but all parameters have + a default value: use default values as arguments .*/ + args = &PyTuple_GET_ITEM(argdefs, 0); + result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); + goto done; + } + } + if (kwargs != NULL) { + Py_ssize_t pos, i; + kwtuple = PyTuple_New(2 * nk); + if (kwtuple == NULL) { + result = NULL; + goto done; + } + k = &PyTuple_GET_ITEM(kwtuple, 0); + pos = i = 0; + while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { + Py_INCREF(k[i]); + Py_INCREF(k[i+1]); + i += 2; + } + nk = i / 2; + } + else { + kwtuple = NULL; + k = NULL; + } + closure = PyFunction_GET_CLOSURE(func); +#if PY_MAJOR_VERSION >= 3 + kwdefs = PyFunction_GET_KW_DEFAULTS(func); +#endif + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } +#if PY_MAJOR_VERSION >= 3 + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, (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; +} +#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 PY_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + #endif + 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 PY_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + #endif + 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 **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 +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **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 PY_VERSION_HEX >= 0x030700A1 + if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) { + return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL); + } + #endif + #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 + #if PY_VERSION_HEX < 0x03090000 + vectorcallfunc f = _PyVectorcall_Function(func); + #else + vectorcallfunc f = PyVectorcall_Function(func); + #endif + if (f) { + return f(func, args, (size_t)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, (size_t)nargs, NULL); + } + #endif + } + if (nargs == 0) { + return __Pyx_PyObject_Call(func, __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 +} + +/* 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); +} + +/* ArgTypeTest */ +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +{ + __Pyx_TypeName type_name; + __Pyx_TypeName obj_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; + } + type_name = __Pyx_PyType_GetName(type); + obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME + ", got " __Pyx_FMT_TYPENAME ")", name, type_name, obj_type_name); + __Pyx_DECREF_TypeName(type_name); + __Pyx_DECREF_TypeName(obj_type_name); + return 0; +} + +/* 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; +} + +/* 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)) +#elif PY_MAJOR_VERSION >= 3 + #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 +#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; + } 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_GetName(tp); + PyErr_Format(PyExc_AttributeError, +#if PY_MAJOR_VERSION >= 3 + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, name); +#else + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", + type_name, PyString_AS_STRING(name)); +#endif + __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) { + 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; +} + +/* 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 if (PyTuple_GET_SIZE(t) < index) { + __Pyx_RaiseNeedMoreValuesError(PyTuple_GET_SIZE(t)); + } else { + __Pyx_RaiseTooManyValuesError(index); + } +} + +/* UnpackTuple2 */ +static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( + PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int decref_tuple) { + PyObject *value1 = NULL, *value2 = NULL; +#if CYTHON_COMPILING_IN_PYPY + value1 = PySequence_ITEM(tuple, 0); if (unlikely(!value1)) goto bad; + value2 = PySequence_ITEM(tuple, 1); if (unlikely(!value2)) goto bad; +#else + value1 = PyTuple_GET_ITEM(tuple, 0); Py_INCREF(value1); + value2 = PyTuple_GET_ITEM(tuple, 1); Py_INCREF(value2); +#endif + if (decref_tuple) { + Py_DECREF(tuple); + } + *pvalue1 = value1; + *pvalue2 = value2; + return 0; +#if CYTHON_COMPILING_IN_PYPY +bad: + Py_XDECREF(value1); + Py_XDECREF(value2); + if (decref_tuple) { Py_XDECREF(tuple); } + return -1; +#endif +} +static int __Pyx_unpack_tuple2_generic(PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, + int has_known_size, int decref_tuple) { + Py_ssize_t index; + PyObject *value1 = NULL, *value2 = NULL, *iter = NULL; + iternextfunc iternext; + iter = PyObject_GetIter(tuple); + if (unlikely(!iter)) goto bad; + if (decref_tuple) { Py_DECREF(tuple); tuple = NULL; } + iternext = __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 && PY_MAJOR_VERSION >= 3 +#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; +#elif PY_MAJOR_VERSION >= 3 + static PyObject *py_items = NULL, *py_keys = NULL, *py_values = NULL; + PyObject **pp = NULL; + if (method_name) { + const char *name = PyUnicode_AsUTF8(method_name); + if (strcmp(name, "iteritems") == 0) pp = &py_items; + else if (strcmp(name, "iterkeys") == 0) pp = &py_keys; + else if (strcmp(name, "itervalues") == 0) pp = &py_values; + if (pp) { + if (!*pp) { + *pp = PyUnicode_FromString(name + 4); + if (!*pp) + return NULL; + } + method_name = *pp; + } + } +#endif + } + *p_orig_length = 0; + if (method_name) { + PyObject* iter; + iterable = __Pyx_PyObject_CallMethod0(iterable, method_name); + if (!iterable) + return NULL; +#if !CYTHON_COMPILING_IN_PYPY + if (PyTuple_CheckExact(iterable) || PyList_CheckExact(iterable)) + return iterable; +#endif + iter = PyObject_GetIter(iterable); + Py_DECREF(iterable); + return iter; + } + return PyObject_GetIter(iterable); +} +static CYTHON_INLINE int __Pyx_dict_iter_next( + PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos, + PyObject** pkey, PyObject** pvalue, PyObject** pitem, int source_is_dict) { + PyObject* next_item; +#if !CYTHON_COMPILING_IN_PYPY + if (source_is_dict) { + PyObject *key, *value; + if (unlikely(orig_length != PyDict_Size(iter_obj))) { + PyErr_SetString(PyExc_RuntimeError, "dictionary changed size during iteration"); + return -1; + } + if (unlikely(!PyDict_Next(iter_obj, ppos, &key, &value))) { + return 0; + } + if (pitem) { + PyObject* tuple = PyTuple_New(2); + if (unlikely(!tuple)) { + return -1; + } + Py_INCREF(key); + Py_INCREF(value); + PyTuple_SET_ITEM(tuple, 0, key); + PyTuple_SET_ITEM(tuple, 1, value); + *pitem = tuple; + } else { + if (pkey) { + Py_INCREF(key); + *pkey = key; + } + if (pvalue) { + Py_INCREF(value); + *pvalue = value; + } + } + return 1; + } else if (PyTuple_CheckExact(iter_obj)) { + Py_ssize_t pos = *ppos; + if (unlikely(pos >= PyTuple_GET_SIZE(iter_obj))) return 0; + *ppos = pos + 1; + next_item = PyTuple_GET_ITEM(iter_obj, pos); + Py_INCREF(next_item); + } else if (PyList_CheckExact(iter_obj)) { + Py_ssize_t pos = *ppos; + if (unlikely(pos >= PyList_GET_SIZE(iter_obj))) return 0; + *ppos = pos + 1; + next_item = PyList_GET_ITEM(iter_obj, pos); + Py_INCREF(next_item); + } else +#endif + { + next_item = PyIter_Next(iter_obj); + if (unlikely(!next_item)) { + return __Pyx_IterFinish(); + } + } + if (pitem) { + *pitem = next_item; + } else if (pkey && pvalue) { + if (__Pyx_unpack_tuple2(next_item, pkey, pvalue, source_is_dict, source_is_dict, 1)) + return -1; + } else if (pkey) { + *pkey = next_item; + } else { + *pvalue = next_item; + } + return 1; +} + +/* WriteUnraisableException */ +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(); + else state = (PyGILState_STATE)0; +#endif + 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) { + Py_XINCREF(old_exc); + Py_XINCREF(old_val); + Py_XINCREF(old_tb); + __Pyx_ErrRestore(old_exc, old_val, old_tb); + PyErr_PrintEx(1); + } + #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); + } else { + PyErr_WriteUnraisable(ctx); + Py_DECREF(ctx); + } +#ifdef WITH_THREAD + if (nogil) + PyGILState_Release(state); +#endif +} + +/* 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 + +/* 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 && PY_VERSION_HEX < 0x030d0000 + 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; + } +#elif CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(!__pyx_m)) { + return NULL; + } + result = PyObject_GetAttr(__pyx_m, name); + if (likely(result)) { + return result; + } +#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); + } +#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); + } + PyErr_Clear(); +#endif + return __Pyx_GetBuiltinName(name); +} + +/* DictGetItem */ +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { + PyObject *value; + value = PyDict_GetItemWithError(d, key); + if (unlikely(!value)) { + if (!PyErr_Occurred()) { + 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 NULL; + } + Py_INCREF(value); + return value; +} +#endif + +/* UnpackUnboundCMethod */ +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; +} +static PyMethodDef __Pyx_UnboundCMethod_Def = { + "CythonUnboundCMethod", + __PYX_REINTERPRET_FUNCION(PyCFunction, __Pyx_SelflessCall), + METH_VARARGS | METH_KEYWORDS, + NULL +}; +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))) + #else + if (likely(!__Pyx_CyOrPyCFunction_Check(method))) + #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); + } 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); + target->method = unbound_method; + } + } + return 0; +} + +/* CallUnboundCMethod2 */ +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030600B1 +static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2) { + if (likely(cfunc->func)) { + PyObject *args[2] = {arg1, arg2}; + if (cfunc->flag == METH_FASTCALL) { + #if PY_VERSION_HEX >= 0x030700A0 + return (*(__Pyx_PyCFunctionFast)(void*)(PyCFunction)cfunc->func)(self, args, 2); + #else + return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, args, 2, NULL); + #endif + } + #if PY_VERSION_HEX >= 0x030700A0 + if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS)) + return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, args, 2, NULL); + #endif + } + return __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2); +} +#endif +static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2){ + 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(2); + if (unlikely(!args)) goto bad; + Py_INCREF(arg1); + PyTuple_SET_ITEM(args, 0, arg1); + Py_INCREF(arg2); + PyTuple_SET_ITEM(args, 1, arg2); + if (cfunc->flag & METH_KEYWORDS) + result = (*(PyCFunctionWithKeywords)(void*)(PyCFunction)cfunc->func)(self, args, NULL); + else + result = (*cfunc->func)(self, args); + } else { + args = PyTuple_New(3); + if (unlikely(!args)) goto bad; + Py_INCREF(self); + PyTuple_SET_ITEM(args, 0, self); + Py_INCREF(arg1); + PyTuple_SET_ITEM(args, 1, arg1); + Py_INCREF(arg2); + PyTuple_SET_ITEM(args, 2, arg2); + result = __Pyx_PyObject_Call(cfunc->method, args, NULL); + } +#else + args = PyTuple_Pack(3, self, arg1, arg2); + if (unlikely(!args)) goto bad; + result = __Pyx_PyObject_Call(cfunc->method, args, NULL); +#endif +bad: + Py_XDECREF(args); + return result; +} + +/* 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); + #endif + } else if ((PY_VERSION_HEX >= 0x030700A0) && flag == (METH_FASTCALL | METH_KEYWORDS)) { + return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, &arg, 1, NULL); + } + } + return __Pyx__CallUnboundCMethod1(cfunc, self, arg); +} +#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); + } +#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; +} + +/* py_dict_pop */ +static CYTHON_INLINE PyObject *__Pyx_PyDict_Pop(PyObject *d, PyObject *key, PyObject *default_value) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B3 & PY_VERSION_HEX < 0x030d0000 + if ((1)) { + return _PyDict_Pop(d, key, default_value); + } else +#endif + if (default_value) { + return __Pyx_CallUnboundCMethod2(&__pyx_umethod_PyDict_Type_pop, d, key, default_value); + } else { + return __Pyx_CallUnboundCMethod1(&__pyx_umethod_PyDict_Type_pop, d, key); + } +} + +/* PySequenceMultiply */ +static PyObject* __Pyx_PySequence_Multiply_Generic(PyObject *seq, Py_ssize_t mul) { + PyObject *result, *pymul = PyInt_FromSsize_t(mul); + if (unlikely(!pymul)) + return NULL; + result = PyNumber_Multiply(seq, pymul); + Py_DECREF(pymul); + return result; +} +static CYTHON_INLINE PyObject* __Pyx_PySequence_Multiply(PyObject *seq, Py_ssize_t mul) { +#if CYTHON_USE_TYPE_SLOTS + PyTypeObject *type = Py_TYPE(seq); + if (likely(type->tp_as_sequence && type->tp_as_sequence->sq_repeat)) { + return type->tp_as_sequence->sq_repeat(seq, mul); + } else +#endif + { + return __Pyx_PySequence_Multiply_Generic(seq, mul); + } +} + +/* FixUpExtensionType */ +#if CYTHON_USE_TYPE_SPECS +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) { +#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + CYTHON_UNUSED_VAR(spec); + CYTHON_UNUSED_VAR(type); +#else + const PyType_Slot *slot = spec->slots; + while (slot && slot->slot && slot->slot != Py_tp_members) + slot++; + if (slot && slot->slot == Py_tp_members) { + int changed = 0; +#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON) + const +#endif + PyMemberDef *memb = (PyMemberDef*) slot->pfunc; + while (memb && memb->name) { + if (memb->name[0] == '_' && memb->name[1] == '_') { +#if PY_VERSION_HEX < 0x030900b1 + 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 +#else + if ((0)); +#endif +#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON + 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; + if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) { + Py_DECREF(descr); + return -1; + } + Py_DECREF(descr); + changed = 1; + } +#endif + } + memb++; + } + if (changed) + PyType_Modified(type); + } +#endif + return 0; +} +#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_MACROS + n = PyTuple_GET_SIZE(bases); +#else + n = PyTuple_Size(bases); + if (n < 0) return -1; +#endif + for (i = 1; i < n; i++) + { +#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 + PyTypeObject *b; +#if PY_MAJOR_VERSION < 3 + if (PyClass_Check(b0)) + { + PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class", + PyString_AS_STRING(((PyClassObject*)b0)->cl_name)); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } +#endif + b = (PyTypeObject*) b0; + if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) + { + __Pyx_TypeName b_name = __Pyx_PyType_GetName(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 || CYTHON_COMPILING_IN_PYPY + 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_GetName(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 || CYTHON_COMPILING_IN_PYPY) + 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 */ +static int __Pyx_PyType_Ready(PyTypeObject *t) { +#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || 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; + 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 PY_VERSION_HEX >= 0x03050000 && !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 PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) + gc = PyImport_GetModule(__pyx_kp_u_gc); + #endif + if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc); + if (unlikely(!gc)) return -1; + py_status = __Pyx_PyObject_CallMethod0(gc, __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_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 PY_VERSION_HEX >= 0x03050000 && !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_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 +} + +/* PyObject_GenericGetAttrNoDict */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { + __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp); + PyErr_Format(PyExc_AttributeError, +#if PY_MAJOR_VERSION >= 3 + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, attr_name); +#else + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", + type_name, PyString_AS_STRING(attr_name)); +#endif + __Pyx_DECREF_TypeName(type_name); + 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); + } + 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 descr; +} +#endif + +/* PyObject_GenericGetAttr */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { + if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { + return PyObject_GenericGetAttr(obj, attr_name); + } + return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); +} +#endif + +/* 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_n_s_pyx_vtable, ob) < 0)) +#else + if (unlikely(PyDict_SetItem(type->tp_dict, __pyx_n_s_pyx_vtable, ob) < 0)) +#endif + 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_n_s_pyx_vtable); +#else + PyObject *ob = PyObject_GetItem(type->tp_dict, __pyx_n_s_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; +} + +/* MergeVTables */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_MergeVtables(PyTypeObject *type) { + int i; + void** base_vtables; + __Pyx_TypeName tp_base_name; + __Pyx_TypeName base_name; + void* unknown = (void*)-1; + PyObject* bases = type->tp_bases; + int base_depth = 0; + { + PyTypeObject* base = type->tp_base; + while (base) { + base_depth += 1; + base = base->tp_base; + } + } + base_vtables = (void**) malloc(sizeof(void*) * (size_t)(base_depth + 1)); + base_vtables[0] = unknown; + for (i = 1; i < PyTuple_GET_SIZE(bases); i++) { + void* base_vtable = __Pyx_GetVtable(((PyTypeObject*)PyTuple_GET_ITEM(bases, i))); + if (base_vtable != NULL) { + int j; + PyTypeObject* base = type->tp_base; + 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 = base->tp_base; + } + } + } + PyErr_Clear(); + free(base_vtables); + return 0; +bad: + tp_base_name = __Pyx_PyType_GetName(type->tp_base); + base_name = __Pyx_PyType_GetName((PyTypeObject*)PyTuple_GET_ITEM(bases, i)); + PyErr_Format(PyExc_TypeError, + "multiple bases have vtable conflict: '" __Pyx_FMT_TYPENAME "' and '" __Pyx_FMT_TYPENAME "'", tp_base_name, base_name); + __Pyx_DECREF_TypeName(tp_base_name); + __Pyx_DECREF_TypeName(base_name); + free(base_vtables); + return -1; +} +#endif + +/* SetupReduce */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { + int ret; + PyObject *name_attr; + name_attr = __Pyx_PyObject_GetAttrStrNoError(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; +} +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_n_s_getstate); +#else + getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate); + if (!getstate && PyErr_Occurred()) { + goto __PYX_BAD; + } +#endif + if (getstate) { +#if CYTHON_USE_PYTYPE_LOOKUP + object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate); +#else + object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_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_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; +#else + object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; +#endif + reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_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_n_s_reduce); if (!object_reduce) goto __PYX_BAD; +#else + object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; +#endif + reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD; + if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { + reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython); + if (likely(reduce_cython)) { + ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_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_n_s_setstate); + if (!setstate) PyErr_Clear(); + if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { + setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); + if (likely(setstate_cython)) { + ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_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_GetName((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; +} +#endif + +/* TypeImport */ +#ifndef __PYX_HAVE_RT_ImportType_3_0_10 +#define __PYX_HAVE_RT_ImportType_3_0_10 +static PyTypeObject *__Pyx_ImportType_3_0_10(PyObject *module, const char *module_name, const char *class_name, + size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_10 check_size) +{ + PyObject *result = 0; + char warning[200]; + 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 + 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_0_10 && + ((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_0_10 && (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 (PyTypeObject *)result; +bad: + Py_XDECREF(result); + return NULL; +} +#endif + +/* Import */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *module = 0; + PyObject *empty_dict = 0; + PyObject *empty_list = 0; + #if PY_MAJOR_VERSION < 3 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (unlikely(!py_import)) + goto bad; + if (!from_list) { + empty_list = PyList_New(0); + if (unlikely(!empty_list)) + goto bad; + from_list = empty_list; + } + #endif + empty_dict = PyDict_New(); + if (unlikely(!empty_dict)) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if (strchr(__Pyx_MODULE_NAME, '.') != NULL) { + module = PyImport_ImportModuleLevelObject( + name, __pyx_d, empty_dict, from_list, 1); + if (unlikely(!module)) { + if (unlikely(!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 (unlikely(!py_level)) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, __pyx_d, empty_dict, from_list, py_level, (PyObject *)NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, __pyx_d, empty_dict, from_list, level); + #endif + } + } +bad: + Py_XDECREF(empty_dict); + Py_XDECREF(empty_list); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_import); + #endif + return module; +} + +/* ImportDottedModule */ +#if PY_MAJOR_VERSION >= 3 +static PyObject *__Pyx__ImportDottedModule_Error(PyObject *name, PyObject *parts_tuple, Py_ssize_t count) { + PyObject *partial_name = NULL, *slice = NULL, *sep = NULL; + if (unlikely(PyErr_Occurred())) { + PyErr_Clear(); + } + if (likely(PyTuple_GET_SIZE(parts_tuple) == 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( +#if PY_MAJOR_VERSION < 3 + PyExc_ImportError, + "No module named '%s'", PyString_AS_STRING(partial_name)); +#else +#if PY_VERSION_HEX >= 0x030600B1 + PyExc_ModuleNotFoundError, +#else + PyExc_ImportError, +#endif + "No module named '%U'", partial_name); +#endif +bad: + Py_XDECREF(sep); + Py_XDECREF(slice); + Py_XDECREF(partial_name); + return NULL; +} +#endif +#if PY_MAJOR_VERSION >= 3 +static PyObject *__Pyx__ImportDottedModule_Lookup(PyObject *name) { + PyObject *imported_module; +#if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) + 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; +} +#endif +#if PY_MAJOR_VERSION >= 3 +static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple) { + Py_ssize_t i, nparts; + nparts = PyTuple_GET_SIZE(parts_tuple); + 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 = PySequence_ITEM(parts_tuple, i); +#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; +} +#endif +static PyObject *__Pyx__ImportDottedModule(PyObject *name, PyObject *parts_tuple) { +#if PY_MAJOR_VERSION < 3 + PyObject *module, *from_list, *star = __pyx_n_s__6; + CYTHON_UNUSED_VAR(parts_tuple); + from_list = PyList_New(1); + if (unlikely(!from_list)) + return NULL; + Py_INCREF(star); + PyList_SET_ITEM(from_list, 0, star); + module = __Pyx_Import(name, from_list, 0); + Py_DECREF(from_list); + return module; +#else + 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); +#endif +} +static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030400B1 + PyObject *module = __Pyx__ImportDottedModule_Lookup(name); + if (likely(module)) { + PyObject *spec = __Pyx_PyObject_GetAttrStrNoError(module, __pyx_n_s_spec); + if (likely(spec)) { + PyObject *unsafe = __Pyx_PyObject_GetAttrStrNoError(spec, __pyx_n_s_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((char*) __PYX_ABI_MODULE_NAME); +} + +/* FetchCommonType */ +static int __Pyx_VerifyCachedType(PyObject *cached_type, + const char *name, + Py_ssize_t basicsize, + Py_ssize_t expected_basicsize) { + if (!PyType_Check(cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", name); + return -1; + } + if (basicsize != expected_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + name); + return -1; + } + return 0; +} +#if !CYTHON_USE_TYPE_SPECS +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { + PyObject* abi_module; + const char* object_name; + PyTypeObject *cached_type = NULL; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) return NULL; + object_name = strrchr(type->tp_name, '.'); + object_name = object_name ? object_name+1 : type->tp_name; + cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name); + if (cached_type) { + if (__Pyx_VerifyCachedType( + (PyObject *)cached_type, + object_name, + cached_type->tp_basicsize, + type->tp_basicsize) < 0) { + goto bad; + } + goto done; + } + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + if (PyType_Ready(type) < 0) goto bad; + if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0) + goto bad; + Py_INCREF(type); + cached_type = type; +done: + Py_DECREF(abi_module); + return cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} +#else +static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *abi_module, *cached_type = NULL; + const char* object_name = strrchr(spec->name, '.'); + object_name = object_name ? object_name+1 : spec->name; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) return NULL; + cached_type = PyObject_GetAttrString(abi_module, object_name); + if (cached_type) { + Py_ssize_t basicsize; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_basicsize; + py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); + if (unlikely(!py_basicsize)) goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; +#else + basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1; +#endif + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + basicsize, + spec->basicsize) < 0) { + goto bad; + } + goto done; + } + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + CYTHON_UNUSED_VAR(module); + cached_type = __Pyx_PyType_FromModuleAndSpec(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; + if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad; +done: + Py_DECREF(abi_module); + assert(cached_type == NULL || PyType_Check(cached_type)); + return (PyTypeObject *) cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} +#endif + +/* PyVectorcallFastCallDict */ +#if CYTHON_METH_FASTCALL +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; + Py_ssize_t nkw = PyDict_GET_SIZE(kw); + 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 &= Py_TYPE(key)->tp_flags; + Py_INCREF(key); + Py_INCREF(value); + PyTuple_SET_ITEM(kwnames, i, key); + 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) +{ + if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) { + return vc(func, args, nargs, NULL); + } + return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); +} +#endif + +/* CythonFunctionShared */ +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { + 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; +} +#else +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { + 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(__pyx_CyFunctionObject *op, void *closure) +{ + CYTHON_UNUSED_VAR(closure); + 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) { +#if PY_MAJOR_VERSION >= 3 + op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); +#else + op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); +#endif + 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 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_Py_XDECREF_SET(op->func_doc, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(op->func_name == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_name = PyObject_GetAttrString(op->func, "__name__"); +#elif PY_MAJOR_VERSION >= 3 + op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); +#else + op->func_name = PyString_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 int +__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) +#else + if (unlikely(value == NULL || !PyString_Check(value))) +#endif + { + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_name, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + Py_INCREF(op->func_qualname); + return op->func_qualname; +} +static int +__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) +#else + if (unlikely(value == NULL || !PyString_Check(value))) +#endif + { + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_qualname, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(op->func_dict == NULL)) { + op->func_dict = PyDict_New(); + if (unlikely(op->func_dict == NULL)) + return NULL; + } + Py_INCREF(op->func_dict); + return op->func_dict; +} +static int +__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, 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_Py_XDECREF_SET(op->func_dict, value); + 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_Py_XDECREF_SET(op->defaults_tuple, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->defaults_tuple; + CYTHON_UNUSED_VAR(context); + 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 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_Py_XDECREF_SET(op->defaults_kwdict, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->defaults_kwdict; + CYTHON_UNUSED_VAR(context); + 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 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_Py_XDECREF_SET(op->func_annotations, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->func_annotations; + CYTHON_UNUSED_VAR(context); + 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_is_coroutine(__pyx_CyFunctionObject *op, void *context) { + int is_coroutine; + CYTHON_UNUSED_VAR(context); + if (op->func_is_coroutine) { + return __Pyx_NewRef(op->func_is_coroutine); + } + is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; +#if PY_VERSION_HEX >= 0x03050000 + if (is_coroutine) { + PyObject *module, *fromlist, *marker = __pyx_n_s_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_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0); + Py_DECREF(fromlist); + if (unlikely(!module)) goto ignore; + op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker); + Py_DECREF(module); + if (likely(op->func_is_coroutine)) { + return __Pyx_NewRef(op->func_is_coroutine); + } +ignore: + PyErr_Clear(); + } +#endif + op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine); + return __Pyx_NewRef(op->func_is_coroutine); +} +#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[] = { + {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, + {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {(char *) "_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 + {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, +#endif +#if CYTHON_USE_TYPE_SPECS + {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, +#if CYTHON_METH_FASTCALL +#if CYTHON_BACKPORT_VECTORCALL + {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, +#else +#if !CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, +#endif +#endif +#endif +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, +#else + {(char *) "__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) +{ + CYTHON_UNUSED_VAR(args); +#if PY_MAJOR_VERSION >= 3 + Py_INCREF(m->func_qualname); + return m->func_qualname; +#else + return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name); +#endif +} +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} +}; +#if PY_VERSION_HEX < 0x030500A0 || 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_pyobjects = 0; + op->defaults_size = 0; + 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 + 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); + } +#endif +#endif + Py_CLEAR(m->defaults_tuple); + Py_CLEAR(m->defaults_kwdict); + Py_CLEAR(m->func_annotations); + Py_CLEAR(m->func_is_coroutine); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_XDECREF(pydefaults[i]); + PyObject_Free(m->defaults); + m->defaults = NULL; + } + return 0; +} +static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + if (__Pyx_CyFunction_weakreflist(m) != NULL) + PyObject_ClearWeakRefs((PyObject *) m); + __Pyx_CyFunction_clear(m); + __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) +{ + 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); + Py_VISIT(m->func_name); + Py_VISIT(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + Py_VISIT(m->func_code); +#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); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_VISIT(pydefaults[i]); + } + return 0; +} +static PyObject* +__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) +{ +#if PY_MAJOR_VERSION >= 3 + return PyUnicode_FromFormat("", + op->func_qualname, (void *)op); +#else + return PyString_FromFormat("", + PyString_AsString(op->func_qualname), (void *)op); +#endif +} +static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *f = ((__pyx_CyFunctionObject*)func)->func; + PyObject *py_name = NULL; + 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*)meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_MACROS + 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); +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, + "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, size); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); +#endif + return NULL; + } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_MACROS + 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; + } +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, + "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, size); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); +#endif + return NULL; + } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + return NULL; + } +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments", + py_name); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", + f->m_ml->ml_name); +#endif + 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 + 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 + __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); + if (vc) { +#if CYTHON_ASSUME_SAFE_MACROS + 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 + } +#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_MACROS + 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); +#if PY_MAJOR_VERSION > 2 + PyErr_Format(PyExc_TypeError, + "unbound method %.200S() needs an argument", + cyfunc->func_qualname); +#else + PyErr_SetString(PyExc_TypeError, + "unbound method needs an argument"); +#endif + return NULL; + } + result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); + Py_DECREF(new_args); + } else { + result = __Pyx_CyFunction_Call(func, args, kw); + } + return result; +} +#if CYTHON_METH_FASTCALL +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)) { + PyErr_Format(PyExc_TypeError, "%.200s() needs an argument", + ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); + return -1; + } + ret = 1; + } + if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); + return -1; + } + return ret; +} +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + if (unlikely(nargs != 0)) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + def->ml_name, nargs); + return NULL; + } + return def->ml_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; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + if (unlikely(nargs != 1)) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + def->ml_name, nargs); + return NULL; + } + return def->ml_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; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_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; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; + 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; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames); +} +#endif +#if CYTHON_USE_TYPE_SPECS +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 (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL) + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + __pyx_CyFunctionType_slots +}; +#else +static PyTypeObject __pyx_CyFunctionType_type = { + PyVarObject_HEAD_INIT(0, 0) + __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, + (destructor) __Pyx_CyFunction_dealloc, +#if !CYTHON_METH_FASTCALL + 0, +#elif CYTHON_BACKPORT_VECTORCALL + (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall), +#else + offsetof(PyCFunctionObject, vectorcall), +#endif + 0, + 0, +#if PY_MAJOR_VERSION < 3 + 0, +#else + 0, +#endif + (reprfunc) __Pyx_CyFunction_repr, + 0, + 0, + 0, + 0, + __Pyx_CyFunction_CallAsMethod, + 0, + 0, + 0, + 0, +#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR + Py_TPFLAGS_METHOD_DESCRIPTOR | +#endif +#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + 0, + (traverseproc) __Pyx_CyFunction_traverse, + (inquiry) __Pyx_CyFunction_clear, + 0, +#if PY_VERSION_HEX < 0x030500A0 + offsetof(__pyx_CyFunctionObject, func_weakreflist), +#else + offsetof(PyCFunctionObject, m_weakreflist), +#endif + 0, + 0, + __pyx_CyFunction_methods, + __pyx_CyFunction_members, + __pyx_CyFunction_getsets, + 0, + 0, + __Pyx_PyMethod_New, + 0, + offsetof(__pyx_CyFunctionObject, func_dict), + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX >= 0x030400a1 + 0, +#endif +#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, +#endif +#if __PYX_NEED_TP_PRINT_SLOT + 0, +#endif +#if PY_VERSION_HEX >= 0x030C0000 + 0, +#endif +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, +#endif +}; +#endif +static int __pyx_CyFunction_init(PyObject *module) { +#if CYTHON_USE_TYPE_SPECS + __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL); +#else + CYTHON_UNUSED_VAR(module); + __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); +#endif + if (unlikely(__pyx_CyFunctionType == NULL)) { + return -1; + } + return 0; +} +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults = PyObject_Malloc(size); + if (unlikely(!m->defaults)) + return PyErr_NoMemory(); + memset(m->defaults, 0, size); + m->defaults_pyobjects = pyobjects; + m->defaults_size = size; + 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_CyFunctionType), + ml, flags, qualname, closure, module, globals, code + ); + if (likely(op)) { + PyObject_GC_Track(op); + } + return op; +} + +/* 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_GetName(Py_TYPE(obj)); + type_name = __Pyx_PyType_GetName(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; +} + +/* CLineInTraceback */ +#ifndef CYTHON_CLINE_IN_TRACEBACK +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 + CYTHON_MAYBE_UNUSED_VAR(tstate); + if (unlikely(!__pyx_cython_runtime)) { + return c_line; + } + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); +#if CYTHON_COMPILING_IN_CPYTHON + cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); + if (likely(cython_runtime_dict)) { + __PYX_PY_DICT_LOOKUP_IF_MODIFIED( + use_cline, *cython_runtime_dict, + __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) + } else +#endif + { + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + if (use_cline_obj) { + use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; + Py_DECREF(use_cline_obj); + } else { + PyErr_Clear(); + use_cline = NULL; + } + } + if (!use_cline) { + c_line = 0; + (void) PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); + } + else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { + c_line = 0; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + return c_line; +} +#endif + +/* CodeObjectCache */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} +#endif + +/* AddTraceback */ +#include "compile.h" +#include "frameobject.h" +#include "traceback.h" +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API + #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; + result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict); + Py_DECREF(replace); + return result; + } + PyErr_Clear(); + #if __PYX_LIMITED_VERSION_HEX < 0x030780000 + { + PyObject *compiled = NULL, *result = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL; + compiled = Py_CompileString( + "out = type(code)(\n" + " code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n" + " code.co_flags, code.co_code, code.co_consts, code.co_names,\n" + " code.co_varnames, code.co_filename, co_name, co_firstlineno,\n" + " code.co_lnotab)\n", "", Py_file_input); + if (!compiled) return NULL; + result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict); + Py_DECREF(compiled); + if (!result) PyErr_Print(); + Py_DECREF(result); + result = PyDict_GetItemString(scratch_dict, "out"); + if (result) Py_INCREF(result); + return result; + } + #else + return NULL; + #endif +} +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 = 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; + 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 = NULL; + PyObject *py_funcname = NULL; + #if PY_MAJOR_VERSION < 3 + PyObject *py_srcfile = NULL; + py_srcfile = PyString_FromString(filename); + if (!py_srcfile) goto bad; + #endif + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + if (!py_funcname) goto bad; + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + if (!py_funcname) goto bad; + funcname = PyUnicode_AsUTF8(py_funcname); + if (!funcname) goto bad; + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + if (!py_funcname) goto bad; + #endif + } + #if PY_MAJOR_VERSION < 3 + py_code = __Pyx_PyCode_New( + 0, + 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); + #else + py_code = PyCode_NewEmpty(filename, funcname, py_line); + #endif + Py_XDECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_funcname); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_srcfile); + #endif + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + 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) { + /* 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,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + __Pyx_PyFrame_SetLineNumber(py_frame, py_line); + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} +#endif + +/* CIntFromPyVerify */ +#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +/* CIntFromPy */ +static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const size_t neg_one = (size_t) -1, const_zero = (size_t) 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(size_t) < sizeof(long))) { + __PYX_VERIFY_RETURN_INT(size_t, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (size_t) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(size_t, __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(size_t) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(size_t) >= 2 * PyLong_SHIFT)) { + return (size_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + } + break; + case 3: + if ((8 * sizeof(size_t) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(size_t) >= 3 * PyLong_SHIFT)) { + return (size_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + } + break; + case 4: + if ((8 * sizeof(size_t) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(size_t, 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(size_t) >= 4 * PyLong_SHIFT)) { + return (size_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + } + break; + } + } +#endif +#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 (size_t) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if ((sizeof(size_t) <= sizeof(unsigned long))) { + __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if ((sizeof(size_t) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(size_t, __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(size_t) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) { + return (size_t) (((size_t)-1)*(((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); + } + } + break; + case 2: + if ((8 * sizeof(size_t) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) { + return (size_t) ((((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); + } + } + break; + case -3: + if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) { + return (size_t) (((size_t)-1)*(((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); + } + } + break; + case 3: + if ((8 * sizeof(size_t) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) { + return (size_t) ((((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); + } + } + break; + case -4: + if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(size_t, 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(size_t) - 1 > 4 * PyLong_SHIFT)) { + return (size_t) (((size_t)-1)*(((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); + } + } + break; + case 4: + if ((8 * sizeof(size_t) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(size_t, 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(size_t) - 1 > 4 * PyLong_SHIFT)) { + return (size_t) ((((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); + } + } + break; + } + } +#endif + if ((sizeof(size_t) <= sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(size_t, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if ((sizeof(size_t) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(size_t, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { + size_t 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 ret = -1; +#if 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 *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (size_t) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (size_t) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (size_t) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (size_t) -1; + } else { + stepval = __Pyx_NewRef(v); + } + val = (size_t) 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(size_t) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((size_t) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(size_t) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((size_t) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + if (!is_unsigned) { + if (unlikely(val & (((size_t) 1) << (sizeof(size_t) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif + Py_DECREF(v); + if (likely(!ret)) + return val; + } + return (size_t) -1; + } + } else { + size_t val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (size_t) -1; + val = __Pyx_PyInt_As_size_t(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to size_t"); + return (size_t) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to size_t"); + return (size_t) -1; +} + +/* FormatTypeName */ +#if CYTHON_COMPILING_IN_LIMITED_API +static __Pyx_TypeName +__Pyx_PyType_GetName(PyTypeObject* tp) +{ + PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_n_s_name); + if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) { + PyErr_Clear(); + Py_XDECREF(name); + name = __Pyx_NewRef(__pyx_n_s__19); + } + return name; +} +#endif + +/* CIntToPy */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_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); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = 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; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + 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) { +#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 PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if ((sizeof(long) < sizeof(long))) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (long) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + 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)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON && 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; + } +#endif + if ((sizeof(long) <= sizeof(unsigned long))) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + 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)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } + } +#endif + if ((sizeof(long) <= sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { + 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 ret = -1; +#if 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 *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (long) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (long) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (long) -1; + } else { + stepval = __Pyx_NewRef(v); + } + 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; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((long) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + 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 CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + 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 + Py_DECREF(v); + if (likely(!ret)) + return val; + } + return (long) -1; + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +/* CIntFromPy */ +static CYTHON_INLINE int __Pyx_PyInt_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 PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if ((sizeof(int) < sizeof(long))) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + 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)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON && 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; + } +#endif + if ((sizeof(int) <= sizeof(unsigned long))) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + 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)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } + } +#endif + if ((sizeof(int) <= sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { + 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 ret = -1; +#if 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 *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (int) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (int) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (int) -1; + } else { + stepval = __Pyx_NewRef(v); + } + 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; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((int) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + 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 CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + 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 + Py_DECREF(v); + if (likely(!ret)) + return val; + } + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +/* FastTypeChecks */ +#if CYTHON_COMPILING_IN_CPYTHON +static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { + while (a) { + a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*); + if (a == b) + return 1; + } + return b == &PyBaseObject_Type; +} +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (a == b) return 1; + mro = a->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(a, b); +} +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); +} +#if PY_MAJOR_VERSION == 2 +static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { + PyObject *exception, *value, *tb; + int res; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&exception, &value, &tb); + res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } + if (!res) { + res = PyObject_IsSubclass(err, exc_type2); + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } + } + __Pyx_ErrRestore(exception, value, tb); + return res; +} +#else +static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { + if (exc_type1) { + return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2); + } else { + return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); + } +} +#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= 0x030B00A4 + return Py_Version & ~0xFFUL; +#else + 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; + } + return version; +#endif +} +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), + "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, (char *)"__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) + 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 */ +#if PY_MAJOR_VERSION >= 3 +static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) { + if (t.is_unicode | t.is_str) { + if (t.intern) { + *str = PyUnicode_InternFromString(t.s); + } else if (t.encoding) { + *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL); + } else { + *str = PyUnicode_FromStringAndSize(t.s, t.n - 1); + } + } else { + *str = PyBytes_FromStringAndSize(t.s, t.n - 1); + } + if (!*str) + return -1; + if (PyObject_Hash(*str) == -1) + return -1; + return 0; +} +#endif +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + while (t->p) { + #if PY_MAJOR_VERSION >= 3 + __Pyx_InitString(*t, t->p); + #else + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + if (!*t->p) + return -1; + if (PyObject_Hash(*t->p) == -1) + return -1; + #endif + ++t; + } + 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) { + 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 + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +} +#else +static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (likely(PyUnicode_IS_ASCII(o))) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +} +#endif +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { + return __Pyx_PyUnicode_AsStringAndSize(o, length); + } else +#endif +#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) + if (PyByteArray_Check(o)) { + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); + } else +#endif + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { + int retval; + if (unlikely(!x)) return -1; + retval = __Pyx_PyObject_IsTrue(x); + Py_DECREF(x); + return retval; +} +static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { + __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result)); +#if PY_MAJOR_VERSION >= 3 + if (PyLong_Check(result)) { + if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, + "__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 " __Pyx_FMT_TYPENAME ")", + type_name, type_name, result_type_name); + __Pyx_DECREF_TypeName(result_type_name); + Py_DECREF(result); + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { +#if CYTHON_USE_TYPE_SLOTS + PyNumberMethods *m; +#endif + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x) || PyLong_Check(x))) +#else + if (likely(PyLong_Check(x))) +#endif + return __Pyx_NewRef(x); +#if CYTHON_USE_TYPE_SLOTS + m = Py_TYPE(x)->tp_as_number; + #if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = m->nb_int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = m->nb_long(x); + } + #else + if (likely(m && m->nb_int)) { + name = "int"; + res = m->nb_int(x); + } + #endif +#else + if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { + res = PyNumber_Int(x); + } +#endif + if (likely(res)) { +#if PY_MAJOR_VERSION < 3 + if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { +#else + if (unlikely(!PyLong_CheckExact(res))) { +#endif + return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(b); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + 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) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE 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); +#if PY_MAJOR_VERSION < 3 + } else if (likely(PyInt_CheckExact(o))) { + return PyInt_AS_LONG(o); +#endif + } else { + Py_ssize_t ival; + PyObject *x; + x = PyNumber_Index(o); + if (!x) return -1; + ival = PyInt_AsLong(x); + Py_DECREF(x); + return ival; + } +} +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { + return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { + return PyInt_FromSize_t(ival); +} + + +/* #### 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/vendor/_cymem/cymem.pxd b/src/hunter/vendor/_cymem/cymem.pxd new file mode 100644 index 00000000..b2c2c425 --- /dev/null +++ b/src/hunter/vendor/_cymem/cymem.pxd @@ -0,0 +1,32 @@ +# cython: language_level=3str +ctypedef void* (*malloc_t)(size_t n) +ctypedef void (*free_t)(void *p) + +cdef class PyMalloc: + cdef malloc_t malloc + cdef void _set(self, malloc_t malloc) + +cdef PyMalloc WrapMalloc(malloc_t malloc) + +cdef class PyFree: + cdef free_t free + cdef void _set(self, free_t free) + +cdef PyFree WrapFree(free_t free) + +cdef class Pool: + cdef readonly size_t size + cdef readonly dict addresses + cdef readonly list refs + cdef readonly PyMalloc pymalloc + cdef readonly PyFree pyfree + + cdef void* alloc(self, size_t number, size_t size) except NULL + cdef void free(self, void* addr) except * + cdef void* realloc(self, void* addr, size_t n) except NULL + + +cdef class Address: + cdef void* ptr + cdef readonly PyMalloc pymalloc + cdef readonly PyFree pyfree diff --git a/src/hunter/vendor/_cymem/cymem.pyx b/src/hunter/vendor/_cymem/cymem.pyx new file mode 100644 index 00000000..b4ecea47 --- /dev/null +++ b/src/hunter/vendor/_cymem/cymem.pyx @@ -0,0 +1,151 @@ +# cython: embedsignature=True, language_level=3str + +from cpython.mem cimport PyMem_Malloc, PyMem_Free +from cpython.ref cimport Py_INCREF, Py_DECREF +from libc.string cimport memset +from libc.string cimport memcpy +import warnings + +WARN_ZERO_ALLOC = False + +cdef class PyMalloc: + cdef void _set(self, malloc_t malloc): + self.malloc = malloc + +cdef PyMalloc WrapMalloc(malloc_t malloc): + cdef PyMalloc o = PyMalloc() + o._set(malloc) + return o + +cdef class PyFree: + cdef void _set(self, free_t free): + self.free = free + +cdef PyFree WrapFree(free_t free): + cdef PyFree o = PyFree() + o._set(free) + return o + +Default_Malloc = WrapMalloc(PyMem_Malloc) +Default_Free = WrapFree(PyMem_Free) + +cdef class Pool: + """Track allocated memory addresses, and free them all when the Pool is + garbage collected. This provides an easy way to avoid memory leaks, and + removes the need for deallocation functions for complicated structs. + + >>> from cymem.cymem cimport Pool + >>> cdef Pool mem = Pool() + >>> data1 = mem.alloc(10, sizeof(int)) + >>> data2 = mem.alloc(12, sizeof(float)) + + Attributes: + size (size_t): The current size (in bytes) allocated by the pool. + addresses (dict): The currently allocated addresses and their sizes. Read-only. + pymalloc (PyMalloc): The allocator to use (default uses PyMem_Malloc). + pyfree (PyFree): The free to use (default uses PyMem_Free). + """ + + def __cinit__(self, PyMalloc pymalloc=Default_Malloc, + PyFree pyfree=Default_Free): + self.size = 0 + self.addresses = {} + self.refs = [] + self.pymalloc = pymalloc + self.pyfree = pyfree + + def __dealloc__(self): + cdef size_t addr + if self.addresses is not None: + for addr in self.addresses: + if addr != 0: + self.pyfree.free(addr) + + cdef void* alloc(self, size_t number, size_t elem_size) except NULL: + """Allocate a 0-initialized number*elem_size-byte block of memory, and + remember its address. The block will be freed when the Pool is garbage + collected. Throw warning when allocating zero-length size and + WARN_ZERO_ALLOC was set to True. + """ + if WARN_ZERO_ALLOC and (number == 0 or elem_size == 0): + warnings.warn("Allocating zero bytes") + cdef void* p = self.pymalloc.malloc(number * elem_size) + if p == NULL: + raise MemoryError("Error assigning %d bytes" % (number * elem_size)) + memset(p, 0, number * elem_size) + self.addresses[p] = number * elem_size + self.size += number * elem_size + return p + + cdef void* realloc(self, void* p, size_t new_size) except NULL: + """Resizes the memory block pointed to by p to new_size bytes, returning + a non-NULL pointer to the new block. new_size must be larger than the + original. + + If p is not in the Pool or new_size is 0, a MemoryError is raised. + """ + if p not in self.addresses: + raise ValueError("Pointer %d not found in Pool %s" % (p, self.addresses)) + if new_size == 0: + raise ValueError("Realloc requires new_size > 0") + assert new_size > self.addresses[p] + cdef void* new_ptr = self.alloc(1, new_size) + if new_ptr == NULL: + raise MemoryError("Error reallocating to %d bytes" % new_size) + memcpy(new_ptr, p, self.addresses[p]) + self.free(p) + self.addresses[new_ptr] = new_size + return new_ptr + + cdef void free(self, void* p) except *: + """Frees the memory block pointed to by p, which must have been returned + by a previous call to Pool.alloc. You don't necessarily need to free + memory addresses manually --- you can instead let the Pool be garbage + collected, at which point all the memory will be freed. + + If p is not in Pool.addresses, a KeyError is raised. + """ + self.size -= self.addresses.pop(p) + self.pyfree.free(p) + + def own_pyref(self, object py_ref): + self.refs.append(py_ref) + + +cdef class Address: + """A block of number * size-bytes of 0-initialized memory, tied to a Python + ref-counted object. When the object is garbage collected, the memory is freed. + + >>> from cymem.cymem cimport Address + >>> cdef Address address = Address(10, sizeof(double)) + >>> d10 = address.ptr + + Args: + number (size_t): The number of elements in the memory block. + elem_size (size_t): The size of each element. + + Attributes: + ptr (void*): Pointer to the memory block. + addr (size_t): Read-only size_t cast of the pointer. + pymalloc (PyMalloc): The allocator to use (default uses PyMem_Malloc). + pyfree (PyFree): The free to use (default uses PyMem_Free). + """ + def __cinit__(self, size_t number, size_t elem_size, + PyMalloc pymalloc=Default_Malloc, PyFree pyfree=Default_Free): + self.ptr = NULL + self.pymalloc = pymalloc + self.pyfree = pyfree + + def __init__(self, size_t number, size_t elem_size): + self.ptr = self.pymalloc.malloc(number * elem_size) + if self.ptr == NULL: + raise MemoryError("Error assigning %d bytes" % number * elem_size) + memset(self.ptr, 0, number * elem_size) + + property addr: + def __get__(self): + return self.ptr + + def __dealloc__(self): + if self.ptr != NULL: + self.pyfree.free(self.ptr) 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..c45735ea --- /dev/null +++ b/tests/eviltracer.pxd @@ -0,0 +1,23 @@ +# cython: language_level=3str +cimport cython + + +cdef extern from "vendor/_compat.h": + """ + #if PY_VERSION_HEX >= 0x030B00A7 + #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..fc5ec418 --- /dev/null +++ b/tests/eviltracer.pyx @@ -0,0 +1,36 @@ +# cython: language_level=3str, c_string_encoding=ascii +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..383d1aa0 100644 --- a/tests/sample5.pyx +++ b/tests/sample5.pyx @@ -1,8 +1,12 @@ # cython: linetrace=True, language_level=3 -foo = bar = lambda x: x +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..a6934c10 --- /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..9acaec23 100644 --- a/tests/sample8errors.py +++ b/tests/sample8errors.py @@ -32,7 +32,7 @@ def silenced3(): try: error() finally: - return "mwhahaha" + 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..ce9de4dc 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 @@ -24,17 +25,25 @@ setup( 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')], + ) + 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..18845a85 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_VALUE +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 == RETURN_VALUE: + # 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 5a479d26..f14ed27b 100644 --- a/tests/test_integration.py +++ b/tests/test_integration.py @@ -7,45 +7,46 @@ 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 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',) 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 @@ -57,7 +58,10 @@ def test_pth_sample4(): 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, ) @@ -69,90 +73,96 @@ def test_pth_sample2(LineMatcher): 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()) @@ -188,26 +230,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 @@ -225,24 +268,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): @@ -256,14 +305,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' @@ -276,18 +328,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) @@ -296,15 +351,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: @@ -317,18 +374,23 @@ def test_depth_limit(LineMatcher, depth): 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: @@ -341,7 +403,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 @@ -353,219 +415,410 @@ 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 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*', + ] + ) + + +def test_stack_printer_2(LineMatcher): + buff = StringIO() + 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*', + ] + ) + + +@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..d7e6e255 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,12 @@ 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, + hunter.Tracer(), + ) def test_no_inf_recursion(mockevent): @@ -112,58 +120,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 +195,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 +203,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 +216,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 +230,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 +280,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 +341,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 +365,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 +381,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..6574cc8f 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('python', '-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('python', '-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('python', '-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('python', '-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 dc7ffa39..5a6e6db5 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 @@ -20,49 +26,65 @@ from hunter import VarsPrinter from hunter import VarsSnooper from hunter import When - -try: - from cStringIO import StringIO -except ImportError: - from io import StringIO - -pytest_plugins = 'pytester', - -PY3 = sys.version_info[0] == 3 - - -class EvilFrame(object): - 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 hunter.actions import StackPrinter + +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)) @@ -77,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' @@ -104,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)' @@ -112,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): @@ -127,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) @@ -146,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'}]) @@ -170,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) @@ -190,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): @@ -222,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 @@ -261,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(): @@ -320,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(): @@ -352,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' @@ -378,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): @@ -398,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): @@ -459,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): @@ -477,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 @@ -493,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 @@ -503,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 + + +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_CFLAGS") == "-DCYTHON_TRACE=1"') +@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 @@ -541,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 @@ -568,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 @@ -602,6 +922,7 @@ def foo(): def test_trace_with_class_actions(): with trace(CodePrinter): + def a(): pass @@ -625,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')) @@ -640,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(_): @@ -648,7 +970,7 @@ def inc(_): handler = Q( Q(module='does-not-exist') | Q(module='does not exist'.split()), - action=inc + action=inc, ) @benchmark @@ -665,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 @@ -685,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() @@ -714,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 @@ -733,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 @@ -771,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 @@ -790,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): @@ -834,7 +1291,7 @@ def old_m(self, _): pass -class Desc(object): +class Desc: def __init__(self, func): self.func = func @@ -842,7 +1299,7 @@ def __get__(self, instance, owner): return self.func -class New(object): +class New: @staticmethod def new_sm(_): pass @@ -866,7 +1323,7 @@ def lf(_): def dlf(_): pass - class Local(object): + class Local: @staticmethod def local_sm(_): pass @@ -884,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) @@ -921,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 @@ -964,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 = [] @@ -982,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' @@ -1004,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): @@ -1027,220 +1518,283 @@ 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", - ]) + 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(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( + [ + '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..1ea033f7 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('