././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788210447.7962487 borghash-0.2.1/0000755000175100017510000000000015245366420012764 5ustar00runnerrunner././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788210425.9461164 borghash-0.2.1/AUTHORS0000644000175100017510000000004515245366372014041 0ustar00runnerrunnerThomas Waldmann ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788210425.9461164 borghash-0.2.1/CHANGES.rst0000644000175100017510000000353115245366372014576 0ustar00runnerrunnerChangelog ========= Version 0.2.1 (2026-08-31) -------------------------- Fixes / improvements: - hash table resize policy: stop pointless and oversized rehashes - reuse tombstone buckets for new entries - do not grow the hash table when it is mostly tombstones - only shrink the hash table when the new capacity is actually smaller Other changes: - add a release workflow (sdist build, pypi, provenance attestation, gh release) - CI: harden the workflows, add dependabot - update docs Version 0.2.0 (2026-08-11) -------------------------- - ``HashTable.items()`` / ``HashTableNT.items()``: add optional ``prefix_bits`` / ``prefix`` arguments to iterate over only the items whose keys start with the given bit prefix. As the keys are random bytes, this partitions the items into ``2 ** prefix_bits`` roughly equally sized, disjoint sets, so a huge hash table can be processed in batches with a small memory footprint, #49. - Require ``key_size >= 4`` to avoid out-of-bounds reads in ``_get_index``, #42. - Add support for Python 3.15, remove 3.10. - Cythonize with the latest Cython release. Version 0.1.1 (2026-02-09) -------------------------- - Cythonize with the latest Cython release. - Use the SPDX license identifier, require a recent setuptools. - Add support for Python 3.14, remove 3.9. - Migrate tox configuration to pyproject.toml. - Fix typos and grammar. Version 0.1.0 2024-11-18 ------------------------ - HashTableNT: handle ``byte_order`` separately. - HashTableNT: provide separate formats in the ``value_format`` namedtuple. Version 0.0.2 2024-11-10 ------------------------ - Fixed "KV array is full" crash on 32-bit platforms (and maybe also some other integer-size related issues), #27. - Added an ``.update()`` method to HashTableNT (like ``dict.update()``), #28. Version 0.0.1 2024-10-31 ------------------------ Initial release. ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788210425.9461164 borghash-0.2.1/LICENSE.rst0000644000175100017510000000271715245366372014615 0ustar00runnerrunnerCopyright (C) 2024-2026 Thomas Waldmann All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. The name of the author may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ././@PaxHeader0000000000000000000000000000003200000000000010210 xustar0026 mtime=1788210447.79622 borghash-0.2.1/PKG-INFO0000644000175100017510000000205715245366420014065 0ustar00runnerrunnerMetadata-Version: 2.4 Name: borghash Version: 0.2.1 Summary: Memory-efficient hash table (implemented in Cython) Author: The Borg Collective (see AUTHORS file) Maintainer-email: Thomas Waldmann License-Expression: BSD-3-Clause Project-URL: Homepage, https://github.com/borgbackup/borghash Project-URL: Changelog, https://github.com/borgbackup/borghash/blob/main/CHANGES.rst Keywords: hashtable,memory,efficient,dense Classifier: Development Status :: 4 - Beta Classifier: Intended Audience :: Developers Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.11 Classifier: Programming Language :: Python :: 3.12 Classifier: Programming Language :: Python :: 3.13 Classifier: Programming Language :: Python :: 3.14 Classifier: Programming Language :: Python :: 3.15 Classifier: Topic :: Software Development :: Libraries Classifier: Topic :: Software Development :: Libraries :: Python Modules Requires-Python: >=3.11 License-File: LICENSE.rst Dynamic: license-file ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788210425.9461164 borghash-0.2.1/README.rst0000644000175100017510000002032015245366372014456 0ustar00runnerrunnerBorgHash ======== Memory-efficient hashtable implementations for Python, written in Cython. HashTable --------- ``HashTable`` is a fairly low-level implementation; usually one will want to use the ``HashTableNT`` wrapper. Read on for the basics... Keys and Values ~~~~~~~~~~~~~~~ The keys MUST be perfectly random ``bytes`` of arbitrary but fixed length (at least 4 bytes), like from a cryptographic hash (SHA-256, HMAC-SHA-256, ...). The implementation relies on this "perfectly random" property and does not implement its own hash function; it just takes the leading 32 bits of the given key. The values are ``bytes`` of arbitrary but fixed length. The lengths of the keys and values are defined when creating a ``HashTable`` instance; thereafter, the lengths must always match the defined sizes. Implementation details ~~~~~~~~~~~~~~~~~~~~~~ To have little memory overhead overall, the hashtable only stores ``uint32_t`` indices into separate keys and values arrays (short: kv arrays). A new key is appended to the keys array. The corresponding value is appended to the values array. After that, the key and value do not change their index as long as they exist in the hashtable and the ht and kv arrays are in memory. Even when kv pairs are deleted from ``HashTable``, the kv arrays never shrink and the indices of other kv pairs don't change. This is because we want to have stable array indices for the keys/values, so the indices can be used outside of ``HashTable`` as memory-efficient references. Memory allocated ~~~~~~~~~~~~~~~~ For a hashtable load factor of 0.1 – 0.5, a kv array growth factor of 1.3, and N kv pairs, memory usage in bytes is approximately: - hashtable: from ``N * 4 / 0.5`` to ``N * 4 / 0.1`` - Keys/Values: from ``N * len(key + value) * 1.0`` to ``N * len(key + value) * 1.3`` - Overall: from ``N * (8 + len(key + value))`` to ``N * (40 + len(key + value) * 1.3)`` When the hashtable or the kv arrays are resized, there will be brief memory-usage spikes. For the kv arrays, ``realloc()`` is used to avoid copying data and to minimize memory-usage spikes, if possible. HashTableNT ----------- ``HashTableNT`` is a convenience wrapper around ``HashTable``: - Accepts and returns ``namedtuple`` values. - Implements persistence: can read the hashtable from a file and write it to a file. Keys and Values ~~~~~~~~~~~~~~~ Keys: ``bytes``, see ``HashTable``. Values: any fixed ``namedtuple`` type that can be serialized to ``bytes`` by Python's ``struct`` module using a given format string. When setting a value, it is automatically serialized. When a value is returned, it will be a ``namedtuple`` of the given type. The ``byte_order`` argument (``"little"`` by default, also ``"big"``, ``"network"`` or ``"native"``) selects the byte order used for serialization, so a serialized hashtable can be read back on a machine with a different native byte order. Persistence ~~~~~~~~~~~ ``HashTableNT`` has ``.write()`` and ``.read()`` methods to save/load its contents to/from a file, using an efficient binary format. When a ``HashTableNT`` is saved to disk, only the non-deleted entries are persisted. When it is loaded from disk, a new hashtable and new, dense kv arrays are built; thus, kv indices will be different! Iterating over key-prefix partitions ------------------------------------ ``items()`` accepts two optional keyword arguments to iterate over only the items whose keys start with a given bit prefix: - ``prefix_bits``: number of leading key bits to compare, ``0 .. 32`` (``0``, the default, means: no filtering) - ``prefix``: expected value of these leading bits, given in the integer's low bits, thus ``0 <= prefix < 2 ** prefix_bits`` As the keys are perfectly random, this partitions the items into ``2 ** prefix_bits`` roughly equally sized, disjoint sets, and iterating over all prefixes visits every item exactly once. Only the matching keys/values are built as Python objects, so a huge hashtable can be processed in batches with a small memory footprint:: prefix_bits = 8 # 256 partitions for prefix in range(2 ** prefix_bits): for key, value in ht.items(prefix_bits=prefix_bits, prefix=prefix): ... # process one partition API --- HashTable and HashTableNT have an API similar to a dict: - ``__init__(items=None, ...)``: optionally fills the new table from a dict or an iterable of ``(key, value)`` pairs - ``__setitem__`` / ``__getitem__`` / ``__delitem__`` / ``__contains__`` - ``get()``, ``pop()``, ``setdefault()``, ``clear()`` - ``items()`` (see above), ``__len__`` - ``stats`` property with operation/resize counters Additionally, both offer access to the stable kv indices (see "Implementation details"), which can be used as memory-efficient references: - ``k_to_idx()``, ``idx_to_k()``, ``kv_to_idx()``, ``idx_to_kv()`` HashTableNT also has: - ``update()`` (like ``dict.update()``) - ``write()``, ``read()``, ``size()`` (see "Persistence"; ``size()`` gives a rough worst-case estimate of the on-disk size) Example code ------------ :: # HashTableNT mapping 256-bit key [bytes] --> Chunk value [namedtuple] Chunk = namedtuple("Chunk", ["refcount", "size"]) ChunkFormat = namedtuple("ChunkFormat", ["refcount", "size"]) chunk_format = ChunkFormat(refcount="I", size="I") # 256-bit (32-byte) key, 2x 32-bit (4-byte) values ht = HashTableNT(key_size=32, value_type=Chunk, value_format=chunk_format) key = b"x" * 32 # the key is usually from a cryptographic hash function value = Chunk(refcount=1, size=42) ht[key] = value assert ht[key] == value for key, value in ht.items(): assert isinstance(key, bytes) assert isinstance(value, Chunk) file = "dump.bin" # giving an fd of a file opened in binary mode also works ht.write(file) ht = HashTableNT.read(file) Building / Installing --------------------- To install the latest release from PyPI:: pip install borghash Building from a git checkout requires Cython:: pip install -r requirements.d/dev.txt For development, install in editable mode (this also cythonizes and builds the extension modules in place):: pip install -e . --no-build-isolation To build a package and install it:: python -m build pip install dist/borghash*.tar.gz The generated C files are included in the sdist, thus installing the built package does not require Cython. Making a release ---------------- Update ``CHANGES.rst`` (the heading of the new section belongs onto the last commit that goes into the release) and merge that via a pull request. Then put an annotated, signed tag named like the version (no ``v`` prefix) onto the "update CHANGES" commit and push it:: git tag -s -m "tagged/signed release 0.3.0" 0.3.0 git push origin 0.3.0 Pushing the tag runs ``.github/workflows/release.yml``, which builds the sdist, checks that it is complete and installable, attests its build provenance and creates a *draft* GitHub release with the sdist and the attestation bundle (``borghash-0.3.0.tar.gz.jsonl``). The upload to PyPI happens in the ``pypi`` job, which uses trusted publishing (no API token) and waits for an approval if the ``pypi`` environment has required reviewers configured. The attestation says that this workflow built this sdist from this repository, and is checked with:: gh attestation verify --owner borgbackup borghash-0.3.0.tar.gz Finally, write the release notes and publish the draft release. Want a demo? ------------ Run ``borghash-demo`` after installing the ``borghash`` package. It will show you the demo code, run it, and print the results for your machine. Results on an Apple MacBook Pro (M3 Pro CPU) look like: :: HashTableNT in-memory ops (count=50000): insert: 0.042s, lookup: 0.045s, pop: 0.043s. HashTableNT serialization (count=50000): write: 0.014s, read: 0.010s. State of this project --------------------- **API is still unstable and expected to change as development continues.** **As long as the API is unstable, there will be no data migration tools, e.g., for reading an existing serialized hashtable.** There might be missing features or optimization potential; feedback is welcome! Borg? ----- BorgBackup (aka "borg") uses ``borghash`` on its master branch (the borg 2 pre-releases), e.g. for the chunks index. License ------- BSD license. ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788210425.9461164 borghash-0.2.1/pyproject.toml0000644000175100017510000000310315245366372015703 0ustar00runnerrunner[project] name = "borghash" dynamic = ["version"] authors = [{name="The Borg Collective (see AUTHORS file)"}] maintainers = [ {name="Thomas Waldmann", email="tw@waldmann-edv.de"}, ] description = "Memory-efficient hash table (implemented in Cython)" requires-python = ">=3.11" keywords = ["hashtable", "memory", "efficient", "dense"] classifiers = [ "Development Status :: 4 - Beta", "Intended Audience :: Developers", "Programming Language :: Python", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Programming Language :: Python :: 3.13", "Programming Language :: Python :: 3.14", "Programming Language :: Python :: 3.15", "Topic :: Software Development :: Libraries", "Topic :: Software Development :: Libraries :: Python Modules", ] license = "BSD-3-Clause" license-files = ["LICENSE.rst"] dependencies = [] [project.urls] "Homepage" = "https://github.com/borgbackup/borghash" "Changelog" = "https://github.com/borgbackup/borghash/blob/main/CHANGES.rst" [project.scripts] borghash-demo = "borghash.__main__:demo" [build-system] requires = ["setuptools>=78.1.1", "wheel", "setuptools_scm[toml]>=6.2"] build-backend = "setuptools.build_meta" [tool.setuptools_scm] [tool.pytest.ini_options] markers = [] [tool.tox] env_list = ["py311", "py312", "py313", "py314", "py315"] [tool.tox.env] [tool.tox.env.py] deps = ["pytest", "pytest-benchmark"] commands = [ ["pytest", "-v", "-rs", "--benchmark-columns=mean", "--benchmark-sort=name", "--benchmark-group-by=func"] ] ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788210447.7965045 borghash-0.2.1/setup.cfg0000644000175100017510000000004615245366420014605 0ustar00runnerrunner[egg_info] tag_build = tag_date = 0 ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788210425.9461164 borghash-0.2.1/setup.py0000644000175100017510000000101715245366372014503 0ustar00runnerrunnerfrom setuptools import Extension, setup try: from Cython.Build import cythonize except ImportError: cythonize = None # we don't have Cython installed ext = '.pyx' if cythonize else '.c' extensions = [ Extension("borghash.HashTable", ["src/borghash/HashTable" + ext]), Extension("borghash.HashTableNT", ["src/borghash/HashTableNT" + ext]), ] if cythonize: extensions = cythonize(extensions, language_level="3str") setup( package_data={"borghash": ["*.pxd", "*.pyx"]}, ext_modules=extensions, ) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788210447.7896638 borghash-0.2.1/src/0000755000175100017510000000000015245366420013553 5ustar00runnerrunner././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788210447.7944627 borghash-0.2.1/src/borghash/0000755000175100017510000000000015245366420015350 5ustar00runnerrunner././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788210436.3122928 borghash-0.2.1/src/borghash/HashTable.c0000644000175100017510000314031415245366404017357 0ustar00runnerrunner/* Generated by Cython 3.3.0 */ /* BEGIN: Cython Metadata { "distutils": { "depends": [], "name": "borghash.HashTable", "sources": [ "src/borghash/HashTable.pyx" ] }, "module_name": "borghash.HashTable" } END: Cython Metadata */ #ifndef PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN #endif /* PY_SSIZE_T_CLEAN */ /* InitLimitedAPI */ #if defined(Py_LIMITED_API) #if !defined(CYTHON_LIMITED_API) #define CYTHON_LIMITED_API 1 #endif #elif defined(CYTHON_LIMITED_API) #ifdef _MSC_VER #pragma message ("Limited API usage is enabled with 'CYTHON_LIMITED_API' but 'Py_LIMITED_API' does not define a Python target version. Consider setting 'Py_LIMITED_API' instead.") #else #warning Limited API usage is enabled with 'CYTHON_LIMITED_API' but 'Py_LIMITED_API' does not define a Python target version. Consider setting 'Py_LIMITED_API' instead. #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 < 0x03090000 #error Cython requires Python 3.9+. #elif defined(Py_LIMITED_API) && (Py_LIMITED_API & 0xFFFF0000) > (PY_VERSION_HEX & 0xFFFF0000) #error 'Py_LIMITED_API' can only select past Python X.Y versions, not future ones. #else #define __PYX_ABI_VERSION "3_3_0" #define CYTHON_HEX_VERSION 0x030300F0 #define CYTHON_FUTURE_DIVISION 1 /* CModulePreamble */ #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 #ifdef __has_builtin #define __Pyx_has_cbuiltin(name) __has_builtin(name) #else #define __Pyx_has_cbuiltin(name) (0) #endif #ifndef DL_IMPORT #define DL_IMPORT(t) t #endif #ifndef DL_EXPORT #define DL_EXPORT(t) t #endif #define __PYX_COMMA , #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(CYTHON_LIMITED_API) #ifdef Py_LIMITED_API #undef __PYX_LIMITED_VERSION_HEX #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API #if Py_LIMITED_API < 0x03090000 #error "Cython 3.3 requires the Python Limited API version to be 3.9 or greater." #endif #endif #if defined(GRAALVM_PYTHON) || defined(PYPY_VERSION) #ifdef _MSC_VER #pragma message ("Py_LIMITED_API is defined on PyPy or GraalPy. This takes precedence over Cython's specialized\ code for PyPy and GraalPy and is unlikely to work.") #else #warning "Py_LIMITED_API is defined on PyPy or GraalPy. This takes precedence over Cython's specialized\ code for PyPy and GraalPy and is unlikely to work." #endif #endif #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_LIMITED_API 1 #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #undef CYTHON_USE_TYPE_SPECS #define CYTHON_USE_TYPE_SPECS 1 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #endif #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0 #endif #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 #undef CYTHON_ASSUME_SAFE_SIZE #define CYTHON_ASSUME_SAFE_SIZE 0 #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_GIL #define CYTHON_FAST_GIL 0 #undef CYTHON_VECTORCALL #define CYTHON_VECTORCALL (__PYX_LIMITED_VERSION_HEX >= 0x030C0000) #ifndef CYTHON_VECTORCALL_TPNEW #define CYTHON_VECTORCALL_TPNEW (CYTHON_VECTORCALL && __PYX_LIMITED_VERSION_HEX >= 0x030E0000) #endif #ifndef CYTHON_PEP487_INIT_SUBCLASS #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif #ifndef CYTHON_USE_MODULE_STATE #define CYTHON_USE_MODULE_STATE 0 #endif #undef CYTHON_USE_SYS_MONITORING #define CYTHON_USE_SYS_MONITORING 0 #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE (__PYX_LIMITED_VERSION_HEX >= 0x030F0000 && PY_VERSION_HEX > 0x030F00A8) #endif #ifndef CYTHON_USE_AM_SEND #define CYTHON_USE_AM_SEND (__PYX_LIMITED_VERSION_HEX >= 0x030A0000) #endif #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif #ifndef CYTHON_USE_OWN_PREP_RERAISE_STAR #define CYTHON_USE_OWN_PREP_RERAISE_STAR 1 #endif #ifndef CYTHON_USE_FREELISTS #define CYTHON_USE_FREELISTS 1 #endif #undef CYTHON_IMMORTAL_CONSTANTS #define CYTHON_IMMORTAL_CONSTANTS 0 #if __PYX_LIMITED_VERSION_HEX < 0x030E0000 #undef CYTHON_OPAQUE_OBJECTS #define CYTHON_OPAQUE_OBJECTS 0 #elif !defined(CYTHON_OPAQUE_OBJECTS) #define CYTHON_OPAQUE_OBJECTS (__PYX_LIMITED_VERSION_HEX >= 0x030F0000) #endif #elif defined(GRAALVM_PYTHON) /* For very preliminary testing purposes. Most variables are set the same as PyPy. The existence of this section does not imply that anything works or is even tested */ #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_LIMITED_API 0 #define CYTHON_COMPILING_IN_GRAAL 1 #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #endif #undef CYTHON_USE_TYPE_SPECS #define CYTHON_USE_TYPE_SPECS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #undef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 1 #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0 #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 #undef CYTHON_ASSUME_SAFE_SIZE #define CYTHON_ASSUME_SAFE_SIZE 0 #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_GIL #define CYTHON_FAST_GIL 0 #ifndef CYTHON_VECTORCALL #define CYTHON_VECTORCALL 1 #endif #if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX < 0x030E0000 #undef CYTHON_VECTORCALL_TPNEW #define CYTHON_VECTORCALL_TPNEW 0 #elif !defined(CYTHON_VECTORCALL_TPNEW) #define CYTHON_VECTORCALL_TPNEW CYTHON_VECTORCALL #endif #ifndef CYTHON_PEP487_INIT_SUBCLASS #define CYTHON_PEP487_INIT_SUBCLASS 1 #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_SYS_MONITORING #define CYTHON_USE_SYS_MONITORING 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_AM_SEND #define CYTHON_USE_AM_SEND 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 1 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif #ifndef CYTHON_USE_OWN_PREP_RERAISE_STAR #define CYTHON_USE_OWN_PREP_RERAISE_STAR 1 #endif #undef CYTHON_USE_FREELISTS #define CYTHON_USE_FREELISTS 0 #undef CYTHON_IMMORTAL_CONSTANTS #define CYTHON_IMMORTAL_CONSTANTS 0 #undef CYTHON_OPAQUE_OBJECTS #define CYTHON_OPAQUE_OBJECTS 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_CPYTHON_FREETHREADING 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #ifndef CYTHON_USE_TYPE_SPECS #define CYTHON_USE_TYPE_SPECS 0 #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_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_AVOID_THREAD_UNSAFE_BORROWED_REFS #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1 #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 #ifndef CYTHON_ASSUME_SAFE_SIZE #define CYTHON_ASSUME_SAFE_SIZE 1 #endif #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_GIL #define CYTHON_FAST_GIL 0 #ifndef CYTHON_VECTORCALL #define CYTHON_VECTORCALL 1 #endif #if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX < 0x030E0000 #undef CYTHON_VECTORCALL_TPNEW #define CYTHON_VECTORCALL_TPNEW 0 #elif !defined(CYTHON_VECTORCALL_TPNEW) #define CYTHON_VECTORCALL_TPNEW (PYPY_VERSION_NUM >= 0x07030800 && CYTHON_VECTORCALL) #endif #ifndef CYTHON_PEP487_INIT_SUBCLASS #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif #undef CYTHON_USE_MODULE_STATE #define CYTHON_USE_MODULE_STATE 0 #undef CYTHON_USE_SYS_MONITORING #define CYTHON_USE_SYS_MONITORING 0 #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE (PYPY_VERSION_NUM >= 0x07030C00) #endif #undef CYTHON_USE_AM_SEND #define CYTHON_USE_AM_SEND 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_NUM >= 0x07031100) #endif #ifndef CYTHON_USE_OWN_PREP_RERAISE_STAR #define CYTHON_USE_OWN_PREP_RERAISE_STAR 1 #endif #undef CYTHON_USE_FREELISTS #define CYTHON_USE_FREELISTS 0 #undef CYTHON_IMMORTAL_CONSTANTS #define CYTHON_IMMORTAL_CONSTANTS 0 #undef CYTHON_OPAQUE_OBJECTS #define CYTHON_OPAQUE_OBJECTS 0 #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 #ifdef Py_GIL_DISABLED #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 1 #else #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 #endif #if PY_VERSION_HEX < 0x030A0000 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #elif !defined(CYTHON_USE_TYPE_SLOTS) #define CYTHON_USE_TYPE_SLOTS 1 #endif #ifndef CYTHON_USE_TYPE_SPECS #define CYTHON_USE_TYPE_SPECS 0 #endif #ifndef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #ifndef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #elif !defined(CYTHON_USE_PYLIST_INTERNALS) #define CYTHON_USE_PYLIST_INTERNALS 1 #endif #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING || PY_VERSION_HEX >= 0x030B00A2 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #elif !defined(CYTHON_USE_UNICODE_WRITER) #define CYTHON_USE_UNICODE_WRITER 1 #endif #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1 #elif !defined(CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS) #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_ASSUME_SAFE_SIZE #define CYTHON_ASSUME_SAFE_SIZE 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING #undef CYTHON_FAST_GIL #define CYTHON_FAST_GIL 0 #elif !defined(CYTHON_FAST_GIL) #define CYTHON_FAST_GIL (PY_VERSION_HEX < 0x030C00A6) #endif #ifndef CYTHON_VECTORCALL #define CYTHON_VECTORCALL 1 #endif #if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX < 0x030E0000 #undef CYTHON_VECTORCALL_TPNEW #define CYTHON_VECTORCALL_TPNEW 0 #elif !defined(CYTHON_VECTORCALL_TPNEW) #define CYTHON_VECTORCALL_TPNEW CYTHON_VECTORCALL #endif #ifndef CYTHON_PEP487_INIT_SUBCLASS #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif #ifndef CYTHON_USE_MODULE_STATE #define CYTHON_USE_MODULE_STATE 0 #endif #ifndef CYTHON_USE_SYS_MONITORING #define CYTHON_USE_SYS_MONITORING (PY_VERSION_HEX >= 0x030d00B1) #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 1 #endif #ifndef CYTHON_USE_AM_SEND #define CYTHON_USE_AM_SEND 1 #endif #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #elif !defined(CYTHON_USE_DICT_VERSIONS) #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5 && !CYTHON_USE_MODULE_STATE) #endif #ifndef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 1 #endif #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 #endif #ifndef CYTHON_USE_OWN_PREP_RERAISE_STAR #define CYTHON_USE_OWN_PREP_RERAISE_STAR (PY_VERSION_HEX < 0x030C00B2) #endif #ifndef CYTHON_USE_FREELISTS #define CYTHON_USE_FREELISTS (!CYTHON_COMPILING_IN_CPYTHON_FREETHREADING) #endif #if defined(CYTHON_IMMORTAL_CONSTANTS) && PY_VERSION_HEX < 0x030C0000 #undef CYTHON_IMMORTAL_CONSTANTS #define CYTHON_IMMORTAL_CONSTANTS 0 // definitely won't work #elif !defined(CYTHON_IMMORTAL_CONSTANTS) #define CYTHON_IMMORTAL_CONSTANTS (PY_VERSION_HEX >= 0x030C0000 && !CYTHON_USE_MODULE_STATE && CYTHON_COMPILING_IN_CPYTHON_FREETHREADING) #endif #ifndef CYTHON_OPAQUE_OBJECTS #define CYTHON_OPAQUE_OBJECTS 0 #endif #endif #if CYTHON_USE_PYLONG_INTERNALS #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 #elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L #define CYTHON_UNUSED [[maybe_unused]] #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 && !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING # define CYTHON_NCP_UNUSED # else # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif #ifndef CYTHON_USE_CPP_STD_MOVE #if defined(__cplusplus) && (\ __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) #define CYTHON_USE_CPP_STD_MOVE 1 #else #define CYTHON_USE_CPP_STD_MOVE 0 #endif #endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) #include typedef uintptr_t __pyx_uintptr_t; #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 Py_UNREACHABLE #define __Pyx_UNREACHABLE() Py_UNREACHABLE() #elif __Pyx_has_cbuiltin(__builtin_unreachable) #define __Pyx_UNREACHABLE() __builtin_unreachable() #elif defined(__clang__) || defined(__INTEL_COMPILER) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5))) #define __Pyx_UNREACHABLE() __builtin_unreachable() #elif defined(_MSC_VER) #define __Pyx_UNREACHABLE() __assume(0) #else #define __Pyx_UNREACHABLE() Py_FatalError("Unreachable C code path reached") #endif #ifndef Py_UNREACHABLE #define Py_UNREACHABLE() __Pyx_UNREACHABLE() #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 < 0x030A0000) #else #define __PYX_NEED_TP_PRINT_SLOT 0 #endif #define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) #if __PYX_LIMITED_VERSION_HEX < 0x030C0000 #define __Pyx_PyErr_FetchException(petype, peval, petb) PyErr_Fetch(petype, peval, petb) #define __Pyx_PyErr_RestoreException(etype, eval, etb) PyErr_Restore(etype, eval, etb) #else #define __Pyx_PyErr_FetchException(petype, peval, petb) *(petype)=NULL; *(peval)=PyErr_GetRaisedException(); *(petb)=NULL #define __Pyx_PyErr_RestoreException(etype, eval, etb) PyErr_SetRaisedException(eval) #endif /* CInitCode */ #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 /* PythonCompatibility */ #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_DefaultClassType PyType_Type #if CYTHON_COMPILING_IN_LIMITED_API #ifndef CO_OPTIMIZED static int CO_OPTIMIZED; #endif #ifndef CO_NEWLOCALS static int CO_NEWLOCALS; #endif #ifndef CO_VARARGS static int CO_VARARGS; #endif #ifndef CO_VARKEYWORDS static int CO_VARKEYWORDS; #endif #ifndef CO_ASYNC_GENERATOR static int CO_ASYNC_GENERATOR; #endif #ifndef CO_GENERATOR static int CO_GENERATOR; #endif #ifndef CO_COROUTINE static int CO_COROUTINE; #endif #else #ifndef CO_COROUTINE #define CO_COROUTINE 0x80 #endif #ifndef CO_ASYNC_GENERATOR #define CO_ASYNC_GENERATOR 0x200 #endif #endif static int __Pyx_init_co_variables(void); #if PY_VERSION_HEX >= 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 CYTHON_COMPILING_IN_PYPY #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) #else #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) #endif #if CYTHON_COMPILING_IN_LIMITED_API static unsigned long __Pyx_Runtime_TPFLAGS_SEQUENCE; static unsigned long __Pyx_Runtime_TPFLAGS_MAPPING; #else #define __Pyx_Runtime_TPFLAGS_SEQUENCE Py_TPFLAGS_SEQUENCE #define __Pyx_Runtime_TPFLAGS_MAPPING Py_TPFLAGS_MAPPING #endif static int __Pyx_init_tpflags_variables(void); #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif #ifndef Py_TPFLAGS_SEQUENCE #define Py_TPFLAGS_SEQUENCE (CYTHON_COMPILING_IN_LIMITED_API ? 0 : 1 << 5) #endif #ifndef Py_TPFLAGS_MAPPING #define Py_TPFLAGS_MAPPING (CYTHON_COMPILING_IN_LIMITED_API ? 0 : 1 << 6) #endif #ifndef Py_TPFLAGS_IMMUTABLETYPE #define Py_TPFLAGS_IMMUTABLETYPE (1UL << 8) #endif #ifndef Py_TPFLAGS_DISALLOW_INSTANTIATION #define Py_TPFLAGS_DISALLOW_INSTANTIATION (1UL << 7) #endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif #if !defined(METH_FASTCALL) || CYTHON_COMPILING_IN_PYPY #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_VECTORCALL #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)) #else #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) #endif #define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) #define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) #elif !CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) #endif #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; } #endif static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void (*cfunc)(void)) { #if CYTHON_COMPILING_IN_LIMITED_API return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; #else return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; #endif } #define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) #else #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) #endif #if CYTHON_COMPILING_IN_PYPY typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); #else #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_PyFrame_SetLineNumber(frame, lineno) #elif CYTHON_COMPILING_IN_GRAAL && defined(GRAALPY_VERSION_NUM) && GRAALPY_VERSION_NUM > 0x19000000 #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) GraalPyFrame_SetLineNumber((frame), (lineno)) #elif CYTHON_COMPILING_IN_GRAAL #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) _PyFrame_SetLineNumber((frame), (lineno)) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif #if CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_PyThreadState_Current PyThreadState_Get() #elif !CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_Current PyThreadState_GET() #elif PY_VERSION_HEX >= 0x030d00A1 #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() #else #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #endif #if CYTHON_OPAQUE_OBJECTS && CYTHON_COMPILING_IN_LIMITED_API #define __PYX_SHARED_SIZEOF(T) -((int)sizeof(T)) #define __PYX_SHARED_RELATIVE_OFFSET Py_RELATIVE_OFFSET #define CYTHON_OPAQUE_SHARED_TYPES 1 #else #define __PYX_SHARED_SIZEOF(T) sizeof(T) #define __PYX_SHARED_RELATIVE_OFFSET 0 #define CYTHON_OPAQUE_SHARED_TYPES 0 #endif #if CYTHON_USE_MODULE_STATE static CYTHON_INLINE void *__Pyx__PyModule_GetState(PyObject *op) { void *result; result = PyModule_GetState(op); if (!result) Py_FatalError("Couldn't find the module state"); return result; } #define __Pyx_PyModule_GetState(o) (__pyx_mstatetype *)__Pyx__PyModule_GetState(o) #else #define __Pyx_PyModule_GetState(op) ((void)op,__pyx_mstate_global) #endif #define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE((PyObject *) obj), name, func_ctype) #define __Pyx_PyObject_TryGetSlot(obj, name, func_ctype) __Pyx_PyType_TryGetSlot(Py_TYPE(obj), name, func_ctype) #define __Pyx_PyObject_GetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_GetSubSlot(Py_TYPE(obj), sub, name, func_ctype) #define __Pyx_PyObject_TryGetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_TryGetSubSlot(Py_TYPE(obj), sub, name, func_ctype) #if CYTHON_USE_TYPE_SLOTS #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) #define __Pyx_PyType_TryGetSlot(type, name, func_ctype) __Pyx_PyType_GetSlot(type, name, func_ctype) #define __Pyx_PyType_GetSubSlot(type, sub, name, func_ctype) (((type)->sub) ? ((type)->sub->name) : NULL) #define __Pyx_PyType_TryGetSubSlot(type, sub, name, func_ctype) __Pyx_PyType_GetSubSlot(type, sub, name, func_ctype) #else #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) #define __Pyx_PyType_TryGetSlot(type, name, func_ctype)\ ((__PYX_LIMITED_VERSION_HEX >= 0x030A0000 ||\ (PyType_GetFlags(type) & Py_TPFLAGS_HEAPTYPE) || __Pyx_get_runtime_version() >= 0x030A0000) ?\ __Pyx_PyType_GetSlot(type, name, func_ctype) : NULL) #define __Pyx_PyType_GetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_GetSlot(obj, name, func_ctype) #define __Pyx_PyType_TryGetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_TryGetSlot(obj, name, func_ctype) #endif #if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() #endif #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) #if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_UNICODE_INTERNALS #define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); if (res == NULL && PyErr_Occurred()) { PyErr_WriteUnraisable(NULL); } return res; } #elif !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000 #define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError #define __Pyx_PyDict_GetItemStr PyDict_GetItem #else static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { #if CYTHON_COMPILING_IN_PYPY return PyDict_GetItem(dict, name); #else PyDictEntry *ep; PyDictObject *mp = (PyDictObject*) dict; long hash = ((PyStringObject *) name)->ob_shash; assert(hash != -1); ep = (mp->ma_lookup)(mp, name, hash); if (ep == NULL) { return NULL; } return ep->me_value; #endif } #define __Pyx_PyDict_GetItemStr PyDict_GetItem #endif #if CYTHON_USE_TYPE_SLOTS #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) #else #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) #endif #define __Pyx_PyObject_GetIterNextFunc(iterator) __Pyx_PyObject_GetSlot(iterator, tp_iternext, iternextfunc) #if CYTHON_USE_TYPE_SPECS #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 __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) #define __Pyx_PyUnicode_KIND_04(u) __Pyx_PyUnicode_KIND(u) #define __Pyx_PyUnicode_DATA(u) ((void*)u) #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) #else #if PY_VERSION_HEX >= 0x030C0000 #define __Pyx_PyUnicode_READY(op) (0) #else #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ 0 : _PyUnicode_Ready((PyObject *)(op))) #endif #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) #define __Pyx_PyUnicode_KIND(u) ((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 #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 static CYTHON_INLINE int __Pyx_PyUnicode_KIND_04(PyObject *o) { return __Pyx_PyUnicode_KIND(o) - (int) !!PyUnicode_IS_ASCII(o); } #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) #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_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 #define __Pyx_PySequence_ListKeepNew(obj)\ (likely(PyList_CheckExact(obj) && PyUnstable_Object_IsUniquelyReferenced(obj)) ? __Pyx_NewRef(obj) : PySequence_List(obj)) #elif 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_IS_TYPE(obj, &PySet_Type) #endif enum __Pyx_ReferenceSharing { __Pyx_ReferenceSharing_DefinitelyUnique, // We created it so we know it's unshared - no need to check __Pyx_ReferenceSharing_OwnStrongReference, __Pyx_ReferenceSharing_FunctionArgument, __Pyx_ReferenceSharing_SharedReference, // Never trust it to be unshared because it's a global or similar }; #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && PY_VERSION_HEX >= 0x030E0000 #define __Pyx_IS_UNIQUELY_REFERENCED(o, sharing)\ (sharing == __Pyx_ReferenceSharing_DefinitelyUnique ? 1 :\ (sharing == __Pyx_ReferenceSharing_FunctionArgument ? PyUnstable_Object_IsUniqueReferencedTemporary(o) :\ (sharing == __Pyx_ReferenceSharing_OwnStrongReference ? PyUnstable_Object_IsUniquelyReferenced(o) : 0))) #elif (CYTHON_COMPILING_IN_CPYTHON && !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING) || CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_IS_UNIQUELY_REFERENCED(o, sharing) (((void)sharing), Py_REFCNT(o) == 1) #else #define __Pyx_IS_UNIQUELY_REFERENCED(o, sharing) (((void)o), ((void)sharing), 0) #endif #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 #define __Pyx_PyList_GetItemRef(o, i) PyList_GetItemRef(o, i) #elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS #if CYTHON_COMPILING_IN_LIMITED_API || !CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PyList_GetItemRef(o, i) (likely((i) >= 0) ? PySequence_GetItem(o, i) : (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) #else #define __Pyx_PyList_GetItemRef(o, i) PySequence_ITEM(o, i) #endif #elif CYTHON_COMPILING_IN_LIMITED_API || !(CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE) #define __Pyx_PyList_GetItemRef(o, i) __Pyx_XNewRef(PyList_GetItem(o, i)) #else #define __Pyx_PyList_GetItemRef(o, i) (likely(__Pyx_is_valid_index(i, PyList_GET_SIZE(o))) ?\ __Pyx_NewRef(PyList_GET_ITEM(o, i)) : (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) #endif #if CYTHON_AVOID_BORROWED_REFS || CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_PyList_GET_ITEM_REF(o, i, unsafe_shared) ((void)(unsafe_shared),\ __Pyx_PyList_GetItemRef(o, i)) #elif CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS #if CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PyList_GET_ITEM_REF(o, i, unsafe_shared) (\ __Pyx_IS_UNIQUELY_REFERENCED(o, unsafe_shared) ?\ __Pyx_NewRef(PyList_GET_ITEM(o, i)) : __Pyx_PyList_GetItemRef(o, i)) #else #define __Pyx_PyList_GET_ITEM_REF(o, i, unsafe_shared) (\ __Pyx_IS_UNIQUELY_REFERENCED(o, unsafe_shared) ?\ __Pyx_XNewRef(PyList_GetItem(o, i)) : __Pyx_PyList_GetItemRef(o, i)) #endif #elif CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PyList_GET_ITEM_REF(o, i, unsafe_shared) ((void)(unsafe_shared),\ __Pyx_NewRef(PyList_GET_ITEM(o, i))) #else #define __Pyx_PyList_GET_ITEM_REF(o, i, unsafe_shared) ((void)(unsafe_shared),\ __Pyx_XNewRef(PyList_GetItem(o, i))) #endif #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 #define __Pyx_PyDict_GetItemRef(dict, key, result) PyDict_GetItemRef(dict, key, result) #elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key, PyObject **result) { *result = PyObject_GetItem(dict, key); if (*result == NULL) { if (PyErr_ExceptionMatches(PyExc_KeyError)) { PyErr_Clear(); return 0; } return -1; } return 1; } #else static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key, PyObject **result) { *result = PyDict_GetItemWithError(dict, key); if (*result == NULL) { return PyErr_Occurred() ? -1 : 0; } Py_INCREF(*result); return 1; } #endif #if defined(CYTHON_DEBUG_VISIT_CONST) && CYTHON_DEBUG_VISIT_CONST #define __Pyx_VISIT_CONST(obj) Py_VISIT(obj) #else #define __Pyx_VISIT_CONST(obj) #endif #if CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i) #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) #define __Pyx_PyTuple_GET_ITEM(o, i) PyTuple_GET_ITEM(o, i) #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) #define __Pyx_PyList_GET_ITEM(o, i) PyList_GET_ITEM(o, i) #else #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) #define __Pyx_PyTuple_GET_ITEM(o, i) PyTuple_GetItem(o, i) #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) #define __Pyx_PyList_GET_ITEM(o, i) PyList_GetItem(o, i) #endif #if CYTHON_ASSUME_SAFE_SIZE #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) #define __Pyx_PyDict_GET_SIZE(o) PyDict_GET_SIZE(o) #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GET_LENGTH(o) #else #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) #define __Pyx_PyDict_GET_SIZE(o) PyDict_Size(o) #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GetLength(o) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_InternFromString) #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) #endif #define __Pyx_PyLong_FromHash_t PyLong_FromSsize_t #define __Pyx_PyLong_AsHash_t __Pyx_PyIndex_AsSsize_t #if __PYX_LIMITED_VERSION_HEX >= 0x030A0000 #define __Pyx_PySendResult PySendResult #else typedef enum { PYGEN_RETURN = 0, PYGEN_ERROR = -1, PYGEN_NEXT = 1, } __Pyx_PySendResult; #endif #if CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX < 0x030A00A3 typedef __Pyx_PySendResult (*__Pyx_pyiter_sendfunc)(PyObject *iter, PyObject *value, PyObject **result); #else #define __Pyx_pyiter_sendfunc sendfunc #endif #if !CYTHON_USE_AM_SEND #define __PYX_HAS_PY_AM_SEND 0 #elif __PYX_LIMITED_VERSION_HEX >= 0x030A0000 #define __PYX_HAS_PY_AM_SEND 1 #else #define __PYX_HAS_PY_AM_SEND 2 // our own backported implementation #endif #if __PYX_HAS_PY_AM_SEND < 2 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods #else typedef struct { unaryfunc am_await; unaryfunc am_aiter; unaryfunc am_anext; __Pyx_pyiter_sendfunc am_send; } __Pyx_PyAsyncMethodsStruct; #define __Pyx_SlotTpAsAsync(s) ((PyAsyncMethods*)(s)) #endif #if CYTHON_USE_AM_SEND && PY_VERSION_HEX < 0x030A00F0 #define __Pyx_TPFLAGS_HAVE_AM_SEND (1UL << 21) #else #define __Pyx_TPFLAGS_HAVE_AM_SEND (0) #endif #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030A0000 #ifdef __cplusplus extern "C" #endif PyAPI_FUNC(void *) PyMem_Calloc(size_t nelem, size_t elsize); #endif #if CYTHON_COMPILING_IN_LIMITED_API static int __Pyx_init_co_variable(PyObject *inspect, const char* name, int *write_to) { int value; PyObject *py_value = PyObject_GetAttrString(inspect, name); if (!py_value) return 0; value = (int) PyLong_AsLong(py_value); Py_DECREF(py_value); *write_to = value; return value != -1 || !PyErr_Occurred(); } static int __Pyx_init_co_variables(void) { PyObject *inspect; int result; inspect = PyImport_ImportModule("inspect"); result = #if !defined(CO_OPTIMIZED) __Pyx_init_co_variable(inspect, "CO_OPTIMIZED", &CO_OPTIMIZED) && #endif #if !defined(CO_NEWLOCALS) __Pyx_init_co_variable(inspect, "CO_NEWLOCALS", &CO_NEWLOCALS) && #endif #if !defined(CO_VARARGS) __Pyx_init_co_variable(inspect, "CO_VARARGS", &CO_VARARGS) && #endif #if !defined(CO_VARKEYWORDS) __Pyx_init_co_variable(inspect, "CO_VARKEYWORDS", &CO_VARKEYWORDS) && #endif #if !defined(CO_ASYNC_GENERATOR) __Pyx_init_co_variable(inspect, "CO_ASYNC_GENERATOR", &CO_ASYNC_GENERATOR) && #endif #if !defined(CO_GENERATOR) __Pyx_init_co_variable(inspect, "CO_GENERATOR", &CO_GENERATOR) && #endif #if !defined(CO_COROUTINE) __Pyx_init_co_variable(inspect, "CO_COROUTINE", &CO_COROUTINE) && #endif 1; Py_DECREF(inspect); return result ? 0 : -1; } static int __Pyx_init_tpflags_bitcount(unsigned long flag) { int count = 0; while (flag) { count += (int) (flag & 1); flag >>= 1; } return count; } static int __Pyx_init_tpflags_variables(void) { if (__Pyx_Runtime_TPFLAGS_SEQUENCE != 0 && __Pyx_Runtime_TPFLAGS_MAPPING != 0) { return 0; } PyObject *collections_abc = PyImport_ImportModule("collections.abc"); if (!collections_abc) return -1; int result = 0; PyObject *sequence = NULL, *mapping = NULL; #if __PYX_LIMITED_VERSION_HEX >= 0x030D0000 if (PyObject_GetOptionalAttrString(collections_abc, "Sequence", &sequence) != 1) goto fail; if (PyObject_GetOptionalAttrString(collections_abc, "Mapping", &mapping) != 1) goto fail; #else sequence = PyObject_GetAttrString(collections_abc, "Sequence"); if (!sequence) goto fail_attr_lookup; mapping = PyObject_GetAttrString(collections_abc, "Mapping"); if (!mapping) goto fail_attr_lookup; #endif if (!PyType_Check(sequence) || !PyType_Check(mapping)) goto fail; { unsigned long sequence_flags = PyType_GetFlags((PyTypeObject*)sequence); unsigned long mapping_flags = PyType_GetFlags((PyTypeObject*)mapping); unsigned long mutual_flags = sequence_flags & mapping_flags; sequence_flags = sequence_flags ^ mutual_flags; mapping_flags = mapping_flags ^ mutual_flags; if (__Pyx_Runtime_TPFLAGS_SEQUENCE == 0 && __Pyx_init_tpflags_bitcount(sequence_flags) == 1) { __Pyx_Runtime_TPFLAGS_SEQUENCE = sequence_flags; } if (__Pyx_Runtime_TPFLAGS_MAPPING == 0 && __Pyx_init_tpflags_bitcount(mapping_flags) == 1) { __Pyx_Runtime_TPFLAGS_MAPPING = mapping_flags; } } cleanup: Py_XDECREF(mapping); Py_XDECREF(sequence); Py_DECREF(collections_abc); return result; #if __PYX_LIMITED_VERSION_HEX < 0x030D0000 fail_attr_lookup: if (PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Clear(); } #endif fail: result = PyErr_Occurred() ? -1 : 0; goto cleanup; } #else static int __Pyx_init_co_variables(void) { return 0; // It's a limited API-only feature } static int __Pyx_init_tpflags_variables(void) { return 0; // It's a limited API-only feature } #endif /* MathInitCode */ #if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) #ifndef _USE_MATH_DEFINES #define _USE_MATH_DEFINES #endif #endif #include #if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) #define __Pyx_truncl trunc #else #define __Pyx_truncl truncl #endif #ifndef CYTHON_CLINE_IN_TRACEBACK_RUNTIME #define CYTHON_CLINE_IN_TRACEBACK_RUNTIME 0 #endif #ifndef CYTHON_CLINE_IN_TRACEBACK #define CYTHON_CLINE_IN_TRACEBACK CYTHON_CLINE_IN_TRACEBACK_RUNTIME #endif #if CYTHON_CLINE_IN_TRACEBACK #define __PYX_MARK_ERR_POS(f_index, lineno) { __pyx_filename = __pyx_f[f_index]; (void) __pyx_filename; __pyx_lineno = lineno; (void) __pyx_lineno; __pyx_clineno = __LINE__; (void) __pyx_clineno; } #else #define __PYX_MARK_ERR_POS(f_index, lineno) { __pyx_filename = __pyx_f[f_index]; (void) __pyx_filename; __pyx_lineno = lineno; (void) __pyx_lineno; (void) __pyx_clineno; } #endif #define __PYX_ERR(f_index, lineno, Ln_error) \ { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } #ifdef CYTHON_EXTERN_C #undef __PYX_EXTERN_C #define __PYX_EXTERN_C CYTHON_EXTERN_C #elif defined(__PYX_EXTERN_C) #ifdef _MSC_VER #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") #else #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. #endif #else #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else #define __PYX_EXTERN_C extern #endif #endif #define __PYX_HAVE__borghash__HashTable #define __PYX_HAVE_API__borghash__HashTable /* Early includes */ #include #include #include #ifdef _OPENMP #include #endif /* _OPENMP */ #if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) #define CYTHON_WITHOUT_ASSERTIONS #endif #ifdef CYTHON_FREETHREADING_COMPATIBLE #if CYTHON_FREETHREADING_COMPATIBLE #define __Pyx_FREETHREADING_COMPATIBLE Py_MOD_GIL_NOT_USED #else #define __Pyx_FREETHREADING_COMPATIBLE Py_MOD_GIL_USED #endif #else #define __Pyx_FREETHREADING_COMPATIBLE Py_MOD_GIL_USED #endif #define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #define __Pyx_uchar_cast(c) ((unsigned char)c) #define __Pyx_long_cast(x) ((long)x) #define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ (sizeof(type) < sizeof(Py_ssize_t)) ||\ (sizeof(type) > sizeof(Py_ssize_t) &&\ likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX) &&\ (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ v == (type)PY_SSIZE_T_MIN))) ||\ (sizeof(type) == sizeof(Py_ssize_t) &&\ (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX))) ) 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 CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyByteArray_AsString(s) PyByteArray_AS_STRING(s) #else #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AsString(s)) #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AsString(s)) #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AsString(s)) #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AsString(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AsString(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AsString(s)) #define __Pyx_PyByteArray_AsString(s) PyByteArray_AsString(s) #endif #define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) #define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) #define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode static CYTHON_INLINE PyObject *__Pyx_NewRef(PyObject *obj) { #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030a0000 || defined(Py_NewRef) return Py_NewRef(obj); #else Py_INCREF(obj); return obj; #endif } static CYTHON_INLINE PyObject *__Pyx_XNewRef(PyObject *obj) { #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030a0000 || defined(Py_XNewRef) return Py_XNewRef(obj); #else Py_XINCREF(obj); return obj; #endif } static CYTHON_INLINE PyObject *__Pyx_Owned_Py_None(int b); static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); static CYTHON_INLINE PyObject* __Pyx_PyNumber_Long(PyObject* x); #define __Pyx_PyObject_RichCompareBool(a,b,cmp) __Pyx_PyObject_IsTrueAndDecref(PyObject_RichCompare((a),(b),(cmp))) #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_PyLong_FromSize_t(size_t); static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); #if CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) #define __Pyx_PyFloat_AS_DOUBLE(x) PyFloat_AS_DOUBLE(x) #define __Pyx_PyFloat_IsNonZero(x) (PyFloat_AS_DOUBLE(x) != 0.0) #else #define __Pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) #define __Pyx_PyFloat_AS_DOUBLE(x) PyFloat_AsDouble(x) #define __Pyx_PyFloat_IsNonZero(x) PyObject_IsTrue(x) #endif #define __Pyx_PyFloat_AsFloat(x) ((float) __Pyx_PyFloat_AsDouble(x)) #define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(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_SignBits(x) ((int) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK)) #define __Pyx_PyLong_Sign(x) (1 - __Pyx_PyLong_SignBits(x)) #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_SignBits(x) & 2) != 0) #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_SignBits(x) & 1) #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_SignBits(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)\ (((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) (((Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) #endif static CYTHON_INLINE Py_ssize_t __Pyx_PyLong_CompareSignAndSize(PyObject *a, PyObject *b) { uintptr_t tag_a = ((PyLongObject*)a)->long_value.lv_tag; uintptr_t tag_b = ((PyLongObject*)b)->long_value.lv_tag; if (tag_a == tag_b) return 0; int sign_a = (int) (tag_a & _PyLong_SIGN_MASK); int sign_b = (int) (tag_b & _PyLong_SIGN_MASK); if (sign_a > sign_b) return -1; if (sign_a < sign_b) return 1; Py_ssize_t size_a = (Py_ssize_t) (tag_a >> _PyLong_NON_SIZE_BITS); Py_ssize_t size_b = (Py_ssize_t) (tag_b >> _PyLong_NON_SIZE_BITS); return (1 - sign_a) * (size_a - size_b); } typedef Py_ssize_t __Pyx_compact_pylong; typedef size_t __Pyx_compact_upylong; #else #define __Pyx_PyLong_Sign(x) ((int) ((Py_SIZE(x) == 0) ? 0 : (Py_SIZE(x) < 0) ? -1 : 1)) #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])) #define __Pyx_PyLong_CompareSignAndSize(a, b) (Py_SIZE(a) - Py_SIZE(b)) 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 #define __Pyx_PyLong_IsNonZero(x) (!__Pyx_PyLong_IsZero(x)) #else #define __Pyx_PyLong_IsNonZero(x) PyObject_IsTrue(x) #endif #if __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) #elif __PYX_DEFAULT_STRING_ENCODING_IS_ASCII #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeASCII(c_str, size, NULL) #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #endif /* 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__ */ /* PretendToInitialize */ #ifdef __cplusplus #if __cplusplus > 201103L #include #endif template static void __Pyx_pretend_to_initialize(T* ptr) { #if __cplusplus > 201103L if ((std::is_trivially_default_constructible::value)) #endif *ptr = T(); (void)ptr; } #else static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } #endif #if !CYTHON_USE_MODULE_STATE static PyObject *__pyx_m = NULL; #endif static const char * const __pyx_cfilenm = __FILE__; /* #### Code section: filename_table ### */ static const char* const __pyx_f[] = { "src/borghash/HashTable.pyx", "src/borghash/HashTable.pxd", "(tree fragment)", }; /* #### Code section: utility_code_proto_before_types ### */ /* Atomics.proto (used by UnpackUnboundCMethod) */ #include #ifndef CYTHON_ATOMICS #define CYTHON_ATOMICS 1 #endif #define __PYX_CYTHON_ATOMICS_ENABLED() CYTHON_ATOMICS #define __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING() CYTHON_COMPILING_IN_CPYTHON_FREETHREADING #define __pyx_atomic_int_type int #define __pyx_nonatomic_int_type int #if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\ (__STDC_VERSION__ >= 201112L) &&\ !defined(__STDC_NO_ATOMICS__)) #include #elif CYTHON_ATOMICS && (defined(__cplusplus) && (\ (__cplusplus >= 201103L) ||\ (defined(_MSC_VER) && _MSC_VER >= 1700))) #include #endif #if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\ (__STDC_VERSION__ >= 201112L) &&\ !defined(__STDC_NO_ATOMICS__) &&\ ATOMIC_INT_LOCK_FREE == 2) #undef __pyx_atomic_int_type #define __pyx_atomic_int_type atomic_int #define __pyx_atomic_ptr_type atomic_uintptr_t #define __pyx_nonatomic_ptr_type uintptr_t #define __pyx_atomic_incr_relaxed(value) atomic_fetch_add_explicit(value, 1, memory_order_relaxed) #define __pyx_atomic_incr_acq_rel(value) atomic_fetch_add_explicit(value, 1, memory_order_acq_rel) #define __pyx_atomic_decr_acq_rel(value) atomic_fetch_sub_explicit(value, 1, memory_order_acq_rel) #define __pyx_atomic_sub(value, arg) atomic_fetch_sub(value, arg) #define __pyx_atomic_int_cmp_exchange(value, expected, desired) atomic_compare_exchange_strong(value, expected, desired) #define __pyx_atomic_load(value) atomic_load(value) #define __pyx_atomic_store(value, new_value) atomic_store(value, new_value) #define __pyx_atomic_pointer_load_relaxed(value) atomic_load_explicit(value, memory_order_relaxed) #define __pyx_atomic_pointer_load_acquire(value) atomic_load_explicit(value, memory_order_acquire) #define __pyx_atomic_pointer_exchange(value, new_value) atomic_exchange(value, (__pyx_nonatomic_ptr_type)new_value) #define __pyx_atomic_pointer_cmp_exchange(value, expected, desired) atomic_compare_exchange_strong(value, expected, desired) #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) #pragma message ("Using standard C atomics") #elif defined(__PYX_DEBUG_ATOMICS) #warning "Using standard C atomics" #endif #elif CYTHON_ATOMICS && (defined(__cplusplus) && (\ (__cplusplus >= 201103L) ||\ \ (defined(_MSC_VER) && _MSC_VER >= 1700)) &&\ ATOMIC_INT_LOCK_FREE == 2) #undef __pyx_atomic_int_type #define __pyx_atomic_int_type std::atomic_int #define __pyx_atomic_ptr_type std::atomic_uintptr_t #define __pyx_nonatomic_ptr_type uintptr_t #define __pyx_atomic_incr_relaxed(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_relaxed) #define __pyx_atomic_incr_acq_rel(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_acq_rel) #define __pyx_atomic_decr_acq_rel(value) std::atomic_fetch_sub_explicit(value, 1, std::memory_order_acq_rel) #define __pyx_atomic_sub(value, arg) std::atomic_fetch_sub(value, arg) #define __pyx_atomic_int_cmp_exchange(value, expected, desired) std::atomic_compare_exchange_strong(value, expected, desired) #define __pyx_atomic_load(value) std::atomic_load(value) #define __pyx_atomic_store(value, new_value) std::atomic_store(value, new_value) #define __pyx_atomic_pointer_load_relaxed(value) std::atomic_load_explicit(value, std::memory_order_relaxed) #define __pyx_atomic_pointer_load_acquire(value) std::atomic_load_explicit(value, std::memory_order_acquire) #define __pyx_atomic_pointer_exchange(value, new_value) std::atomic_exchange(value, (__pyx_nonatomic_ptr_type)new_value) #define __pyx_atomic_pointer_cmp_exchange(value, expected, desired) std::atomic_compare_exchange_strong(value, expected, desired) #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) #pragma message ("Using standard C++ atomics") #elif defined(__PYX_DEBUG_ATOMICS) #warning "Using standard C++ atomics" #endif #elif CYTHON_ATOMICS && (__GNUC__ >= 5 || (__GNUC__ == 4 &&\ (__GNUC_MINOR__ > 1 ||\ (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ >= 2)))) #define __pyx_atomic_ptr_type void* #define __pyx_nonatomic_ptr_type void* #define __pyx_atomic_incr_relaxed(value) __sync_fetch_and_add(value, 1) #define __pyx_atomic_incr_acq_rel(value) __sync_fetch_and_add(value, 1) #define __pyx_atomic_decr_acq_rel(value) __sync_fetch_and_sub(value, 1) #define __pyx_atomic_sub(value, arg) __sync_fetch_and_sub(value, arg) static CYTHON_INLINE int __pyx_atomic_int_cmp_exchange(__pyx_atomic_int_type* value, __pyx_nonatomic_int_type* expected, __pyx_nonatomic_int_type desired) { __pyx_nonatomic_int_type old = __sync_val_compare_and_swap(value, *expected, desired); int result = old == *expected; *expected = old; return result; } #define __pyx_atomic_load(value) __sync_fetch_and_add(value, 0) #define __pyx_atomic_store(value, new_value) __sync_lock_test_and_set(value, new_value) #define __pyx_atomic_pointer_load_relaxed(value) __sync_fetch_and_add(value, 0) #define __pyx_atomic_pointer_load_acquire(value) __sync_fetch_and_add(value, 0) #define __pyx_atomic_pointer_exchange(value, new_value) __sync_lock_test_and_set(value, (__pyx_atomic_ptr_type)new_value) static CYTHON_INLINE int __pyx_atomic_pointer_cmp_exchange(__pyx_atomic_ptr_type* value, __pyx_nonatomic_ptr_type* expected, __pyx_nonatomic_ptr_type desired) { __pyx_nonatomic_ptr_type old = __sync_val_compare_and_swap(value, *expected, desired); int result = old == *expected; *expected = old; return result; } #ifdef __PYX_DEBUG_ATOMICS #warning "Using GNU atomics" #endif #elif CYTHON_ATOMICS && defined(_MSC_VER) #include #undef __pyx_atomic_int_type #define __pyx_atomic_int_type long #define __pyx_atomic_ptr_type void* #undef __pyx_nonatomic_int_type #define __pyx_nonatomic_int_type long #define __pyx_nonatomic_ptr_type void* #pragma intrinsic (_InterlockedExchangeAdd, _InterlockedExchange, _InterlockedCompareExchange, _InterlockedCompareExchangePointer, _InterlockedExchangePointer) #define __pyx_atomic_incr_relaxed(value) _InterlockedExchangeAdd(value, 1) #define __pyx_atomic_incr_acq_rel(value) _InterlockedExchangeAdd(value, 1) #define __pyx_atomic_decr_acq_rel(value) _InterlockedExchangeAdd(value, -1) #define __pyx_atomic_sub(value, arg) _InterlockedExchangeAdd(value, -arg) static CYTHON_INLINE int __pyx_atomic_int_cmp_exchange(__pyx_atomic_int_type* value, __pyx_nonatomic_int_type* expected, __pyx_nonatomic_int_type desired) { __pyx_nonatomic_int_type old = _InterlockedCompareExchange(value, desired, *expected); int result = old == *expected; *expected = old; return result; } #define __pyx_atomic_load(value) _InterlockedExchangeAdd(value, 0) #define __pyx_atomic_store(value, new_value) _InterlockedExchange(value, new_value) #define __pyx_atomic_pointer_load_relaxed(value) *(void * volatile *)value #define __pyx_atomic_pointer_load_acquire(value) _InterlockedCompareExchangePointer(value, 0, 0) #define __pyx_atomic_pointer_exchange(value, new_value) _InterlockedExchangePointer(value, (__pyx_atomic_ptr_type)new_value) static CYTHON_INLINE int __pyx_atomic_pointer_cmp_exchange(__pyx_atomic_ptr_type* value, __pyx_nonatomic_ptr_type* expected, __pyx_nonatomic_ptr_type desired) { __pyx_atomic_ptr_type old = _InterlockedCompareExchangePointer(value, desired, *expected); int result = old == *expected; *expected = old; return result; } #ifdef __PYX_DEBUG_ATOMICS #pragma message ("Using MSVC atomics") #endif #else #undef CYTHON_ATOMICS #define CYTHON_ATOMICS 0 #ifdef __PYX_DEBUG_ATOMICS #warning "Not using atomics" #endif #endif /* CriticalSectionsDefinition.proto (used by CriticalSections) */ #if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING #define __Pyx_PyCriticalSection void* #define __Pyx_PyCriticalSection2 void* #define __Pyx_PyCriticalSection_End(cs) #define __Pyx_PyCriticalSection2_End(cs) #else #define __Pyx_PyCriticalSection PyCriticalSection #define __Pyx_PyCriticalSection2 PyCriticalSection2 #define __Pyx_PyCriticalSection_End PyCriticalSection_End #define __Pyx_PyCriticalSection2_End PyCriticalSection2_End #endif /* CriticalSections.proto (used by ParseKeywordsImpl) */ #if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING #define __Pyx_PyCriticalSection_Begin(cs, arg) (void)(cs) #define __Pyx_PyCriticalSection2_Begin(cs, arg1, arg2) (void)(cs) #else #define __Pyx_PyCriticalSection_Begin PyCriticalSection_Begin #define __Pyx_PyCriticalSection2_Begin PyCriticalSection2_Begin #endif #if PY_VERSION_HEX < 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_BEGIN_CRITICAL_SECTION(o) { #define __Pyx_END_CRITICAL_SECTION() } #else #define __Pyx_BEGIN_CRITICAL_SECTION Py_BEGIN_CRITICAL_SECTION #define __Pyx_END_CRITICAL_SECTION Py_END_CRITICAL_SECTION #endif /* IncludeStructmemberH.proto (used by CythonFunctionShared) */ #include /* #### Code section: numeric_typedefs ### */ /* #### Code section: complex_type_declarations ### */ /* #### Code section: type_declarations ### */ /*--- Type declarations ---*/ struct __pyx_obj_8borghash_9HashTable_HashTable; struct __pyx_obj_8borghash_9HashTable___pyx_scope_struct__items; struct __pyx_opt_args_8borghash_9HashTable_9HashTable__lookup_index; /* "borghash/HashTable.pxd":17 * * cdef size_t _get_index(self, uint8_t* key) * cdef int _lookup_index(self, uint8_t* key_ptr, size_t* index_ptr, size_t* tombstone_ptr = *) # <<<<<<<<<<<<<< * cdef void _resize_table(self, size_t new_capacity) * cdef void _resize_kv(self, size_t new_capacity) */ struct __pyx_opt_args_8borghash_9HashTable_9HashTable__lookup_index { int __pyx_n; size_t *tombstone_ptr; }; /* "borghash/HashTable.pxd":3 * from libc.stdint cimport uint8_t, uint32_t * * cdef class HashTable: # <<<<<<<<<<<<<< * cdef int ksize, vsize * cdef readonly size_t capacity, used */ struct __pyx_obj_8borghash_9HashTable_HashTable { PyObject_HEAD struct __pyx_vtabstruct_8borghash_9HashTable_HashTable *__pyx_vtab; int ksize; int vsize; size_t capacity; size_t used; size_t initial_capacity; size_t tombstones; float max_load_factor; float min_load_factor; float shrink_factor; float grow_factor; float rehash_threshold; uint32_t *table; uint32_t kv_capacity; uint32_t kv_used; float kv_grow_factor; uint8_t *keys; uint8_t *values; int stats_get; int stats_set; int stats_del; int stats_iter; int stats_lookup; int stats_linear; int stats_resize_table; int stats_resize_kv; }; /* "borghash/HashTable.pyx":248 * return value * * def items(self, *, prefix_bits: int = 0, prefix: int = 0) -> Iterator[tuple[bytes, bytes]]: # <<<<<<<<<<<<<< * """ * Iterate over items, optionally only over items whose key starts with the given bit prefix. */ struct __pyx_obj_8borghash_9HashTable___pyx_scope_struct__items { PyObject_HEAD int __pyx_v_filtering; size_t __pyx_v_i; PyObject *__pyx_v_key; uint32_t __pyx_v_key32; uint8_t *__pyx_v_key_ptr; uint32_t __pyx_v_kv_index; PyObject *__pyx_v_prefix; PyObject *__pyx_v_prefix_bits; struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self; int __pyx_v_shift; PyObject *__pyx_v_value; uint32_t __pyx_v_wanted; size_t __pyx_t_0; size_t __pyx_t_1; size_t __pyx_t_2; }; /* "borghash/HashTable.pyx":45 * * * cdef class HashTable: # <<<<<<<<<<<<<< * def __init__(self, items=None, *, * key_size: int = 0, value_size: int = 0, capacity: int = MIN_CAPACITY, */ struct __pyx_vtabstruct_8borghash_9HashTable_HashTable { size_t (*_get_index)(struct __pyx_obj_8borghash_9HashTable_HashTable *, uint8_t *); int (*_lookup_index)(struct __pyx_obj_8borghash_9HashTable_HashTable *, uint8_t *, size_t *, struct __pyx_opt_args_8borghash_9HashTable_9HashTable__lookup_index *__pyx_optional_args); void (*_resize_table)(struct __pyx_obj_8borghash_9HashTable_HashTable *, size_t); void (*_resize_kv)(struct __pyx_obj_8borghash_9HashTable_HashTable *, size_t); }; static struct __pyx_vtabstruct_8borghash_9HashTable_HashTable *__pyx_vtabptr_8borghash_9HashTable_HashTable; /* #### 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; #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);\ } #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) /* FastTypeChecks.proto (used by GivenExceptionMatches) */ #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); #define __Pyx_PyAnySet_Check(obj) __Pyx_TypeCheck2(obj, &PySet_Type, &PyFrozenSet_Type) #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_PyAnySet_Check(obj) PyAnySet_Check(obj) #endif /* PyThreadStateGet.proto (used by PyErrFetchRestore) */ #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 (used by GivenExceptionMatches) */ #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 /* GivenExceptionMatches.proto (used by PyErrExceptionMatches) */ #if CYTHON_COMPILING_IN_CPYTHON 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_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2) { return PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2); } #endif #define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) /* PyErrExceptionMatches.proto (used by PyObjectGetAttrStrNoError) */ #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 /* PyObjectGetAttrStr.proto (used by PyObjectGetAttrStrNoError) */ #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 (used by GetBuiltinName) */ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); /* CopyObjectArray.proto (used by TupleOrListFromArrayImpl) */ #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); #endif /* TupleOrListFromArrayImpl.proto (used by TupleFromArray) */ #if PY_VERSION_HEX >= 0x030F0000 && !CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_PyTuple_FromArray(src, n) PyTuple_FromArray(src, ((n)<0) ? 0 : (n)) #else CYTHON_UNUSED static PyObject * __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); #endif /* TupleFromArray.proto (used by fastcall) */ /* IncludeStringH.proto (used by PyObjectCompare) */ #include /* PyObjectCompare.proto (used by UnicodeEquals) */ static CYTHON_INLINE int __Pyx_PyObject_CompareBoolEq_str_str(PyObject *op1, PyObject *op2, int pyop); /* UnicodeEquals.proto (used by fastcall) */ #define __Pyx_PyUnicode_Equals(s1, s2) __Pyx_PyObject_CompareBoolEq_str_str(s1, s2, Py_EQ) /* fastcall.proto */ #if CYTHON_AVOID_BORROWED_REFS #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_PySequence_ITEM(args, i) #elif CYTHON_ASSUME_SAFE_MACROS #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_NewRef(__Pyx_PyTuple_GET_ITEM(args, i)) #else #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_XNewRef(PyTuple_GetItem(args, i)) #endif #define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) #define __Pyx_KwValues_VARARGS(args, nargs) NULL #define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) #define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) #if CYTHON_VECTORCALL #define __Pyx_ArgRef_FASTCALL(args, i) __Pyx_NewRef(args[i]) #define __Pyx_NumKwargs_FASTCALL(kwds) __Pyx_PyTuple_GET_SIZE(kwds) #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_GRAAL CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); #else #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) #endif #else #define __Pyx_ArgRef_FASTCALL __Pyx_ArgRef_VARARGS #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS #endif #if CYTHON_VECTORCALL_TPNEW #if !CYTHON_VECTORCALL #error Enabling CYTHON_VECTORCALL_TPNEW without CYTHON_VECTORCALL is not supported #endif #define __Pyx_ArgRef_FASTCALL_TPNEW __Pyx_ArgRef_FASTCALL #define __Pyx_NumKwargs_FASTCALL_TPNEW __Pyx_NumKwargs_FASTCALL #define __Pyx_KwValues_FASTCALL_TPNEW __Pyx_KwValues_FASTCALL #define __Pyx_GetKwValue_FASTCALL_TPNEW __Pyx_GetKwValue_FASTCALL #define __Pyx_KwargsAsDict_FASTCALL_TPNEW __Pyx_KwargsAsDict_FASTCALL #else #define __Pyx_ArgRef_FASTCALL_TPNEW __Pyx_ArgRef_VARARGS #define __Pyx_NumKwargs_FASTCALL_TPNEW __Pyx_NumKwargs_VARARGS #define __Pyx_KwValues_FASTCALL_TPNEW __Pyx_KwValues_VARARGS #define __Pyx_GetKwValue_FASTCALL_TPNEW __Pyx_GetKwValue_VARARGS #define __Pyx_KwargsAsDict_FASTCALL_TPNEW __Pyx_KwargsAsDict_VARARGS #endif #define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) #if CYTHON_VECTORCALL #define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(args + start, stop - start) #else #define __Pyx_ArgsSlice_FASTCALL __Pyx_ArgsSlice_VARARGS #endif /* py_dict_items.proto (used by OwnedDictNext) */ #define __Pyx_PyDict_items_TypePtr (&PyDictKeys_Type) #define __Pyx_PyDict_items_Check(obj) PyObject_TypeCheck((obj), __Pyx_PyDictItems_TypePtr) #define __Pyx_PyDict_items_CheckExact(obj) Py_IS_TYPE((obj), __Pyx_PyDictItems_TypePtr) static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d); /* CallCFunction.proto (used by CallUnboundCMethod0) */ #define __Pyx_CallCFunction(cfunc, self, args)\ ((PyCFunction)(void(*)(void))(cfunc)->func)(self, args) #define __Pyx_CallCFunctionWithKeywords(cfunc, self, args, kwargs)\ ((PyCFunctionWithKeywords)(void(*)(void))(cfunc)->func)(self, args, kwargs) #define __Pyx_CallCFunctionFast(cfunc, self, args, nargs)\ ((__Pyx_PyCFunctionFast)(void(*)(void))(PyCFunction)(cfunc)->func)(self, args, nargs) #define __Pyx_CallCFunctionFastWithKeywords(cfunc, self, args, nargs, kwnames)\ ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))(PyCFunction)(cfunc)->func)(self, args, nargs, kwnames) /* PyObjectCall.proto (used by PyObjectFastCall) */ #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 (used by PyObjectFastCall) */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif /* PyObjectFastCall.proto (used by PyObjectCallOneArg) */ #define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject * const*args, size_t nargsf, PyObject *kwargs); /* PyObjectCallOneArg.proto (used by CallUnboundCMethod0) */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); /* UnpackUnboundCMethod_decl.proto (used by UnpackUnboundCMethod) */ typedef struct { PyObject *type; PyObject **method_name; PyCFunction func; PyObject *method; int flag; #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && CYTHON_ATOMICS __pyx_atomic_int_type initialized; #endif } __Pyx_CachedCFunction; /* IgnoreException.proto (used by UnpackUnboundCMethod_impl) */ static CYTHON_INLINE int __Pyx_IgnoreGivenException(PyObject *given_exception, PyObject *ignorable_exception); #define __Pyx_IgnoreException(ignorable_exception) __Pyx_IgnoreGivenException(NULL, ignorable_exception) /* UnpackUnboundCMethod_impl.export */ static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target); /* UnpackUnboundCMethod.proto (used by CallUnboundCMethod0) */ #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING static CYTHON_INLINE int __Pyx_CachedCFunction_GetAndSetInitializing(__Pyx_CachedCFunction *cfunc) { #if !CYTHON_ATOMICS return 1; #else __pyx_nonatomic_int_type expected = 0; if (__pyx_atomic_int_cmp_exchange(&cfunc->initialized, &expected, 1)) { return 0; } return expected; #endif } static CYTHON_INLINE void __Pyx_CachedCFunction_SetFinishedInitializing(__Pyx_CachedCFunction *cfunc) { #if CYTHON_ATOMICS __pyx_atomic_store(&cfunc->initialized, 2); #endif } #else #define __Pyx_CachedCFunction_GetAndSetInitializing(cfunc) 2 #define __Pyx_CachedCFunction_SetFinishedInitializing(cfunc) #endif /* CallUnboundCMethod0.proto */ CYTHON_UNUSED static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self); #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self); #else #define __Pyx_CallUnboundCMethod0(cfunc, self) __Pyx__CallUnboundCMethod0(cfunc, self) #endif /* py_dict_values.proto (used by OwnedDictNext) */ #define __Pyx_PyDict_values_TypePtr (&PyDictKeys_Type) #define __Pyx_PyDict_values_Check(obj) PyObject_TypeCheck((obj), __Pyx_PyDictValues_TypePtr) #define __Pyx_PyDict_values_CheckExact(obj) Py_IS_TYPE((obj), __Pyx_PyDictValues_TypePtr) static CYTHON_INLINE PyObject* __Pyx_PyDict_Values(PyObject* d); /* OwnedDictNext.proto (used by ParseKeywordsImpl) */ #if CYTHON_AVOID_BORROWED_REFS static int __Pyx_PyDict_NextRef(PyObject *p, PyObject **ppos, PyObject **pkey, PyObject **pvalue); #else CYTHON_INLINE static int __Pyx_PyDict_NextRef(PyObject *p, Py_ssize_t *ppos, PyObject **pkey, PyObject **pvalue); #endif /* RaiseDoubleKeywords.proto (used by ParseKeywordsImpl) */ static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); /* ParseKeywordsImpl.export */ static int __Pyx_ParseKeywordsTuple( PyObject *kwds, PyObject * const *kwvalues, PyObject ** const argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, Py_ssize_t num_kwargs, const char* function_name, int ignore_unknown_kwargs ); static int __Pyx_ParseKeywordDictToDict( PyObject *kwds, PyObject ** const argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name ); static int __Pyx_ParseKeywordDict( PyObject *kwds, PyObject ** const argnames[], PyObject *values[], Py_ssize_t num_pos_args, Py_ssize_t num_kwargs, const char* function_name, int ignore_unknown_kwargs ); /* CallUnboundCMethod2.proto */ CYTHON_UNUSED static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2); #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2); #else #define __Pyx_CallUnboundCMethod2(cfunc, self, arg1, arg2) __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2) #endif /* ParseKeywords.proto */ static CYTHON_INLINE int __Pyx_ParseKeywords( PyObject *kwds, PyObject *const *kwvalues, PyObject ** const argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, Py_ssize_t num_kwargs, const char* function_name, int ignore_unknown_kwargs ); /* RaiseArgTupleInvalid.export */ 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); /* PyDictVersioning.proto (used by GetModuleGlobalName) */ #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_XNewRef(__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_mstate_global->__pyx_d))) ?\ (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } while(0) #define __Pyx_GetModuleGlobalNameUncached(var, name) do {\ PY_UINT64_T __pyx_dict_version;\ PyObject *__pyx_dict_cached_value;\ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } while(0) static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); #else #define __Pyx_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 /* PyFrozenDict.proto (used by GetItemInt) */ #if CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_PyFrozenDict_TypePtr ((PyTypeObject*) __pyx_mstate_global->__Pyx_PyFrozenDictType) #define __Pyx_PyFrozenDict_New(it) __Pyx__PyFrozenDict_New(__pyx_mstate_global->__Pyx_PyFrozenDictType, it) static CYTHON_INLINE PyObject* __Pyx__PyFrozenDict_New(PyObject* frozendict_type, PyObject* it); #define __Pyx_PyFrozenDict_NewEmpty() __Pyx_PyFrozenDict_New(NULL) #define __Pyx_PyFrozenDict_Check(obj) PyObject_TypeCheck((obj), __Pyx_PyFrozenDict_TypePtr) #define __Pyx_PyFrozenDict_CheckExact(obj) Py_IS_TYPE((obj), __Pyx_PyFrozenDict_TypePtr) #define __Pyx_PyAnyDict_Check(obj) __Pyx__PyAnyDict_Check(obj, __Pyx_PyFrozenDict_TypePtr) static CYTHON_INLINE int __Pyx__PyAnyDict_Check(PyObject *obj, PyTypeObject* frozendict_type) { return PyObject_TypeCheck(obj, &PyDict_Type) || PyObject_TypeCheck(obj, frozendict_type); } #define __Pyx_PyAnyDict_CheckExact(obj) __Pyx__PyAnyDict_CheckExact(obj, __Pyx_PyFrozenDict_TypePtr) static CYTHON_INLINE int __Pyx__PyAnyDict_CheckExact(PyObject *obj, PyTypeObject* frozendict_type) { return Py_IS_TYPE(obj, &PyDict_Type) || Py_IS_TYPE(obj, frozendict_type); } #elif PY_VERSION_HEX >= 0x030f00a6 ||\ (defined(PyFrozenDict_Check) && defined(PyAnyDict_Check) && defined(PyFrozenDict_New)) #define __Pyx_PyFrozenDict_TypePtr (&PyFrozenDict_Type) #define __Pyx_PyFrozenDict_New(it) PyFrozenDict_New(it) #define __Pyx_PyFrozenDict_NewEmpty() PyFrozenDict_New(NULL) #define __Pyx_PyFrozenDict_Check(obj) PyFrozenDict_Check(obj) #define __Pyx_PyFrozenDict_CheckExact(obj) PyFrozenDict_CheckExact(obj) #define __Pyx_PyAnyDict_Check(obj) PyAnyDict_Check(obj) #define __Pyx_PyAnyDict_CheckExact(obj) PyAnyDict_CheckExact(obj) #else #define __Pyx_PyFrozenDict_TypePtr (&PyDict_Type) static CYTHON_INLINE PyObject* __Pyx_PyFrozenDict_New(PyObject* it) { if (!it) { return PyDict_New(); } else if (PyDict_Check(it)) { return PyDict_Copy(it); } else { PyObject *dict = PyDict_New(); if (!dict) return NULL; PyObject *result = PyNumber_InPlaceOr(dict, it); Py_DECREF(dict); return result; } } #define __Pyx_PyFrozenDict_NewEmpty() PyDict_New() #define __Pyx_PyFrozenDict_Check(obj) PyDict_Check(obj) #define __Pyx_PyFrozenDict_CheckExact(obj) PyDict_CheckExact(obj) #define __Pyx_PyAnyDict_Check(obj) PyDict_Check(obj) #define __Pyx_PyAnyDict_CheckExact(obj) PyDict_CheckExact(obj) #endif /* GetItemInt.proto */ #define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, wraparound, boundscheck, has_gil, unsafe_shared)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, wraparound, boundscheck, unsafe_shared) :\ __Pyx_GetItemInt_Generic(o, to_py_func(i))) #define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, wraparound, boundscheck, has_gil, unsafe_shared)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck, unsafe_shared) :\ (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, int unsafe_shared); #define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, wraparound, boundscheck, has_gil, unsafe_shared)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck, unsafe_shared) :\ (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, int unsafe_shared); static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck, int unsafe_shared); /* FormatTypeName.proto (used by RaiseErrorWithObjectType) */ #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX >= 0x030d0000 typedef PyObject *__Pyx_TypeName; #define __Pyx_FMT_TYPENAME "%N" #define __Pyx_PyType_GetFullyQualifiedName(tp) Py_NewRef((PyObject*)tp) #define __Pyx_DECREF_TypeName(obj) Py_DECREF(obj) #elif CYTHON_COMPILING_IN_LIMITED_API typedef PyObject *__Pyx_TypeName; #define __Pyx_FMT_TYPENAME "%U" #define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) static __Pyx_TypeName __Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp); #else // !LIMITED_API typedef const char *__Pyx_TypeName; #define __Pyx_FMT_TYPENAME "%.200s" #define __Pyx_PyType_GetFullyQualifiedName(tp) ((tp)->tp_name) #define __Pyx_DECREF_TypeName(obj) #endif /* RaiseErrorWithObjectType.proto (used by ObjectGetItem) */ #define __Pyx_RaiseTypeErrorWithObjectType(message, obj) __Pyx_RaiseErrorWithObjectType(PyExc_TypeError, message, obj) #define __Pyx_RaiseErrorWithObjectType(exc_type, message, obj) __Pyx_RaiseErrorWithType(exc_type, message, Py_TYPE(obj)) CYTHON_UNUSED static void __Pyx_RaiseErrorWithType(PyObject* exc_type, const char* message, PyTypeObject *type_obj); /* ObjectGetItem.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key); #else #define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key) #endif /* HasAttr.proto */ #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 #define __Pyx_HasAttr(o, n) PyObject_HasAttrWithError(o, n) #else static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); #endif /* IterFinish.proto (used by dict_iter_common) */ static CYTHON_INLINE int __Pyx_IterFinish(void); /* PyObjectCallMethod0.proto (used by dict_iter_common) */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); /* RaiseNeedMoreValuesToUnpack.proto (used by UnpackTuple2) */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); /* RaiseTooManyValuesToUnpack.proto (used by UnpackItemEndCheck) */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); /* UnpackItemEndCheck.proto (used by UnpackTuple2) */ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); /* RaiseNoneIterError.proto (used by UnpackTupleError) */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); /* UnpackTupleError.proto (used by UnpackTuple2) */ static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index); /* UnpackTuple2.proto (used by dict_iter_common) */ static CYTHON_INLINE int __Pyx_unpack_tuple2( PyObject* tuple, PyObject** value1, PyObject** value2, int is_tuple, int has_known_size, int decref_tuple); static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( PyObject* tuple, PyObject** value1, PyObject** value2, int decref_tuple); static int __Pyx_unpack_tuple2_generic( PyObject* tuple, PyObject** value1, PyObject** value2, int has_known_size, int decref_tuple); /* dict_iter_common.proto (used by dict_iter) */ static PyObject *__Pyx_dict_call_to_get_iterable(PyObject* iterable, PyObject* method_name); 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); /* 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); /* pybuiltin_invalid.export */ static void __Pyx_PyBuiltin_Invalid(PyObject *obj, const char *builtin_type_name, const char *argname); /* pyint_simplify.proto */ static CYTHON_INLINE int __Pyx_PyInt_FromNumber(PyObject **number_var, const char *argname, int accept_none); /* ArgTypeTestError.export */ static void __Pyx_ArgTypeError(PyObject *obj, PyTypeObject *type, const char *name, int exact); /* ArgTypeTest.proto */ static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, const char *name, int exact); /* PyObjectCompare.proto */ static CYTHON_INLINE int __Pyx_PyObject_CompareBoolLt_int_int(PyObject *op1, PyObject *op2, int pyop); /* PyValueError_Check.proto */ #define __Pyx_PyExc_ValueError_Check(obj) __Pyx_TypeCheck(obj, PyExc_ValueError) /* RaiseException.export */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); /* RejectKeywords.export */ static void __Pyx_RejectKeywords(const char* function_name, PyObject *kwds); /* PyRuntimeError_Check.proto */ #define __Pyx_PyExc_RuntimeError_Check(obj) __Pyx_TypeCheck(obj, PyExc_RuntimeError) /* PyKeyError_Check.proto */ #define __Pyx_PyExc_KeyError_Check(obj) __Pyx_TypeCheck(obj, PyExc_KeyError) /* PyObjectCompare.proto */ static CYTHON_INLINE int __Pyx_PyObject_CompareBoolGt_object_int(PyObject *op1, PyObject *op2, int pyop); /* PyObjectCompare.proto */ static CYTHON_INLINE int __Pyx_PyObject_CompareBoolLt_object_int(PyObject *op1, PyObject *op2, int pyop); /* 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)); } /* RaiseErrorWithObjectType1.proto (used by RaiseUnexpectedTypeError) */ #define __Pyx_RaiseTypeErrorWithObjectType1(message, arg, obj) __Pyx_RaiseErrorWithObjectType1(PyExc_TypeError, message, arg, obj) #define __Pyx_RaiseErrorWithObjectType1(exc_type, message, arg, obj) __Pyx_RaiseErrorWithType1(exc_type, message, arg, Py_TYPE(obj)) CYTHON_UNUSED static void __Pyx_RaiseErrorWithType1(PyObject* exc_type, const char* message, const char *arg, PyTypeObject *type_obj); /* RaiseUnexpectedTypeError.proto */ CYTHON_UNUSED static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj); /* GetTopmostException.proto (used by SaveResetException) */ #if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); #endif /* SaveResetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); #else #define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) #define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) #endif /* 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 /* PyObjectCompare.proto */ static CYTHON_INLINE int __Pyx_PyObject_CompareBoolLe_int_int(PyObject *op1, PyObject *op2, int pyop); /* PyLongBinop.proto */ #if !CYTHON_COMPILING_IN_PYPY static CYTHON_INLINE PyObject* __Pyx_PyLong_SubtractCObj(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); #else #define __Pyx_PyLong_SubtractCObj(op1, op2, intval, inplace, zerodivision_check)\ (inplace ? PyNumber_InPlaceSubtract(op1, op2) : PyNumber_Subtract(op1, op2)) #endif /* PyObjectCompare.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CompareGt_int_int(PyObject *op1, PyObject *op2, int pyop); /* pep479.proto */ static void __Pyx_Generator_Replace_StopIteration(int in_async_gen); /* PyObjectCompare.proto */ static CYTHON_INLINE int __Pyx_PyObject_CompareBoolEq_bytes_bytes(PyObject *op1, PyObject *op2, int pyop); /* PyTypeError_Check.proto */ #define __Pyx_PyExc_TypeError_Check(obj) __Pyx_TypeCheck(obj, PyExc_TypeError) /* AllocateExtensionType.proto */ static PyObject *__Pyx_AllocateExtensionType(PyTypeObject *t, int is_final); /* CallSlotAsVectorcall.proto */ #if CYTHON_VECTORCALL_TPNEW typedef PyObject * (*__Pyx_tpnewvectorcallfunc)(PyTypeObject* o, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); static PyObject * __Pyx_CallTpnewAsVectorcall(__Pyx_tpnewvectorcallfunc f, PyTypeObject* o, PyObject *a, PyObject *k); #endif /* CallNewInitFromVectorcall.proto */ #if CYTHON_VECTORCALL_TPNEW static PyObject *__Pyx_CallNewInitFromVectorcall(PyTypeObject *t, PyObject *const *args, size_t nargsf, PyObject *kwnames); #endif /* CallSlotAsVectorcall.proto */ #if CYTHON_VECTORCALL_TPNEW typedef int (*__Pyx_tpinitvectorcallfunc)(PyObject* o, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); static int __Pyx_CallTpinitAsVectorcall(__Pyx_tpinitvectorcallfunc f, PyObject* o, PyObject *a, PyObject *k); #endif /* CheckTypeForFreelists.proto */ #if CYTHON_USE_FREELISTS #if CYTHON_USE_TYPE_SPECS #define __PYX_CHECK_FINAL_TYPE_FOR_FREELISTS(t, expected_tp, expected_size) ((int) ((t) == (expected_tp))) #define __PYX_CHECK_TYPE_FOR_FREELIST_FLAGS Py_TPFLAGS_IS_ABSTRACT #else #define __PYX_CHECK_FINAL_TYPE_FOR_FREELISTS(t, expected_tp, expected_size) ((int) ((t)->tp_basicsize == (expected_size))) #define __PYX_CHECK_TYPE_FOR_FREELIST_FLAGS (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE) #endif #define __PYX_CHECK_TYPE_FOR_FREELISTS(t, expected_tp, expected_size)\ (__PYX_CHECK_FINAL_TYPE_FOR_FREELISTS((t), (expected_tp), (expected_size)) &\ (int) (!__Pyx_PyType_HasFeature((t), __PYX_CHECK_TYPE_FOR_FREELIST_FLAGS))) #endif /* CallTypeTraverse.proto */ #if !CYTHON_USE_TYPE_SPECS #define __Pyx_call_type_traverse(o, always_call, visit, arg) 0 #else static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg); #endif /* GetTypeDictOffset.proto (used by ValidateBasesTuple) */ #if !CYTHON_USE_TYPE_SLOTS CYTHON_UNUSED static Py_ssize_t __Pyx_GetTypeDictOffset(PyObject *tp, int require_cython_valid_result); #endif /* ValidateBasesTuple.proto (used by PyType_Ready) */ #if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS static int __Pyx_validate_bases_tuple(const char *type_name, int has_dictoffset, PyObject *bases); #endif /* PyType_Ready.export */ CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t); /* GetVTable.proto (used by MergeVTables) */ static int __Pyx_GetVtable(PyTypeObject *type, void** table); /* RaiseErrorWithObjectTypes.proto (used by MergeVTables) */ #define __Pyx_RaiseErrorWithObjectTypes1(exc_type, message, arg, obj1, obj2) __Pyx_RaiseErrorWithTypes1(exc_type, message, arg, Py_TYPE(obj1), Py_TYPE(obj2)) #define __Pyx_RaiseTypeErrorWithObjectTypes(message, obj1, obj2) __Pyx_RaiseTypeErrorWithTypes(message, Py_TYPE(obj1), Py_TYPE(obj2)) #define __Pyx_RaiseTypeErrorWithTypes(message, type_obj1, type_obj2) __Pyx_RaiseErrorWithTypes1(PyExc_TypeError, "%.1s" message, "", type_obj1, type_obj2) CYTHON_UNUSED static void __Pyx_RaiseErrorWithTypes1(PyObject* exc_type, const char *message, const char *arg, PyTypeObject *type_obj1, PyTypeObject *type_obj2); /* MergeVTables.proto (used by SetVTable) */ static int __Pyx_MergeVtables(PyTypeObject *type); /* SetVTable.export */ static int __Pyx_SetVtable(PyTypeObject* typeptr , void* vtable); /* LimitedApiGetTypeTypeDict.proto (used by DelItemOnTypeDict) */ #if CYTHON_COMPILING_IN_LIMITED_API static PyObject *__Pyx_GetTypeTypeDict(PyTypeObject *tp); #endif /* DelItemOnTypeDict.proto (used by SetupReduce) */ #define __Pyx_DelItemOnTypeDict(tp, k) __Pyx__DelItemOnTypeDict((PyTypeObject*)tp, k) /* DelItemOnTypeDict.export */ static int __Pyx__DelItemOnTypeDict(PyTypeObject *tp, PyObject *k); /* SetItemOnTypeDict.proto (used by SetupReduce) */ #define __Pyx_SetItemOnTypeDict(tp, k, v) __Pyx__SetItemOnTypeDict((PyTypeObject*)tp, k, v) /* SetItemOnTypeDict.export */ static int __Pyx__SetItemOnTypeDict(PyTypeObject *tp, PyObject *k, PyObject *v); /* SetupReduce.export */ static int __Pyx_setup_reduce(PyObject* type_obj); /* TupleOrListFromArrayImpl.proto (used by ListFromArray) */ CYTHON_UNUSED static PyObject * __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); /* ListFromArray.proto (used by ImportImpl) */ /* ImportImpl.export */ static PyObject *__Pyx__Import(PyObject *name, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject *qualname, PyObject *moddict, int level); /* Import.proto */ static CYTHON_INLINE PyObject *__Pyx_Import(PyObject *name, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject *qualname, int level); /* ImportFrom.export */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); /* AssertionsEnabled.proto */ #if CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX >= 0x030C0000 static int __pyx_assertions_enabled_flag; #define __pyx_assertions_enabled() (__pyx_assertions_enabled_flag) #if __clang__ || __GNUC__ __attribute__((no_sanitize("thread"))) #endif 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 /* PyAssertionError_Check.proto */ #define __Pyx_PyExc_AssertionError_Check(obj) __Pyx_TypeCheck(obj, PyExc_AssertionError) /* dict_setdefault.proto (used by FetchCommonType) */ static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value); /* AddModuleRef.proto (used by FetchSharedCythonModule) */ #if ((CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && PY_VERSION_HEX < 0x030F00a3) ||\ __PYX_LIMITED_VERSION_HEX < 0x030d0000) static PyObject *__Pyx_PyImport_AddModuleRef(const char *name); #else #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) #endif /* FetchSharedCythonModule.proto (used by FetchCommonType) */ static PyObject *__Pyx_FetchSharedCythonABIModule(void); /* VerifyCachedType.proto (used by FetchCommonType) */ static int __Pyx_VerifyCachedType(PyObject *cached_type, const char *name, Py_ssize_t expected_basicsize); /* FetchCommonType.proto (used by CommonTypesMetaclass) */ static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases); /* CommonTypesMetaclass.proto (used by CythonFunctionShared) */ static int __pyx_CommonTypesMetaclass_init(PyObject *module); #define __Pyx_CommonTypesMetaclass_USED /* CythonFunctionPerModule.proto (used by CythonFunctionShared) */ #define __Pyx_CyFunction_USED #if CYTHON_OPAQUE_SHARED_TYPES #define __Pyx_as_CyFunctionObject(o) ((__pyx_CyFunctionObject *)PyObject_GetTypeData((o), __pyx_mstate_global->__pyx_CyFunctionType)) #else #define __Pyx_as_CyFunctionObject(o) ((__pyx_CyFunctionObject *)o) #endif #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_as_CyFunctionObject(f))->func_closure) #if CYTHON_COMPILING_IN_LIMITED_API #define __Pyx__CyFunction_GetClassObj(f)\ ((f)->func_classobj) #else #define __Pyx__CyFunction_GetClassObj(f)\ ((PyObject*) ((PyCMethodObject *) (f))->mm_class) #endif #define __Pyx_CyFunction_GetClassObj(f)\ __Pyx__CyFunction_GetClassObj(__Pyx_as_CyFunctionObject(f)) #define __Pyx_CyFunction_SetClassObj(f, classobj)\ __Pyx__CyFunction_SetClassObj(__Pyx_as_CyFunctionObject(f), (classobj)) #define __Pyx_CyFunction_Defaults(type, f)\ ((type *)((__Pyx_as_CyFunctionObject(f))->defaults)) #define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ (__Pyx_as_CyFunctionObject(f))->defaults_getter = (g) typedef struct { #if CYTHON_COMPILING_IN_LIMITED_API #if !CYTHON_OPAQUE_OBJECTS PyObject_HEAD #endif PyMethodDef *func_methoddef; PyObject *func_module; #else PyCMethodObject func; #endif #if (CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY) && CYTHON_VECTORCALL __pyx_vectorcallfunc func_vectorcall; #endif #if CYTHON_COMPILING_IN_LIMITED_API PyObject *func_weakreflist; #endif #if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API PyObject *func_dict; #endif PyObject *func_name; PyObject *func_qualname; PyObject *func_doc; PyObject *func_globals; PyObject *func_code; PyObject *func_closure; #if CYTHON_COMPILING_IN_LIMITED_API PyObject *func_classobj; #endif PyObject *defaults; int flags; PyObject *defaults_tuple; PyObject *defaults_kwdict; PyObject *(*defaults_getter)(PyObject *); PyObject *func_annotations; #if __PYX_LIMITED_VERSION_HEX < 0x030B0000 PyObject *func_is_coroutine; #endif } __pyx_CyFunctionObject; #undef __Pyx_CyOrPyCFunction_Check #define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_mstate_global->__pyx_CyFunctionType) #define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_mstate_global->__pyx_CyFunctionType, &PyCFunction_Type) #define __Pyx_CyFunction_CheckExact(obj) Py_IS_TYPE(obj, __pyx_mstate_global->__pyx_CyFunctionType) static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)); #undef __Pyx_IsSameCFunction #define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCyOrCFunction(func, cfunc) static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); static CYTHON_INLINE PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func, PyTypeObject *defaults_type); static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, PyObject *tuple); static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, PyObject *dict); static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, PyObject *dict); static int __pyx_CyFunction_init(PyObject *module); #if CYTHON_VECTORCALL #if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY #define __Pyx_CyFunction_func_vectorcall(f) ((f)->func_vectorcall) #else #define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall) #endif #endif /* PyMethodNew.proto (used by CythonFunctionShared) */ static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ); /* PyVectorcallFastCallDict.proto (used by CythonFunctionShared) */ #if CYTHON_VECTORCALL static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw); #endif /* CythonFunctionShared.proto (used by CythonFunction) */ static PyObject *__Pyx_CyFunction_Init(PyObject *op_in, PyMethodDef *ml, int flags, PyObject* qualname, PyObject *closure, PyObject *module, PyObject *globals, PyObject* code); #if CYTHON_VECTORCALL 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); #endif /* CythonFunction.export */ static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, PyObject *closure, PyObject *module, PyObject *globals, PyObject* code); static PyTypeObject *__Pyx_Get_CyFunction_Type(void); /* CLineInTraceback.proto (used by AddTraceback) */ #if CYTHON_CLINE_IN_TRACEBACK && CYTHON_CLINE_IN_TRACEBACK_RUNTIME static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #else #define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) #endif /* CodeObjectCache.proto (used by AddTraceback) */ #if CYTHON_COMPILING_IN_LIMITED_API typedef PyObject __Pyx_CachedCodeObjectType; #else typedef PyCodeObject __Pyx_CachedCodeObjectType; #endif typedef struct { __Pyx_CachedCodeObjectType* code_object; int code_line; } __Pyx_CodeObjectCacheEntry; struct __Pyx_CodeObjectCache { int count; int max_count; __Pyx_CodeObjectCacheEntry* entries; #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING __pyx_atomic_int_type accessor_count; #endif }; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static __Pyx_CachedCodeObjectType *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, __Pyx_CachedCodeObjectType* code_object); /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); /* GCCDiagnostics.proto */ #if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) #define __Pyx_HAS_GCC_DIAGNOSTIC #endif /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE size_t __Pyx_PyLong_As_size_t(PyObject *); /* PyObjectVectorcallKwds.proto (used by PyObjectVectorcallMethodKwds) */ #if CYTHON_VECTORCALL #define __Pyx_Object_VectorcallKwds PyObject_Vectorcall CYTHON_UNUSED static int __Pyx_CheckVectorcallKwarg(PyObject *kwnames, Py_ssize_t i); #else #define __Pyx_Object_VectorcallKwds __Pyx_PyObject_FastCallDict CYTHON_UNUSED static PyObject *__Pyx_MakeKwargDict(PyObject **keys, PyObject **values, Py_ssize_t n); CYTHON_UNUSED static int __Pyx_CheckVectorcallKwarg(PyObject **kwnames, Py_ssize_t i); #endif /* PyObjectVectorcallMethodKwds.proto (used by CIntToPy) */ #if CYTHON_VECTORCALL #define __Pyx_Object_VectorcallMethodKwds PyObject_VectorcallMethod #else static PyObject *__Pyx_Object_VectorcallMethodKwds(PyObject *name, PyObject *const *args, size_t nargsf, PyObject *kwnames); #endif /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_int(int value); /* CIntFromPy.proto */ static CYTHON_INLINE uint32_t __Pyx_PyLong_As_uint32_t(PyObject *); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_uint32_t(uint32_t value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value); /* CIntFromPy.proto */ static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *); /* GetRuntimeVersion.proto */ #if __PYX_LIMITED_VERSION_HEX < 0x030b0000 static unsigned long __Pyx_cached_runtime_version = 0; static void __Pyx_init_runtime_version(void); #else #define __Pyx_init_runtime_version() #endif static unsigned long __Pyx_get_runtime_version(void); /* SwapException.proto (used by CoroutineBase) */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSwap(type, value, tb) __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #else static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); #endif /* IterNextPlain.proto (used by CoroutineBase) */ static CYTHON_INLINE PyObject *__Pyx_PyIter_Next_Plain(PyObject *iterator); #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 static PyObject *__Pyx_GetBuiltinNext_LimitedAPI(void); #endif /* PyObjectCallMethod1.proto (used by CoroutineBase) */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg); /* PyObjectCallNoArg.proto (used by CoroutineBase) */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); /* ReturnWithStopIteration.proto (used by CoroutineBase) */ static CYTHON_INLINE void __Pyx_ReturnWithStopIteration(PyObject* value, int async, int iternext); /* CoroutineBase.proto (used by Generator) */ 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 typedef struct { PyObject *exc_type; PyObject *exc_value; PyObject *exc_traceback; } __Pyx_ExcInfoStruct; #endif typedef struct __pyx_CoroutineObject { PyObject_HEAD __pyx_coroutine_body_t body; PyObject *closure; __Pyx_ExcInfoStruct gi_exc_state; #if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API PyObject *gi_weakreflist; #endif PyObject *classobj; PyObject *yieldfrom; __Pyx_pyiter_sendfunc yieldfrom_am_send; PyObject *gi_name; PyObject *gi_qualname; PyObject *gi_modulename; PyObject *gi_code; PyObject *gi_frame; #if CYTHON_USE_SYS_MONITORING && (CYTHON_PROFILE || CYTHON_TRACE) PyMonitoringState __pyx_pymonitoring_state[__Pyx_MonitoringEventTypes_CyGen_count]; uint64_t __pyx_pymonitoring_version; #endif int resume_label; char is_running; } __pyx_CoroutineObject; static __pyx_CoroutineObject *__Pyx__Coroutine_New( PyTypeObject *type, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, PyObject *name, PyObject *qualname, PyObject *module_name); static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit( __pyx_CoroutineObject *gen, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, PyObject *name, PyObject *qualname, PyObject *module_name); static CYTHON_INLINE void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *self); static int __Pyx_Coroutine_clear(PyObject *self); static __Pyx_PySendResult __Pyx_Coroutine_AmSend(PyObject *self, PyObject *value, PyObject **retval); static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value); static __Pyx_PySendResult __Pyx_Coroutine_Close(PyObject *self, PyObject **retval); static PyObject *__Pyx_Coroutine_Throw(PyObject *gen, #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 PyObject *args #else PyObject *const *args, Py_ssize_t nargs #endif ); #if CYTHON_USE_EXC_INFO_STACK #define __Pyx_Coroutine_SwapException(self) #define __Pyx_Coroutine_ResetAndClearException(self) __Pyx_Coroutine_ExceptionClear(&(self)->gi_exc_state) #else #define __Pyx_Coroutine_SwapException(self) {\ __Pyx_ExceptionSwap(&(self)->gi_exc_state.exc_type, &(self)->gi_exc_state.exc_value, &(self)->gi_exc_state.exc_traceback);\ __Pyx_Coroutine_ResetFrameBackpointer(&(self)->gi_exc_state);\ } #define __Pyx_Coroutine_ResetAndClearException(self) {\ __Pyx_ExceptionReset((self)->gi_exc_state.exc_type, (self)->gi_exc_state.exc_value, (self)->gi_exc_state.exc_traceback);\ (self)->gi_exc_state.exc_type = (self)->gi_exc_state.exc_value = (self)->gi_exc_state.exc_traceback = NULL;\ } #endif #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyGen_FetchStopIterationValue(pvalue)\ __Pyx_PyGen__FetchStopIterationValue(__pyx_tstate, pvalue) #else #define __Pyx_PyGen_FetchStopIterationValue(pvalue)\ __Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, pvalue) #endif static int __Pyx_PyGen__FetchStopIterationValue(PyThreadState *tstate, PyObject **pvalue); static CYTHON_INLINE void __Pyx_Coroutine_ResetFrameBackpointer(__Pyx_ExcInfoStruct *exc_state); static char __Pyx_Coroutine_test_and_set_is_running(__pyx_CoroutineObject *gen); static void __Pyx_Coroutine_unset_is_running(__pyx_CoroutineObject *gen); static char __Pyx_Coroutine_get_is_running(__pyx_CoroutineObject *gen); static PyObject *__Pyx_Coroutine_get_is_running_getter(PyObject *gen, void *closure); #if __PYX_HAS_PY_AM_SEND == 2 static void __Pyx_SetBackportTypeAmSend(PyTypeObject *type, __Pyx_PyAsyncMethodsStruct *static_amsend_methods, __Pyx_pyiter_sendfunc am_send); #endif static PyObject *__Pyx_Coroutine_fail_reduce_ex(PyObject *self, PyObject *arg); /* Generator.proto */ #define __Pyx_Generator_USED #define __Pyx_Generator_CheckExact(obj) Py_IS_TYPE(obj, __pyx_mstate_global->__pyx_GeneratorType) #define __Pyx_Generator_New(body, code, closure, name, qualname, module_name)\ __Pyx__Coroutine_New(__pyx_mstate_global->__pyx_GeneratorType, body, code, closure, name, qualname, module_name) static PyObject *__Pyx_Generator_Next(PyObject *self); static int __pyx_Generator_init(PyObject *module); static CYTHON_INLINE PyObject *__Pyx_Generator_GetInlinedResult(PyObject *self); /* CheckBinaryVersion.proto */ static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); /* DecompressString.proto */ static PyObject *__Pyx_DecompressString(const char *s, Py_ssize_t length, int algo); /* DecompressString_LZSS.proto */ static PyObject *__Pyx_DecompressString_LZSS(const char *s, size_t compressed_length, size_t uncompressed_length); /* MultiPhaseInitModuleState.proto */ #if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE #include static PyObject *__Pyx_State_FindModule(void*); static int __Pyx_State_AddModule(PyObject* module, void*); static int __Pyx_State_RemoveModule(void*); #elif CYTHON_USE_MODULE_STATE #define __Pyx_State_FindModule PyState_FindModule #define __Pyx_State_AddModule PyState_AddModule #define __Pyx_State_RemoveModule PyState_RemoveModule #endif /* #### Code section: module_declarations ### */ /* CythonABIVersion.proto */ #if CYTHON_COMPILING_IN_LIMITED_API #if CYTHON_VECTORCALL #define __PYX_VECTORCALL_ABI_SUFFIX "_vectorcall" #else #define __PYX_VECTORCALL_ABI_SUFFIX #endif #define __PYX_LIMITED_ABI_SUFFIX "limited" __PYX_VECTORCALL_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX #else #define __PYX_LIMITED_ABI_SUFFIX #endif #if __PYX_HAS_PY_AM_SEND == 1 #define __PYX_AM_SEND_ABI_SUFFIX #elif __PYX_HAS_PY_AM_SEND == 2 #define __PYX_AM_SEND_ABI_SUFFIX "amsendbackport" #else #define __PYX_AM_SEND_ABI_SUFFIX "noamsend" #endif #ifndef __PYX_MONITORING_ABI_SUFFIX #define __PYX_MONITORING_ABI_SUFFIX #endif #if CYTHON_USE_TP_FINALIZE #define __PYX_TP_FINALIZE_ABI_SUFFIX #else #define __PYX_TP_FINALIZE_ABI_SUFFIX "nofinalize" #endif #if CYTHON_USE_FREELISTS || !defined(__Pyx_AsyncGen_USED) #define __PYX_FREELISTS_ABI_SUFFIX #else #define __PYX_FREELISTS_ABI_SUFFIX "nofreelists" #endif #if CYTHON_OPAQUE_OBJECTS && CYTHON_COMPILING_IN_LIMITED_API #define __PYX_OPAQUE_OBJECTS_ABI_SUFFIX "opaque" #else #define __PYX_OPAQUE_OBJECTS_ABI_SUFFIX #endif #define CYTHON_ABI __PYX_ABI_VERSION __PYX_LIMITED_ABI_SUFFIX __PYX_MONITORING_ABI_SUFFIX __PYX_TP_FINALIZE_ABI_SUFFIX __PYX_FREELISTS_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX __PYX_OPAQUE_OBJECTS_ABI_SUFFIX #define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI #define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." static size_t __pyx_f_8borghash_9HashTable_9HashTable__get_index(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, uint8_t *__pyx_v_key); /* proto*/ static int __pyx_f_8borghash_9HashTable_9HashTable__lookup_index(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, uint8_t *__pyx_v_key_ptr, size_t *__pyx_v_index_ptr, struct __pyx_opt_args_8borghash_9HashTable_9HashTable__lookup_index *__pyx_optional_args); /* proto*/ static void __pyx_f_8borghash_9HashTable_9HashTable__resize_table(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, size_t __pyx_v_new_capacity); /* proto*/ static void __pyx_f_8borghash_9HashTable_9HashTable__resize_kv(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, size_t __pyx_v_new_capacity); /* proto*/ /* Module declarations from "libc.stdint" */ /* Module declarations from "libc.string" */ /* Module declarations from "libc.stdlib" */ /* Module declarations from "borghash.HashTable" */ static uint32_t __pyx_v_8borghash_9HashTable_FREE_BUCKET; static uint32_t __pyx_v_8borghash_9HashTable_TOMBSTONE_BUCKET; static uint32_t __pyx_v_8borghash_9HashTable_RESERVED; /* #### Code section: typeinfo ### */ /* #### Code section: before_global_var ### */ #define __Pyx_MODULE_NAME "borghash.HashTable" extern int __pyx_module_is_main_borghash__HashTable; int __pyx_module_is_main_borghash__HashTable = 0; /* Implementation of "borghash.HashTable" */ /* #### Code section: global_var ### */ static PyObject *__pyx_builtin_object; /* #### Code section: string_decls ### */ static const char __pyx_k_HashTable_low_level_hash_table[] = "\nHashTable: low-level hash table mapping fully random bytes keys to bytes values.\n Key and value lengths can be chosen, but are fixed thereafter.\n The keys and values are stored in arrays separate from the hashtable.\n The hashtable only stores the 32-bit indices into the key/value arrays.\n"; /* #### Code section: decls ### */ static PyObject *__pyx_pf_8borghash_9HashTable__fill(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_this, PyObject *__pyx_v_other); /* proto */ static int __pyx_pf_8borghash_9HashTable_9HashTable___init__(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, PyObject *__pyx_v_items, PyObject *__pyx_v_key_size, PyObject *__pyx_v_value_size, PyObject *__pyx_v_capacity, double __pyx_v_max_load_factor, double __pyx_v_min_load_factor, double __pyx_v_shrink_factor, double __pyx_v_grow_factor, double __pyx_v_rehash_threshold, double __pyx_v_kv_grow_factor); /* proto */ static void __pyx_pf_8borghash_9HashTable_9HashTable_2__del__(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8borghash_9HashTable_9HashTable_4clear(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self); /* proto */ static Py_ssize_t __pyx_pf_8borghash_9HashTable_9HashTable_6__len__(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self); /* proto */ static int __pyx_pf_8borghash_9HashTable_9HashTable_8__setitem__(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value); /* proto */ static int __pyx_pf_8borghash_9HashTable_9HashTable_10__contains__(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, PyObject *__pyx_v_key); /* proto */ static PyObject *__pyx_pf_8borghash_9HashTable_9HashTable_12__getitem__(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, PyObject *__pyx_v_key); /* proto */ static int __pyx_pf_8borghash_9HashTable_9HashTable_14__delitem__(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, PyObject *__pyx_v_key); /* proto */ static PyObject *__pyx_pf_8borghash_9HashTable_9HashTable_16setdefault(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value); /* proto */ static PyObject *__pyx_pf_8borghash_9HashTable_9HashTable_18get(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_default); /* proto */ static PyObject *__pyx_pf_8borghash_9HashTable_9HashTable_20pop(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_default); /* proto */ static PyObject *__pyx_pf_8borghash_9HashTable_9HashTable_22items(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, PyObject *__pyx_v_prefix_bits, PyObject *__pyx_v_prefix); /* proto */ static PyObject *__pyx_pf_8borghash_9HashTable_9HashTable_25k_to_idx(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, PyObject *__pyx_v_key); /* proto */ static PyObject *__pyx_pf_8borghash_9HashTable_9HashTable_27idx_to_k(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, PyObject *__pyx_v_idx); /* proto */ static PyObject *__pyx_pf_8borghash_9HashTable_9HashTable_29kv_to_idx(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value); /* proto */ static PyObject *__pyx_pf_8borghash_9HashTable_9HashTable_31idx_to_kv(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, PyObject *__pyx_v_idx); /* proto */ static PyObject *__pyx_pf_8borghash_9HashTable_9HashTable_5stats___get__(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8borghash_9HashTable_9HashTable_8capacity___get__(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8borghash_9HashTable_9HashTable_4used___get__(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8borghash_9HashTable_9HashTable_33__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8borghash_9HashTable_9HashTable_35__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_tp_new__initialisation_8borghash_9HashTable_HashTable(PyObject *o, #if CYTHON_VECTORCALL_TPNEW PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames #else PyObject *a, PyObject *k #endif ); /*proto*/ static PyObject *__pyx_tp_new_vectorcall_8borghash_9HashTable_HashTable(PyTypeObject *t, #if CYTHON_VECTORCALL_TPNEW PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames #else PyObject *a, PyObject *k #endif ); /*proto*/ #if CYTHON_VECTORCALL_TPNEW static PyObject *__pyx_tp_new_8borghash_9HashTable_HashTable(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ #endif #if !CYTHON_VECTORCALL_TPNEW #define __pyx_tp_new_8borghash_9HashTable_HashTable __pyx_tp_new_vectorcall_8borghash_9HashTable_HashTable #endif #if CYTHON_VECTORCALL_TPNEW static PyObject *__pyx_tp_vectorcall_8borghash_9HashTable_HashTable(PyObject *t, PyObject *const *args, size_t nargsf, PyObject *kwnames); /*proto*/ #endif #if CYTHON_VECTORCALL_TPNEW static int __pyx_tp_init_8borghash_9HashTable_HashTable(PyObject *o, PyObject *args, PyObject *kwds); /*proto*/ #endif #if !CYTHON_VECTORCALL_TPNEW #define __pyx_tp_init_8borghash_9HashTable_HashTable __pyx_pw_8borghash_9HashTable_9HashTable_1__init__ #endif static PyObject *__pyx_tp_new__initialisation_8borghash_9HashTable___pyx_scope_struct__items(PyObject *o, #if CYTHON_VECTORCALL_TPNEW PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames #else PyObject *a, PyObject *k #endif ); /*proto*/ static PyObject *__pyx_tp_new_vectorcall_8borghash_9HashTable___pyx_scope_struct__items(PyTypeObject *t, #if CYTHON_VECTORCALL_TPNEW PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames #else PyObject *a, PyObject *k #endif ); /*proto*/ #if CYTHON_VECTORCALL_TPNEW static PyObject *__pyx_tp_new_8borghash_9HashTable___pyx_scope_struct__items(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ #endif #if !CYTHON_VECTORCALL_TPNEW #define __pyx_tp_new_8borghash_9HashTable___pyx_scope_struct__items __pyx_tp_new_vectorcall_8borghash_9HashTable___pyx_scope_struct__items #endif #if CYTHON_VECTORCALL_TPNEW static PyObject *__pyx_tp_vectorcall_8borghash_9HashTable___pyx_scope_struct__items(PyObject *t, PyObject *const *args, size_t nargsf, PyObject *kwnames); /*proto*/ #endif /* #### Code section: late_includes ### */ /* #### Code section: module_state ### */ /* SmallCodeConfig */ #ifndef CYTHON_SMALL_CODE #if defined(__clang__) #define CYTHON_SMALL_CODE #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) #define CYTHON_SMALL_CODE __attribute__((cold)) #else #define CYTHON_SMALL_CODE #endif #endif #ifdef __cplusplus namespace { #endif typedef struct { PyObject *__pyx_d; PyObject *__pyx_b; PyObject *__pyx_cython_runtime; PyObject *__pyx_empty_tuple; PyObject *__pyx_empty_bytes; PyObject *__pyx_empty_unicode; PyObject *__pyx_type_8borghash_9HashTable_HashTable; PyObject *__pyx_type_8borghash_9HashTable___pyx_scope_struct__items; PyTypeObject *__pyx_ptype_8borghash_9HashTable_HashTable; PyTypeObject *__pyx_ptype_8borghash_9HashTable___pyx_scope_struct__items; __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_items; __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_pop; __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_values; PyObject *__pyx_k__2; PyObject *__pyx_k__3; PyObject *__pyx_tuple[1]; PyObject *__pyx_codeobj_tab[12]; PyObject *__pyx_string_tab[137]; PyObject *__pyx_number_tab[5]; /* #### Code section: module_state_contents ### */ /* PyFrozenDict.module_state_decls */ #if CYTHON_COMPILING_IN_LIMITED_API PyObject *__Pyx_PyFrozenDictType; #endif #if CYTHON_USE_FREELISTS struct __pyx_obj_8borghash_9HashTable___pyx_scope_struct__items *__pyx_freelist_8borghash_9HashTable___pyx_scope_struct__items[8]; int __pyx_freecount_8borghash_9HashTable___pyx_scope_struct__items; #endif /* CommonTypesMetaclass.module_state_decls */ PyTypeObject *__pyx_CommonTypesMetaclassType; /* CachedMethodType.module_state_decls */ #if CYTHON_COMPILING_IN_LIMITED_API PyObject *__Pyx_CachedMethodType; #endif /* CythonFunctionPerModule.module_state_decls */ PyTypeObject *__pyx_CyFunctionType; /* CodeObjectCache.module_state_decls */ struct __Pyx_CodeObjectCache __pyx_code_cache; /* IterNextPlain.module_state_decls */ #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 PyObject *__Pyx_GetBuiltinNext_LimitedAPI_cache; #endif /* Generator.module_state_decls */ PyTypeObject *__pyx_GeneratorType; /* #### Code section: module_state_end ### */ } __pyx_mstatetype; #ifdef __cplusplus } /* anonymous namespace */ #endif #if CYTHON_USE_MODULE_STATE #ifdef __cplusplus namespace { extern struct PyModuleDef __pyx_moduledef; } /* anonymous namespace */ #else static struct PyModuleDef __pyx_moduledef; #endif #define __pyx_mstate_global (__Pyx_PyModule_GetState(__Pyx_State_FindModule(&__pyx_moduledef))) #define __pyx_m (__Pyx_State_FindModule(&__pyx_moduledef)) #else static __pyx_mstatetype __pyx_mstate_global_static = #ifdef __cplusplus {}; #else {0}; #endif static __pyx_mstatetype * const __pyx_mstate_global = &__pyx_mstate_global_static; #endif /* #### Code section: constant_name_defines ### */ #define __pyx_kp_u_tree_fragment __pyx_string_tab[0] #define __pyx_kp_u__4 __pyx_string_tab[1] #define __pyx_kp_u_8sII __pyx_string_tab[2] #define __pyx_kp_u_ __pyx_string_tab[3] #define __pyx_kp_u_Iterator_tuple_bytes_bytes __pyx_string_tab[4] #define __pyx_kp_u_KV_array_is_full __pyx_string_tab[5] #define __pyx_kp_u_Key_not_found __pyx_string_tab[6] #define __pyx_kp_u_Key_or_value_size_does_not_match __pyx_string_tab[7] #define __pyx_kp_u_Key_size_does_not_match_the_defi __pyx_string_tab[8] #define __pyx_kp_u_Key_Value_not_found __pyx_string_tab[9] #define __pyx_kp_u_Note_that_Cython_is_deliberately __pyx_string_tab[10] #define __pyx_kp_u_Value_size_does_not_match_the_de __pyx_string_tab[11] #define __pyx_kp_u_add_note __pyx_string_tab[12] #define __pyx_kp_u_bytes_Any __pyx_string_tab[13] #define __pyx_kp_u_disable __pyx_string_tab[14] #define __pyx_kp_u_enable __pyx_string_tab[15] #define __pyx_kp_u_gc __pyx_string_tab[16] #define __pyx_kp_u_isenabled __pyx_string_tab[17] #define __pyx_kp_u_key_size_must_be_specified_and_m __pyx_string_tab[18] #define __pyx_kp_u_prefix_must_be_in_range_0_2_pref __pyx_string_tab[19] #define __pyx_kp_u_prefix_bits_must_be_in_range_0_3 __pyx_string_tab[20] #define __pyx_kp_u_self_table_cannot_be_converted_t __pyx_string_tab[21] #define __pyx_kp_u_src_borghash_HashTable_pyx __pyx_string_tab[22] #define __pyx_kp_u_tuple_bytes_bytes __pyx_string_tab[23] #define __pyx_kp_u_value_size_must_be_specified_and __pyx_string_tab[24] #define __pyx_n_u_Any __pyx_string_tab[25] #define __pyx_n_u_BinaryIO __pyx_string_tab[26] #define __pyx_n_u_HEADER_FMT __pyx_string_tab[27] #define __pyx_n_u_HashTable __pyx_string_tab[28] #define __pyx_n_u_HashTable___reduce_cython __pyx_string_tab[29] #define __pyx_n_u_HashTable___setstate_cython __pyx_string_tab[30] #define __pyx_n_u_HashTable_clear __pyx_string_tab[31] #define __pyx_n_u_HashTable_get __pyx_string_tab[32] #define __pyx_n_u_HashTable_idx_to_k __pyx_string_tab[33] #define __pyx_n_u_HashTable_idx_to_kv __pyx_string_tab[34] #define __pyx_n_u_HashTable_items __pyx_string_tab[35] #define __pyx_n_u_HashTable_k_to_idx __pyx_string_tab[36] #define __pyx_n_u_HashTable_kv_to_idx __pyx_string_tab[37] #define __pyx_n_u_HashTable_pop __pyx_string_tab[38] #define __pyx_n_u_HashTable_setdefault __pyx_string_tab[39] #define __pyx_n_u_Iterator __pyx_string_tab[40] #define __pyx_n_u_MAGIC __pyx_string_tab[41] #define __pyx_n_u_MIN_CAPACITY __pyx_string_tab[42] #define __pyx_n_u_Mapping __pyx_string_tab[43] #define __pyx_n_u_None __pyx_string_tab[44] #define __pyx_n_u_VERSION __pyx_string_tab[45] #define __pyx_n_u_NoDefault __pyx_string_tab[46] #define __pyx_n_u_Pyx_PyDict_NextRef __pyx_string_tab[47] #define __pyx_n_u_annotate __pyx_string_tab[48] #define __pyx_n_u_class_getitem __pyx_string_tab[49] #define __pyx_n_u_func __pyx_string_tab[50] #define __pyx_n_u_getstate __pyx_string_tab[51] #define __pyx_n_u_main __pyx_string_tab[52] #define __pyx_n_u_module __pyx_string_tab[53] #define __pyx_n_u_name __pyx_string_tab[54] #define __pyx_n_u_pyx_state __pyx_string_tab[55] #define __pyx_n_u_pyx_vtable __pyx_string_tab[56] #define __pyx_n_u_qualname __pyx_string_tab[57] #define __pyx_n_u_reduce __pyx_string_tab[58] #define __pyx_n_u_reduce_cython __pyx_string_tab[59] #define __pyx_n_u_reduce_ex __pyx_string_tab[60] #define __pyx_n_u_set_name __pyx_string_tab[61] #define __pyx_n_u_setstate __pyx_string_tab[62] #define __pyx_n_u_setstate_cython __pyx_string_tab[63] #define __pyx_n_u_test __pyx_string_tab[64] #define __pyx_n_u_fill __pyx_string_tab[65] #define __pyx_n_u_is_coroutine __pyx_string_tab[66] #define __pyx_n_u_asyncio_coroutines __pyx_string_tab[67] #define __pyx_n_u_borghash_HashTable __pyx_string_tab[68] #define __pyx_n_u_bytes __pyx_string_tab[69] #define __pyx_n_u_capacity __pyx_string_tab[70] #define __pyx_n_u_clear __pyx_string_tab[71] #define __pyx_n_u_cline_in_traceback __pyx_string_tab[72] #define __pyx_n_u_close __pyx_string_tab[73] #define __pyx_n_u_collections_abc __pyx_string_tab[74] #define __pyx_n_u_default __pyx_string_tab[75] #define __pyx_n_u_del __pyx_string_tab[76] #define __pyx_n_u_filtering __pyx_string_tab[77] #define __pyx_n_u_get __pyx_string_tab[78] #define __pyx_n_u_grow_factor __pyx_string_tab[79] #define __pyx_n_u_i __pyx_string_tab[80] #define __pyx_n_u_idx __pyx_string_tab[81] #define __pyx_n_u_idx_to_k __pyx_string_tab[82] #define __pyx_n_u_idx_to_kv __pyx_string_tab[83] #define __pyx_n_u_index __pyx_string_tab[84] #define __pyx_n_u_int __pyx_string_tab[85] #define __pyx_n_u_items __pyx_string_tab[86] #define __pyx_n_u_iter __pyx_string_tab[87] #define __pyx_n_u_k_to_idx __pyx_string_tab[88] #define __pyx_n_u_key __pyx_string_tab[89] #define __pyx_n_u_key32 __pyx_string_tab[90] #define __pyx_n_u_key_ptr __pyx_string_tab[91] #define __pyx_n_u_key_size __pyx_string_tab[92] #define __pyx_n_u_keys __pyx_string_tab[93] #define __pyx_n_u_kv_grow_factor __pyx_string_tab[94] #define __pyx_n_u_kv_index __pyx_string_tab[95] #define __pyx_n_u_kv_to_idx __pyx_string_tab[96] #define __pyx_n_u_linear __pyx_string_tab[97] #define __pyx_n_u_lookup __pyx_string_tab[98] #define __pyx_n_u_max_load_factor __pyx_string_tab[99] #define __pyx_n_u_min_load_factor __pyx_string_tab[100] #define __pyx_n_u_next __pyx_string_tab[101] #define __pyx_n_u_object __pyx_string_tab[102] #define __pyx_n_u_other __pyx_string_tab[103] #define __pyx_n_u_pop __pyx_string_tab[104] #define __pyx_n_u_prefix __pyx_string_tab[105] #define __pyx_n_u_prefix_bits __pyx_string_tab[106] #define __pyx_n_u_rehash_threshold __pyx_string_tab[107] #define __pyx_n_u_resize_kv __pyx_string_tab[108] #define __pyx_n_u_resize_table __pyx_string_tab[109] #define __pyx_n_u_return __pyx_string_tab[110] #define __pyx_n_u_self __pyx_string_tab[111] #define __pyx_n_u_send __pyx_string_tab[112] #define __pyx_n_u_set __pyx_string_tab[113] #define __pyx_n_u_setdefault __pyx_string_tab[114] #define __pyx_n_u_shift __pyx_string_tab[115] #define __pyx_n_u_shrink_factor __pyx_string_tab[116] #define __pyx_n_u_this __pyx_string_tab[117] #define __pyx_n_u_throw __pyx_string_tab[118] #define __pyx_n_u_typing __pyx_string_tab[119] #define __pyx_n_u_value __pyx_string_tab[120] #define __pyx_n_u_value_found __pyx_string_tab[121] #define __pyx_n_u_value_size __pyx_string_tab[122] #define __pyx_n_u_values __pyx_string_tab[123] #define __pyx_n_u_wanted __pyx_string_tab[124] #define __pyx_n_b_BORGHASH __pyx_string_tab[125] #define __pyx_kp_b_iso88591_Q __pyx_string_tab[126] #define __pyx_kp_b_iso88591_HA_vS_z_G1_Qa_G5_Q_Qa_E __pyx_string_tab[127] #define __pyx_kp_b_iso88591_q_L_HA_N_4q_Kq_Kq_1D_2_D __pyx_string_tab[128] #define __pyx_kp_b_iso88591_vYa_4q_1 __pyx_string_tab[129] #define __pyx_kp_b_iso88591_v_A_D_xs_1_AQ_1 __pyx_string_tab[130] #define __pyx_kp_b_iso88591_HA_A_t5_D_3b_A __pyx_string_tab[131] #define __pyx_kp_b_iso88591_Ja_3auCt1_AQ_4_Qk_aq_4vQa_1 __pyx_string_tab[132] #define __pyx_kp_b_iso88591_XQ_A_d_q_4xy_Rt1_G1IRt89Bc_4q_u __pyx_string_tab[133] #define __pyx_kp_b_iso88591_Q_3auCt1_AQ_3awc_Q_AQ_4_Qk_aq_t __pyx_string_tab[134] #define __pyx_kp_b_iso88591_nJa_t3a_t1A __pyx_string_tab[135] #define __pyx_kp_b_iso88591_F_V6 __pyx_string_tab[136] #define __pyx_int_0 __pyx_number_tab[0] #define __pyx_int_1 __pyx_number_tab[1] #define __pyx_int_4 __pyx_number_tab[2] #define __pyx_int_32 __pyx_number_tab[3] #define __pyx_int_1000 __pyx_number_tab[4] /* #### Code section: module_state_clear ### */ #if CYTHON_USE_MODULE_STATE static CYTHON_SMALL_CODE int __pyx_m_clear(PyObject *m) { __pyx_mstatetype *clear_module_state = __Pyx_PyModule_GetState(m); if (!clear_module_state) return 0; Py_CLEAR(clear_module_state->__pyx_d); Py_CLEAR(clear_module_state->__pyx_b); Py_CLEAR(clear_module_state->__pyx_cython_runtime); Py_CLEAR(clear_module_state->__pyx_empty_tuple); Py_CLEAR(clear_module_state->__pyx_empty_bytes); Py_CLEAR(clear_module_state->__pyx_empty_unicode); #if CYTHON_PEP489_MULTI_PHASE_INIT __Pyx_State_RemoveModule(NULL); #endif Py_CLEAR(clear_module_state->__pyx_ptype_8borghash_9HashTable_HashTable); Py_CLEAR(clear_module_state->__pyx_type_8borghash_9HashTable_HashTable); Py_CLEAR(clear_module_state->__pyx_ptype_8borghash_9HashTable___pyx_scope_struct__items); Py_CLEAR(clear_module_state->__pyx_type_8borghash_9HashTable___pyx_scope_struct__items); Py_CLEAR(clear_module_state->__pyx_umethod_PyDict_Type_items.method); Py_CLEAR(clear_module_state->__pyx_umethod_PyDict_Type_pop.method); Py_CLEAR(clear_module_state->__pyx_umethod_PyDict_Type_values.method); Py_CLEAR(clear_module_state->__pyx_k__2); Py_CLEAR(clear_module_state->__pyx_k__3); for (int i=0; i<1; ++i) { Py_CLEAR(clear_module_state->__pyx_tuple[i]); } for (int i=0; i<12; ++i) { Py_CLEAR(clear_module_state->__pyx_codeobj_tab[i]); } for (int i=0; i<137; ++i) { Py_CLEAR(clear_module_state->__pyx_string_tab[i]); } for (int i=0; i<5; ++i) { Py_CLEAR(clear_module_state->__pyx_number_tab[i]); } /* #### Code section: module_state_clear_contents ### */ /* CommonTypesMetaclass.module_state_clear */ Py_CLEAR(clear_module_state->__pyx_CommonTypesMetaclassType); /* CythonFunctionPerModule.module_state_clear */ Py_CLEAR(clear_module_state->__pyx_CyFunctionType); /* Generator.module_state_clear */ Py_CLEAR(clear_module_state->__pyx_GeneratorType); /* #### Code section: module_state_clear_end ### */ return 0; } #endif /* #### Code section: module_state_traverse ### */ #if CYTHON_USE_MODULE_STATE static CYTHON_SMALL_CODE int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { __pyx_mstatetype *traverse_module_state = __Pyx_PyModule_GetState(m); if (!traverse_module_state) return 0; Py_VISIT(traverse_module_state->__pyx_d); Py_VISIT(traverse_module_state->__pyx_b); Py_VISIT(traverse_module_state->__pyx_cython_runtime); __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_tuple); __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_bytes); __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_unicode); Py_VISIT(traverse_module_state->__pyx_ptype_8borghash_9HashTable_HashTable); Py_VISIT(traverse_module_state->__pyx_type_8borghash_9HashTable_HashTable); Py_VISIT(traverse_module_state->__pyx_ptype_8borghash_9HashTable___pyx_scope_struct__items); Py_VISIT(traverse_module_state->__pyx_type_8borghash_9HashTable___pyx_scope_struct__items); Py_VISIT(traverse_module_state->__pyx_umethod_PyDict_Type_items.method); Py_VISIT(traverse_module_state->__pyx_umethod_PyDict_Type_pop.method); Py_VISIT(traverse_module_state->__pyx_umethod_PyDict_Type_values.method); Py_VISIT(traverse_module_state->__pyx_k__2); Py_VISIT(traverse_module_state->__pyx_k__3); for (int i=0; i<1; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_tuple[i]); } for (int i=0; i<12; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_codeobj_tab[i]); } for (int i=0; i<137; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_string_tab[i]); } for (int i=0; i<5; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_number_tab[i]); } /* #### Code section: module_state_traverse_contents ### */ /* CommonTypesMetaclass.module_state_traverse */ Py_VISIT(traverse_module_state->__pyx_CommonTypesMetaclassType); /* CythonFunctionPerModule.module_state_traverse */ Py_VISIT(traverse_module_state->__pyx_CyFunctionType); /* Generator.module_state_traverse */ Py_VISIT(traverse_module_state->__pyx_GeneratorType); /* #### Code section: module_state_traverse_end ### */ return 0; } #endif /* #### Code section: module_code ### */ /* "borghash/HashTable.pyx":30 * _NoDefault = object() * * def _fill(this: Any, other: Any) -> None: # <<<<<<<<<<<<<< * """fill this mapping from other""" * if other is None: */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_9HashTable_1_fill(PyObject *__pyx_self, #if CYTHON_VECTORCALL 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_8borghash_9HashTable__fill, "fill this mapping from other"); static PyMethodDef __pyx_mdef_8borghash_9HashTable_1_fill = {"_fill", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_9HashTable_1_fill, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8borghash_9HashTable__fill}; static PyObject *__pyx_pw_8borghash_9HashTable_1_fill(PyObject *__pyx_self, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_this = 0; PyObject *__pyx_v_other = 0; #if !CYTHON_VECTORCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_fill (wrapper)", 0); #if !CYTHON_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_this,&__pyx_mstate_global->__pyx_n_u_other,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 30, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 30, __pyx_L3_error) CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 30, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_fill", 0) < (0)) __PYX_ERR(0, 30, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_fill", 1, 2, 2, i); __PYX_ERR(0, 30, __pyx_L3_error) } } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 30, __pyx_L3_error) values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 30, __pyx_L3_error) } __pyx_v_this = values[0]; __pyx_v_other = values[1]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("_fill", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 30, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("borghash.HashTable._fill", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8borghash_9HashTable__fill(__pyx_self, __pyx_v_this, __pyx_v_other); /* function exit code */ for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_9HashTable__fill(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_this, PyObject *__pyx_v_other) { PyObject *__pyx_v_key = NULL; PyObject *__pyx_v_value = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; Py_ssize_t __pyx_t_3; PyObject *(*__pyx_t_4)(PyObject *); PyObject *__pyx_t_5 = NULL; Py_ssize_t __pyx_t_6; int __pyx_t_7; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *(*__pyx_t_12)(PyObject *); int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_fill", 0); /* "borghash/HashTable.pyx":32 * def _fill(this: Any, other: Any) -> None: * """fill this mapping from other""" * if other is None: # <<<<<<<<<<<<<< * return * if isinstance(other, Mapping): */ __pyx_t_1 = (__pyx_v_other == Py_None); if (__pyx_t_1) { /* "borghash/HashTable.pyx":33 * """fill this mapping from other""" * if other is None: * return # <<<<<<<<<<<<<< * if isinstance(other, Mapping): * for key in other: */ { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __pyx_r = Py_None; __Pyx_INCREF(Py_None); } __Pyx_XDECREF(__pyx_temp); } goto __pyx_L0; /* "borghash/HashTable.pyx":32 * def _fill(this: Any, other: Any) -> None: * """fill this mapping from other""" * if other is None: # <<<<<<<<<<<<<< * return * if isinstance(other, Mapping): */ } /* "borghash/HashTable.pyx":34 * if other is None: * return * if isinstance(other, Mapping): # <<<<<<<<<<<<<< * for key in other: * this[key] = other[key] */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_Mapping); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 34, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = PyObject_IsInstance(__pyx_v_other, __pyx_t_2); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 34, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__pyx_t_1) { /* "borghash/HashTable.pyx":35 * return * if isinstance(other, Mapping): * for key in other: # <<<<<<<<<<<<<< * this[key] = other[key] * elif hasattr(other, "keys"): */ if (likely(PyList_CheckExact(__pyx_v_other)) || PyTuple_CheckExact(__pyx_v_other)) { __pyx_t_2 = __pyx_v_other; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; __pyx_t_4 = NULL; } else { __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_other); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 35, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 35, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_4)) { if (likely(PyList_CheckExact(__pyx_t_2))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 35, __pyx_L1_error) #endif if (__pyx_t_3 >= __pyx_temp) break; } __pyx_t_5 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_2, __pyx_t_3, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_3; } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 35, __pyx_L1_error) #endif if (__pyx_t_3 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_5 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3)); #else __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_3); #endif ++__pyx_t_3; } if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 35, __pyx_L1_error) } else { __pyx_t_5 = __pyx_t_4(__pyx_t_2); if (unlikely(!__pyx_t_5)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 35, __pyx_L1_error) PyErr_Clear(); } break; } } __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_5); __pyx_t_5 = 0; /* "borghash/HashTable.pyx":36 * if isinstance(other, Mapping): * for key in other: * this[key] = other[key] # <<<<<<<<<<<<<< * elif hasattr(other, "keys"): * for key in other.keys(): */ __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_v_other, __pyx_v_key); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 36, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (unlikely((PyObject_SetItem(__pyx_v_this, __pyx_v_key, __pyx_t_5) < 0))) __PYX_ERR(0, 36, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; /* "borghash/HashTable.pyx":35 * return * if isinstance(other, Mapping): * for key in other: # <<<<<<<<<<<<<< * this[key] = other[key] * elif hasattr(other, "keys"): */ } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTable.pyx":34 * if other is None: * return * if isinstance(other, Mapping): # <<<<<<<<<<<<<< * for key in other: * this[key] = other[key] */ goto __pyx_L4; } /* "borghash/HashTable.pyx":37 * for key in other: * this[key] = other[key] * elif hasattr(other, "keys"): # <<<<<<<<<<<<<< * for key in other.keys(): * this[key] = other[key] */ __pyx_t_1 = __Pyx_HasAttr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_keys); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 37, __pyx_L1_error) if (__pyx_t_1) { /* "borghash/HashTable.pyx":38 * this[key] = other[key] * elif hasattr(other, "keys"): * for key in other.keys(): # <<<<<<<<<<<<<< * this[key] = other[key] * else: */ __pyx_t_3 = 0; if (unlikely(__pyx_v_other == Py_None)) { PyErr_Format(PyExc_AttributeError, "\047NoneType\047 object has no attribute \047%.30s\047", "keys"); __PYX_ERR(0, 38, __pyx_L1_error) } __pyx_t_5 = __Pyx_dict_iterator(__pyx_v_other, 0, __pyx_mstate_global->__pyx_n_u_keys, (&__pyx_t_6), (&__pyx_t_7)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 38, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = __pyx_t_5; __pyx_t_5 = 0; while (1) { __pyx_t_8 = __Pyx_dict_iter_next(__pyx_t_2, __pyx_t_6, &__pyx_t_3, &__pyx_t_5, NULL, NULL, __pyx_t_7); if (unlikely(__pyx_t_8 == 0)) break; if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 38, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_5); __pyx_t_5 = 0; /* "borghash/HashTable.pyx":39 * elif hasattr(other, "keys"): * for key in other.keys(): * this[key] = other[key] # <<<<<<<<<<<<<< * else: * for key, value in other: */ __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_v_other, __pyx_v_key); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 39, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (unlikely((PyObject_SetItem(__pyx_v_this, __pyx_v_key, __pyx_t_5) < 0))) __PYX_ERR(0, 39, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTable.pyx":37 * for key in other: * this[key] = other[key] * elif hasattr(other, "keys"): # <<<<<<<<<<<<<< * for key in other.keys(): * this[key] = other[key] */ goto __pyx_L4; } /* "borghash/HashTable.pyx":41 * this[key] = other[key] * else: * for key, value in other: # <<<<<<<<<<<<<< * this[key] = value * */ /*else*/ { if (likely(PyList_CheckExact(__pyx_v_other)) || PyTuple_CheckExact(__pyx_v_other)) { __pyx_t_2 = __pyx_v_other; __Pyx_INCREF(__pyx_t_2); __pyx_t_6 = 0; __pyx_t_4 = NULL; } else { __pyx_t_6 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_other); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 41, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 41, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_4)) { if (likely(PyList_CheckExact(__pyx_t_2))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 41, __pyx_L1_error) #endif if (__pyx_t_6 >= __pyx_temp) break; } __pyx_t_5 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_2, __pyx_t_6, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_6; } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 41, __pyx_L1_error) #endif if (__pyx_t_6 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_5 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_6)); #else __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_6); #endif ++__pyx_t_6; } if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 41, __pyx_L1_error) } else { __pyx_t_5 = __pyx_t_4(__pyx_t_2); if (unlikely(!__pyx_t_5)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 41, __pyx_L1_error) PyErr_Clear(); } break; } } __Pyx_GOTREF(__pyx_t_5); if ((likely(PyTuple_CheckExact(__pyx_t_5))) || (PyList_CheckExact(__pyx_t_5))) { PyObject* sequence = __pyx_t_5; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); __PYX_ERR(0, 41, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_9 = PyTuple_GET_ITEM(sequence, 0); __Pyx_INCREF(__pyx_t_9); __pyx_t_10 = PyTuple_GET_ITEM(sequence, 1); __Pyx_INCREF(__pyx_t_10); } else { __pyx_t_9 = __Pyx_PyList_GET_ITEM_REF(sequence, 0, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 41, __pyx_L1_error) __Pyx_XGOTREF(__pyx_t_9); __pyx_t_10 = __Pyx_PyList_GET_ITEM_REF(sequence, 1, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 41, __pyx_L1_error) __Pyx_XGOTREF(__pyx_t_10); } #else __pyx_t_9 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 41, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_10 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 41, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); #endif __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else { Py_ssize_t index = -1; __pyx_t_11 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 41, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_12 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_11); index = 0; __pyx_t_9 = __pyx_t_12(__pyx_t_11); if (unlikely(!__pyx_t_9)) goto __pyx_L12_unpacking_failed; __Pyx_GOTREF(__pyx_t_9); index = 1; __pyx_t_10 = __pyx_t_12(__pyx_t_11); if (unlikely(!__pyx_t_10)) goto __pyx_L12_unpacking_failed; __Pyx_GOTREF(__pyx_t_10); if (__Pyx_IternextUnpackEndCheck(__pyx_t_12(__pyx_t_11), 2) < (0)) __PYX_ERR(0, 41, __pyx_L1_error) __pyx_t_12 = NULL; __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L13_unpacking_done; __pyx_L12_unpacking_failed:; __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __pyx_t_12 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); __PYX_ERR(0, 41, __pyx_L1_error) __pyx_L13_unpacking_done:; } __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_10); __pyx_t_10 = 0; /* "borghash/HashTable.pyx":42 * else: * for key, value in other: * this[key] = value # <<<<<<<<<<<<<< * * */ if (unlikely((PyObject_SetItem(__pyx_v_this, __pyx_v_key, __pyx_v_value) < 0))) __PYX_ERR(0, 42, __pyx_L1_error) /* "borghash/HashTable.pyx":41 * this[key] = other[key] * else: * for key, value in other: # <<<<<<<<<<<<<< * this[key] = value * */ } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_L4:; /* "borghash/HashTable.pyx":30 * _NoDefault = object() * * def _fill(this: Any, other: Any) -> None: # <<<<<<<<<<<<<< * """fill this mapping from other""" * if other is None: */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); __Pyx_XDECREF(__pyx_t_11); __Pyx_AddTraceback("borghash.HashTable._fill", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_key); __Pyx_XDECREF(__pyx_v_value); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTable.pyx":46 * * cdef class HashTable: * def __init__(self, items=None, *, # <<<<<<<<<<<<<< * key_size: int = 0, value_size: int = 0, capacity: int = MIN_CAPACITY, * max_load_factor: float = 0.5, min_load_factor: float = 0.10, */ /* Python wrapper */ static int __pyx_pw_8borghash_9HashTable_9HashTable_1__init__(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL_TPNEW PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ static int __pyx_pw_8borghash_9HashTable_9HashTable_1__init__(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL_TPNEW PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_items = 0; PyObject *__pyx_v_key_size = 0; PyObject *__pyx_v_value_size = 0; PyObject *__pyx_v_capacity = 0; double __pyx_v_max_load_factor; double __pyx_v_min_load_factor; double __pyx_v_shrink_factor; double __pyx_v_grow_factor; double __pyx_v_rehash_threshold; double __pyx_v_kv_grow_factor; #if !CYTHON_VECTORCALL_TPNEW CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[10] = {0,0,0,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_VECTORCALL_TPNEW #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL_TPNEW(__pyx_args, __pyx_nargs); { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_items,&__pyx_mstate_global->__pyx_n_u_key_size,&__pyx_mstate_global->__pyx_n_u_value_size,&__pyx_mstate_global->__pyx_n_u_capacity,&__pyx_mstate_global->__pyx_n_u_max_load_factor,&__pyx_mstate_global->__pyx_n_u_min_load_factor,&__pyx_mstate_global->__pyx_n_u_shrink_factor,&__pyx_mstate_global->__pyx_n_u_grow_factor,&__pyx_mstate_global->__pyx_n_u_rehash_threshold,&__pyx_mstate_global->__pyx_n_u_kv_grow_factor,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL_TPNEW(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 46, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: values[0] = __Pyx_ArgRef_FASTCALL_TPNEW(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 46, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__init__", 0) < (0)) __PYX_ERR(0, 46, __pyx_L3_error) if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)Py_None)); if (!values[1]) values[1] = __Pyx_NewRef(((PyObject*)__pyx_mstate_global->__pyx_int_0)); if (!values[2]) values[2] = __Pyx_NewRef(((PyObject*)__pyx_mstate_global->__pyx_int_0)); if (!values[3]) values[3] = __Pyx_NewRef(__pyx_mstate_global->__pyx_k__2); } else { switch (__pyx_nargs) { case 1: values[0] = __Pyx_ArgRef_FASTCALL_TPNEW(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 46, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)Py_None)); if (!values[1]) values[1] = __Pyx_NewRef(((PyObject*)__pyx_mstate_global->__pyx_int_0)); if (!values[2]) values[2] = __Pyx_NewRef(((PyObject*)__pyx_mstate_global->__pyx_int_0)); if (!values[3]) values[3] = __Pyx_NewRef(__pyx_mstate_global->__pyx_k__2); } __pyx_v_items = values[0]; if (__Pyx_PyInt_FromNumber(&values[1], "key_size", 0) < (0)) __PYX_ERR(0, 47, __pyx_L3_error) __pyx_v_key_size = ((PyObject*)values[1]); if (__Pyx_PyInt_FromNumber(&values[2], "value_size", 0) < (0)) __PYX_ERR(0, 47, __pyx_L3_error) __pyx_v_value_size = ((PyObject*)values[2]); if (__Pyx_PyInt_FromNumber(&values[3], "capacity", 0) < (0)) __PYX_ERR(0, 47, __pyx_L3_error) __pyx_v_capacity = ((PyObject*)values[3]); if (values[4]) { __pyx_v_max_load_factor = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_max_load_factor == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 48, __pyx_L3_error) } else { __pyx_v_max_load_factor = ((double)0.5); } if (values[5]) { __pyx_v_min_load_factor = __Pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_min_load_factor == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 48, __pyx_L3_error) } else { __pyx_v_min_load_factor = ((double)0.10); } if (values[6]) { __pyx_v_shrink_factor = __Pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_shrink_factor == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 49, __pyx_L3_error) } else { __pyx_v_shrink_factor = ((double)0.4); } if (values[7]) { __pyx_v_grow_factor = __Pyx_PyFloat_AsDouble(values[7]); if (unlikely((__pyx_v_grow_factor == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 49, __pyx_L3_error) } else { __pyx_v_grow_factor = ((double)2.0); } if (values[8]) { __pyx_v_rehash_threshold = __Pyx_PyFloat_AsDouble(values[8]); if (unlikely((__pyx_v_rehash_threshold == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 50, __pyx_L3_error) } else { __pyx_v_rehash_threshold = ((double)0.75); } if (values[9]) { __pyx_v_kv_grow_factor = __Pyx_PyFloat_AsDouble(values[9]); if (unlikely((__pyx_v_kv_grow_factor == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 50, __pyx_L3_error) } else { __pyx_v_kv_grow_factor = ((double)1.3); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__init__", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 46, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("borghash.HashTable.HashTable.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_key_size), (&PyLong_Type), 0, "key_size", 2))) __PYX_ERR(0, 47, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_value_size), (&PyLong_Type), 0, "value_size", 2))) __PYX_ERR(0, 47, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_capacity), (&PyLong_Type), 0, "capacity", 2))) __PYX_ERR(0, 47, __pyx_L1_error) __pyx_r = __pyx_pf_8borghash_9HashTable_9HashTable___init__(((struct __pyx_obj_8borghash_9HashTable_HashTable *)__pyx_v_self), __pyx_v_items, __pyx_v_key_size, __pyx_v_value_size, __pyx_v_capacity, __pyx_v_max_load_factor, __pyx_v_min_load_factor, __pyx_v_shrink_factor, __pyx_v_grow_factor, __pyx_v_rehash_threshold, __pyx_v_kv_grow_factor); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = -1; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } goto __pyx_L7_cleaned_up; __pyx_L0:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_8borghash_9HashTable_9HashTable___init__(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, PyObject *__pyx_v_items, PyObject *__pyx_v_key_size, PyObject *__pyx_v_value_size, PyObject *__pyx_v_capacity, double __pyx_v_max_load_factor, double __pyx_v_min_load_factor, double __pyx_v_shrink_factor, double __pyx_v_grow_factor, double __pyx_v_rehash_threshold, double __pyx_v_kv_grow_factor) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; size_t __pyx_t_4; 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("__init__", 0); /* "borghash/HashTable.pyx":59 * # rehashing at the same capacity. rehash_threshold decides between the two: only grow the ht if * # the used entries alone occupy more than that fraction of the load budget. * if key_size < 4: # <<<<<<<<<<<<<< * raise ValueError("key_size must be specified and must be >= 4.") * if not value_size: */ __pyx_t_1 = __Pyx_PyObject_CompareBoolLt_int_int(__pyx_v_key_size, __pyx_mstate_global->__pyx_int_4, Py_LT); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 59, __pyx_L1_error) if (unlikely(__pyx_t_1)) { /* "borghash/HashTable.pyx":60 * # the used entries alone occupy more than that fraction of the load budget. * if key_size < 4: * raise ValueError("key_size must be specified and must be >= 4.") # <<<<<<<<<<<<<< * if not value_size: * raise ValueError("value_size must be specified and must be > 0.") */ __pyx_t_3 = NULL; __pyx_t_4 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_key_size_must_be_specified_and_m}; __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __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, 60, __pyx_L1_error) /* "borghash/HashTable.pyx":59 * # rehashing at the same capacity. rehash_threshold decides between the two: only grow the ht if * # the used entries alone occupy more than that fraction of the load budget. * if key_size < 4: # <<<<<<<<<<<<<< * raise ValueError("key_size must be specified and must be >= 4.") * if not value_size: */ } /* "borghash/HashTable.pyx":61 * if key_size < 4: * raise ValueError("key_size must be specified and must be >= 4.") * if not value_size: # <<<<<<<<<<<<<< * raise ValueError("value_size must be specified and must be > 0.") * self.ksize = key_size */ { Py_ssize_t __pyx_temp = __Pyx_PyLong_IsNonZero(__pyx_v_value_size); if (unlikely(((!CYTHON_USE_PYLONG_INTERNALS) && __pyx_temp < 0))) __PYX_ERR(0, 61, __pyx_L1_error) __pyx_t_1 = (__pyx_temp != 0); } __pyx_t_5 = (!__pyx_t_1); if (unlikely(__pyx_t_5)) { /* "borghash/HashTable.pyx":62 * raise ValueError("key_size must be specified and must be >= 4.") * if not value_size: * raise ValueError("value_size must be specified and must be > 0.") # <<<<<<<<<<<<<< * self.ksize = key_size * self.vsize = value_size */ __pyx_t_3 = NULL; __pyx_t_4 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_value_size_must_be_specified_and}; __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 62, __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, 62, __pyx_L1_error) /* "borghash/HashTable.pyx":61 * if key_size < 4: * raise ValueError("key_size must be specified and must be >= 4.") * if not value_size: # <<<<<<<<<<<<<< * raise ValueError("value_size must be specified and must be > 0.") * self.ksize = key_size */ } /* "borghash/HashTable.pyx":63 * if not value_size: * raise ValueError("value_size must be specified and must be > 0.") * self.ksize = key_size # <<<<<<<<<<<<<< * self.vsize = value_size * # vvv hash table vvv */ __pyx_t_6 = __Pyx_PyLong_As_int(__pyx_v_key_size); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 63, __pyx_L1_error) __pyx_v_self->ksize = __pyx_t_6; /* "borghash/HashTable.pyx":64 * raise ValueError("value_size must be specified and must be > 0.") * self.ksize = key_size * self.vsize = value_size # <<<<<<<<<<<<<< * # vvv hash table vvv * self.max_load_factor = max_load_factor */ __pyx_t_6 = __Pyx_PyLong_As_int(__pyx_v_value_size); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 64, __pyx_L1_error) __pyx_v_self->vsize = __pyx_t_6; /* "borghash/HashTable.pyx":66 * self.vsize = value_size * # vvv hash table vvv * self.max_load_factor = max_load_factor # <<<<<<<<<<<<<< * self.min_load_factor = min_load_factor * self.shrink_factor = shrink_factor */ __pyx_v_self->max_load_factor = __pyx_v_max_load_factor; /* "borghash/HashTable.pyx":67 * # vvv hash table vvv * self.max_load_factor = max_load_factor * self.min_load_factor = min_load_factor # <<<<<<<<<<<<<< * self.shrink_factor = shrink_factor * self.grow_factor = grow_factor */ __pyx_v_self->min_load_factor = __pyx_v_min_load_factor; /* "borghash/HashTable.pyx":68 * self.max_load_factor = max_load_factor * self.min_load_factor = min_load_factor * self.shrink_factor = shrink_factor # <<<<<<<<<<<<<< * self.grow_factor = grow_factor * self.rehash_threshold = rehash_threshold */ __pyx_v_self->shrink_factor = __pyx_v_shrink_factor; /* "borghash/HashTable.pyx":69 * self.min_load_factor = min_load_factor * self.shrink_factor = shrink_factor * self.grow_factor = grow_factor # <<<<<<<<<<<<<< * self.rehash_threshold = rehash_threshold * self.initial_capacity = capacity */ __pyx_v_self->grow_factor = __pyx_v_grow_factor; /* "borghash/HashTable.pyx":70 * self.shrink_factor = shrink_factor * self.grow_factor = grow_factor * self.rehash_threshold = rehash_threshold # <<<<<<<<<<<<<< * self.initial_capacity = capacity * self.capacity = 0 */ __pyx_v_self->rehash_threshold = __pyx_v_rehash_threshold; /* "borghash/HashTable.pyx":71 * self.grow_factor = grow_factor * self.rehash_threshold = rehash_threshold * self.initial_capacity = capacity # <<<<<<<<<<<<<< * self.capacity = 0 * self.used = 0 */ __pyx_t_4 = __Pyx_PyLong_As_size_t(__pyx_v_capacity); if (unlikely((__pyx_t_4 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L1_error) __pyx_v_self->initial_capacity = __pyx_t_4; /* "borghash/HashTable.pyx":72 * self.rehash_threshold = rehash_threshold * self.initial_capacity = capacity * self.capacity = 0 # <<<<<<<<<<<<<< * self.used = 0 * self.tombstones = 0 */ __pyx_v_self->capacity = 0; /* "borghash/HashTable.pyx":73 * self.initial_capacity = capacity * self.capacity = 0 * self.used = 0 # <<<<<<<<<<<<<< * self.tombstones = 0 * self.table = NULL */ __pyx_v_self->used = 0; /* "borghash/HashTable.pyx":74 * self.capacity = 0 * self.used = 0 * self.tombstones = 0 # <<<<<<<<<<<<<< * self.table = NULL * self._resize_table(self.initial_capacity) */ __pyx_v_self->tombstones = 0; /* "borghash/HashTable.pyx":75 * self.used = 0 * self.tombstones = 0 * self.table = NULL # <<<<<<<<<<<<<< * self._resize_table(self.initial_capacity) * # ^^^ hash table ^^^ */ __pyx_v_self->table = NULL; /* "borghash/HashTable.pyx":76 * self.tombstones = 0 * self.table = NULL * self._resize_table(self.initial_capacity) # <<<<<<<<<<<<<< * # ^^^ hash table ^^^ * # vvv kv arrays vvv */ ((struct __pyx_vtabstruct_8borghash_9HashTable_HashTable *)__pyx_v_self->__pyx_vtab)->_resize_table(__pyx_v_self, __pyx_v_self->initial_capacity); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 76, __pyx_L1_error) /* "borghash/HashTable.pyx":79 * # ^^^ hash table ^^^ * # vvv kv arrays vvv * self.kv_grow_factor = kv_grow_factor # <<<<<<<<<<<<<< * self.kv_used = 0 * self.keys = NULL */ __pyx_v_self->kv_grow_factor = __pyx_v_kv_grow_factor; /* "borghash/HashTable.pyx":80 * # vvv kv arrays vvv * self.kv_grow_factor = kv_grow_factor * self.kv_used = 0 # <<<<<<<<<<<<<< * self.keys = NULL * self.values = NULL */ __pyx_v_self->kv_used = 0; /* "borghash/HashTable.pyx":81 * self.kv_grow_factor = kv_grow_factor * self.kv_used = 0 * self.keys = NULL # <<<<<<<<<<<<<< * self.values = NULL * self._resize_kv(int(self.initial_capacity * self.max_load_factor)) */ __pyx_v_self->keys = NULL; /* "borghash/HashTable.pyx":82 * self.kv_used = 0 * self.keys = NULL * self.values = NULL # <<<<<<<<<<<<<< * self._resize_kv(int(self.initial_capacity * self.max_load_factor)) * # ^^^ kv arrays ^^^ */ __pyx_v_self->values = NULL; /* "borghash/HashTable.pyx":83 * self.keys = NULL * self.values = NULL * self._resize_kv(int(self.initial_capacity * self.max_load_factor)) # <<<<<<<<<<<<<< * # ^^^ kv arrays ^^^ * # vvv stats vvv */ ((struct __pyx_vtabstruct_8borghash_9HashTable_HashTable *)__pyx_v_self->__pyx_vtab)->_resize_kv(__pyx_v_self, ((size_t)(__pyx_v_self->initial_capacity * __pyx_v_self->max_load_factor))); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 83, __pyx_L1_error) /* "borghash/HashTable.pyx":86 * # ^^^ kv arrays ^^^ * # vvv stats vvv * self.stats_get = 0 # <<<<<<<<<<<<<< * self.stats_set = 0 * self.stats_del = 0 */ __pyx_v_self->stats_get = 0; /* "borghash/HashTable.pyx":87 * # vvv stats vvv * self.stats_get = 0 * self.stats_set = 0 # <<<<<<<<<<<<<< * self.stats_del = 0 * self.stats_iter = 0 # .items() calls */ __pyx_v_self->stats_set = 0; /* "borghash/HashTable.pyx":88 * self.stats_get = 0 * self.stats_set = 0 * self.stats_del = 0 # <<<<<<<<<<<<<< * self.stats_iter = 0 # .items() calls * self.stats_lookup = 0 # _lookup_index calls */ __pyx_v_self->stats_del = 0; /* "borghash/HashTable.pyx":89 * self.stats_set = 0 * self.stats_del = 0 * self.stats_iter = 0 # .items() calls # <<<<<<<<<<<<<< * self.stats_lookup = 0 # _lookup_index calls * self.stats_linear = 0 # how many steps the linear search inside _lookup_index needed */ __pyx_v_self->stats_iter = 0; /* "borghash/HashTable.pyx":90 * self.stats_del = 0 * self.stats_iter = 0 # .items() calls * self.stats_lookup = 0 # _lookup_index calls # <<<<<<<<<<<<<< * self.stats_linear = 0 # how many steps the linear search inside _lookup_index needed * self.stats_resize_table = 0 */ __pyx_v_self->stats_lookup = 0; /* "borghash/HashTable.pyx":91 * self.stats_iter = 0 # .items() calls * self.stats_lookup = 0 # _lookup_index calls * self.stats_linear = 0 # how many steps the linear search inside _lookup_index needed # <<<<<<<<<<<<<< * self.stats_resize_table = 0 * self.stats_resize_kv = 0 */ __pyx_v_self->stats_linear = 0; /* "borghash/HashTable.pyx":92 * self.stats_lookup = 0 # _lookup_index calls * self.stats_linear = 0 # how many steps the linear search inside _lookup_index needed * self.stats_resize_table = 0 # <<<<<<<<<<<<<< * self.stats_resize_kv = 0 * # ^^^ stats ^^^ */ __pyx_v_self->stats_resize_table = 0; /* "borghash/HashTable.pyx":93 * self.stats_linear = 0 # how many steps the linear search inside _lookup_index needed * self.stats_resize_table = 0 * self.stats_resize_kv = 0 # <<<<<<<<<<<<<< * # ^^^ stats ^^^ * _fill(self, items) */ __pyx_v_self->stats_resize_kv = 0; /* "borghash/HashTable.pyx":95 * self.stats_resize_kv = 0 * # ^^^ stats ^^^ * _fill(self, items) # <<<<<<<<<<<<<< * * def __del__(self) -> None: */ __pyx_t_3 = NULL; __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_fill); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 95, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_4 = 1; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_7); assert(__pyx_t_3); PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(__pyx__function); __Pyx_DECREF_SET(__pyx_t_7, __pyx__function); __pyx_t_4 = 0; } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_3, ((PyObject *)__pyx_v_self), __pyx_v_items}; __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_7, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 95, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTable.pyx":46 * * cdef class HashTable: * def __init__(self, items=None, *, # <<<<<<<<<<<<<< * key_size: int = 0, value_size: int = 0, capacity: int = MIN_CAPACITY, * max_load_factor: float = 0.5, min_load_factor: float = 0.10, */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("borghash.HashTable.HashTable.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTable.pyx":97 * _fill(self, items) * * def __del__(self) -> None: # <<<<<<<<<<<<<< * free(self.table) * free(self.keys) */ /* Python wrapper */ static void __pyx_pw_8borghash_9HashTable_9HashTable_3__del__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_pw_8borghash_9HashTable_9HashTable_3__del__(PyObject *__pyx_v_self) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_pf_8borghash_9HashTable_9HashTable_2__del__(((struct __pyx_obj_8borghash_9HashTable_HashTable *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); } static void __pyx_pf_8borghash_9HashTable_9HashTable_2__del__(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self) { /* "borghash/HashTable.pyx":98 * * def __del__(self) -> None: * free(self.table) # <<<<<<<<<<<<<< * free(self.keys) * free(self.values) */ free(__pyx_v_self->table); /* "borghash/HashTable.pyx":99 * def __del__(self) -> None: * free(self.table) * free(self.keys) # <<<<<<<<<<<<<< * free(self.values) * */ free(__pyx_v_self->keys); /* "borghash/HashTable.pyx":100 * free(self.table) * free(self.keys) * free(self.values) # <<<<<<<<<<<<<< * * def clear(self) -> None: */ free(__pyx_v_self->values); /* "borghash/HashTable.pyx":97 * _fill(self, items) * * def __del__(self) -> None: # <<<<<<<<<<<<<< * free(self.table) * free(self.keys) */ /* function exit code */ } /* "borghash/HashTable.pyx":102 * free(self.values) * * def clear(self) -> None: # <<<<<<<<<<<<<< * """Empty the HashTable and start from scratch.""" * self.capacity = 0 */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_9HashTable_9HashTable_5clear(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_8borghash_9HashTable_9HashTable_4clear, "Empty the HashTable and start from scratch."); static PyMethodDef __pyx_mdef_8borghash_9HashTable_9HashTable_5clear = {"clear", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_9HashTable_9HashTable_5clear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8borghash_9HashTable_9HashTable_4clear}; static PyObject *__pyx_pw_8borghash_9HashTable_9HashTable_5clear(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { #if !CYTHON_VECTORCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("clear (wrapper)", 0); #if !CYTHON_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("clear", 1, 0, 0, __pyx_nargs); return NULL; } const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) return NULL; if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("clear", __pyx_kwds); return NULL;} __pyx_r = __pyx_pf_8borghash_9HashTable_9HashTable_4clear(((struct __pyx_obj_8borghash_9HashTable_HashTable *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_9HashTable_9HashTable_4clear(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("clear", 0); /* "borghash/HashTable.pyx":104 * def clear(self) -> None: * """Empty the HashTable and start from scratch.""" * self.capacity = 0 # <<<<<<<<<<<<<< * self.used = 0 * self._resize_table(self.initial_capacity) */ __pyx_v_self->capacity = 0; /* "borghash/HashTable.pyx":105 * """Empty the HashTable and start from scratch.""" * self.capacity = 0 * self.used = 0 # <<<<<<<<<<<<<< * self._resize_table(self.initial_capacity) * self.kv_used = 0 */ __pyx_v_self->used = 0; /* "borghash/HashTable.pyx":106 * self.capacity = 0 * self.used = 0 * self._resize_table(self.initial_capacity) # <<<<<<<<<<<<<< * self.kv_used = 0 * self._resize_kv(int(self.initial_capacity * self.max_load_factor)) */ ((struct __pyx_vtabstruct_8borghash_9HashTable_HashTable *)__pyx_v_self->__pyx_vtab)->_resize_table(__pyx_v_self, __pyx_v_self->initial_capacity); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 106, __pyx_L1_error) /* "borghash/HashTable.pyx":107 * self.used = 0 * self._resize_table(self.initial_capacity) * self.kv_used = 0 # <<<<<<<<<<<<<< * self._resize_kv(int(self.initial_capacity * self.max_load_factor)) * */ __pyx_v_self->kv_used = 0; /* "borghash/HashTable.pyx":108 * self._resize_table(self.initial_capacity) * self.kv_used = 0 * self._resize_kv(int(self.initial_capacity * self.max_load_factor)) # <<<<<<<<<<<<<< * * def __len__(self) -> int: */ ((struct __pyx_vtabstruct_8borghash_9HashTable_HashTable *)__pyx_v_self->__pyx_vtab)->_resize_kv(__pyx_v_self, ((size_t)(__pyx_v_self->initial_capacity * __pyx_v_self->max_load_factor))); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 108, __pyx_L1_error) /* "borghash/HashTable.pyx":102 * free(self.values) * * def clear(self) -> None: # <<<<<<<<<<<<<< * """Empty the HashTable and start from scratch.""" * self.capacity = 0 */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("borghash.HashTable.HashTable.clear", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTable.pyx":110 * self._resize_kv(int(self.initial_capacity * self.max_load_factor)) * * def __len__(self) -> int: # <<<<<<<<<<<<<< * return self.used * */ /* Python wrapper */ static Py_ssize_t __pyx_pw_8borghash_9HashTable_9HashTable_7__len__(PyObject *__pyx_v_self); /*proto*/ static Py_ssize_t __pyx_pw_8borghash_9HashTable_9HashTable_7__len__(PyObject *__pyx_v_self) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; Py_ssize_t __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_8borghash_9HashTable_9HashTable_6__len__(((struct __pyx_obj_8borghash_9HashTable_HashTable *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static Py_ssize_t __pyx_pf_8borghash_9HashTable_9HashTable_6__len__(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self) { Py_ssize_t __pyx_r; /* "borghash/HashTable.pyx":111 * * def __len__(self) -> int: * return self.used # <<<<<<<<<<<<<< * * cdef size_t _get_index(self, uint8_t* key): */ { __pyx_r = __pyx_v_self->used; } goto __pyx_L0; /* "borghash/HashTable.pyx":110 * self._resize_kv(int(self.initial_capacity * self.max_load_factor)) * * def __len__(self) -> int: # <<<<<<<<<<<<<< * return self.used * */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "borghash/HashTable.pyx":113 * return self.used * * cdef size_t _get_index(self, uint8_t* key): # <<<<<<<<<<<<<< * """Key must be perfectly random bytes, so we don't need a hash function here.""" * cdef uint32_t key32 = (key[0] << 24) | (key[1] << 16) | (key[2] << 8) | key[3] */ static size_t __pyx_f_8borghash_9HashTable_9HashTable__get_index(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, uint8_t *__pyx_v_key) { uint32_t __pyx_v_key32; size_t __pyx_r; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; /* "borghash/HashTable.pyx":115 * cdef size_t _get_index(self, uint8_t* key): * """Key must be perfectly random bytes, so we don't need a hash function here.""" * cdef uint32_t key32 = (key[0] << 24) | (key[1] << 16) | (key[2] << 8) | key[3] # <<<<<<<<<<<<<< * return key32 % self.capacity * */ __pyx_v_key32 = (((((__pyx_v_key[0]) << 24) | ((__pyx_v_key[1]) << 16)) | ((__pyx_v_key[2]) << 8)) | (__pyx_v_key[3])); /* "borghash/HashTable.pyx":116 * """Key must be perfectly random bytes, so we don't need a hash function here.""" * cdef uint32_t key32 = (key[0] << 24) | (key[1] << 16) | (key[2] << 8) | key[3] * return key32 % self.capacity # <<<<<<<<<<<<<< * * cdef int _lookup_index(self, uint8_t* key_ptr, size_t* index_ptr, size_t* tombstone_ptr = NULL): */ if (unlikely(__pyx_v_self->capacity == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); __PYX_ERR(0, 116, __pyx_L1_error) } { __pyx_r = (__pyx_v_key32 % __pyx_v_self->capacity); } goto __pyx_L0; /* "borghash/HashTable.pyx":113 * return self.used * * cdef size_t _get_index(self, uint8_t* key): # <<<<<<<<<<<<<< * """Key must be perfectly random bytes, so we don't need a hash function here.""" * cdef uint32_t key32 = (key[0] << 24) | (key[1] << 16) | (key[2] << 8) | key[3] */ /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("borghash.HashTable.HashTable._get_index", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; return __pyx_r; } /* "borghash/HashTable.pyx":118 * return key32 % self.capacity * * cdef int _lookup_index(self, uint8_t* key_ptr, size_t* index_ptr, size_t* tombstone_ptr = NULL): # <<<<<<<<<<<<<< * """ * search for a specific key. */ static int __pyx_f_8borghash_9HashTable_9HashTable__lookup_index(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, uint8_t *__pyx_v_key_ptr, size_t *__pyx_v_index_ptr, struct __pyx_opt_args_8borghash_9HashTable_9HashTable__lookup_index *__pyx_optional_args) { size_t *__pyx_v_tombstone_ptr = ((size_t *)NULL); size_t __pyx_v_index; size_t __pyx_v_first_tombstone; uint32_t __pyx_v_kv_index; int __pyx_r; size_t __pyx_t_1; uint32_t __pyx_t_2; int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; if (__pyx_optional_args) { if (__pyx_optional_args->__pyx_n > 0) { __pyx_v_tombstone_ptr = __pyx_optional_args->tombstone_ptr; } } /* "borghash/HashTable.pyx":126 * tombstone bucket that was passed on the way, or to self.capacity if there was none. * """ * cdef size_t index = self._get_index(key_ptr) # <<<<<<<<<<<<<< * cdef size_t first_tombstone = self.capacity # == "none", indices are < self.capacity * cdef uint32_t kv_index */ __pyx_t_1 = ((struct __pyx_vtabstruct_8borghash_9HashTable_HashTable *)__pyx_v_self->__pyx_vtab)->_get_index(__pyx_v_self, __pyx_v_key_ptr); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 126, __pyx_L1_error) __pyx_v_index = __pyx_t_1; /* "borghash/HashTable.pyx":127 * """ * cdef size_t index = self._get_index(key_ptr) * cdef size_t first_tombstone = self.capacity # == "none", indices are < self.capacity # <<<<<<<<<<<<<< * cdef uint32_t kv_index * self.stats_lookup += 1 */ __pyx_t_1 = __pyx_v_self->capacity; __pyx_v_first_tombstone = __pyx_t_1; /* "borghash/HashTable.pyx":129 * cdef size_t first_tombstone = self.capacity # == "none", indices are < self.capacity * cdef uint32_t kv_index * self.stats_lookup += 1 # <<<<<<<<<<<<<< * while (kv_index := self.table[index]) != FREE_BUCKET: * self.stats_linear += 1 */ __pyx_v_self->stats_lookup = (__pyx_v_self->stats_lookup + 1); /* "borghash/HashTable.pyx":130 * cdef uint32_t kv_index * self.stats_lookup += 1 * while (kv_index := self.table[index]) != FREE_BUCKET: # <<<<<<<<<<<<<< * self.stats_linear += 1 * if kv_index == TOMBSTONE_BUCKET: */ while (1) { __pyx_t_2 = (__pyx_v_self->table[__pyx_v_index]); __pyx_v_kv_index = __pyx_t_2; __pyx_t_3 = (__pyx_t_2 != __pyx_v_8borghash_9HashTable_FREE_BUCKET); if (!__pyx_t_3) break; /* "borghash/HashTable.pyx":131 * self.stats_lookup += 1 * while (kv_index := self.table[index]) != FREE_BUCKET: * self.stats_linear += 1 # <<<<<<<<<<<<<< * if kv_index == TOMBSTONE_BUCKET: * if first_tombstone == self.capacity: */ __pyx_v_self->stats_linear = (__pyx_v_self->stats_linear + 1); /* "borghash/HashTable.pyx":132 * while (kv_index := self.table[index]) != FREE_BUCKET: * self.stats_linear += 1 * if kv_index == TOMBSTONE_BUCKET: # <<<<<<<<<<<<<< * if first_tombstone == self.capacity: * first_tombstone = index */ __pyx_t_3 = (__pyx_v_kv_index == __pyx_v_8borghash_9HashTable_TOMBSTONE_BUCKET); if (__pyx_t_3) { /* "borghash/HashTable.pyx":133 * self.stats_linear += 1 * if kv_index == TOMBSTONE_BUCKET: * if first_tombstone == self.capacity: # <<<<<<<<<<<<<< * first_tombstone = index * elif memcmp(self.keys + kv_index * self.ksize, key_ptr, self.ksize) == 0: */ __pyx_t_3 = (__pyx_v_first_tombstone == __pyx_v_self->capacity); if (__pyx_t_3) { /* "borghash/HashTable.pyx":134 * if kv_index == TOMBSTONE_BUCKET: * if first_tombstone == self.capacity: * first_tombstone = index # <<<<<<<<<<<<<< * elif memcmp(self.keys + kv_index * self.ksize, key_ptr, self.ksize) == 0: * if index_ptr: */ __pyx_v_first_tombstone = __pyx_v_index; /* "borghash/HashTable.pyx":133 * self.stats_linear += 1 * if kv_index == TOMBSTONE_BUCKET: * if first_tombstone == self.capacity: # <<<<<<<<<<<<<< * first_tombstone = index * elif memcmp(self.keys + kv_index * self.ksize, key_ptr, self.ksize) == 0: */ } /* "borghash/HashTable.pyx":132 * while (kv_index := self.table[index]) != FREE_BUCKET: * self.stats_linear += 1 * if kv_index == TOMBSTONE_BUCKET: # <<<<<<<<<<<<<< * if first_tombstone == self.capacity: * first_tombstone = index */ goto __pyx_L5; } /* "borghash/HashTable.pyx":135 * if first_tombstone == self.capacity: * first_tombstone = index * elif memcmp(self.keys + kv_index * self.ksize, key_ptr, self.ksize) == 0: # <<<<<<<<<<<<<< * if index_ptr: * index_ptr[0] = index */ __pyx_t_3 = (memcmp((__pyx_v_self->keys + (__pyx_v_kv_index * __pyx_v_self->ksize)), __pyx_v_key_ptr, __pyx_v_self->ksize) == 0); if (__pyx_t_3) { /* "borghash/HashTable.pyx":136 * first_tombstone = index * elif memcmp(self.keys + kv_index * self.ksize, key_ptr, self.ksize) == 0: * if index_ptr: # <<<<<<<<<<<<<< * index_ptr[0] = index * return 1 # found */ __pyx_t_3 = (__pyx_v_index_ptr != 0); if (__pyx_t_3) { /* "borghash/HashTable.pyx":137 * elif memcmp(self.keys + kv_index * self.ksize, key_ptr, self.ksize) == 0: * if index_ptr: * index_ptr[0] = index # <<<<<<<<<<<<<< * return 1 # found * index = (index + 1) % self.capacity */ (__pyx_v_index_ptr[0]) = __pyx_v_index; /* "borghash/HashTable.pyx":136 * first_tombstone = index * elif memcmp(self.keys + kv_index * self.ksize, key_ptr, self.ksize) == 0: * if index_ptr: # <<<<<<<<<<<<<< * index_ptr[0] = index * return 1 # found */ } /* "borghash/HashTable.pyx":138 * if index_ptr: * index_ptr[0] = index * return 1 # found # <<<<<<<<<<<<<< * index = (index + 1) % self.capacity * if index_ptr: */ { __pyx_r = 1; } goto __pyx_L0; /* "borghash/HashTable.pyx":135 * if first_tombstone == self.capacity: * first_tombstone = index * elif memcmp(self.keys + kv_index * self.ksize, key_ptr, self.ksize) == 0: # <<<<<<<<<<<<<< * if index_ptr: * index_ptr[0] = index */ } __pyx_L5:; /* "borghash/HashTable.pyx":139 * index_ptr[0] = index * return 1 # found * index = (index + 1) % self.capacity # <<<<<<<<<<<<<< * if index_ptr: * index_ptr[0] = index */ __pyx_t_1 = (__pyx_v_index + 1); if (unlikely(__pyx_v_self->capacity == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); __PYX_ERR(0, 139, __pyx_L1_error) } __pyx_v_index = (__pyx_t_1 % __pyx_v_self->capacity); } /* "borghash/HashTable.pyx":140 * return 1 # found * index = (index + 1) % self.capacity * if index_ptr: # <<<<<<<<<<<<<< * index_ptr[0] = index * if tombstone_ptr: */ __pyx_t_3 = (__pyx_v_index_ptr != 0); if (__pyx_t_3) { /* "borghash/HashTable.pyx":141 * index = (index + 1) % self.capacity * if index_ptr: * index_ptr[0] = index # <<<<<<<<<<<<<< * if tombstone_ptr: * tombstone_ptr[0] = first_tombstone */ (__pyx_v_index_ptr[0]) = __pyx_v_index; /* "borghash/HashTable.pyx":140 * return 1 # found * index = (index + 1) % self.capacity * if index_ptr: # <<<<<<<<<<<<<< * index_ptr[0] = index * if tombstone_ptr: */ } /* "borghash/HashTable.pyx":142 * if index_ptr: * index_ptr[0] = index * if tombstone_ptr: # <<<<<<<<<<<<<< * tombstone_ptr[0] = first_tombstone * return 0 # not found */ __pyx_t_3 = (__pyx_v_tombstone_ptr != 0); if (__pyx_t_3) { /* "borghash/HashTable.pyx":143 * index_ptr[0] = index * if tombstone_ptr: * tombstone_ptr[0] = first_tombstone # <<<<<<<<<<<<<< * return 0 # not found * */ (__pyx_v_tombstone_ptr[0]) = __pyx_v_first_tombstone; /* "borghash/HashTable.pyx":142 * if index_ptr: * index_ptr[0] = index * if tombstone_ptr: # <<<<<<<<<<<<<< * tombstone_ptr[0] = first_tombstone * return 0 # not found */ } /* "borghash/HashTable.pyx":144 * if tombstone_ptr: * tombstone_ptr[0] = first_tombstone * return 0 # not found # <<<<<<<<<<<<<< * * def __setitem__(self, key: bytes, value: bytes) -> None: */ { __pyx_r = 0; } goto __pyx_L0; /* "borghash/HashTable.pyx":118 * return key32 % self.capacity * * cdef int _lookup_index(self, uint8_t* key_ptr, size_t* index_ptr, size_t* tombstone_ptr = NULL): # <<<<<<<<<<<<<< * """ * search for a specific key. */ /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("borghash.HashTable.HashTable._lookup_index", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; return __pyx_r; } /* "borghash/HashTable.pyx":146 * return 0 # not found * * def __setitem__(self, key: bytes, value: bytes) -> None: # <<<<<<<<<<<<<< * if len(key) != self.ksize or len(value) != self.vsize: * raise ValueError("Key or value size does not match the defined sizes") */ /* Python wrapper */ static int __pyx_pw_8borghash_9HashTable_9HashTable_9__setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_8borghash_9HashTable_9HashTable_9__setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_key), (&PyBytes_Type), 0, "key", 2))) __PYX_ERR(0, 146, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_value), (&PyBytes_Type), 0, "value", 2))) __PYX_ERR(0, 146, __pyx_L1_error) __pyx_r = __pyx_pf_8borghash_9HashTable_9HashTable_8__setitem__(((struct __pyx_obj_8borghash_9HashTable_HashTable *)__pyx_v_self), ((PyObject*)__pyx_v_key), ((PyObject*)__pyx_v_value)); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = -1; goto __pyx_L5_cleaned_up; __pyx_L0:; __pyx_L5_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_8borghash_9HashTable_9HashTable_8__setitem__(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value) { uint8_t *__pyx_v_key_ptr; uint8_t *__pyx_v_value_ptr; uint32_t __pyx_v_kv_index; size_t __pyx_v_index; size_t __pyx_v_tombstone_index; int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; Py_ssize_t __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; size_t __pyx_t_6; uint8_t *__pyx_t_7; int __pyx_t_8; struct __pyx_opt_args_8borghash_9HashTable_9HashTable__lookup_index __pyx_t_9; uint32_t __pyx_t_10; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setitem__", 0); /* "borghash/HashTable.pyx":147 * * def __setitem__(self, key: bytes, value: bytes) -> None: * if len(key) != self.ksize or len(value) != self.vsize: # <<<<<<<<<<<<<< * raise ValueError("Key or value size does not match the defined sizes") * */ __pyx_t_2 = __Pyx_PyBytes_GET_SIZE(__pyx_v_key); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 147, __pyx_L1_error) __pyx_t_3 = (__pyx_t_2 != __pyx_v_self->ksize); if (!__pyx_t_3) { } else { __pyx_t_1 = __pyx_t_3; goto __pyx_L4_bool_binop_done; } __pyx_t_2 = __Pyx_PyBytes_GET_SIZE(__pyx_v_value); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 147, __pyx_L1_error) __pyx_t_3 = (__pyx_t_2 != __pyx_v_self->vsize); __pyx_t_1 = __pyx_t_3; __pyx_L4_bool_binop_done:; if (unlikely(__pyx_t_1)) { /* "borghash/HashTable.pyx":148 * def __setitem__(self, key: bytes, value: bytes) -> None: * if len(key) != self.ksize or len(value) != self.vsize: * raise ValueError("Key or value size does not match the defined sizes") # <<<<<<<<<<<<<< * * cdef uint8_t* key_ptr = key */ __pyx_t_5 = NULL; __pyx_t_6 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_Key_or_value_size_does_not_match}; __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 148, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); } __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 148, __pyx_L1_error) /* "borghash/HashTable.pyx":147 * * def __setitem__(self, key: bytes, value: bytes) -> None: * if len(key) != self.ksize or len(value) != self.vsize: # <<<<<<<<<<<<<< * raise ValueError("Key or value size does not match the defined sizes") * */ } /* "borghash/HashTable.pyx":150 * raise ValueError("Key or value size does not match the defined sizes") * * cdef uint8_t* key_ptr = key # <<<<<<<<<<<<<< * cdef uint8_t* value_ptr = value * cdef uint32_t kv_index */ __pyx_t_7 = __Pyx_PyBytes_AsWritableUString(__pyx_v_key); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(0, 150, __pyx_L1_error) __pyx_v_key_ptr = ((uint8_t *)__pyx_t_7); /* "borghash/HashTable.pyx":151 * * cdef uint8_t* key_ptr = key * cdef uint8_t* value_ptr = value # <<<<<<<<<<<<<< * cdef uint32_t kv_index * cdef size_t index, tombstone_index */ __pyx_t_7 = __Pyx_PyBytes_AsWritableUString(__pyx_v_value); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(0, 151, __pyx_L1_error) __pyx_v_value_ptr = ((uint8_t *)__pyx_t_7); /* "borghash/HashTable.pyx":154 * cdef uint32_t kv_index * cdef size_t index, tombstone_index * self.stats_set += 1 # <<<<<<<<<<<<<< * if self._lookup_index(key_ptr, &index, &tombstone_index): * kv_index = self.table[index] */ __pyx_v_self->stats_set = (__pyx_v_self->stats_set + 1); /* "borghash/HashTable.pyx":155 * cdef size_t index, tombstone_index * self.stats_set += 1 * if self._lookup_index(key_ptr, &index, &tombstone_index): # <<<<<<<<<<<<<< * kv_index = self.table[index] * memcpy(self.values + kv_index * self.vsize, value_ptr, self.vsize) */ __pyx_t_9.__pyx_n = 1; __pyx_t_9.tombstone_ptr = (&__pyx_v_tombstone_index); __pyx_t_8 = ((struct __pyx_vtabstruct_8borghash_9HashTable_HashTable *)__pyx_v_self->__pyx_vtab)->_lookup_index(__pyx_v_self, __pyx_v_key_ptr, (&__pyx_v_index), &__pyx_t_9); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 155, __pyx_L1_error) __pyx_t_1 = (__pyx_t_8 != 0); if (__pyx_t_1) { /* "borghash/HashTable.pyx":156 * self.stats_set += 1 * if self._lookup_index(key_ptr, &index, &tombstone_index): * kv_index = self.table[index] # <<<<<<<<<<<<<< * memcpy(self.values + kv_index * self.vsize, value_ptr, self.vsize) * return */ __pyx_v_kv_index = (__pyx_v_self->table[__pyx_v_index]); /* "borghash/HashTable.pyx":157 * if self._lookup_index(key_ptr, &index, &tombstone_index): * kv_index = self.table[index] * memcpy(self.values + kv_index * self.vsize, value_ptr, self.vsize) # <<<<<<<<<<<<<< * return * */ (void)(memcpy((__pyx_v_self->values + (__pyx_v_kv_index * __pyx_v_self->vsize)), __pyx_v_value_ptr, __pyx_v_self->vsize)); /* "borghash/HashTable.pyx":158 * kv_index = self.table[index] * memcpy(self.values + kv_index * self.vsize, value_ptr, self.vsize) * return # <<<<<<<<<<<<<< * * if self.kv_used >= self.kv_capacity: */ { __pyx_r = 0; } goto __pyx_L0; /* "borghash/HashTable.pyx":155 * cdef size_t index, tombstone_index * self.stats_set += 1 * if self._lookup_index(key_ptr, &index, &tombstone_index): # <<<<<<<<<<<<<< * kv_index = self.table[index] * memcpy(self.values + kv_index * self.vsize, value_ptr, self.vsize) */ } /* "borghash/HashTable.pyx":160 * return * * if self.kv_used >= self.kv_capacity: # <<<<<<<<<<<<<< * self._resize_kv(int(self.kv_capacity * self.kv_grow_factor)) * if self.kv_used >= self.kv_capacity: */ __pyx_t_1 = (__pyx_v_self->kv_used >= __pyx_v_self->kv_capacity); if (__pyx_t_1) { /* "borghash/HashTable.pyx":161 * * if self.kv_used >= self.kv_capacity: * self._resize_kv(int(self.kv_capacity * self.kv_grow_factor)) # <<<<<<<<<<<<<< * if self.kv_used >= self.kv_capacity: * # Should never happen. See "RESERVED" constant - we allow almost 4Gi kv entries. */ ((struct __pyx_vtabstruct_8borghash_9HashTable_HashTable *)__pyx_v_self->__pyx_vtab)->_resize_kv(__pyx_v_self, ((size_t)(__pyx_v_self->kv_capacity * __pyx_v_self->kv_grow_factor))); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 161, __pyx_L1_error) /* "borghash/HashTable.pyx":160 * return * * if self.kv_used >= self.kv_capacity: # <<<<<<<<<<<<<< * self._resize_kv(int(self.kv_capacity * self.kv_grow_factor)) * if self.kv_used >= self.kv_capacity: */ } /* "borghash/HashTable.pyx":162 * if self.kv_used >= self.kv_capacity: * self._resize_kv(int(self.kv_capacity * self.kv_grow_factor)) * if self.kv_used >= self.kv_capacity: # <<<<<<<<<<<<<< * # Should never happen. See "RESERVED" constant - we allow almost 4Gi kv entries. * # For a typical 256-bit key and a small 32-bit value that would already consume 176GiB+ */ __pyx_t_1 = (__pyx_v_self->kv_used >= __pyx_v_self->kv_capacity); if (unlikely(__pyx_t_1)) { /* "borghash/HashTable.pyx":166 * # For a typical 256-bit key and a small 32-bit value that would already consume 176GiB+ * # memory (plus spikes to even more when hashtable or kv arrays get resized). * raise RuntimeError("KV array is full") # <<<<<<<<<<<<<< * * kv_index = self.kv_used */ __pyx_t_5 = NULL; __pyx_t_6 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_KV_array_is_full}; __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_RuntimeError)), __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 166, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); } __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 166, __pyx_L1_error) /* "borghash/HashTable.pyx":162 * if self.kv_used >= self.kv_capacity: * self._resize_kv(int(self.kv_capacity * self.kv_grow_factor)) * if self.kv_used >= self.kv_capacity: # <<<<<<<<<<<<<< * # Should never happen. See "RESERVED" constant - we allow almost 4Gi kv entries. * # For a typical 256-bit key and a small 32-bit value that would already consume 176GiB+ */ } /* "borghash/HashTable.pyx":168 * raise RuntimeError("KV array is full") * * kv_index = self.kv_used # <<<<<<<<<<<<<< * memcpy(self.keys + kv_index * self.ksize, key_ptr, self.ksize) * memcpy(self.values + kv_index * self.vsize, value_ptr, self.vsize) */ __pyx_t_10 = __pyx_v_self->kv_used; __pyx_v_kv_index = __pyx_t_10; /* "borghash/HashTable.pyx":169 * * kv_index = self.kv_used * memcpy(self.keys + kv_index * self.ksize, key_ptr, self.ksize) # <<<<<<<<<<<<<< * memcpy(self.values + kv_index * self.vsize, value_ptr, self.vsize) * self.kv_used += 1 */ (void)(memcpy((__pyx_v_self->keys + (__pyx_v_kv_index * __pyx_v_self->ksize)), __pyx_v_key_ptr, __pyx_v_self->ksize)); /* "borghash/HashTable.pyx":170 * kv_index = self.kv_used * memcpy(self.keys + kv_index * self.ksize, key_ptr, self.ksize) * memcpy(self.values + kv_index * self.vsize, value_ptr, self.vsize) # <<<<<<<<<<<<<< * self.kv_used += 1 * */ (void)(memcpy((__pyx_v_self->values + (__pyx_v_kv_index * __pyx_v_self->vsize)), __pyx_v_value_ptr, __pyx_v_self->vsize)); /* "borghash/HashTable.pyx":171 * memcpy(self.keys + kv_index * self.ksize, key_ptr, self.ksize) * memcpy(self.values + kv_index * self.vsize, value_ptr, self.vsize) * self.kv_used += 1 # <<<<<<<<<<<<<< * * self.used += 1 */ __pyx_v_self->kv_used = (__pyx_v_self->kv_used + 1); /* "borghash/HashTable.pyx":173 * self.kv_used += 1 * * self.used += 1 # <<<<<<<<<<<<<< * if tombstone_index < self.capacity: # prefer a tombstone bucket, it is dead weight otherwise * index = tombstone_index */ __pyx_v_self->used = (__pyx_v_self->used + 1); /* "borghash/HashTable.pyx":174 * * self.used += 1 * if tombstone_index < self.capacity: # prefer a tombstone bucket, it is dead weight otherwise # <<<<<<<<<<<<<< * index = tombstone_index * self.tombstones -= 1 */ __pyx_t_1 = (__pyx_v_tombstone_index < __pyx_v_self->capacity); if (__pyx_t_1) { /* "borghash/HashTable.pyx":175 * self.used += 1 * if tombstone_index < self.capacity: # prefer a tombstone bucket, it is dead weight otherwise * index = tombstone_index # <<<<<<<<<<<<<< * self.tombstones -= 1 * self.table[index] = kv_index # _lookup_index has set index to a free bucket */ __pyx_v_index = __pyx_v_tombstone_index; /* "borghash/HashTable.pyx":176 * if tombstone_index < self.capacity: # prefer a tombstone bucket, it is dead weight otherwise * index = tombstone_index * self.tombstones -= 1 # <<<<<<<<<<<<<< * self.table[index] = kv_index # _lookup_index has set index to a free bucket * */ __pyx_v_self->tombstones = (__pyx_v_self->tombstones - 1); /* "borghash/HashTable.pyx":174 * * self.used += 1 * if tombstone_index < self.capacity: # prefer a tombstone bucket, it is dead weight otherwise # <<<<<<<<<<<<<< * index = tombstone_index * self.tombstones -= 1 */ } /* "borghash/HashTable.pyx":177 * index = tombstone_index * self.tombstones -= 1 * self.table[index] = kv_index # _lookup_index has set index to a free bucket # <<<<<<<<<<<<<< * * if self.used + self.tombstones > self.capacity * self.max_load_factor: */ (__pyx_v_self->table[__pyx_v_index]) = __pyx_v_kv_index; /* "borghash/HashTable.pyx":179 * self.table[index] = kv_index # _lookup_index has set index to a free bucket * * if self.used + self.tombstones > self.capacity * self.max_load_factor: # <<<<<<<<<<<<<< * if self.used > self.capacity * self.max_load_factor * self.rehash_threshold: * self._resize_table(int(self.capacity * self.grow_factor)) */ __pyx_t_1 = ((__pyx_v_self->used + __pyx_v_self->tombstones) > (__pyx_v_self->capacity * __pyx_v_self->max_load_factor)); if (__pyx_t_1) { /* "borghash/HashTable.pyx":180 * * if self.used + self.tombstones > self.capacity * self.max_load_factor: * if self.used > self.capacity * self.max_load_factor * self.rehash_threshold: # <<<<<<<<<<<<<< * self._resize_table(int(self.capacity * self.grow_factor)) * else: # mostly tombstones: rehashing at the same capacity drops them */ __pyx_t_1 = (__pyx_v_self->used > ((__pyx_v_self->capacity * __pyx_v_self->max_load_factor) * __pyx_v_self->rehash_threshold)); if (__pyx_t_1) { /* "borghash/HashTable.pyx":181 * if self.used + self.tombstones > self.capacity * self.max_load_factor: * if self.used > self.capacity * self.max_load_factor * self.rehash_threshold: * self._resize_table(int(self.capacity * self.grow_factor)) # <<<<<<<<<<<<<< * else: # mostly tombstones: rehashing at the same capacity drops them * self._resize_table(self.capacity) */ ((struct __pyx_vtabstruct_8borghash_9HashTable_HashTable *)__pyx_v_self->__pyx_vtab)->_resize_table(__pyx_v_self, ((size_t)(__pyx_v_self->capacity * __pyx_v_self->grow_factor))); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 181, __pyx_L1_error) /* "borghash/HashTable.pyx":180 * * if self.used + self.tombstones > self.capacity * self.max_load_factor: * if self.used > self.capacity * self.max_load_factor * self.rehash_threshold: # <<<<<<<<<<<<<< * self._resize_table(int(self.capacity * self.grow_factor)) * else: # mostly tombstones: rehashing at the same capacity drops them */ goto __pyx_L11; } /* "borghash/HashTable.pyx":183 * self._resize_table(int(self.capacity * self.grow_factor)) * else: # mostly tombstones: rehashing at the same capacity drops them * self._resize_table(self.capacity) # <<<<<<<<<<<<<< * * def __contains__(self, key: bytes) -> bool: */ /*else*/ { ((struct __pyx_vtabstruct_8borghash_9HashTable_HashTable *)__pyx_v_self->__pyx_vtab)->_resize_table(__pyx_v_self, __pyx_v_self->capacity); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 183, __pyx_L1_error) } __pyx_L11:; /* "borghash/HashTable.pyx":179 * self.table[index] = kv_index # _lookup_index has set index to a free bucket * * if self.used + self.tombstones > self.capacity * self.max_load_factor: # <<<<<<<<<<<<<< * if self.used > self.capacity * self.max_load_factor * self.rehash_threshold: * self._resize_table(int(self.capacity * self.grow_factor)) */ } /* "borghash/HashTable.pyx":146 * return 0 # not found * * def __setitem__(self, key: bytes, value: bytes) -> None: # <<<<<<<<<<<<<< * if len(key) != self.ksize or len(value) != self.vsize: * raise ValueError("Key or value size does not match the defined sizes") */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("borghash.HashTable.HashTable.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTable.pyx":185 * self._resize_table(self.capacity) * * def __contains__(self, key: bytes) -> bool: # <<<<<<<<<<<<<< * if len(key) != self.ksize: * raise ValueError("Key size does not match the defined size") */ /* Python wrapper */ static int __pyx_pw_8borghash_9HashTable_9HashTable_11__contains__(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/ static int __pyx_pw_8borghash_9HashTable_9HashTable_11__contains__(PyObject *__pyx_v_self, PyObject *__pyx_v_key) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__contains__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_key), (&PyBytes_Type), 0, "key", 2))) __PYX_ERR(0, 185, __pyx_L1_error) __pyx_r = __pyx_pf_8borghash_9HashTable_9HashTable_10__contains__(((struct __pyx_obj_8borghash_9HashTable_HashTable *)__pyx_v_self), ((PyObject*)__pyx_v_key)); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = -1; goto __pyx_L5_cleaned_up; __pyx_L0:; __pyx_L5_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_8borghash_9HashTable_9HashTable_10__contains__(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, PyObject *__pyx_v_key) { int __pyx_r; __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; size_t __pyx_t_5; uint8_t *__pyx_t_6; int __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__contains__", 0); /* "borghash/HashTable.pyx":186 * * def __contains__(self, key: bytes) -> bool: * if len(key) != self.ksize: # <<<<<<<<<<<<<< * raise ValueError("Key size does not match the defined size") * return bool(self._lookup_index( key, NULL)) */ __pyx_t_1 = __Pyx_PyBytes_GET_SIZE(__pyx_v_key); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 186, __pyx_L1_error) __pyx_t_2 = (__pyx_t_1 != __pyx_v_self->ksize); if (unlikely(__pyx_t_2)) { /* "borghash/HashTable.pyx":187 * def __contains__(self, key: bytes) -> bool: * if len(key) != self.ksize: * raise ValueError("Key size does not match the defined size") # <<<<<<<<<<<<<< * return bool(self._lookup_index( key, NULL)) * */ __pyx_t_4 = NULL; __pyx_t_5 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_Key_size_does_not_match_the_defi}; __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 187, __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, 187, __pyx_L1_error) /* "borghash/HashTable.pyx":186 * * def __contains__(self, key: bytes) -> bool: * if len(key) != self.ksize: # <<<<<<<<<<<<<< * raise ValueError("Key size does not match the defined size") * return bool(self._lookup_index( key, NULL)) */ } /* "borghash/HashTable.pyx":188 * if len(key) != self.ksize: * raise ValueError("Key size does not match the defined size") * return bool(self._lookup_index( key, NULL)) # <<<<<<<<<<<<<< * * def __getitem__(self, key: bytes) -> bytes: */ __pyx_t_6 = __Pyx_PyBytes_AsWritableUString(__pyx_v_key); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 188, __pyx_L1_error) __pyx_t_7 = ((struct __pyx_vtabstruct_8borghash_9HashTable_HashTable *)__pyx_v_self->__pyx_vtab)->_lookup_index(__pyx_v_self, ((uint8_t *)__pyx_t_6), NULL, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 188, __pyx_L1_error) { __pyx_r = (!(!(__pyx_t_7 != 0))); } goto __pyx_L0; /* "borghash/HashTable.pyx":185 * self._resize_table(self.capacity) * * def __contains__(self, key: bytes) -> bool: # <<<<<<<<<<<<<< * if len(key) != self.ksize: * raise ValueError("Key size does not match the defined size") */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("borghash.HashTable.HashTable.__contains__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTable.pyx":190 * return bool(self._lookup_index( key, NULL)) * * def __getitem__(self, key: bytes) -> bytes: # <<<<<<<<<<<<<< * if len(key) != self.ksize: * raise ValueError("Key size does not match the defined size") */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_9HashTable_9HashTable_13__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/ static PyObject *__pyx_pw_8borghash_9HashTable_9HashTable_13__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_key), (&PyBytes_Type), 0, "key", 2))) __PYX_ERR(0, 190, __pyx_L1_error) __pyx_r = __pyx_pf_8borghash_9HashTable_9HashTable_12__getitem__(((struct __pyx_obj_8borghash_9HashTable_HashTable *)__pyx_v_self), ((PyObject*)__pyx_v_key)); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; goto __pyx_L5_cleaned_up; __pyx_L0:; __pyx_L5_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_9HashTable_9HashTable_12__getitem__(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, PyObject *__pyx_v_key) { uint32_t __pyx_v_kv_index; size_t __pyx_v_index; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; size_t __pyx_t_5; uint8_t *__pyx_t_6; int __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__getitem__", 0); /* "borghash/HashTable.pyx":191 * * def __getitem__(self, key: bytes) -> bytes: * if len(key) != self.ksize: # <<<<<<<<<<<<<< * raise ValueError("Key size does not match the defined size") * cdef uint32_t kv_index */ __pyx_t_1 = __Pyx_PyBytes_GET_SIZE(__pyx_v_key); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 191, __pyx_L1_error) __pyx_t_2 = (__pyx_t_1 != __pyx_v_self->ksize); if (unlikely(__pyx_t_2)) { /* "borghash/HashTable.pyx":192 * def __getitem__(self, key: bytes) -> bytes: * if len(key) != self.ksize: * raise ValueError("Key size does not match the defined size") # <<<<<<<<<<<<<< * cdef uint32_t kv_index * cdef size_t index */ __pyx_t_4 = NULL; __pyx_t_5 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_Key_size_does_not_match_the_defi}; __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 192, __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, 192, __pyx_L1_error) /* "borghash/HashTable.pyx":191 * * def __getitem__(self, key: bytes) -> bytes: * if len(key) != self.ksize: # <<<<<<<<<<<<<< * raise ValueError("Key size does not match the defined size") * cdef uint32_t kv_index */ } /* "borghash/HashTable.pyx":195 * cdef uint32_t kv_index * cdef size_t index * self.stats_get += 1 # <<<<<<<<<<<<<< * if self._lookup_index( key, &index): * kv_index = self.table[index] */ __pyx_v_self->stats_get = (__pyx_v_self->stats_get + 1); /* "borghash/HashTable.pyx":196 * cdef size_t index * self.stats_get += 1 * if self._lookup_index( key, &index): # <<<<<<<<<<<<<< * kv_index = self.table[index] * return self.values[kv_index * self.vsize:(kv_index + 1) * self.vsize] */ __pyx_t_6 = __Pyx_PyBytes_AsWritableUString(__pyx_v_key); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 196, __pyx_L1_error) __pyx_t_7 = ((struct __pyx_vtabstruct_8borghash_9HashTable_HashTable *)__pyx_v_self->__pyx_vtab)->_lookup_index(__pyx_v_self, ((uint8_t *)__pyx_t_6), (&__pyx_v_index), NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 196, __pyx_L1_error) __pyx_t_2 = (__pyx_t_7 != 0); if (likely(__pyx_t_2)) { /* "borghash/HashTable.pyx":197 * self.stats_get += 1 * if self._lookup_index( key, &index): * kv_index = self.table[index] # <<<<<<<<<<<<<< * return self.values[kv_index * self.vsize:(kv_index + 1) * self.vsize] * else: */ __pyx_v_kv_index = (__pyx_v_self->table[__pyx_v_index]); /* "borghash/HashTable.pyx":198 * if self._lookup_index( key, &index): * kv_index = self.table[index] * return self.values[kv_index * self.vsize:(kv_index + 1) * self.vsize] # <<<<<<<<<<<<<< * else: * raise KeyError("Key not found") */ __pyx_t_3 = __Pyx_PyBytes_FromStringAndSize(((char const *)__pyx_v_self->values) + (__pyx_v_kv_index * __pyx_v_self->vsize), ((__pyx_v_kv_index + 1) * __pyx_v_self->vsize) - (__pyx_v_kv_index * __pyx_v_self->vsize)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 198, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __pyx_r = __pyx_t_3; } __Pyx_XDECREF(__pyx_temp); } __pyx_t_3 = 0; goto __pyx_L0; /* "borghash/HashTable.pyx":196 * cdef size_t index * self.stats_get += 1 * if self._lookup_index( key, &index): # <<<<<<<<<<<<<< * kv_index = self.table[index] * return self.values[kv_index * self.vsize:(kv_index + 1) * self.vsize] */ } /* "borghash/HashTable.pyx":200 * return self.values[kv_index * self.vsize:(kv_index + 1) * self.vsize] * else: * raise KeyError("Key not found") # <<<<<<<<<<<<<< * * def __delitem__(self, key: bytes) -> None: */ /*else*/ { __pyx_t_4 = NULL; __pyx_t_5 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_Key_not_found}; __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_KeyError)), __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 200, __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, 200, __pyx_L1_error) } /* "borghash/HashTable.pyx":190 * return bool(self._lookup_index( key, NULL)) * * def __getitem__(self, key: bytes) -> bytes: # <<<<<<<<<<<<<< * if len(key) != self.ksize: * raise ValueError("Key size does not match the defined size") */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("borghash.HashTable.HashTable.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTable.pyx":202 * raise KeyError("Key not found") * * def __delitem__(self, key: bytes) -> None: # <<<<<<<<<<<<<< * if len(key) != self.ksize: * raise ValueError("Key size does not match the defined size") */ /* Python wrapper */ static int __pyx_pw_8borghash_9HashTable_9HashTable_15__delitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/ static int __pyx_pw_8borghash_9HashTable_9HashTable_15__delitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__delitem__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_key), (&PyBytes_Type), 0, "key", 2))) __PYX_ERR(0, 202, __pyx_L1_error) __pyx_r = __pyx_pf_8borghash_9HashTable_9HashTable_14__delitem__(((struct __pyx_obj_8borghash_9HashTable_HashTable *)__pyx_v_self), ((PyObject*)__pyx_v_key)); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = -1; goto __pyx_L5_cleaned_up; __pyx_L0:; __pyx_L5_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_8borghash_9HashTable_9HashTable_14__delitem__(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, PyObject *__pyx_v_key) { uint8_t *__pyx_v_key_ptr; size_t __pyx_v_index; uint32_t __pyx_v_kv_index; PyObject *__pyx_v_new_capacity = NULL; int __pyx_r; __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; size_t __pyx_t_5; uint8_t *__pyx_t_6; int __pyx_t_7; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__delitem__", 0); /* "borghash/HashTable.pyx":203 * * def __delitem__(self, key: bytes) -> None: * if len(key) != self.ksize: # <<<<<<<<<<<<<< * raise ValueError("Key size does not match the defined size") * cdef uint8_t* key_ptr = key */ __pyx_t_1 = __Pyx_PyBytes_GET_SIZE(__pyx_v_key); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 203, __pyx_L1_error) __pyx_t_2 = (__pyx_t_1 != __pyx_v_self->ksize); if (unlikely(__pyx_t_2)) { /* "borghash/HashTable.pyx":204 * def __delitem__(self, key: bytes) -> None: * if len(key) != self.ksize: * raise ValueError("Key size does not match the defined size") # <<<<<<<<<<<<<< * cdef uint8_t* key_ptr = key * cdef size_t index */ __pyx_t_4 = NULL; __pyx_t_5 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_Key_size_does_not_match_the_defi}; __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 204, __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, 204, __pyx_L1_error) /* "borghash/HashTable.pyx":203 * * def __delitem__(self, key: bytes) -> None: * if len(key) != self.ksize: # <<<<<<<<<<<<<< * raise ValueError("Key size does not match the defined size") * cdef uint8_t* key_ptr = key */ } /* "borghash/HashTable.pyx":205 * if len(key) != self.ksize: * raise ValueError("Key size does not match the defined size") * cdef uint8_t* key_ptr = key # <<<<<<<<<<<<<< * cdef size_t index * cdef uint32_t kv_index */ __pyx_t_6 = __Pyx_PyBytes_AsWritableUString(__pyx_v_key); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 205, __pyx_L1_error) __pyx_v_key_ptr = ((uint8_t *)__pyx_t_6); /* "borghash/HashTable.pyx":209 * cdef uint32_t kv_index * * self.stats_del += 1 # <<<<<<<<<<<<<< * if self._lookup_index(key_ptr, &index): * kv_index = self.table[index] */ __pyx_v_self->stats_del = (__pyx_v_self->stats_del + 1); /* "borghash/HashTable.pyx":210 * * self.stats_del += 1 * if self._lookup_index(key_ptr, &index): # <<<<<<<<<<<<<< * kv_index = self.table[index] * memset(self.keys + kv_index * self.ksize, 0, self.ksize) */ __pyx_t_7 = ((struct __pyx_vtabstruct_8borghash_9HashTable_HashTable *)__pyx_v_self->__pyx_vtab)->_lookup_index(__pyx_v_self, __pyx_v_key_ptr, (&__pyx_v_index), NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 210, __pyx_L1_error) __pyx_t_2 = (__pyx_t_7 != 0); if (likely(__pyx_t_2)) { /* "borghash/HashTable.pyx":211 * self.stats_del += 1 * if self._lookup_index(key_ptr, &index): * kv_index = self.table[index] # <<<<<<<<<<<<<< * memset(self.keys + kv_index * self.ksize, 0, self.ksize) * memset(self.values + kv_index * self.vsize, 0, self.vsize) */ __pyx_v_kv_index = (__pyx_v_self->table[__pyx_v_index]); /* "borghash/HashTable.pyx":212 * if self._lookup_index(key_ptr, &index): * kv_index = self.table[index] * memset(self.keys + kv_index * self.ksize, 0, self.ksize) # <<<<<<<<<<<<<< * memset(self.values + kv_index * self.vsize, 0, self.vsize) * self.table[index] = TOMBSTONE_BUCKET */ (void)(memset((__pyx_v_self->keys + (__pyx_v_kv_index * __pyx_v_self->ksize)), 0, __pyx_v_self->ksize)); /* "borghash/HashTable.pyx":213 * kv_index = self.table[index] * memset(self.keys + kv_index * self.ksize, 0, self.ksize) * memset(self.values + kv_index * self.vsize, 0, self.vsize) # <<<<<<<<<<<<<< * self.table[index] = TOMBSTONE_BUCKET * self.used -= 1 */ (void)(memset((__pyx_v_self->values + (__pyx_v_kv_index * __pyx_v_self->vsize)), 0, __pyx_v_self->vsize)); /* "borghash/HashTable.pyx":214 * memset(self.keys + kv_index * self.ksize, 0, self.ksize) * memset(self.values + kv_index * self.vsize, 0, self.vsize) * self.table[index] = TOMBSTONE_BUCKET # <<<<<<<<<<<<<< * self.used -= 1 * self.tombstones += 1 */ (__pyx_v_self->table[__pyx_v_index]) = __pyx_v_8borghash_9HashTable_TOMBSTONE_BUCKET; /* "borghash/HashTable.pyx":215 * memset(self.values + kv_index * self.vsize, 0, self.vsize) * self.table[index] = TOMBSTONE_BUCKET * self.used -= 1 # <<<<<<<<<<<<<< * self.tombstones += 1 * */ __pyx_v_self->used = (__pyx_v_self->used - 1); /* "borghash/HashTable.pyx":216 * self.table[index] = TOMBSTONE_BUCKET * self.used -= 1 * self.tombstones += 1 # <<<<<<<<<<<<<< * * # Resize down if necessary */ __pyx_v_self->tombstones = (__pyx_v_self->tombstones + 1); /* "borghash/HashTable.pyx":219 * * # Resize down if necessary * if self.used < self.capacity * self.min_load_factor: # <<<<<<<<<<<<<< * new_capacity = max(int(self.capacity * self.shrink_factor), MIN_CAPACITY) * if new_capacity < self.capacity: # at the MIN_CAPACITY floor, this would rehash per delete */ __pyx_t_2 = (__pyx_v_self->used < (__pyx_v_self->capacity * __pyx_v_self->min_load_factor)); if (__pyx_t_2) { /* "borghash/HashTable.pyx":220 * # Resize down if necessary * if self.used < self.capacity * self.min_load_factor: * new_capacity = max(int(self.capacity * self.shrink_factor), MIN_CAPACITY) # <<<<<<<<<<<<<< * if new_capacity < self.capacity: # at the MIN_CAPACITY floor, this would rehash per delete * self._resize_table(new_capacity) */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_MIN_CAPACITY); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyLong_FromDouble((__pyx_v_self->capacity * __pyx_v_self->shrink_factor)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = __Pyx_PyObject_CompareBoolGt_object_int(__pyx_t_3, __pyx_t_4, Py_GT); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 220, __pyx_L1_error) if (__pyx_t_2) { __Pyx_INCREF(__pyx_t_3); __pyx_t_8 = __pyx_t_3; } else { __Pyx_INCREF(__pyx_t_4); __pyx_t_8 = __pyx_t_4; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __pyx_t_8; __Pyx_INCREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_new_capacity = __pyx_t_3; __pyx_t_3 = 0; /* "borghash/HashTable.pyx":221 * if self.used < self.capacity * self.min_load_factor: * new_capacity = max(int(self.capacity * self.shrink_factor), MIN_CAPACITY) * if new_capacity < self.capacity: # at the MIN_CAPACITY floor, this would rehash per delete # <<<<<<<<<<<<<< * self._resize_table(new_capacity) * else: */ __pyx_t_3 = __Pyx_PyLong_FromSize_t(__pyx_v_self->capacity); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 221, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = __Pyx_PyObject_CompareBoolLt_object_int(__pyx_v_new_capacity, __pyx_t_3, Py_LT); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 221, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_2) { /* "borghash/HashTable.pyx":222 * new_capacity = max(int(self.capacity * self.shrink_factor), MIN_CAPACITY) * if new_capacity < self.capacity: # at the MIN_CAPACITY floor, this would rehash per delete * self._resize_table(new_capacity) # <<<<<<<<<<<<<< * else: * raise KeyError("Key not found") */ __pyx_t_5 = __Pyx_PyLong_As_size_t(__pyx_v_new_capacity); if (unlikely((__pyx_t_5 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 222, __pyx_L1_error) ((struct __pyx_vtabstruct_8borghash_9HashTable_HashTable *)__pyx_v_self->__pyx_vtab)->_resize_table(__pyx_v_self, __pyx_t_5); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 222, __pyx_L1_error) /* "borghash/HashTable.pyx":221 * if self.used < self.capacity * self.min_load_factor: * new_capacity = max(int(self.capacity * self.shrink_factor), MIN_CAPACITY) * if new_capacity < self.capacity: # at the MIN_CAPACITY floor, this would rehash per delete # <<<<<<<<<<<<<< * self._resize_table(new_capacity) * else: */ } /* "borghash/HashTable.pyx":219 * * # Resize down if necessary * if self.used < self.capacity * self.min_load_factor: # <<<<<<<<<<<<<< * new_capacity = max(int(self.capacity * self.shrink_factor), MIN_CAPACITY) * if new_capacity < self.capacity: # at the MIN_CAPACITY floor, this would rehash per delete */ } /* "borghash/HashTable.pyx":210 * * self.stats_del += 1 * if self._lookup_index(key_ptr, &index): # <<<<<<<<<<<<<< * kv_index = self.table[index] * memset(self.keys + kv_index * self.ksize, 0, self.ksize) */ goto __pyx_L4; } /* "borghash/HashTable.pyx":224 * self._resize_table(new_capacity) * else: * raise KeyError("Key not found") # <<<<<<<<<<<<<< * * def setdefault(self, key: bytes, value: bytes) -> bytes: */ /*else*/ { __pyx_t_8 = NULL; __pyx_t_5 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_mstate_global->__pyx_kp_u_Key_not_found}; __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_KeyError)), __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 224, __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, 224, __pyx_L1_error) } __pyx_L4:; /* "borghash/HashTable.pyx":202 * raise KeyError("Key not found") * * def __delitem__(self, key: bytes) -> None: # <<<<<<<<<<<<<< * if len(key) != self.ksize: * raise ValueError("Key size does not match the defined size") */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("borghash.HashTable.HashTable.__delitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_XDECREF(__pyx_v_new_capacity); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTable.pyx":226 * raise KeyError("Key not found") * * def setdefault(self, key: bytes, value: bytes) -> bytes: # <<<<<<<<<<<<<< * if not key in self: * self[key] = value */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_9HashTable_9HashTable_17setdefault(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_8borghash_9HashTable_9HashTable_17setdefault = {"setdefault", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_9HashTable_9HashTable_17setdefault, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_8borghash_9HashTable_9HashTable_17setdefault(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_key = 0; PyObject *__pyx_v_value = 0; #if !CYTHON_VECTORCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("setdefault (wrapper)", 0); #if !CYTHON_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_key,&__pyx_mstate_global->__pyx_n_u_value,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 226, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 226, __pyx_L3_error) CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 226, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "setdefault", 0) < (0)) __PYX_ERR(0, 226, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("setdefault", 1, 2, 2, i); __PYX_ERR(0, 226, __pyx_L3_error) } } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 226, __pyx_L3_error) values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 226, __pyx_L3_error) } __pyx_v_key = ((PyObject*)values[0]); __pyx_v_value = ((PyObject*)values[1]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("setdefault", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 226, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("borghash.HashTable.HashTable.setdefault", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_key), (&PyBytes_Type), 0, "key", 2))) __PYX_ERR(0, 226, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_value), (&PyBytes_Type), 0, "value", 2))) __PYX_ERR(0, 226, __pyx_L1_error) __pyx_r = __pyx_pf_8borghash_9HashTable_9HashTable_16setdefault(((struct __pyx_obj_8borghash_9HashTable_HashTable *)__pyx_v_self), __pyx_v_key, __pyx_v_value); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } goto __pyx_L7_cleaned_up; __pyx_L0:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_9HashTable_9HashTable_16setdefault(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value) { 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("setdefault", 0); /* "borghash/HashTable.pyx":227 * * def setdefault(self, key: bytes, value: bytes) -> bytes: * if not key in self: # <<<<<<<<<<<<<< * self[key] = value * return self[key] */ __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_key, ((PyObject *)__pyx_v_self), Py_NE)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 227, __pyx_L1_error) if (__pyx_t_1) { /* "borghash/HashTable.pyx":228 * def setdefault(self, key: bytes, value: bytes) -> bytes: * if not key in self: * self[key] = value # <<<<<<<<<<<<<< * return self[key] * */ if (unlikely((PyObject_SetItem(((PyObject *)__pyx_v_self), __pyx_v_key, __pyx_v_value) < 0))) __PYX_ERR(0, 228, __pyx_L1_error) /* "borghash/HashTable.pyx":227 * * def setdefault(self, key: bytes, value: bytes) -> bytes: * if not key in self: # <<<<<<<<<<<<<< * self[key] = value * return self[key] */ } /* "borghash/HashTable.pyx":229 * if not key in self: * self[key] = value * return self[key] # <<<<<<<<<<<<<< * * def get(self, key: bytes, default: Any = None) -> bytes|Any: */ __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_key); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 229, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (!(likely(PyBytes_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_2))) __PYX_ERR(0, 229, __pyx_L1_error) { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __pyx_r = ((PyObject*)__pyx_t_2); } __Pyx_XDECREF(__pyx_temp); } __pyx_t_2 = 0; goto __pyx_L0; /* "borghash/HashTable.pyx":226 * raise KeyError("Key not found") * * def setdefault(self, key: bytes, value: bytes) -> bytes: # <<<<<<<<<<<<<< * if not key in self: * self[key] = value */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("borghash.HashTable.HashTable.setdefault", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTable.pyx":231 * return self[key] * * def get(self, key: bytes, default: Any = None) -> bytes|Any: # <<<<<<<<<<<<<< * try: * return self[key] */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_9HashTable_9HashTable_19get(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_8borghash_9HashTable_9HashTable_19get = {"get", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_9HashTable_9HashTable_19get, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_8borghash_9HashTable_9HashTable_19get(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_key = 0; PyObject *__pyx_v_default = 0; #if !CYTHON_VECTORCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[2] = {0,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); #if !CYTHON_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_key,&__pyx_mstate_global->__pyx_n_u_default,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 231, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 231, __pyx_L3_error) CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 231, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get", 0) < (0)) __PYX_ERR(0, 231, __pyx_L3_error) if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_None)); for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get", 0, 1, 2, i); __PYX_ERR(0, 231, __pyx_L3_error) } } } else { switch (__pyx_nargs) { case 2: values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 231, __pyx_L3_error) CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 231, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_None)); } __pyx_v_key = ((PyObject*)values[0]); __pyx_v_default = values[1]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("get", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 231, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("borghash.HashTable.HashTable.get", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_key), (&PyBytes_Type), 0, "key", 2))) __PYX_ERR(0, 231, __pyx_L1_error) __pyx_r = __pyx_pf_8borghash_9HashTable_9HashTable_18get(((struct __pyx_obj_8borghash_9HashTable_HashTable *)__pyx_v_self), __pyx_v_key, __pyx_v_default); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } goto __pyx_L7_cleaned_up; __pyx_L0:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_9HashTable_9HashTable_18get(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_default) { PyObject *__pyx_r = NULL; __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_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get", 0); /* "borghash/HashTable.pyx":232 * * def get(self, key: bytes, default: Any = None) -> bytes|Any: * try: # <<<<<<<<<<<<<< * return self[key] * except KeyError: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "borghash/HashTable.pyx":233 * def get(self, key: bytes, default: Any = None) -> bytes|Any: * try: * return self[key] # <<<<<<<<<<<<<< * except KeyError: * return default */ __pyx_t_4 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_key); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 233, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_4); { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __pyx_r = __pyx_t_4; } __Pyx_XDECREF(__pyx_temp); } __pyx_t_4 = 0; goto __pyx_L7_try_return; /* "borghash/HashTable.pyx":232 * * def get(self, key: bytes, default: Any = None) -> bytes|Any: * try: # <<<<<<<<<<<<<< * return self[key] * except KeyError: */ } __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "borghash/HashTable.pyx":234 * try: * return self[key] * except KeyError: # <<<<<<<<<<<<<< * return default * */ __pyx_t_5 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_KeyError)))); if (__pyx_t_5) { __Pyx_ErrRestore(0,0,0); /* "borghash/HashTable.pyx":235 * return self[key] * except KeyError: * return default # <<<<<<<<<<<<<< * * def pop(self, key: bytes, default: Any = _NoDefault) -> bytes|Any: */ { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __Pyx_INCREF(__pyx_v_default); __pyx_r = __pyx_v_default; } __Pyx_XDECREF(__pyx_temp); } goto __pyx_L6_except_return; } goto __pyx_L5_except_error; /* "borghash/HashTable.pyx":232 * * def get(self, key: bytes, default: Any = None) -> bytes|Any: * try: # <<<<<<<<<<<<<< * return self[key] * except KeyError: */ __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L7_try_return:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L0; __pyx_L6_except_return:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L0; } /* "borghash/HashTable.pyx":231 * return self[key] * * def get(self, key: bytes, default: Any = None) -> bytes|Any: # <<<<<<<<<<<<<< * try: * return self[key] */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("borghash.HashTable.HashTable.get", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTable.pyx":237 * return default * * def pop(self, key: bytes, default: Any = _NoDefault) -> bytes|Any: # <<<<<<<<<<<<<< * try: * value = self[key] */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_9HashTable_9HashTable_21pop(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_8borghash_9HashTable_9HashTable_21pop = {"pop", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_9HashTable_9HashTable_21pop, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_8borghash_9HashTable_9HashTable_21pop(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_key = 0; PyObject *__pyx_v_default = 0; #if !CYTHON_VECTORCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("pop (wrapper)", 0); #if !CYTHON_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_key,&__pyx_mstate_global->__pyx_n_u_default,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 237, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 237, __pyx_L3_error) CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 237, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "pop", 0) < (0)) __PYX_ERR(0, 237, __pyx_L3_error) if (!values[1]) values[1] = __Pyx_NewRef(__pyx_mstate_global->__pyx_k__3); for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("pop", 0, 1, 2, i); __PYX_ERR(0, 237, __pyx_L3_error) } } } else { switch (__pyx_nargs) { case 2: values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 237, __pyx_L3_error) CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 237, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } if (!values[1]) values[1] = __Pyx_NewRef(__pyx_mstate_global->__pyx_k__3); } __pyx_v_key = ((PyObject*)values[0]); __pyx_v_default = values[1]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("pop", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 237, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("borghash.HashTable.HashTable.pop", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_key), (&PyBytes_Type), 0, "key", 2))) __PYX_ERR(0, 237, __pyx_L1_error) __pyx_r = __pyx_pf_8borghash_9HashTable_9HashTable_20pop(((struct __pyx_obj_8borghash_9HashTable_HashTable *)__pyx_v_self), __pyx_v_key, __pyx_v_default); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } goto __pyx_L7_cleaned_up; __pyx_L0:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_9HashTable_9HashTable_20pop(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_default) { PyObject *__pyx_v_value = NULL; PyObject *__pyx_r = NULL; __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; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_t_9; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("pop", 0); /* "borghash/HashTable.pyx":238 * * def pop(self, key: bytes, default: Any = _NoDefault) -> bytes|Any: * try: # <<<<<<<<<<<<<< * value = self[key] * except KeyError: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "borghash/HashTable.pyx":239 * def pop(self, key: bytes, default: Any = _NoDefault) -> bytes|Any: * try: * value = self[key] # <<<<<<<<<<<<<< * except KeyError: * if default is _NoDefault: */ __pyx_t_4 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_key); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 239, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_value = __pyx_t_4; __pyx_t_4 = 0; /* "borghash/HashTable.pyx":238 * * def pop(self, key: bytes, default: Any = _NoDefault) -> bytes|Any: * try: # <<<<<<<<<<<<<< * value = self[key] * except KeyError: */ } /* "borghash/HashTable.pyx":245 * return default * else: * del self[key] # <<<<<<<<<<<<<< * return value * */ /*else:*/ { if (unlikely((PyObject_DelItem(((PyObject *)__pyx_v_self), __pyx_v_key) < 0))) __PYX_ERR(0, 245, __pyx_L5_except_error) /* "borghash/HashTable.pyx":246 * else: * del self[key] * return value # <<<<<<<<<<<<<< * * def items(self, *, prefix_bits: int = 0, prefix: int = 0) -> Iterator[tuple[bytes, bytes]]: */ { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __Pyx_INCREF(__pyx_v_value); __pyx_r = __pyx_v_value; } __Pyx_XDECREF(__pyx_temp); } goto __pyx_L6_except_return; } __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "borghash/HashTable.pyx":240 * try: * value = self[key] * except KeyError: # <<<<<<<<<<<<<< * if default is _NoDefault: * raise */ __pyx_t_5 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_KeyError)))); if (__pyx_t_5) { __Pyx_AddTraceback("borghash.HashTable.HashTable.pop", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(0, 240, __pyx_L5_except_error) __Pyx_XGOTREF(__pyx_t_4); __Pyx_XGOTREF(__pyx_t_6); __Pyx_XGOTREF(__pyx_t_7); /* "borghash/HashTable.pyx":241 * value = self[key] * except KeyError: * if default is _NoDefault: # <<<<<<<<<<<<<< * raise * return default */ __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_NoDefault); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 241, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = (__pyx_v_default == __pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(__pyx_t_9)) { /* "borghash/HashTable.pyx":242 * except KeyError: * if default is _NoDefault: * raise # <<<<<<<<<<<<<< * return default * else: */ __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_7); __Pyx_ErrRestoreWithState(__pyx_t_4, __pyx_t_6, __pyx_t_7); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; __PYX_ERR(0, 242, __pyx_L5_except_error) /* "borghash/HashTable.pyx":241 * value = self[key] * except KeyError: * if default is _NoDefault: # <<<<<<<<<<<<<< * raise * return default */ } /* "borghash/HashTable.pyx":243 * if default is _NoDefault: * raise * return default # <<<<<<<<<<<<<< * else: * del self[key] */ { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __Pyx_INCREF(__pyx_v_default); __pyx_r = __pyx_v_default; } __Pyx_XDECREF(__pyx_temp); } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L6_except_return; } goto __pyx_L5_except_error; /* "borghash/HashTable.pyx":238 * * def pop(self, key: bytes, default: Any = _NoDefault) -> bytes|Any: * try: # <<<<<<<<<<<<<< * value = self[key] * except KeyError: */ __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L6_except_return:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L0; } /* "borghash/HashTable.pyx":237 * return default * * def pop(self, key: bytes, default: Any = _NoDefault) -> bytes|Any: # <<<<<<<<<<<<<< * try: * value = self[key] */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("borghash.HashTable.HashTable.pop", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_value); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_8borghash_9HashTable_9HashTable_24generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "borghash/HashTable.pyx":248 * return value * * def items(self, *, prefix_bits: int = 0, prefix: int = 0) -> Iterator[tuple[bytes, bytes]]: # <<<<<<<<<<<<<< * """ * Iterate over items, optionally only over items whose key starts with the given bit prefix. */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_9HashTable_9HashTable_23items(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_8borghash_9HashTable_9HashTable_22items, "\n Iterate over items, optionally only over items whose key starts with the given bit prefix.\n\n prefix_bits: number of leading key bits to compare, 0..32 (0 means: no filtering).\n prefix: expected value of these leading key bits, given in the integer\047s low bits,\n thus: 0 <= prefix < 2 ** prefix_bits.\n\n As the keys are expected to be random bytes, this partitions the keys into\n 2 ** prefix_bits roughly equally sized, disjoint sets, while only creating\n bytes objects for the matching keys/values. As the prefix compares the keys\047\n leading bits, each set is a contiguous range of the sorted key space.\n "); static PyMethodDef __pyx_mdef_8borghash_9HashTable_9HashTable_23items = {"items", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_9HashTable_9HashTable_23items, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8borghash_9HashTable_9HashTable_22items}; static PyObject *__pyx_pw_8borghash_9HashTable_9HashTable_23items(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_prefix_bits = 0; PyObject *__pyx_v_prefix = 0; #if !CYTHON_VECTORCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("items (wrapper)", 0); #if !CYTHON_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_prefix_bits,&__pyx_mstate_global->__pyx_n_u_prefix,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 248, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 0: break; default: goto __pyx_L5_argtuple_error; } if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, 0, __pyx_kwds_len, "items", 0) < (0)) __PYX_ERR(0, 248, __pyx_L3_error) if (!values[0]) values[0] = __Pyx_NewRef(((PyObject*)__pyx_mstate_global->__pyx_int_0)); if (!values[1]) values[1] = __Pyx_NewRef(((PyObject*)__pyx_mstate_global->__pyx_int_0)); } else if (unlikely(__pyx_nargs != 0)) { goto __pyx_L5_argtuple_error; } else { if (!values[0]) values[0] = __Pyx_NewRef(((PyObject*)__pyx_mstate_global->__pyx_int_0)); if (!values[1]) values[1] = __Pyx_NewRef(((PyObject*)__pyx_mstate_global->__pyx_int_0)); } if (__Pyx_PyInt_FromNumber(&values[0], "prefix_bits", 0) < (0)) __PYX_ERR(0, 248, __pyx_L3_error) __pyx_v_prefix_bits = ((PyObject*)values[0]); if (__Pyx_PyInt_FromNumber(&values[1], "prefix", 0) < (0)) __PYX_ERR(0, 248, __pyx_L3_error) __pyx_v_prefix = ((PyObject*)values[1]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("items", 1, 0, 0, __pyx_nargs); __PYX_ERR(0, 248, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("borghash.HashTable.HashTable.items", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_prefix_bits), (&PyLong_Type), 0, "prefix_bits", 2))) __PYX_ERR(0, 248, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_prefix), (&PyLong_Type), 0, "prefix", 2))) __PYX_ERR(0, 248, __pyx_L1_error) __pyx_r = __pyx_pf_8borghash_9HashTable_9HashTable_22items(((struct __pyx_obj_8borghash_9HashTable_HashTable *)__pyx_v_self), __pyx_v_prefix_bits, __pyx_v_prefix); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } goto __pyx_L7_cleaned_up; __pyx_L0:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_9HashTable_9HashTable_22items(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, PyObject *__pyx_v_prefix_bits, PyObject *__pyx_v_prefix) { struct __pyx_obj_8borghash_9HashTable___pyx_scope_struct__items *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("items", 0); __pyx_cur_scope = (struct __pyx_obj_8borghash_9HashTable___pyx_scope_struct__items *)__pyx_tp_new_8borghash_9HashTable___pyx_scope_struct__items(__pyx_mstate_global->__pyx_ptype_8borghash_9HashTable___pyx_scope_struct__items, __pyx_mstate_global->__pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_8borghash_9HashTable___pyx_scope_struct__items *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(0, 248, __pyx_L1_error) } else { __Pyx_GOTREF((PyObject *)__pyx_cur_scope); } __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_cur_scope->__pyx_v_prefix_bits = __pyx_v_prefix_bits; __Pyx_INCREF(__pyx_cur_scope->__pyx_v_prefix_bits); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_prefix_bits); __pyx_cur_scope->__pyx_v_prefix = __pyx_v_prefix; __Pyx_INCREF(__pyx_cur_scope->__pyx_v_prefix); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_prefix); { __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_8borghash_9HashTable_9HashTable_24generator, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[0]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_items, __pyx_mstate_global->__pyx_n_u_HashTable_items, __pyx_mstate_global->__pyx_n_u_borghash_HashTable); if (unlikely(!gen)) __PYX_ERR(0, 248, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("borghash.HashTable.HashTable.items", __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_8borghash_9HashTable_9HashTable_24generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_8borghash_9HashTable___pyx_scope_struct__items *__pyx_cur_scope = ((struct __pyx_obj_8borghash_9HashTable___pyx_scope_struct__items *)__pyx_generator->closure); PyObject *__pyx_r = NULL; int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; size_t __pyx_t_5; int __pyx_t_6; uint32_t __pyx_t_7; size_t __pyx_t_8; size_t __pyx_t_9; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("items", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L13_resume_from_yield; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(__pyx_sent_value != Py_None)) { if (unlikely(__pyx_sent_value)) PyErr_SetString(PyExc_TypeError, "can't send non-None value to a just-started generator"); __PYX_ERR(0, 248, __pyx_L1_error) } /* "borghash/HashTable.pyx":261 * leading bits, each set is a contiguous range of the sorted key space. * """ * if not 0 <= prefix_bits <= 32: # <<<<<<<<<<<<<< * raise ValueError("prefix_bits must be in range 0..32.") * if not 0 <= prefix < (1 << prefix_bits): */ __pyx_t_1 = __Pyx_PyObject_CompareBoolLe_int_int(__pyx_mstate_global->__pyx_int_0, __pyx_cur_scope->__pyx_v_prefix_bits, Py_LE); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 261, __pyx_L1_error) if (__pyx_t_1) { __pyx_t_1 = __Pyx_PyObject_CompareBoolLe_int_int(__pyx_cur_scope->__pyx_v_prefix_bits, __pyx_mstate_global->__pyx_int_32, Py_LE); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 261, __pyx_L1_error) } __pyx_t_2 = (!__pyx_t_1); if (unlikely(__pyx_t_2)) { /* "borghash/HashTable.pyx":262 * """ * if not 0 <= prefix_bits <= 32: * raise ValueError("prefix_bits must be in range 0..32.") # <<<<<<<<<<<<<< * if not 0 <= prefix < (1 << prefix_bits): * raise ValueError("prefix must be in range 0..(2 ** prefix_bits - 1).") */ __pyx_t_4 = NULL; __pyx_t_5 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_prefix_bits_must_be_in_range_0_3}; __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 262, __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, 262, __pyx_L1_error) /* "borghash/HashTable.pyx":261 * leading bits, each set is a contiguous range of the sorted key space. * """ * if not 0 <= prefix_bits <= 32: # <<<<<<<<<<<<<< * raise ValueError("prefix_bits must be in range 0..32.") * if not 0 <= prefix < (1 << prefix_bits): */ } /* "borghash/HashTable.pyx":263 * if not 0 <= prefix_bits <= 32: * raise ValueError("prefix_bits must be in range 0..32.") * if not 0 <= prefix < (1 << prefix_bits): # <<<<<<<<<<<<<< * raise ValueError("prefix must be in range 0..(2 ** prefix_bits - 1).") * cdef size_t i */ __pyx_t_2 = __Pyx_PyObject_CompareBoolLe_int_int(__pyx_mstate_global->__pyx_int_0, __pyx_cur_scope->__pyx_v_prefix, Py_LE); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 263, __pyx_L1_error) if (__pyx_t_2) { __pyx_t_3 = PyNumber_Lshift(__pyx_mstate_global->__pyx_int_1, __pyx_cur_scope->__pyx_v_prefix_bits); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 263, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = __Pyx_PyObject_CompareBoolLt_int_int(__pyx_cur_scope->__pyx_v_prefix, __pyx_t_3, Py_LT); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 263, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_t_1 = (!__pyx_t_2); if (unlikely(__pyx_t_1)) { /* "borghash/HashTable.pyx":264 * raise ValueError("prefix_bits must be in range 0..32.") * if not 0 <= prefix < (1 << prefix_bits): * raise ValueError("prefix must be in range 0..(2 ** prefix_bits - 1).") # <<<<<<<<<<<<<< * cdef size_t i * cdef uint32_t kv_index */ __pyx_t_4 = NULL; __pyx_t_5 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_prefix_must_be_in_range_0_2_pref}; __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 264, __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, 264, __pyx_L1_error) /* "borghash/HashTable.pyx":263 * if not 0 <= prefix_bits <= 32: * raise ValueError("prefix_bits must be in range 0..32.") * if not 0 <= prefix < (1 << prefix_bits): # <<<<<<<<<<<<<< * raise ValueError("prefix must be in range 0..(2 ** prefix_bits - 1).") * cdef size_t i */ } /* "borghash/HashTable.pyx":269 * cdef uint8_t* key_ptr * cdef uint32_t key32 * cdef int shift = 32 - prefix_bits # <<<<<<<<<<<<<< * cdef uint32_t wanted = prefix * cdef bint filtering = prefix_bits > 0 */ __pyx_t_3 = __Pyx_PyLong_SubtractCObj(__pyx_mstate_global->__pyx_int_32, __pyx_cur_scope->__pyx_v_prefix_bits, 32, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 269, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_6 = __Pyx_PyLong_As_int(__pyx_t_3); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 269, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_cur_scope->__pyx_v_shift = __pyx_t_6; /* "borghash/HashTable.pyx":270 * cdef uint32_t key32 * cdef int shift = 32 - prefix_bits * cdef uint32_t wanted = prefix # <<<<<<<<<<<<<< * cdef bint filtering = prefix_bits > 0 * self.stats_iter += 1 */ __pyx_t_7 = __Pyx_PyLong_As_uint32_t(__pyx_cur_scope->__pyx_v_prefix); if (unlikely((__pyx_t_7 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 270, __pyx_L1_error) __pyx_cur_scope->__pyx_v_wanted = ((uint32_t)__pyx_t_7); /* "borghash/HashTable.pyx":271 * cdef int shift = 32 - prefix_bits * cdef uint32_t wanted = prefix * cdef bint filtering = prefix_bits > 0 # <<<<<<<<<<<<<< * self.stats_iter += 1 * for i in range(self.capacity): */ __pyx_t_3 = __Pyx_PyObject_CompareGt_int_int(__pyx_cur_scope->__pyx_v_prefix_bits, __pyx_mstate_global->__pyx_int_0, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 271, __pyx_L1_error) __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 271, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_cur_scope->__pyx_v_filtering = __pyx_t_1; /* "borghash/HashTable.pyx":272 * cdef uint32_t wanted = prefix * cdef bint filtering = prefix_bits > 0 * self.stats_iter += 1 # <<<<<<<<<<<<<< * for i in range(self.capacity): * kv_index = self.table[i] */ __pyx_cur_scope->__pyx_v_self->stats_iter = (__pyx_cur_scope->__pyx_v_self->stats_iter + 1); /* "borghash/HashTable.pyx":273 * cdef bint filtering = prefix_bits > 0 * self.stats_iter += 1 * for i in range(self.capacity): # <<<<<<<<<<<<<< * kv_index = self.table[i] * if kv_index not in (FREE_BUCKET, TOMBSTONE_BUCKET): */ __pyx_t_5 = __pyx_cur_scope->__pyx_v_self->capacity; __pyx_t_8 = __pyx_t_5; for (__pyx_t_9 = 0; __pyx_t_9 < __pyx_t_8; __pyx_t_9+=1) { __pyx_cur_scope->__pyx_v_i = __pyx_t_9; /* "borghash/HashTable.pyx":274 * self.stats_iter += 1 * for i in range(self.capacity): * kv_index = self.table[i] # <<<<<<<<<<<<<< * if kv_index not in (FREE_BUCKET, TOMBSTONE_BUCKET): * if filtering: */ __pyx_cur_scope->__pyx_v_kv_index = (__pyx_cur_scope->__pyx_v_self->table[__pyx_cur_scope->__pyx_v_i]); /* "borghash/HashTable.pyx":275 * for i in range(self.capacity): * kv_index = self.table[i] * if kv_index not in (FREE_BUCKET, TOMBSTONE_BUCKET): # <<<<<<<<<<<<<< * if filtering: * key_ptr = self.keys + kv_index * self.ksize */ __pyx_t_7 = __pyx_cur_scope->__pyx_v_kv_index; __pyx_t_2 = (__pyx_t_7 != __pyx_v_8borghash_9HashTable_FREE_BUCKET); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L9_bool_binop_done; } __pyx_t_2 = (__pyx_t_7 != __pyx_v_8borghash_9HashTable_TOMBSTONE_BUCKET); __pyx_t_1 = __pyx_t_2; __pyx_L9_bool_binop_done:; __pyx_t_2 = __pyx_t_1; if (__pyx_t_2) { /* "borghash/HashTable.pyx":276 * kv_index = self.table[i] * if kv_index not in (FREE_BUCKET, TOMBSTONE_BUCKET): * if filtering: # <<<<<<<<<<<<<< * key_ptr = self.keys + kv_index * self.ksize * key32 = (key_ptr[0] << 24) | (key_ptr[1] << 16) | (key_ptr[2] << 8) | key_ptr[3] */ if (__pyx_cur_scope->__pyx_v_filtering) { /* "borghash/HashTable.pyx":277 * if kv_index not in (FREE_BUCKET, TOMBSTONE_BUCKET): * if filtering: * key_ptr = self.keys + kv_index * self.ksize # <<<<<<<<<<<<<< * key32 = (key_ptr[0] << 24) | (key_ptr[1] << 16) | (key_ptr[2] << 8) | key_ptr[3] * if (key32 >> shift) != wanted: */ __pyx_cur_scope->__pyx_v_key_ptr = (__pyx_cur_scope->__pyx_v_self->keys + (__pyx_cur_scope->__pyx_v_kv_index * __pyx_cur_scope->__pyx_v_self->ksize)); /* "borghash/HashTable.pyx":278 * if filtering: * key_ptr = self.keys + kv_index * self.ksize * key32 = (key_ptr[0] << 24) | (key_ptr[1] << 16) | (key_ptr[2] << 8) | key_ptr[3] # <<<<<<<<<<<<<< * if (key32 >> shift) != wanted: * continue */ __pyx_cur_scope->__pyx_v_key32 = (((((__pyx_cur_scope->__pyx_v_key_ptr[0]) << 24) | ((__pyx_cur_scope->__pyx_v_key_ptr[1]) << 16)) | ((__pyx_cur_scope->__pyx_v_key_ptr[2]) << 8)) | (__pyx_cur_scope->__pyx_v_key_ptr[3])); /* "borghash/HashTable.pyx":279 * key_ptr = self.keys + kv_index * self.ksize * key32 = (key_ptr[0] << 24) | (key_ptr[1] << 16) | (key_ptr[2] << 8) | key_ptr[3] * if (key32 >> shift) != wanted: # <<<<<<<<<<<<<< * continue * key = self.keys[kv_index * self.ksize:(kv_index + 1) * self.ksize] */ __pyx_t_2 = ((__pyx_cur_scope->__pyx_v_key32 >> __pyx_cur_scope->__pyx_v_shift) != __pyx_cur_scope->__pyx_v_wanted); if (__pyx_t_2) { /* "borghash/HashTable.pyx":280 * key32 = (key_ptr[0] << 24) | (key_ptr[1] << 16) | (key_ptr[2] << 8) | key_ptr[3] * if (key32 >> shift) != wanted: * continue # <<<<<<<<<<<<<< * key = self.keys[kv_index * self.ksize:(kv_index + 1) * self.ksize] * value = self.values[kv_index * self.vsize:(kv_index + 1) * self.vsize] */ goto __pyx_L6_continue; /* "borghash/HashTable.pyx":279 * key_ptr = self.keys + kv_index * self.ksize * key32 = (key_ptr[0] << 24) | (key_ptr[1] << 16) | (key_ptr[2] << 8) | key_ptr[3] * if (key32 >> shift) != wanted: # <<<<<<<<<<<<<< * continue * key = self.keys[kv_index * self.ksize:(kv_index + 1) * self.ksize] */ } /* "borghash/HashTable.pyx":276 * kv_index = self.table[i] * if kv_index not in (FREE_BUCKET, TOMBSTONE_BUCKET): * if filtering: # <<<<<<<<<<<<<< * key_ptr = self.keys + kv_index * self.ksize * key32 = (key_ptr[0] << 24) | (key_ptr[1] << 16) | (key_ptr[2] << 8) | key_ptr[3] */ } /* "borghash/HashTable.pyx":281 * if (key32 >> shift) != wanted: * continue * key = self.keys[kv_index * self.ksize:(kv_index + 1) * self.ksize] # <<<<<<<<<<<<<< * value = self.values[kv_index * self.vsize:(kv_index + 1) * self.vsize] * yield key, value */ __pyx_t_3 = __Pyx_PyBytes_FromStringAndSize(((char const *)__pyx_cur_scope->__pyx_v_self->keys) + (__pyx_cur_scope->__pyx_v_kv_index * __pyx_cur_scope->__pyx_v_self->ksize), ((__pyx_cur_scope->__pyx_v_kv_index + 1) * __pyx_cur_scope->__pyx_v_self->ksize) - (__pyx_cur_scope->__pyx_v_kv_index * __pyx_cur_scope->__pyx_v_self->ksize)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 281, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_key); __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_key, ((PyObject*)__pyx_t_3)); __Pyx_GIVEREF(__pyx_t_3); __pyx_t_3 = 0; /* "borghash/HashTable.pyx":282 * continue * key = self.keys[kv_index * self.ksize:(kv_index + 1) * self.ksize] * value = self.values[kv_index * self.vsize:(kv_index + 1) * self.vsize] # <<<<<<<<<<<<<< * yield key, value * */ __pyx_t_3 = __Pyx_PyBytes_FromStringAndSize(((char const *)__pyx_cur_scope->__pyx_v_self->values) + (__pyx_cur_scope->__pyx_v_kv_index * __pyx_cur_scope->__pyx_v_self->vsize), ((__pyx_cur_scope->__pyx_v_kv_index + 1) * __pyx_cur_scope->__pyx_v_self->vsize) - (__pyx_cur_scope->__pyx_v_kv_index * __pyx_cur_scope->__pyx_v_self->vsize)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 282, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_value); __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_value, ((PyObject*)__pyx_t_3)); __Pyx_GIVEREF(__pyx_t_3); __pyx_t_3 = 0; /* "borghash/HashTable.pyx":283 * key = self.keys[kv_index * self.ksize:(kv_index + 1) * self.ksize] * value = self.values[kv_index * self.vsize:(kv_index + 1) * self.vsize] * yield key, value # <<<<<<<<<<<<<< * * cdef void _resize_table(self, size_t new_capacity): */ __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 283, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_key); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_key); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_cur_scope->__pyx_v_key) != (0)) __PYX_ERR(0, 283, __pyx_L1_error); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_value); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_value); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_cur_scope->__pyx_v_value) != (0)) __PYX_ERR(0, 283, __pyx_L1_error); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; __pyx_cur_scope->__pyx_t_0 = __pyx_t_5; __pyx_cur_scope->__pyx_t_1 = __pyx_t_8; __pyx_cur_scope->__pyx_t_2 = __pyx_t_9; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, yielding value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L13_resume_from_yield:; __pyx_t_5 = __pyx_cur_scope->__pyx_t_0; __pyx_t_8 = __pyx_cur_scope->__pyx_t_1; __pyx_t_9 = __pyx_cur_scope->__pyx_t_2; if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 283, __pyx_L1_error) /* "borghash/HashTable.pyx":275 * for i in range(self.capacity): * kv_index = self.table[i] * if kv_index not in (FREE_BUCKET, TOMBSTONE_BUCKET): # <<<<<<<<<<<<<< * if filtering: * key_ptr = self.keys + kv_index * self.ksize */ } __pyx_L6_continue:; } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "borghash/HashTable.pyx":248 * return value * * def items(self, *, prefix_bits: int = 0, prefix: int = 0) -> Iterator[tuple[bytes, bytes]]: # <<<<<<<<<<<<<< * """ * Iterate over items, optionally only over items whose key starts with the given bit prefix. */ /* 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); if (__Pyx_PyErr_Occurred()) { __Pyx_Generator_Replace_StopIteration(0); __Pyx_AddTraceback("items", __pyx_clineno, __pyx_lineno, __pyx_filename); } __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTable.pyx":285 * yield key, value * * cdef void _resize_table(self, size_t new_capacity): # <<<<<<<<<<<<<< * cdef size_t i, index * cdef uint32_t kv_index */ static void __pyx_f_8borghash_9HashTable_9HashTable__resize_table(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, size_t __pyx_v_new_capacity) { size_t __pyx_v_i; size_t __pyx_v_index; uint32_t __pyx_v_kv_index; uint32_t *__pyx_v_new_table; size_t __pyx_v_current_capacity; size_t __pyx_t_1; size_t __pyx_t_2; size_t __pyx_t_3; uint32_t __pyx_t_4; int __pyx_t_5; int __pyx_t_6; size_t __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; /* "borghash/HashTable.pyx":288 * cdef size_t i, index * cdef uint32_t kv_index * cdef uint32_t* new_table = malloc(new_capacity * sizeof(uint32_t)) # <<<<<<<<<<<<<< * for i in range(new_capacity): * new_table[i] = FREE_BUCKET */ __pyx_v_new_table = ((uint32_t *)malloc((__pyx_v_new_capacity * (sizeof(uint32_t))))); /* "borghash/HashTable.pyx":289 * cdef uint32_t kv_index * cdef uint32_t* new_table = malloc(new_capacity * sizeof(uint32_t)) * for i in range(new_capacity): # <<<<<<<<<<<<<< * new_table[i] = FREE_BUCKET * */ __pyx_t_1 = __pyx_v_new_capacity; __pyx_t_2 = __pyx_t_1; for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { __pyx_v_i = __pyx_t_3; /* "borghash/HashTable.pyx":290 * cdef uint32_t* new_table = malloc(new_capacity * sizeof(uint32_t)) * for i in range(new_capacity): * new_table[i] = FREE_BUCKET # <<<<<<<<<<<<<< * * self.stats_resize_table += 1 */ (__pyx_v_new_table[__pyx_v_i]) = __pyx_v_8borghash_9HashTable_FREE_BUCKET; } /* "borghash/HashTable.pyx":292 * new_table[i] = FREE_BUCKET * * self.stats_resize_table += 1 # <<<<<<<<<<<<<< * current_capacity = self.capacity * self.capacity = new_capacity */ __pyx_v_self->stats_resize_table = (__pyx_v_self->stats_resize_table + 1); /* "borghash/HashTable.pyx":293 * * self.stats_resize_table += 1 * current_capacity = self.capacity # <<<<<<<<<<<<<< * self.capacity = new_capacity * for i in range(current_capacity): */ __pyx_t_1 = __pyx_v_self->capacity; __pyx_v_current_capacity = __pyx_t_1; /* "borghash/HashTable.pyx":294 * self.stats_resize_table += 1 * current_capacity = self.capacity * self.capacity = new_capacity # <<<<<<<<<<<<<< * for i in range(current_capacity): * kv_index = self.table[i] */ __pyx_v_self->capacity = __pyx_v_new_capacity; /* "borghash/HashTable.pyx":295 * current_capacity = self.capacity * self.capacity = new_capacity * for i in range(current_capacity): # <<<<<<<<<<<<<< * kv_index = self.table[i] * if kv_index not in (FREE_BUCKET, TOMBSTONE_BUCKET): */ __pyx_t_1 = __pyx_v_current_capacity; __pyx_t_2 = __pyx_t_1; for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { __pyx_v_i = __pyx_t_3; /* "borghash/HashTable.pyx":296 * self.capacity = new_capacity * for i in range(current_capacity): * kv_index = self.table[i] # <<<<<<<<<<<<<< * if kv_index not in (FREE_BUCKET, TOMBSTONE_BUCKET): * index = self._get_index(self.keys + kv_index * self.ksize) */ __pyx_v_kv_index = (__pyx_v_self->table[__pyx_v_i]); /* "borghash/HashTable.pyx":297 * for i in range(current_capacity): * kv_index = self.table[i] * if kv_index not in (FREE_BUCKET, TOMBSTONE_BUCKET): # <<<<<<<<<<<<<< * index = self._get_index(self.keys + kv_index * self.ksize) * while new_table[index] != FREE_BUCKET: */ __pyx_t_4 = __pyx_v_kv_index; __pyx_t_6 = (__pyx_t_4 != __pyx_v_8borghash_9HashTable_FREE_BUCKET); if (__pyx_t_6) { } else { __pyx_t_5 = __pyx_t_6; goto __pyx_L8_bool_binop_done; } __pyx_t_6 = (__pyx_t_4 != __pyx_v_8borghash_9HashTable_TOMBSTONE_BUCKET); __pyx_t_5 = __pyx_t_6; __pyx_L8_bool_binop_done:; __pyx_t_6 = __pyx_t_5; if (__pyx_t_6) { /* "borghash/HashTable.pyx":298 * kv_index = self.table[i] * if kv_index not in (FREE_BUCKET, TOMBSTONE_BUCKET): * index = self._get_index(self.keys + kv_index * self.ksize) # <<<<<<<<<<<<<< * while new_table[index] != FREE_BUCKET: * index = (index + 1) % new_capacity */ __pyx_t_7 = ((struct __pyx_vtabstruct_8borghash_9HashTable_HashTable *)__pyx_v_self->__pyx_vtab)->_get_index(__pyx_v_self, (__pyx_v_self->keys + (__pyx_v_kv_index * __pyx_v_self->ksize))); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 298, __pyx_L1_error) __pyx_v_index = __pyx_t_7; /* "borghash/HashTable.pyx":299 * if kv_index not in (FREE_BUCKET, TOMBSTONE_BUCKET): * index = self._get_index(self.keys + kv_index * self.ksize) * while new_table[index] != FREE_BUCKET: # <<<<<<<<<<<<<< * index = (index + 1) % new_capacity * new_table[index] = kv_index */ while (1) { __pyx_t_6 = ((__pyx_v_new_table[__pyx_v_index]) != __pyx_v_8borghash_9HashTable_FREE_BUCKET); if (!__pyx_t_6) break; /* "borghash/HashTable.pyx":300 * index = self._get_index(self.keys + kv_index * self.ksize) * while new_table[index] != FREE_BUCKET: * index = (index + 1) % new_capacity # <<<<<<<<<<<<<< * new_table[index] = kv_index * */ __pyx_t_7 = (__pyx_v_index + 1); if (unlikely(__pyx_v_new_capacity == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); __PYX_ERR(0, 300, __pyx_L1_error) } __pyx_v_index = (__pyx_t_7 % __pyx_v_new_capacity); } /* "borghash/HashTable.pyx":301 * while new_table[index] != FREE_BUCKET: * index = (index + 1) % new_capacity * new_table[index] = kv_index # <<<<<<<<<<<<<< * * free(self.table) */ (__pyx_v_new_table[__pyx_v_index]) = __pyx_v_kv_index; /* "borghash/HashTable.pyx":297 * for i in range(current_capacity): * kv_index = self.table[i] * if kv_index not in (FREE_BUCKET, TOMBSTONE_BUCKET): # <<<<<<<<<<<<<< * index = self._get_index(self.keys + kv_index * self.ksize) * while new_table[index] != FREE_BUCKET: */ } } /* "borghash/HashTable.pyx":303 * new_table[index] = kv_index * * free(self.table) # <<<<<<<<<<<<<< * self.table = new_table * self.tombstones = 0 */ free(__pyx_v_self->table); /* "borghash/HashTable.pyx":304 * * free(self.table) * self.table = new_table # <<<<<<<<<<<<<< * self.tombstones = 0 * */ __pyx_v_self->table = __pyx_v_new_table; /* "borghash/HashTable.pyx":305 * free(self.table) * self.table = new_table * self.tombstones = 0 # <<<<<<<<<<<<<< * * cdef void _resize_kv(self, size_t new_capacity): */ __pyx_v_self->tombstones = 0; /* "borghash/HashTable.pyx":285 * yield key, value * * cdef void _resize_table(self, size_t new_capacity): # <<<<<<<<<<<<<< * cdef size_t i, index * cdef uint32_t kv_index */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("borghash.HashTable.HashTable._resize_table", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; } /* "borghash/HashTable.pyx":307 * self.tombstones = 0 * * cdef void _resize_kv(self, size_t new_capacity): # <<<<<<<<<<<<<< * # We must never use kv indices >= RESERVED; thus, we'll never need more capacity either. * cdef size_t capacity = min(new_capacity, RESERVED - 1) */ static void __pyx_f_8borghash_9HashTable_9HashTable__resize_kv(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, size_t __pyx_v_new_capacity) { size_t __pyx_v_capacity; size_t __pyx_t_1; size_t __pyx_t_2; size_t __pyx_t_3; int __pyx_t_4; /* "borghash/HashTable.pyx":309 * cdef void _resize_kv(self, size_t new_capacity): * # We must never use kv indices >= RESERVED; thus, we'll never need more capacity either. * cdef size_t capacity = min(new_capacity, RESERVED - 1) # <<<<<<<<<<<<<< * self.stats_resize_kv += 1 * # realloc is already highly optimized (in Linux). By using mremap internally only the peak address space usage is "old size" + "new size", while the peak memory usage is only "new size". */ __pyx_t_1 = (((size_t)__pyx_v_8borghash_9HashTable_RESERVED) - 1); __pyx_t_2 = __pyx_v_new_capacity; __pyx_t_4 = (__pyx_t_1 < __pyx_t_2); if (__pyx_t_4) { __pyx_t_3 = __pyx_t_1; } else { __pyx_t_3 = __pyx_t_2; } __pyx_v_capacity = __pyx_t_3; /* "borghash/HashTable.pyx":310 * # We must never use kv indices >= RESERVED; thus, we'll never need more capacity either. * cdef size_t capacity = min(new_capacity, RESERVED - 1) * self.stats_resize_kv += 1 # <<<<<<<<<<<<<< * # realloc is already highly optimized (in Linux). By using mremap internally only the peak address space usage is "old size" + "new size", while the peak memory usage is only "new size". * self.keys = realloc(self.keys, capacity * self.ksize * sizeof(uint8_t)) */ __pyx_v_self->stats_resize_kv = (__pyx_v_self->stats_resize_kv + 1); /* "borghash/HashTable.pyx":312 * self.stats_resize_kv += 1 * # realloc is already highly optimized (in Linux). By using mremap internally only the peak address space usage is "old size" + "new size", while the peak memory usage is only "new size". * self.keys = realloc(self.keys, capacity * self.ksize * sizeof(uint8_t)) # <<<<<<<<<<<<<< * self.values = realloc(self.values, capacity * self.vsize * sizeof(uint8_t)) * self.kv_capacity = capacity */ __pyx_v_self->keys = ((uint8_t *)realloc(__pyx_v_self->keys, ((__pyx_v_capacity * __pyx_v_self->ksize) * (sizeof(uint8_t))))); /* "borghash/HashTable.pyx":313 * # realloc is already highly optimized (in Linux). By using mremap internally only the peak address space usage is "old size" + "new size", while the peak memory usage is only "new size". * self.keys = realloc(self.keys, capacity * self.ksize * sizeof(uint8_t)) * self.values = realloc(self.values, capacity * self.vsize * sizeof(uint8_t)) # <<<<<<<<<<<<<< * self.kv_capacity = capacity * */ __pyx_v_self->values = ((uint8_t *)realloc(__pyx_v_self->values, ((__pyx_v_capacity * __pyx_v_self->vsize) * (sizeof(uint8_t))))); /* "borghash/HashTable.pyx":314 * self.keys = realloc(self.keys, capacity * self.ksize * sizeof(uint8_t)) * self.values = realloc(self.values, capacity * self.vsize * sizeof(uint8_t)) * self.kv_capacity = capacity # <<<<<<<<<<<<<< * * def k_to_idx(self, key: bytes) -> int: */ __pyx_v_self->kv_capacity = ((uint32_t)__pyx_v_capacity); /* "borghash/HashTable.pyx":307 * self.tombstones = 0 * * cdef void _resize_kv(self, size_t new_capacity): # <<<<<<<<<<<<<< * # We must never use kv indices >= RESERVED; thus, we'll never need more capacity either. * cdef size_t capacity = min(new_capacity, RESERVED - 1) */ /* function exit code */ } /* "borghash/HashTable.pyx":316 * self.kv_capacity = capacity * * def k_to_idx(self, key: bytes) -> int: # <<<<<<<<<<<<<< * """ * Return the key's index in the keys array (index is stable while in memory). */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_9HashTable_9HashTable_26k_to_idx(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_8borghash_9HashTable_9HashTable_25k_to_idx, "\n Return the key\047s index in the keys array (index is stable while in memory).\n This can be used to \"abbreviate\" a known key (e.g., 256-bit key -> 32-bit index).\n "); static PyMethodDef __pyx_mdef_8borghash_9HashTable_9HashTable_26k_to_idx = {"k_to_idx", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_9HashTable_9HashTable_26k_to_idx, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8borghash_9HashTable_9HashTable_25k_to_idx}; static PyObject *__pyx_pw_8borghash_9HashTable_9HashTable_26k_to_idx(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_key = 0; #if !CYTHON_VECTORCALL 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("k_to_idx (wrapper)", 0); #if !CYTHON_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_key,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 316, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 316, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "k_to_idx", 0) < (0)) __PYX_ERR(0, 316, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("k_to_idx", 1, 1, 1, i); __PYX_ERR(0, 316, __pyx_L3_error) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 316, __pyx_L3_error) } __pyx_v_key = ((PyObject*)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("k_to_idx", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 316, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("borghash.HashTable.HashTable.k_to_idx", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_key), (&PyBytes_Type), 0, "key", 2))) __PYX_ERR(0, 316, __pyx_L1_error) __pyx_r = __pyx_pf_8borghash_9HashTable_9HashTable_25k_to_idx(((struct __pyx_obj_8borghash_9HashTable_HashTable *)__pyx_v_self), __pyx_v_key); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } goto __pyx_L7_cleaned_up; __pyx_L0:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_9HashTable_9HashTable_25k_to_idx(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, PyObject *__pyx_v_key) { size_t __pyx_v_index; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; size_t __pyx_t_5; uint8_t *__pyx_t_6; int __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("k_to_idx", 0); /* "borghash/HashTable.pyx":321 * This can be used to "abbreviate" a known key (e.g., 256-bit key -> 32-bit index). * """ * if len(key) != self.ksize: # <<<<<<<<<<<<<< * raise ValueError("Key size does not match the defined size") * cdef size_t index */ __pyx_t_1 = __Pyx_PyBytes_GET_SIZE(__pyx_v_key); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 321, __pyx_L1_error) __pyx_t_2 = (__pyx_t_1 != __pyx_v_self->ksize); if (unlikely(__pyx_t_2)) { /* "borghash/HashTable.pyx":322 * """ * if len(key) != self.ksize: * raise ValueError("Key size does not match the defined size") # <<<<<<<<<<<<<< * cdef size_t index * if self._lookup_index( key, &index): */ __pyx_t_4 = NULL; __pyx_t_5 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_Key_size_does_not_match_the_defi}; __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 322, __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, 322, __pyx_L1_error) /* "borghash/HashTable.pyx":321 * This can be used to "abbreviate" a known key (e.g., 256-bit key -> 32-bit index). * """ * if len(key) != self.ksize: # <<<<<<<<<<<<<< * raise ValueError("Key size does not match the defined size") * cdef size_t index */ } /* "borghash/HashTable.pyx":324 * raise ValueError("Key size does not match the defined size") * cdef size_t index * if self._lookup_index( key, &index): # <<<<<<<<<<<<<< * return self.table[index] # == uint32_t kv_index * else: */ __pyx_t_6 = __Pyx_PyBytes_AsWritableUString(__pyx_v_key); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 324, __pyx_L1_error) __pyx_t_7 = ((struct __pyx_vtabstruct_8borghash_9HashTable_HashTable *)__pyx_v_self->__pyx_vtab)->_lookup_index(__pyx_v_self, ((uint8_t *)__pyx_t_6), (&__pyx_v_index), NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 324, __pyx_L1_error) __pyx_t_2 = (__pyx_t_7 != 0); if (likely(__pyx_t_2)) { /* "borghash/HashTable.pyx":325 * cdef size_t index * if self._lookup_index( key, &index): * return self.table[index] # == uint32_t kv_index # <<<<<<<<<<<<<< * else: * raise KeyError("Key not found") */ __pyx_t_3 = __Pyx_PyLong_From_uint32_t((__pyx_v_self->table[__pyx_v_index])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__Pyx_PyInt_FromNumber(&__pyx_t_3, NULL, 0) < (0)) __PYX_ERR(0, 325, __pyx_L1_error) { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __pyx_r = ((PyObject*)__pyx_t_3); } __Pyx_XDECREF(__pyx_temp); } __pyx_t_3 = 0; goto __pyx_L0; /* "borghash/HashTable.pyx":324 * raise ValueError("Key size does not match the defined size") * cdef size_t index * if self._lookup_index( key, &index): # <<<<<<<<<<<<<< * return self.table[index] # == uint32_t kv_index * else: */ } /* "borghash/HashTable.pyx":327 * return self.table[index] # == uint32_t kv_index * else: * raise KeyError("Key not found") # <<<<<<<<<<<<<< * * def idx_to_k(self, idx: int) -> bytes: */ /*else*/ { __pyx_t_4 = NULL; __pyx_t_5 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_Key_not_found}; __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_KeyError)), __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 327, __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, 327, __pyx_L1_error) } /* "borghash/HashTable.pyx":316 * self.kv_capacity = capacity * * def k_to_idx(self, key: bytes) -> int: # <<<<<<<<<<<<<< * """ * Return the key's index in the keys array (index is stable while in memory). */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("borghash.HashTable.HashTable.k_to_idx", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTable.pyx":329 * raise KeyError("Key not found") * * def idx_to_k(self, idx: int) -> bytes: # <<<<<<<<<<<<<< * """ * For a given index, return the key stored at that index in the keys array. */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_9HashTable_9HashTable_28idx_to_k(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_8borghash_9HashTable_9HashTable_27idx_to_k, "\n For a given index, return the key stored at that index in the keys array.\n This is the reverse of k_to_idx (e.g., 32-bit index -> 256-bit key).\n "); static PyMethodDef __pyx_mdef_8borghash_9HashTable_9HashTable_28idx_to_k = {"idx_to_k", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_9HashTable_9HashTable_28idx_to_k, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8borghash_9HashTable_9HashTable_27idx_to_k}; static PyObject *__pyx_pw_8borghash_9HashTable_9HashTable_28idx_to_k(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_idx = 0; #if !CYTHON_VECTORCALL 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("idx_to_k (wrapper)", 0); #if !CYTHON_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_idx,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 329, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 329, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "idx_to_k", 0) < (0)) __PYX_ERR(0, 329, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("idx_to_k", 1, 1, 1, i); __PYX_ERR(0, 329, __pyx_L3_error) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 329, __pyx_L3_error) } if (__Pyx_PyInt_FromNumber(&values[0], "idx", 0) < (0)) __PYX_ERR(0, 329, __pyx_L3_error) __pyx_v_idx = ((PyObject*)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("idx_to_k", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 329, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("borghash.HashTable.HashTable.idx_to_k", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_idx), (&PyLong_Type), 0, "idx", 2))) __PYX_ERR(0, 329, __pyx_L1_error) __pyx_r = __pyx_pf_8borghash_9HashTable_9HashTable_27idx_to_k(((struct __pyx_obj_8borghash_9HashTable_HashTable *)__pyx_v_self), __pyx_v_idx); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } goto __pyx_L7_cleaned_up; __pyx_L0:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_9HashTable_9HashTable_27idx_to_k(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, PyObject *__pyx_v_idx) { uint32_t __pyx_v_kv_index; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations uint32_t __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("idx_to_k", 0); /* "borghash/HashTable.pyx":334 * This is the reverse of k_to_idx (e.g., 32-bit index -> 256-bit key). * """ * cdef uint32_t kv_index = idx # <<<<<<<<<<<<<< * return self.keys[kv_index * self.ksize:(kv_index + 1) * self.ksize] * */ __pyx_t_1 = __Pyx_PyLong_As_uint32_t(__pyx_v_idx); if (unlikely((__pyx_t_1 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 334, __pyx_L1_error) __pyx_v_kv_index = ((uint32_t)__pyx_t_1); /* "borghash/HashTable.pyx":335 * """ * cdef uint32_t kv_index = idx * return self.keys[kv_index * self.ksize:(kv_index + 1) * self.ksize] # <<<<<<<<<<<<<< * * def kv_to_idx(self, key: bytes, value: bytes) -> int: */ __pyx_t_2 = __Pyx_PyBytes_FromStringAndSize(((char const *)__pyx_v_self->keys) + (__pyx_v_kv_index * __pyx_v_self->ksize), ((__pyx_v_kv_index + 1) * __pyx_v_self->ksize) - (__pyx_v_kv_index * __pyx_v_self->ksize)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 335, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __pyx_r = ((PyObject*)__pyx_t_2); } __Pyx_XDECREF(__pyx_temp); } __pyx_t_2 = 0; goto __pyx_L0; /* "borghash/HashTable.pyx":329 * raise KeyError("Key not found") * * def idx_to_k(self, idx: int) -> bytes: # <<<<<<<<<<<<<< * """ * For a given index, return the key stored at that index in the keys array. */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("borghash.HashTable.HashTable.idx_to_k", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTable.pyx":337 * return self.keys[kv_index * self.ksize:(kv_index + 1) * self.ksize] * * def kv_to_idx(self, key: bytes, value: bytes) -> int: # <<<<<<<<<<<<<< * """ * Return the key's/value's index in the keys/values array (index is stable while in memory). */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_9HashTable_9HashTable_30kv_to_idx(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_8borghash_9HashTable_9HashTable_29kv_to_idx, "\n Return the key\047s/value\047s index in the keys/values array (index is stable while in memory).\n This can be used to \"abbreviate\" a known key/value pair (e.g., 256-bit key + 32-bit value -> 32-bit index).\n "); static PyMethodDef __pyx_mdef_8borghash_9HashTable_9HashTable_30kv_to_idx = {"kv_to_idx", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_9HashTable_9HashTable_30kv_to_idx, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8borghash_9HashTable_9HashTable_29kv_to_idx}; static PyObject *__pyx_pw_8borghash_9HashTable_9HashTable_30kv_to_idx(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_key = 0; PyObject *__pyx_v_value = 0; #if !CYTHON_VECTORCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("kv_to_idx (wrapper)", 0); #if !CYTHON_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_key,&__pyx_mstate_global->__pyx_n_u_value,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 337, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 337, __pyx_L3_error) CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 337, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "kv_to_idx", 0) < (0)) __PYX_ERR(0, 337, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("kv_to_idx", 1, 2, 2, i); __PYX_ERR(0, 337, __pyx_L3_error) } } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 337, __pyx_L3_error) values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 337, __pyx_L3_error) } __pyx_v_key = ((PyObject*)values[0]); __pyx_v_value = ((PyObject*)values[1]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("kv_to_idx", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 337, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("borghash.HashTable.HashTable.kv_to_idx", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_key), (&PyBytes_Type), 0, "key", 2))) __PYX_ERR(0, 337, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_value), (&PyBytes_Type), 0, "value", 2))) __PYX_ERR(0, 337, __pyx_L1_error) __pyx_r = __pyx_pf_8borghash_9HashTable_9HashTable_29kv_to_idx(((struct __pyx_obj_8borghash_9HashTable_HashTable *)__pyx_v_self), __pyx_v_key, __pyx_v_value); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } goto __pyx_L7_cleaned_up; __pyx_L0:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_9HashTable_9HashTable_29kv_to_idx(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value) { size_t __pyx_v_index; uint32_t __pyx_v_kv_index; PyObject *__pyx_v_value_found = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; size_t __pyx_t_5; uint8_t *__pyx_t_6; int __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("kv_to_idx", 0); /* "borghash/HashTable.pyx":342 * This can be used to "abbreviate" a known key/value pair (e.g., 256-bit key + 32-bit value -> 32-bit index). * """ * if len(key) != self.ksize: # <<<<<<<<<<<<<< * raise ValueError("Key size does not match the defined size") * if len(value) != self.vsize: */ __pyx_t_1 = __Pyx_PyBytes_GET_SIZE(__pyx_v_key); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 342, __pyx_L1_error) __pyx_t_2 = (__pyx_t_1 != __pyx_v_self->ksize); if (unlikely(__pyx_t_2)) { /* "borghash/HashTable.pyx":343 * """ * if len(key) != self.ksize: * raise ValueError("Key size does not match the defined size") # <<<<<<<<<<<<<< * if len(value) != self.vsize: * raise ValueError("Value size does not match the defined size") */ __pyx_t_4 = NULL; __pyx_t_5 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_Key_size_does_not_match_the_defi}; __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 343, __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, 343, __pyx_L1_error) /* "borghash/HashTable.pyx":342 * This can be used to "abbreviate" a known key/value pair (e.g., 256-bit key + 32-bit value -> 32-bit index). * """ * if len(key) != self.ksize: # <<<<<<<<<<<<<< * raise ValueError("Key size does not match the defined size") * if len(value) != self.vsize: */ } /* "borghash/HashTable.pyx":344 * if len(key) != self.ksize: * raise ValueError("Key size does not match the defined size") * if len(value) != self.vsize: # <<<<<<<<<<<<<< * raise ValueError("Value size does not match the defined size") * cdef size_t index */ __pyx_t_1 = __Pyx_PyBytes_GET_SIZE(__pyx_v_value); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 344, __pyx_L1_error) __pyx_t_2 = (__pyx_t_1 != __pyx_v_self->vsize); if (unlikely(__pyx_t_2)) { /* "borghash/HashTable.pyx":345 * raise ValueError("Key size does not match the defined size") * if len(value) != self.vsize: * raise ValueError("Value size does not match the defined size") # <<<<<<<<<<<<<< * cdef size_t index * cdef uint32_t kv_index */ __pyx_t_4 = NULL; __pyx_t_5 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_Value_size_does_not_match_the_de}; __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 345, __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, 345, __pyx_L1_error) /* "borghash/HashTable.pyx":344 * if len(key) != self.ksize: * raise ValueError("Key size does not match the defined size") * if len(value) != self.vsize: # <<<<<<<<<<<<<< * raise ValueError("Value size does not match the defined size") * cdef size_t index */ } /* "borghash/HashTable.pyx":348 * cdef size_t index * cdef uint32_t kv_index * if self._lookup_index( key, &index): # <<<<<<<<<<<<<< * kv_index = self.table[index] * value_found = self.values[kv_index * self.vsize:(kv_index + 1) * self.vsize] */ __pyx_t_6 = __Pyx_PyBytes_AsWritableUString(__pyx_v_key); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 348, __pyx_L1_error) __pyx_t_7 = ((struct __pyx_vtabstruct_8borghash_9HashTable_HashTable *)__pyx_v_self->__pyx_vtab)->_lookup_index(__pyx_v_self, ((uint8_t *)__pyx_t_6), (&__pyx_v_index), NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 348, __pyx_L1_error) __pyx_t_2 = (__pyx_t_7 != 0); if (__pyx_t_2) { /* "borghash/HashTable.pyx":349 * cdef uint32_t kv_index * if self._lookup_index( key, &index): * kv_index = self.table[index] # <<<<<<<<<<<<<< * value_found = self.values[kv_index * self.vsize:(kv_index + 1) * self.vsize] * if value == value_found: */ __pyx_v_kv_index = (__pyx_v_self->table[__pyx_v_index]); /* "borghash/HashTable.pyx":350 * if self._lookup_index( key, &index): * kv_index = self.table[index] * value_found = self.values[kv_index * self.vsize:(kv_index + 1) * self.vsize] # <<<<<<<<<<<<<< * if value == value_found: * return kv_index */ __pyx_t_3 = __Pyx_PyBytes_FromStringAndSize(((char const *)__pyx_v_self->values) + (__pyx_v_kv_index * __pyx_v_self->vsize), ((__pyx_v_kv_index + 1) * __pyx_v_self->vsize) - (__pyx_v_kv_index * __pyx_v_self->vsize)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 350, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_value_found = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; /* "borghash/HashTable.pyx":351 * kv_index = self.table[index] * value_found = self.values[kv_index * self.vsize:(kv_index + 1) * self.vsize] * if value == value_found: # <<<<<<<<<<<<<< * return kv_index * raise KeyError("Key/Value not found") */ __pyx_t_2 = __Pyx_PyObject_CompareBoolEq_bytes_bytes(__pyx_v_value, __pyx_v_value_found, Py_EQ); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 351, __pyx_L1_error) if (__pyx_t_2) { /* "borghash/HashTable.pyx":352 * value_found = self.values[kv_index * self.vsize:(kv_index + 1) * self.vsize] * if value == value_found: * return kv_index # <<<<<<<<<<<<<< * raise KeyError("Key/Value not found") * */ __pyx_t_3 = __Pyx_PyLong_From_uint32_t(__pyx_v_kv_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 352, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__Pyx_PyInt_FromNumber(&__pyx_t_3, NULL, 0) < (0)) __PYX_ERR(0, 352, __pyx_L1_error) { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __pyx_r = ((PyObject*)__pyx_t_3); } __Pyx_XDECREF(__pyx_temp); } __pyx_t_3 = 0; goto __pyx_L0; /* "borghash/HashTable.pyx":351 * kv_index = self.table[index] * value_found = self.values[kv_index * self.vsize:(kv_index + 1) * self.vsize] * if value == value_found: # <<<<<<<<<<<<<< * return kv_index * raise KeyError("Key/Value not found") */ } /* "borghash/HashTable.pyx":348 * cdef size_t index * cdef uint32_t kv_index * if self._lookup_index( key, &index): # <<<<<<<<<<<<<< * kv_index = self.table[index] * value_found = self.values[kv_index * self.vsize:(kv_index + 1) * self.vsize] */ } /* "borghash/HashTable.pyx":353 * if value == value_found: * return kv_index * raise KeyError("Key/Value not found") # <<<<<<<<<<<<<< * * def idx_to_kv(self, idx: int) -> tuple[bytes, bytes]: */ __pyx_t_4 = NULL; __pyx_t_5 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_Key_Value_not_found}; __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_KeyError)), __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 353, __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, 353, __pyx_L1_error) /* "borghash/HashTable.pyx":337 * return self.keys[kv_index * self.ksize:(kv_index + 1) * self.ksize] * * def kv_to_idx(self, key: bytes, value: bytes) -> int: # <<<<<<<<<<<<<< * """ * Return the key's/value's index in the keys/values array (index is stable while in memory). */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("borghash.HashTable.HashTable.kv_to_idx", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_value_found); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTable.pyx":355 * raise KeyError("Key/Value not found") * * def idx_to_kv(self, idx: int) -> tuple[bytes, bytes]: # <<<<<<<<<<<<<< * """ * For a given index, return the key/value stored at that index in the keys/values array. */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_9HashTable_9HashTable_32idx_to_kv(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_8borghash_9HashTable_9HashTable_31idx_to_kv, "\n For a given index, return the key/value stored at that index in the keys/values array.\n This is the reverse of kv_to_idx (e.g., 32-bit index -> 256-bit key + 32-bit value).\n "); static PyMethodDef __pyx_mdef_8borghash_9HashTable_9HashTable_32idx_to_kv = {"idx_to_kv", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_9HashTable_9HashTable_32idx_to_kv, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8borghash_9HashTable_9HashTable_31idx_to_kv}; static PyObject *__pyx_pw_8borghash_9HashTable_9HashTable_32idx_to_kv(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_idx = 0; #if !CYTHON_VECTORCALL 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("idx_to_kv (wrapper)", 0); #if !CYTHON_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_idx,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 355, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 355, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "idx_to_kv", 0) < (0)) __PYX_ERR(0, 355, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("idx_to_kv", 1, 1, 1, i); __PYX_ERR(0, 355, __pyx_L3_error) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 355, __pyx_L3_error) } if (__Pyx_PyInt_FromNumber(&values[0], "idx", 0) < (0)) __PYX_ERR(0, 355, __pyx_L3_error) __pyx_v_idx = ((PyObject*)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("idx_to_kv", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 355, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("borghash.HashTable.HashTable.idx_to_kv", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_idx), (&PyLong_Type), 0, "idx", 2))) __PYX_ERR(0, 355, __pyx_L1_error) __pyx_r = __pyx_pf_8borghash_9HashTable_9HashTable_31idx_to_kv(((struct __pyx_obj_8borghash_9HashTable_HashTable *)__pyx_v_self), __pyx_v_idx); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } goto __pyx_L7_cleaned_up; __pyx_L0:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_9HashTable_9HashTable_31idx_to_kv(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self, PyObject *__pyx_v_idx) { uint32_t __pyx_v_kv_index; PyObject *__pyx_v_key = NULL; PyObject *__pyx_v_value = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations uint32_t __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("idx_to_kv", 0); /* "borghash/HashTable.pyx":360 * This is the reverse of kv_to_idx (e.g., 32-bit index -> 256-bit key + 32-bit value). * """ * cdef uint32_t kv_index = idx # <<<<<<<<<<<<<< * key = self.keys[kv_index * self.ksize:(kv_index + 1) * self.ksize] * value = self.values[kv_index * self.vsize:(kv_index + 1) * self.vsize] */ __pyx_t_1 = __Pyx_PyLong_As_uint32_t(__pyx_v_idx); if (unlikely((__pyx_t_1 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 360, __pyx_L1_error) __pyx_v_kv_index = ((uint32_t)__pyx_t_1); /* "borghash/HashTable.pyx":361 * """ * cdef uint32_t kv_index = idx * key = self.keys[kv_index * self.ksize:(kv_index + 1) * self.ksize] # <<<<<<<<<<<<<< * value = self.values[kv_index * self.vsize:(kv_index + 1) * self.vsize] * return key, value */ __pyx_t_2 = __Pyx_PyBytes_FromStringAndSize(((char const *)__pyx_v_self->keys) + (__pyx_v_kv_index * __pyx_v_self->ksize), ((__pyx_v_kv_index + 1) * __pyx_v_self->ksize) - (__pyx_v_kv_index * __pyx_v_self->ksize)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 361, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_key = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTable.pyx":362 * cdef uint32_t kv_index = idx * key = self.keys[kv_index * self.ksize:(kv_index + 1) * self.ksize] * value = self.values[kv_index * self.vsize:(kv_index + 1) * self.vsize] # <<<<<<<<<<<<<< * return key, value * */ __pyx_t_2 = __Pyx_PyBytes_FromStringAndSize(((char const *)__pyx_v_self->values) + (__pyx_v_kv_index * __pyx_v_self->vsize), ((__pyx_v_kv_index + 1) * __pyx_v_self->vsize) - (__pyx_v_kv_index * __pyx_v_self->vsize)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 362, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_value = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTable.pyx":363 * key = self.keys[kv_index * self.ksize:(kv_index + 1) * self.ksize] * value = self.values[kv_index * self.vsize:(kv_index + 1) * self.vsize] * return key, value # <<<<<<<<<<<<<< * * @property */ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 363, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_key); __Pyx_GIVEREF(__pyx_v_key); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_key) != (0)) __PYX_ERR(0, 363, __pyx_L1_error); __Pyx_INCREF(__pyx_v_value); __Pyx_GIVEREF(__pyx_v_value); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_value) != (0)) __PYX_ERR(0, 363, __pyx_L1_error); { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __pyx_r = ((PyObject*)__pyx_t_2); } __Pyx_XDECREF(__pyx_temp); } __pyx_t_2 = 0; goto __pyx_L0; /* "borghash/HashTable.pyx":355 * raise KeyError("Key/Value not found") * * def idx_to_kv(self, idx: int) -> tuple[bytes, bytes]: # <<<<<<<<<<<<<< * """ * For a given index, return the key/value stored at that index in the keys/values array. */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("borghash.HashTable.HashTable.idx_to_kv", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_key); __Pyx_XDECREF(__pyx_v_value); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTable.pyx":365 * return key, value * * @property # <<<<<<<<<<<<<< * def stats(self) -> dict[str, int]: * return { */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_9HashTable_9HashTable_5stats_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_8borghash_9HashTable_9HashTable_5stats_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_8borghash_9HashTable_9HashTable_5stats___get__(((struct __pyx_obj_8borghash_9HashTable_HashTable *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_9HashTable_9HashTable_5stats___get__(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self) { PyObject *__pyx_r = NULL; __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("__get__", 0); /* "borghash/HashTable.pyx":368 * def stats(self) -> dict[str, int]: * return { * "get": self.stats_get, # <<<<<<<<<<<<<< * "set": self.stats_set, * "del": self.stats_del, */ __pyx_t_1 = __Pyx_PyDict_NewPresized(8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 368, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_self->stats_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 368, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_get, __pyx_t_2) < (0)) __PYX_ERR(0, 368, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTable.pyx":369 * return { * "get": self.stats_get, * "set": self.stats_set, # <<<<<<<<<<<<<< * "del": self.stats_del, * "iter": self.stats_iter, */ __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_self->stats_set); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 369, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_set, __pyx_t_2) < (0)) __PYX_ERR(0, 368, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTable.pyx":370 * "get": self.stats_get, * "set": self.stats_set, * "del": self.stats_del, # <<<<<<<<<<<<<< * "iter": self.stats_iter, * "lookup": self.stats_lookup, */ __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_self->stats_del); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 370, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_del, __pyx_t_2) < (0)) __PYX_ERR(0, 368, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTable.pyx":371 * "set": self.stats_set, * "del": self.stats_del, * "iter": self.stats_iter, # <<<<<<<<<<<<<< * "lookup": self.stats_lookup, * "linear": self.stats_linear, */ __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_self->stats_iter); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 371, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_iter, __pyx_t_2) < (0)) __PYX_ERR(0, 368, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTable.pyx":372 * "del": self.stats_del, * "iter": self.stats_iter, * "lookup": self.stats_lookup, # <<<<<<<<<<<<<< * "linear": self.stats_linear, * "resize_table": self.stats_resize_table, */ __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_self->stats_lookup); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 372, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_lookup, __pyx_t_2) < (0)) __PYX_ERR(0, 368, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTable.pyx":373 * "iter": self.stats_iter, * "lookup": self.stats_lookup, * "linear": self.stats_linear, # <<<<<<<<<<<<<< * "resize_table": self.stats_resize_table, * "resize_kv": self.stats_resize_kv, */ __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_self->stats_linear); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 373, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_linear, __pyx_t_2) < (0)) __PYX_ERR(0, 368, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTable.pyx":374 * "lookup": self.stats_lookup, * "linear": self.stats_linear, * "resize_table": self.stats_resize_table, # <<<<<<<<<<<<<< * "resize_kv": self.stats_resize_kv, * } */ __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_self->stats_resize_table); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 374, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_resize_table, __pyx_t_2) < (0)) __PYX_ERR(0, 368, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTable.pyx":375 * "linear": self.stats_linear, * "resize_table": self.stats_resize_table, * "resize_kv": self.stats_resize_kv, # <<<<<<<<<<<<<< * } */ __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_self->stats_resize_kv); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 375, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_resize_kv, __pyx_t_2) < (0)) __PYX_ERR(0, 368, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __pyx_r = __pyx_t_1; } __Pyx_XDECREF(__pyx_temp); } __pyx_t_1 = 0; goto __pyx_L0; /* "borghash/HashTable.pyx":365 * return key, value * * @property # <<<<<<<<<<<<<< * def stats(self) -> dict[str, int]: * return { */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("borghash.HashTable.HashTable.stats.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTable.pxd":5 * cdef class HashTable: * cdef int ksize, vsize * cdef readonly size_t capacity, used # <<<<<<<<<<<<<< * cdef size_t initial_capacity, tombstones * cdef float max_load_factor, min_load_factor, shrink_factor, grow_factor, rehash_threshold */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_9HashTable_9HashTable_8capacity_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_8borghash_9HashTable_9HashTable_8capacity_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_8borghash_9HashTable_9HashTable_8capacity___get__(((struct __pyx_obj_8borghash_9HashTable_HashTable *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_9HashTable_9HashTable_8capacity___get__(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self) { PyObject *__pyx_r = NULL; __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("__get__", 0); { __Pyx_PyCriticalSection __pyx_cs; __pyx_t_1 = ((PyObject *)__pyx_v_self); __Pyx_INCREF(__pyx_t_1); __Pyx_PyCriticalSection_Begin(&__pyx_cs, (PyObject*)__pyx_t_1); /*try:*/ { __pyx_t_2 = __Pyx_PyLong_FromSize_t(__pyx_v_self->capacity); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_2); { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __pyx_r = __pyx_t_2; } __Pyx_XDECREF(__pyx_temp); } __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L3_return; } /*finally:*/ { __pyx_L3_return: { __pyx_t_3 = __pyx_r; __pyx_r = 0; __Pyx_PyCriticalSection_End(&__pyx_cs); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; } __pyx_L4_error: { __Pyx_PyCriticalSection_End(&__pyx_cs); goto __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("borghash.HashTable.HashTable.capacity.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_pw_8borghash_9HashTable_9HashTable_4used_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_8borghash_9HashTable_9HashTable_4used_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_8borghash_9HashTable_9HashTable_4used___get__(((struct __pyx_obj_8borghash_9HashTable_HashTable *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_9HashTable_9HashTable_4used___get__(struct __pyx_obj_8borghash_9HashTable_HashTable *__pyx_v_self) { PyObject *__pyx_r = NULL; __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("__get__", 0); { __Pyx_PyCriticalSection __pyx_cs; __pyx_t_1 = ((PyObject *)__pyx_v_self); __Pyx_INCREF(__pyx_t_1); __Pyx_PyCriticalSection_Begin(&__pyx_cs, (PyObject*)__pyx_t_1); /*try:*/ { __pyx_t_2 = __Pyx_PyLong_FromSize_t(__pyx_v_self->used); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_2); { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __pyx_r = __pyx_t_2; } __Pyx_XDECREF(__pyx_temp); } __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L3_return; } /*finally:*/ { __pyx_L3_return: { __pyx_t_3 = __pyx_r; __pyx_r = 0; __Pyx_PyCriticalSection_End(&__pyx_cs); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; } __pyx_L4_error: { __Pyx_PyCriticalSection_End(&__pyx_cs); goto __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("borghash.HashTable.HashTable.used.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "self.table cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_9HashTable_9HashTable_34__reduce_cython__(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_8borghash_9HashTable_9HashTable_34__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_9HashTable_9HashTable_34__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_8borghash_9HashTable_9HashTable_34__reduce_cython__(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { #if !CYTHON_VECTORCALL 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_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; } const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) return NULL; if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;} __pyx_r = __pyx_pf_8borghash_9HashTable_9HashTable_33__reduce_cython__(((struct __pyx_obj_8borghash_9HashTable_HashTable *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_9HashTable_9HashTable_33__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_8borghash_9HashTable_HashTable *__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__", 0); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError, "self.table cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError, "self.table cannot be converted to a Python object for pickling" */ __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_TypeError))), __pyx_mstate_global->__pyx_kp_u_self_table_cannot_be_converted_t, 0, 0); __PYX_ERR(2, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "self.table cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("borghash.HashTable.HashTable.__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.table cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "self.table cannot be converted to a Python object for pickling" */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_9HashTable_9HashTable_36__setstate_cython__(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_8borghash_9HashTable_9HashTable_36__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_9HashTable_9HashTable_36__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_8borghash_9HashTable_9HashTable_36__setstate_cython__(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_VECTORCALL 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_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 3, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 3, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__setstate_cython__", 0) < (0)) __PYX_ERR(2, 3, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(2, 3, __pyx_L3_error) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 3, __pyx_L3_error) } __pyx_v___pyx_state = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 3, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("borghash.HashTable.HashTable.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8borghash_9HashTable_9HashTable_35__setstate_cython__(((struct __pyx_obj_8borghash_9HashTable_HashTable *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_9HashTable_9HashTable_35__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_8borghash_9HashTable_HashTable *__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__", 0); /* "(tree fragment)":4 * raise TypeError, "self.table cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): * raise TypeError, "self.table cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< */ __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_TypeError))), __pyx_mstate_global->__pyx_kp_u_self_table_cannot_be_converted_t, 0, 0); __PYX_ERR(2, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError, "self.table cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "self.table cannot be converted to a Python object for pickling" */ /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("borghash.HashTable.HashTable.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* #### Code section: module_exttypes ### */ static struct __pyx_vtabstruct_8borghash_9HashTable_HashTable __pyx_vtable_8borghash_9HashTable_HashTable; static PyObject *__pyx_tp_new__initialisation_8borghash_9HashTable_HashTable(PyObject *o, #if CYTHON_VECTORCALL_TPNEW CYTHON_UNUSED PyObject *const *args, CYTHON_UNUSED Py_ssize_t nargs, CYTHON_UNUSED PyObject *kwnames #else CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k #endif ) { struct __pyx_obj_8borghash_9HashTable_HashTable *p = ((struct __pyx_obj_8borghash_9HashTable_HashTable *)o); p->__pyx_vtab = __pyx_vtabptr_8borghash_9HashTable_HashTable; return o; } static PyObject *__pyx_tp_new_vectorcall_8borghash_9HashTable_HashTable(PyTypeObject *t, #if CYTHON_VECTORCALL_TPNEW PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames #else PyObject *a, PyObject *k #endif ) { PyObject *o; o = __Pyx_AllocateExtensionType(t, 0); if (unlikely(!o)) return 0; return __pyx_tp_new__initialisation_8borghash_9HashTable_HashTable(o, #if CYTHON_VECTORCALL_TPNEW args, nargs, kwnames #else a, k #endif ); } #if CYTHON_VECTORCALL_TPNEW static PyObject *__pyx_tp_new_8borghash_9HashTable_HashTable(PyTypeObject *t, PyObject *a, PyObject *k) { return __Pyx_CallTpnewAsVectorcall(__pyx_tp_new_vectorcall_8borghash_9HashTable_HashTable, t, a, k); } #endif #if CYTHON_VECTORCALL_TPNEW static PyObject *__pyx_tp_vectorcall_8borghash_9HashTable_HashTable(PyObject *t, PyObject *const *args, size_t nargsf, PyObject *kwnames) { if (unlikely((PyTypeObject*)t != __pyx_mstate_global->__pyx_ptype_8borghash_9HashTable_HashTable || __Pyx_PyType_HasFeature((PyTypeObject*)t, Py_TPFLAGS_IS_ABSTRACT))) { return __Pyx_CallNewInitFromVectorcall((PyTypeObject*)t, args, nargsf, kwnames); } Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); PyObject *o = __pyx_tp_new_vectorcall_8borghash_9HashTable_HashTable((PyTypeObject*)t, args, nargs, kwnames); if (likely(o)) { assert(Py_TYPE(o) == (PyTypeObject*)t); if (unlikely(__pyx_pw_8borghash_9HashTable_9HashTable_1__init__(o, args, nargs, kwnames) < 0)) { Py_CLEAR(o); } } return o; } #endif #if CYTHON_VECTORCALL_TPNEW static int __pyx_tp_init_8borghash_9HashTable_HashTable(PyObject *o, PyObject *args, PyObject *kwds) { return __Pyx_CallTpinitAsVectorcall(__pyx_pw_8borghash_9HashTable_9HashTable_1__init__, o, args, kwds); } #endif #if CYTHON_USE_TP_FINALIZE static void __pyx_tp_finalize_8borghash_9HashTable_HashTable(PyObject *o) { PyObject *etype, *eval, *etb; __Pyx_PyErr_FetchException(&etype, &eval, &etb); __pyx_pw_8borghash_9HashTable_9HashTable_3__del__(o); __Pyx_PyErr_RestoreException(etype, eval, etb); } #endif static void __pyx_tp_dealloc_8borghash_9HashTable_HashTable(PyObject *o) { #if CYTHON_USE_TP_FINALIZE if (unlikely(__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_8borghash_9HashTable_HashTable) { if (PyObject_CallFinalizerFromDealloc(o)) return; } } #endif PyTypeObject *tp = Py_TYPE(o); #if CYTHON_USE_TYPE_SLOTS (*tp->tp_free)(o); #else { freefunc tp_free = (freefunc)PyType_GetSlot(tp, Py_tp_free); if (tp_free) tp_free(o); } #endif #if CYTHON_USE_TYPE_SPECS Py_DECREF(tp); #endif } static PyObject *__pyx_sq_item_8borghash_9HashTable_HashTable(PyObject *o, Py_ssize_t i) { PyObject *r; PyObject *x = PyLong_FromSsize_t(i); if (unlikely(!x)) return NULL; #if CYTHON_USE_TYPE_SLOTS || (!CYTHON_USE_TYPE_SPECS && __PYX_LIMITED_VERSION_HEX < 0x030A0000) binaryfunc f = Py_TYPE(o)->tp_as_mapping->mp_subscript; #else binaryfunc f = ((binaryfunc)PyType_GetSlot(Py_TYPE(o), Py_mp_subscript)); #endif r = f(o, x); Py_DECREF(x); return r; } static PyObject *__pyx_mp_subscript_8borghash_9HashTable_HashTable(PyObject *o, PyObject *i) { return __pyx_pw_8borghash_9HashTable_9HashTable_13__getitem__(o, i); } static int __pyx_sq_ass_item_8borghash_9HashTable_HashTable(PyObject *o, Py_ssize_t i, PyObject *v) { if (v) { PyObject *x = PyLong_FromSsize_t(i); if (unlikely(!x)) return -1; int r = __pyx_pw_8borghash_9HashTable_9HashTable_9__setitem__(o, x, v); Py_DECREF(x); return r; } else { PyObject *x = PyLong_FromSsize_t(i); if (unlikely(!x)) return -1; int r = __pyx_pw_8borghash_9HashTable_9HashTable_15__delitem__(o, x); Py_DECREF(x); return r; } } static int __pyx_mp_ass_subscript_8borghash_9HashTable_HashTable(PyObject *o, PyObject *i, PyObject *v) { if (v) { return __pyx_pw_8borghash_9HashTable_9HashTable_9__setitem__(o, i, v); } else { return __pyx_pw_8borghash_9HashTable_9HashTable_15__delitem__(o, i); } } static PyObject *__pyx_getprop_8borghash_9HashTable_9HashTable_stats(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_8borghash_9HashTable_9HashTable_5stats_1__get__(o); } static PyObject *__pyx_getprop_8borghash_9HashTable_9HashTable_capacity(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_8borghash_9HashTable_9HashTable_8capacity_1__get__(o); } static PyObject *__pyx_getprop_8borghash_9HashTable_9HashTable_used(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_8borghash_9HashTable_9HashTable_4used_1__get__(o); } static PyMethodDef __pyx_methods_8borghash_9HashTable_HashTable[] = { {"clear", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_9HashTable_9HashTable_5clear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8borghash_9HashTable_9HashTable_4clear}, {"setdefault", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_9HashTable_9HashTable_17setdefault, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {"get", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_9HashTable_9HashTable_19get, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {"pop", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_9HashTable_9HashTable_21pop, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {"items", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_9HashTable_9HashTable_23items, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8borghash_9HashTable_9HashTable_22items}, {"k_to_idx", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_9HashTable_9HashTable_26k_to_idx, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8borghash_9HashTable_9HashTable_25k_to_idx}, {"idx_to_k", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_9HashTable_9HashTable_28idx_to_k, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8borghash_9HashTable_9HashTable_27idx_to_k}, {"kv_to_idx", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_9HashTable_9HashTable_30kv_to_idx, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8borghash_9HashTable_9HashTable_29kv_to_idx}, {"idx_to_kv", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_9HashTable_9HashTable_32idx_to_kv, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8borghash_9HashTable_9HashTable_31idx_to_kv}, {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_9HashTable_9HashTable_34__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_9HashTable_9HashTable_36__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_8borghash_9HashTable_HashTable[] = { {"stats", __pyx_getprop_8borghash_9HashTable_9HashTable_stats, 0, 0, 0}, {"capacity", __pyx_getprop_8borghash_9HashTable_9HashTable_capacity, 0, 0, 0}, {"used", __pyx_getprop_8borghash_9HashTable_9HashTable_used, 0, 0, 0}, {0, 0, 0, 0, 0} }; #if CYTHON_USE_TYPE_SPECS static PyType_Slot __pyx_type_8borghash_9HashTable_HashTable_slots[] = { {Py_tp_dealloc, (void *)__pyx_tp_dealloc_8borghash_9HashTable_HashTable}, {Py_sq_length, (void *)__pyx_pw_8borghash_9HashTable_9HashTable_7__len__}, {Py_sq_item, (void *)__pyx_sq_item_8borghash_9HashTable_HashTable}, {Py_sq_ass_item, (void *)__pyx_sq_ass_item_8borghash_9HashTable_HashTable}, {Py_sq_contains, (void *)__pyx_pw_8borghash_9HashTable_9HashTable_11__contains__}, {Py_mp_length, (void *)__pyx_pw_8borghash_9HashTable_9HashTable_7__len__}, {Py_mp_subscript, (void *)__pyx_mp_subscript_8borghash_9HashTable_HashTable}, {Py_mp_ass_subscript, (void *)__pyx_mp_ass_subscript_8borghash_9HashTable_HashTable}, {Py_tp_methods, (void *)__pyx_methods_8borghash_9HashTable_HashTable}, {Py_tp_getset, (void *)__pyx_getsets_8borghash_9HashTable_HashTable}, {Py_tp_init, (void *)__pyx_tp_init_8borghash_9HashTable_HashTable}, {Py_tp_new, (void *)__pyx_tp_new_8borghash_9HashTable_HashTable}, #if CYTHON_USE_TP_FINALIZE {Py_tp_finalize, (void *)__pyx_tp_finalize_8borghash_9HashTable_HashTable}, #endif #if (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) && (!CYTHON_COMPILING_IN_LIMITED_API || __PYX_LIMITED_VERSION_HEX >= 0x030E0000) #if CYTHON_VECTORCALL_TPNEW {Py_tp_vectorcall, (void *)__pyx_tp_vectorcall_8borghash_9HashTable_HashTable}, #endif #endif {0, 0}, }; static PyType_Spec __pyx_type_8borghash_9HashTable_HashTable_spec = { "borghash.HashTable.HashTable", sizeof(struct __pyx_obj_8borghash_9HashTable_HashTable), 0, Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_BASETYPE, __pyx_type_8borghash_9HashTable_HashTable_slots, }; #else static PySequenceMethods __pyx_tp_as_sequence_HashTable = { __pyx_pw_8borghash_9HashTable_9HashTable_7__len__, /*sq_length*/ 0, /*sq_concat*/ 0, /*sq_repeat*/ __pyx_sq_item_8borghash_9HashTable_HashTable, /*sq_item*/ 0, /*sq_slice*/ __pyx_sq_ass_item_8borghash_9HashTable_HashTable, /*sq_ass_item*/ 0, /*sq_ass_slice*/ __pyx_pw_8borghash_9HashTable_9HashTable_11__contains__, /*sq_contains*/ 0, /*sq_inplace_concat*/ 0, /*sq_inplace_repeat*/ }; static PyMappingMethods __pyx_tp_as_mapping_HashTable = { __pyx_pw_8borghash_9HashTable_9HashTable_7__len__, /*mp_length*/ __pyx_mp_subscript_8borghash_9HashTable_HashTable, /*mp_subscript*/ __pyx_mp_ass_subscript_8borghash_9HashTable_HashTable, /*mp_ass_subscript*/ }; static PyTypeObject __pyx_type_8borghash_9HashTable_HashTable = { PyVarObject_HEAD_INIT(0, 0) "borghash.HashTable.""HashTable", /*tp_name*/ sizeof(struct __pyx_obj_8borghash_9HashTable_HashTable), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_8borghash_9HashTable_HashTable, /*tp_dealloc*/ 0, /*tp_vectorcall_offset*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ 0, /*tp_as_async*/ 0, /*tp_repr*/ 0, /*tp_as_number*/ &__pyx_tp_as_sequence_HashTable, /*tp_as_sequence*/ &__pyx_tp_as_mapping_HashTable, /*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_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_8borghash_9HashTable_HashTable, /*tp_methods*/ 0, /*tp_members*/ __pyx_getsets_8borghash_9HashTable_HashTable, /*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_tp_init_8borghash_9HashTable_HashTable, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_8borghash_9HashTable_HashTable, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if CYTHON_USE_TP_FINALIZE __pyx_tp_finalize_8borghash_9HashTable_HashTable, /*tp_finalize*/ #else NULL, /*tp_finalize*/ #endif #if (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) && (!CYTHON_COMPILING_IN_LIMITED_API || __PYX_LIMITED_VERSION_HEX >= 0x030E0000) #if CYTHON_VECTORCALL_TPNEW __pyx_tp_vectorcall_8borghash_9HashTable_HashTable, /*tp_vectorcall*/ #else NULL, /*tp_vectorcall*/ #endif #endif #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030C0000 0, /*tp_watched*/ #endif #if PY_VERSION_HEX >= 0x030d00A4 0, /*tp_versions_used*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; #endif static PyObject *__pyx_tp_new__initialisation_8borghash_9HashTable___pyx_scope_struct__items(PyObject *o, #if CYTHON_VECTORCALL_TPNEW CYTHON_UNUSED PyObject *const *args, CYTHON_UNUSED Py_ssize_t nargs, CYTHON_UNUSED PyObject *kwnames #else CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k #endif ) { return o; } static PyObject *__pyx_tp_new_vectorcall_8borghash_9HashTable___pyx_scope_struct__items(PyTypeObject *t, #if CYTHON_VECTORCALL_TPNEW PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames #else PyObject *a, PyObject *k #endif ) { PyObject *o; #if CYTHON_USE_FREELISTS if (likely((int)(__pyx_mstate_global->__pyx_freecount_8borghash_9HashTable___pyx_scope_struct__items > 0) & __PYX_CHECK_FINAL_TYPE_FOR_FREELISTS(t, __pyx_mstate_global->__pyx_ptype_8borghash_9HashTable___pyx_scope_struct__items, sizeof(struct __pyx_obj_8borghash_9HashTable___pyx_scope_struct__items)))) { o = (PyObject*)__pyx_mstate_global->__pyx_freelist_8borghash_9HashTable___pyx_scope_struct__items[--__pyx_mstate_global->__pyx_freecount_8borghash_9HashTable___pyx_scope_struct__items]; #if CYTHON_USE_TYPE_SPECS Py_DECREF(Py_TYPE(o)); #endif memset(o, 0, sizeof(struct __pyx_obj_8borghash_9HashTable___pyx_scope_struct__items)); #if CYTHON_COMPILING_IN_LIMITED_API (void) PyObject_Init(o, t); #else (void) PyObject_INIT(o, t); #endif PyObject_GC_Track(o); } else #endif { o = __Pyx_AllocateExtensionType(t, 1); } if (unlikely(!o)) return 0; return __pyx_tp_new__initialisation_8borghash_9HashTable___pyx_scope_struct__items(o, #if CYTHON_VECTORCALL_TPNEW args, nargs, kwnames #else a, k #endif ); } #if CYTHON_VECTORCALL_TPNEW static PyObject *__pyx_tp_new_8borghash_9HashTable___pyx_scope_struct__items(PyTypeObject *t, PyObject *a, PyObject *k) { return __Pyx_CallTpnewAsVectorcall(__pyx_tp_new_vectorcall_8borghash_9HashTable___pyx_scope_struct__items, t, a, k); } #endif #if CYTHON_VECTORCALL_TPNEW static PyObject *__pyx_tp_vectorcall_8borghash_9HashTable___pyx_scope_struct__items(PyObject *t, PyObject *const *args, size_t nargsf, PyObject *kwnames) { if (unlikely((PyTypeObject*)t != __pyx_mstate_global->__pyx_ptype_8borghash_9HashTable___pyx_scope_struct__items || __Pyx_PyType_HasFeature((PyTypeObject*)t, Py_TPFLAGS_IS_ABSTRACT))) { return __Pyx_CallNewInitFromVectorcall((PyTypeObject*)t, args, nargsf, kwnames); } Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); PyObject *o = __pyx_tp_new_vectorcall_8borghash_9HashTable___pyx_scope_struct__items((PyTypeObject*)t, args, nargs, kwnames); return o; } #endif static void __pyx_tp_dealloc_8borghash_9HashTable___pyx_scope_struct__items(PyObject *o) { struct __pyx_obj_8borghash_9HashTable___pyx_scope_struct__items *p = (struct __pyx_obj_8borghash_9HashTable___pyx_scope_struct__items *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_8borghash_9HashTable___pyx_scope_struct__items) { if (PyObject_CallFinalizerFromDealloc(o)) return; } } #endif PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_key); Py_CLEAR(p->__pyx_v_prefix); Py_CLEAR(p->__pyx_v_prefix_bits); Py_CLEAR(p->__pyx_v_self); Py_CLEAR(p->__pyx_v_value); #if CYTHON_USE_FREELISTS if (likely((int)(__pyx_mstate_global->__pyx_freecount_8borghash_9HashTable___pyx_scope_struct__items < 8) & __PYX_CHECK_FINAL_TYPE_FOR_FREELISTS(Py_TYPE(o), __pyx_mstate_global->__pyx_ptype_8borghash_9HashTable___pyx_scope_struct__items, sizeof(struct __pyx_obj_8borghash_9HashTable___pyx_scope_struct__items)))) { __pyx_mstate_global->__pyx_freelist_8borghash_9HashTable___pyx_scope_struct__items[__pyx_mstate_global->__pyx_freecount_8borghash_9HashTable___pyx_scope_struct__items++] = ((struct __pyx_obj_8borghash_9HashTable___pyx_scope_struct__items *)o); } else #endif { PyTypeObject *tp = Py_TYPE(o); #if CYTHON_USE_TYPE_SLOTS (*tp->tp_free)(o); #else { freefunc tp_free = (freefunc)PyType_GetSlot(tp, Py_tp_free); if (tp_free) tp_free(o); } #endif #if CYTHON_USE_TYPE_SPECS Py_DECREF(tp); #endif } } static int __pyx_tp_traverse_8borghash_9HashTable___pyx_scope_struct__items(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_8borghash_9HashTable___pyx_scope_struct__items *p = (struct __pyx_obj_8borghash_9HashTable___pyx_scope_struct__items *)o; { e = __Pyx_call_type_traverse(o, 1, v, a); if (e) return e; } if (p->__pyx_v_self) { e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e; } return 0; } #if CYTHON_USE_TYPE_SPECS static PyType_Slot __pyx_type_8borghash_9HashTable___pyx_scope_struct__items_slots[] = { {Py_tp_dealloc, (void *)__pyx_tp_dealloc_8borghash_9HashTable___pyx_scope_struct__items}, {Py_tp_traverse, (void *)__pyx_tp_traverse_8borghash_9HashTable___pyx_scope_struct__items}, {Py_tp_new, (void *)__pyx_tp_new_8borghash_9HashTable___pyx_scope_struct__items}, #if (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) && (!CYTHON_COMPILING_IN_LIMITED_API || __PYX_LIMITED_VERSION_HEX >= 0x030E0000) #if CYTHON_VECTORCALL_TPNEW {Py_tp_vectorcall, (void *)__pyx_tp_vectorcall_8borghash_9HashTable___pyx_scope_struct__items}, #endif #endif {0, 0}, }; static PyType_Spec __pyx_type_8borghash_9HashTable___pyx_scope_struct__items_spec = { "borghash.HashTable.__pyx_scope_struct__items", sizeof(struct __pyx_obj_8borghash_9HashTable___pyx_scope_struct__items), 0, Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_HAVE_GC, __pyx_type_8borghash_9HashTable___pyx_scope_struct__items_slots, }; #else static PyTypeObject __pyx_type_8borghash_9HashTable___pyx_scope_struct__items = { PyVarObject_HEAD_INIT(0, 0) "borghash.HashTable.""__pyx_scope_struct__items", /*tp_name*/ sizeof(struct __pyx_obj_8borghash_9HashTable___pyx_scope_struct__items), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_8borghash_9HashTable___pyx_scope_struct__items, /*tp_dealloc*/ 0, /*tp_vectorcall_offset*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ 0, /*tp_as_async*/ 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_8borghash_9HashTable___pyx_scope_struct__items, /*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_8borghash_9HashTable___pyx_scope_struct__items, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ #else NULL, /*tp_finalize*/ #endif #if (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) && (!CYTHON_COMPILING_IN_LIMITED_API || __PYX_LIMITED_VERSION_HEX >= 0x030E0000) #if CYTHON_VECTORCALL_TPNEW __pyx_tp_vectorcall_8borghash_9HashTable___pyx_scope_struct__items, /*tp_vectorcall*/ #else NULL, /*tp_vectorcall*/ #endif #endif #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030C0000 0, /*tp_watched*/ #endif #if PY_VERSION_HEX >= 0x030d00A4 0, /*tp_versions_used*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; #endif static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; /* #### Code section: initfunc_declarations ### */ static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(__pyx_mstatetype *__pyx_mstate); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_InitAfterSharedUtility(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_Global_init_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_Variable_export_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_Function_export_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_Exttype___pyx_obj_8borghash_9HashTable_HashTable(__pyx_mstatetype *__pyx_mstate); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_Exttype___pyx_obj_8borghash_9HashTable___pyx_scope_struct__items(__pyx_mstatetype *__pyx_mstate); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_Type_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_Variable_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_Function_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate); /*proto*/ /* #### Code section: init_module ### */ static int __Pyx_modinit_Global_init_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_modinit_Global_init_code", 0); /*--- Global init code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_Variable_export_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_modinit_Variable_export_code", 0); /*--- Variable export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_Function_export_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_modinit_Function_export_code", 0); /*--- Function export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_Exttype___pyx_obj_8borghash_9HashTable_HashTable(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_modinit_Exttype___pyx_obj_8borghash_9HashTable_HashTable", 0); /*--- Exttype __pyx_obj_8borghash_9HashTable_HashTable ---*/ __pyx_vtabptr_8borghash_9HashTable_HashTable = &__pyx_vtable_8borghash_9HashTable_HashTable; __pyx_vtable_8borghash_9HashTable_HashTable._get_index = (size_t (*)(struct __pyx_obj_8borghash_9HashTable_HashTable *, uint8_t *))__pyx_f_8borghash_9HashTable_9HashTable__get_index; __pyx_vtable_8borghash_9HashTable_HashTable._lookup_index = (int (*)(struct __pyx_obj_8borghash_9HashTable_HashTable *, uint8_t *, size_t *, struct __pyx_opt_args_8borghash_9HashTable_9HashTable__lookup_index *__pyx_optional_args))__pyx_f_8borghash_9HashTable_9HashTable__lookup_index; __pyx_vtable_8borghash_9HashTable_HashTable._resize_table = (void (*)(struct __pyx_obj_8borghash_9HashTable_HashTable *, size_t))__pyx_f_8borghash_9HashTable_9HashTable__resize_table; __pyx_vtable_8borghash_9HashTable_HashTable._resize_kv = (void (*)(struct __pyx_obj_8borghash_9HashTable_HashTable *, size_t))__pyx_f_8borghash_9HashTable_9HashTable__resize_kv; #if CYTHON_USE_TYPE_SPECS __pyx_mstate->__pyx_ptype_8borghash_9HashTable_HashTable = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_8borghash_9HashTable_HashTable_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_8borghash_9HashTable_HashTable)) __PYX_ERR(0, 45, __pyx_L1_error) #else __pyx_mstate->__pyx_ptype_8borghash_9HashTable_HashTable = &__pyx_type_8borghash_9HashTable_HashTable; #endif #if !CYTHON_COMPILING_IN_LIMITED_API #endif #if !CYTHON_USE_TYPE_SPECS if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_8borghash_9HashTable_HashTable) < (0)) __PYX_ERR(0, 45, __pyx_L1_error) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_ptype_8borghash_9HashTable_HashTable); #endif #if !CYTHON_COMPILING_IN_LIMITED_API if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_8borghash_9HashTable_HashTable->tp_dictoffset && __pyx_mstate->__pyx_ptype_8borghash_9HashTable_HashTable->tp_getattro == PyObject_GenericGetAttr)) { __pyx_mstate->__pyx_ptype_8borghash_9HashTable_HashTable->tp_getattro = PyObject_GenericGetAttr; } #endif if (__Pyx_SetVtable(__pyx_mstate->__pyx_ptype_8borghash_9HashTable_HashTable, __pyx_vtabptr_8borghash_9HashTable_HashTable) < (0)) __PYX_ERR(0, 45, __pyx_L1_error) if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_HashTable, (PyObject *) __pyx_mstate->__pyx_ptype_8borghash_9HashTable_HashTable) < (0)) __PYX_ERR(0, 45, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_8borghash_9HashTable_HashTable) < (0)) __PYX_ERR(0, 45, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_modinit_Exttype___pyx_obj_8borghash_9HashTable___pyx_scope_struct__items(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_modinit_Exttype___pyx_obj_8borghash_9HashTable___pyx_scope_struct__items", 0); /*--- Exttype __pyx_obj_8borghash_9HashTable___pyx_scope_struct__items ---*/ #if CYTHON_USE_TYPE_SPECS __pyx_mstate->__pyx_ptype_8borghash_9HashTable___pyx_scope_struct__items = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_8borghash_9HashTable___pyx_scope_struct__items_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_8borghash_9HashTable___pyx_scope_struct__items)) __PYX_ERR(0, 248, __pyx_L1_error) #else __pyx_mstate->__pyx_ptype_8borghash_9HashTable___pyx_scope_struct__items = &__pyx_type_8borghash_9HashTable___pyx_scope_struct__items; #endif #if !CYTHON_COMPILING_IN_LIMITED_API #endif #if !CYTHON_USE_TYPE_SPECS if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_8borghash_9HashTable___pyx_scope_struct__items) < (0)) __PYX_ERR(0, 248, __pyx_L1_error) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_ptype_8borghash_9HashTable___pyx_scope_struct__items); #endif #if !CYTHON_COMPILING_IN_LIMITED_API if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_8borghash_9HashTable___pyx_scope_struct__items->tp_dictoffset && __pyx_mstate->__pyx_ptype_8borghash_9HashTable___pyx_scope_struct__items->tp_getattro == PyObject_GenericGetAttr)) { __pyx_mstate->__pyx_ptype_8borghash_9HashTable___pyx_scope_struct__items->tp_getattro = PyObject_GenericGetAttr; } #endif __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_modinit_Type_import_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_modinit_Type_import_code", 0); /*--- Type import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_Variable_import_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_modinit_Variable_import_code", 0); /*--- Variable import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_Function_import_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_modinit_Function_import_code", 0); /*--- Function import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } #if CYTHON_PEP489_MULTI_PHASE_INIT static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ static int __pyx_pymod_exec_HashTable(PyObject* module); /*proto*/ static PyModuleDef_Slot __pyx_moduledef_slots[] = { {Py_mod_create, (void*)__pyx_pymod_create}, {Py_mod_exec, (void*)__pyx_pymod_exec_HashTable}, #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING {Py_mod_gil, __Pyx_FREETHREADING_COMPATIBLE}, #endif #if PY_VERSION_HEX >= 0x030C0000 && CYTHON_USE_MODULE_STATE {Py_mod_multiple_interpreters, Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED}, #endif {0, NULL} }; #endif #ifdef __cplusplus namespace { struct PyModuleDef __pyx_moduledef = #else static struct PyModuleDef __pyx_moduledef = #endif { PyModuleDef_HEAD_INIT, "HashTable", __pyx_k_HashTable_low_level_hash_table, /* m_doc */ #if CYTHON_USE_MODULE_STATE sizeof(__pyx_mstatetype), /* m_size */ #else (CYTHON_PEP489_MULTI_PHASE_INIT) ? 0 : -1, /* m_size */ #endif __pyx_methods /* m_methods */, #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_moduledef_slots, /* m_slots */ #else NULL, /* m_reload */ #endif #if CYTHON_USE_MODULE_STATE __pyx_m_traverse, /* m_traverse */ __pyx_m_clear, /* m_clear */ NULL /* m_free */ #else NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ #endif }; #ifdef __cplusplus } /* anonymous namespace */ #endif /* PyModInitFuncType */ #ifndef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #else #ifdef __cplusplus #define __Pyx_PyMODINIT_FUNC extern "C" PyObject * #else #define __Pyx_PyMODINIT_FUNC PyObject * #endif #endif __Pyx_PyMODINIT_FUNC PyInit_HashTable(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC PyInit_HashTable(void) #if CYTHON_PEP489_MULTI_PHASE_INIT { return PyModuleDef_Init(&__pyx_moduledef); } /* ModuleCreationPEP489 */ #if CYTHON_COMPILING_IN_LIMITED_API && (__PYX_LIMITED_VERSION_HEX < 0x030A0000 &&\ (defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS))) static PY_INT64_T __Pyx_GetCurrentInterpreterId(void) { { PyObject *module = PyImport_ImportModule("_interpreters"); // 3.13+ I think if (!module) { if (!PyErr_ExceptionMatches(PyExc_Exception)) { goto bad; // BaseException } PyErr_Clear(); // just try the 3.8-3.12 version module = PyImport_ImportModule("_xxsubinterpreters"); if (!module) goto bad; } PyObject *current = PyObject_CallMethod(module, "get_current", NULL); Py_DECREF(module); if (!current) goto bad; if (PyTuple_Check(current)) { PyObject *new_current = PySequence_GetItem(current, 0); Py_DECREF(current); current = new_current; if (!new_current) goto bad; } long long as_c_int = PyLong_AsLongLong(current); Py_DECREF(current); return as_c_int; } bad: PySys_WriteStderr("__Pyx_GetCurrentInterpreterId failed. Try setting the C define CYTHON_PEP489_MULTI_PHASE_INIT=0\n"); return -1; } #endif #if !CYTHON_USE_MODULE_STATE static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { static PY_INT64_T main_interpreter_id = -1; #if CYTHON_COMPILING_IN_GRAAL && defined(GRAALPY_VERSION_NUM) && GRAALPY_VERSION_NUM > 0x19000000 PY_INT64_T current_id = GraalPyInterpreterState_GetIDFromThreadState(PyThreadState_Get()); #elif CYTHON_COMPILING_IN_GRAAL PY_INT64_T current_id = PyInterpreterState_GetIDFromThreadState(PyThreadState_Get()); #elif CYTHON_COMPILING_IN_LIMITED_API && (__PYX_LIMITED_VERSION_HEX < 0x030A0000 &&\ (defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS))) PY_INT64_T current_id = __Pyx_GetCurrentInterpreterId(); #elif CYTHON_COMPILING_IN_LIMITED_API PY_INT64_T current_id = PyInterpreterState_GetID(PyInterpreterState_Get()); #else PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); #endif if (unlikely(current_id == -1)) { return -1; } if (main_interpreter_id == -1) { main_interpreter_id = current_id; return 0; } else if (unlikely(main_interpreter_id != current_id)) { PyErr_SetString( PyExc_ImportError, "Interpreter change detected - this module can only be loaded into one interpreter per process."); return -1; } return 0; } #endif static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { if (allow_none || value != Py_None) { result = PyDict_SetItemString(moddict, to_name, value); } Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Clear(); } else { result = -1; } return result; } static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; CYTHON_UNUSED_VAR(def); #if !CYTHON_USE_MODULE_STATE if (__Pyx_check_single_interpreter()) return NULL; #endif if (__pyx_m) return __Pyx_NewRef(__pyx_m); modname = PyObject_GetAttrString(spec, "name"); if (unlikely(!modname)) goto bad; module = PyModule_NewObject(modname); Py_DECREF(modname); if (unlikely(!module)) goto bad; moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; return module; bad: Py_XDECREF(module); return NULL; } static CYTHON_SMALL_CODE int __pyx_pymod_exec_HashTable(PyObject *__pyx_pyinit_module) #endif { int stringtab_initialized = 0; #if CYTHON_USE_MODULE_STATE int pystate_addmodule_run = 0; #endif __pyx_mstatetype *__pyx_mstate = NULL; PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; Py_ssize_t __pyx_t_3; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; size_t __pyx_t_6; PyObject *__pyx_t_7 = 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 'HashTable' has already been imported. Re-initialisation is not supported."); return -1; } #else if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif /*--- Module creation code ---*/ #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_t_1 = __pyx_pyinit_module; Py_INCREF(__pyx_t_1); #else __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) #endif #if CYTHON_USE_MODULE_STATE { int add_module_result = __Pyx_State_AddModule(__pyx_t_1, &__pyx_moduledef); __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "HashTable" pseudovariable */ if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error) pystate_addmodule_run = 1; } #else __pyx_m = __pyx_t_1; #endif #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING PyUnstable_Module_SetGIL(__pyx_m, Py_MOD_GIL_USED); #endif __pyx_mstate = __pyx_mstate_global; CYTHON_UNUSED_VAR(__pyx_t_1); __pyx_mstate->__pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_mstate->__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_mstate->__pyx_d); __pyx_mstate->__pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_mstate->__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_mstate->__pyx_cython_runtime = __Pyx_PyImport_AddModuleRef("cython_runtime"); if (unlikely(!__pyx_mstate->__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_mstate->__pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) /* ImportRefnannyAPI */ #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { if (PyErr_ExceptionMatches(PyExc_Exception)) { PyErr_Clear(); __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); } if (!__Pyx_RefNanny) Py_FatalError("failed to import 'refnanny' module"); } #endif __Pyx_RefNannySetupContext("PyInit_HashTable", 0); __Pyx_init_runtime_version(); 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) __pyx_mstate->__pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_mstate->__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_mstate->__pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_mstate->__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_mstate->__pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_mstate->__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Library function declarations ---*/ /*--- Initialize various global constants etc. ---*/ if (__Pyx_InitConstants(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) stringtab_initialized = 1; if (__Pyx_InitGlobals() < (0)) __PYX_ERR(0, 1, __pyx_L1_error) if (__pyx_module_is_main_borghash__HashTable) { if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_name, __pyx_mstate_global->__pyx_n_u_main) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) } { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) if (!PyDict_GetItemString(modules, "borghash.HashTable")) { if (unlikely((PyDict_SetItemString(modules, "borghash.HashTable", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) } } /*--- Builtin init code ---*/ if (__Pyx_InitCachedBuiltins(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Constants init code ---*/ if (__Pyx_InitCachedConstants(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) if (__Pyx_CreateCodeObjects(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Global type/function init code ---*/ (void)__Pyx_modinit_Global_init_code(__pyx_mstate); (void)__Pyx_modinit_Variable_export_code(__pyx_mstate); (void)__Pyx_modinit_Function_export_code(__pyx_mstate); /*--- Type init code ---*/ if (unlikely((__Pyx_modinit_Exttype___pyx_obj_8borghash_9HashTable_HashTable(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) if (unlikely((__Pyx_modinit_Exttype___pyx_obj_8borghash_9HashTable___pyx_scope_struct__items(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) (void)__Pyx_modinit_Type_import_code(__pyx_mstate); (void)__Pyx_modinit_Variable_import_code(__pyx_mstate); (void)__Pyx_modinit_Function_import_code(__pyx_mstate); if (__Pyx_InitAfterSharedUtility() < (0)) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Execution code ---*/ /* "borghash/HashTable.pyx":8 * """ * from __future__ import annotations * from typing import BinaryIO, Iterator, Any # <<<<<<<<<<<<<< * * from libc.stdlib cimport malloc, free, realloc */ { PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_BinaryIO,__pyx_mstate_global->__pyx_n_u_Iterator,__pyx_mstate_global->__pyx_n_u_Any}; __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_typing, __pyx_imported_names, 3, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) } __pyx_t_2 = __pyx_t_1; __Pyx_GOTREF(__pyx_t_2); { PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_BinaryIO,__pyx_mstate_global->__pyx_n_u_Iterator,__pyx_mstate_global->__pyx_n_u_Any}; for (__pyx_t_3=0; __pyx_t_3 < 3; __pyx_t_3++) { __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_3], __pyx_t_4) < (0)) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTable.pyx":14 * from libc.stdint cimport uint8_t, uint32_t * * from collections.abc import Mapping # <<<<<<<<<<<<<< * * MAGIC = b"BORGHASH" */ { PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_Mapping}; __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_collections_abc, __pyx_imported_names, 1, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 14, __pyx_L1_error) } __pyx_t_2 = __pyx_t_1; __Pyx_GOTREF(__pyx_t_2); { PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_Mapping}; __pyx_t_3 = 0; { __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_3], __pyx_t_4) < (0)) __PYX_ERR(0, 14, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTable.pyx":16 * from collections.abc import Mapping * * MAGIC = b"BORGHASH" # <<<<<<<<<<<<<< * assert len(MAGIC) == 8 * VERSION = 1 # version of the on-disk (serialized) format produced by .write(). */ if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MAGIC, __pyx_mstate_global->__pyx_n_b_BORGHASH) < (0)) __PYX_ERR(0, 16, __pyx_L1_error) /* "borghash/HashTable.pyx":17 * * MAGIC = b"BORGHASH" * assert len(MAGIC) == 8 # <<<<<<<<<<<<<< * VERSION = 1 # version of the on-disk (serialized) format produced by .write(). * HEADER_FMT = "<8sII" # magic, version, meta length */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(__pyx_assertions_enabled())) { __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_MAGIC); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 17, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyObject_Length(__pyx_t_2); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 17, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_5 = (__pyx_t_3 == 8); if (unlikely(!__pyx_t_5)) { __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_AssertionError))), 0, 0, 0); __PYX_ERR(0, 17, __pyx_L1_error) } } #else if ((1)); else __PYX_ERR(0, 17, __pyx_L1_error) #endif /* "borghash/HashTable.pyx":18 * MAGIC = b"BORGHASH" * assert len(MAGIC) == 8 * VERSION = 1 # version of the on-disk (serialized) format produced by .write(). # <<<<<<<<<<<<<< * HEADER_FMT = "<8sII" # magic, version, meta length * */ if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_VERSION, __pyx_mstate_global->__pyx_int_1) < (0)) __PYX_ERR(0, 18, __pyx_L1_error) /* "borghash/HashTable.pyx":19 * assert len(MAGIC) == 8 * VERSION = 1 # version of the on-disk (serialized) format produced by .write(). * HEADER_FMT = "<8sII" # magic, version, meta length # <<<<<<<<<<<<<< * * MIN_CAPACITY = 1000 # never shrink the hash table below this capacity */ if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_HEADER_FMT, __pyx_mstate_global->__pyx_kp_u_8sII) < (0)) __PYX_ERR(0, 19, __pyx_L1_error) /* "borghash/HashTable.pyx":21 * HEADER_FMT = "<8sII" # magic, version, meta length * * MIN_CAPACITY = 1000 # never shrink the hash table below this capacity # <<<<<<<<<<<<<< * * cdef uint32_t FREE_BUCKET = 0xFFFFFFFF */ if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MIN_CAPACITY, __pyx_mstate_global->__pyx_int_1000) < (0)) __PYX_ERR(0, 21, __pyx_L1_error) /* "borghash/HashTable.pyx":23 * MIN_CAPACITY = 1000 # never shrink the hash table below this capacity * * cdef uint32_t FREE_BUCKET = 0xFFFFFFFF # <<<<<<<<<<<<<< * cdef uint32_t TOMBSTONE_BUCKET = 0xFFFFFFFE * # ... */ __pyx_v_8borghash_9HashTable_FREE_BUCKET = 0xFFFFFFFF; /* "borghash/HashTable.pyx":24 * * cdef uint32_t FREE_BUCKET = 0xFFFFFFFF * cdef uint32_t TOMBSTONE_BUCKET = 0xFFFFFFFE # <<<<<<<<<<<<<< * # ... * cdef uint32_t RESERVED = 0xFFFFFF00 # all >= this is reserved */ __pyx_v_8borghash_9HashTable_TOMBSTONE_BUCKET = 0xFFFFFFFE; /* "borghash/HashTable.pyx":26 * cdef uint32_t TOMBSTONE_BUCKET = 0xFFFFFFFE * # ... * cdef uint32_t RESERVED = 0xFFFFFF00 # all >= this is reserved # <<<<<<<<<<<<<< * * _NoDefault = object() */ __pyx_v_8borghash_9HashTable_RESERVED = 0xFFFFFF00; /* "borghash/HashTable.pyx":28 * cdef uint32_t RESERVED = 0xFFFFFF00 # all >= this is reserved * * _NoDefault = object() # <<<<<<<<<<<<<< * * def _fill(this: Any, other: Any) -> None: */ __pyx_t_4 = NULL; __pyx_t_6 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_object, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 28, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); } if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_NoDefault, __pyx_t_2) < (0)) __PYX_ERR(0, 28, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTable.pyx":30 * _NoDefault = object() * * def _fill(this: Any, other: Any) -> None: # <<<<<<<<<<<<<< * """fill this mapping from other""" * if other is None: */ __pyx_t_2 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 30, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_this, __pyx_mstate_global->__pyx_n_u_Any) < (0)) __PYX_ERR(0, 30, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_other, __pyx_mstate_global->__pyx_n_u_Any) < (0)) __PYX_ERR(0, 30, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < (0)) __PYX_ERR(0, 30, __pyx_L1_error) __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_9HashTable_1_fill, 0, __pyx_mstate_global->__pyx_n_u_fill, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTable, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[1])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 30, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_fill, __pyx_t_4) < (0)) __PYX_ERR(0, 30, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "borghash/HashTable.pyx":47 * cdef class HashTable: * def __init__(self, items=None, *, * key_size: int = 0, value_size: int = 0, capacity: int = MIN_CAPACITY, # <<<<<<<<<<<<<< * max_load_factor: float = 0.5, min_load_factor: float = 0.10, * shrink_factor: float = 0.4, grow_factor: float = 2.0, */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_MIN_CAPACITY); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 47, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyInt_FromNumber(&__pyx_t_4, NULL, 1) < (0)) __PYX_ERR(0, 47, __pyx_L1_error) __pyx_mstate_global->__pyx_k__2 = ((PyObject*)__pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __pyx_t_4 = 0; /* "borghash/HashTable.pyx":102 * free(self.values) * * def clear(self) -> None: # <<<<<<<<<<<<<< * """Empty the HashTable and start from scratch.""" * self.capacity = 0 */ __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 102, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < (0)) __PYX_ERR(0, 102, __pyx_L1_error) __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_9HashTable_9HashTable_5clear, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTable_clear, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTable, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[2])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 102, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); #endif __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_9HashTable_HashTable, __pyx_mstate_global->__pyx_n_u_clear, __pyx_t_2) < (0)) __PYX_ERR(0, 102, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTable.pyx":226 * raise KeyError("Key not found") * * def setdefault(self, key: bytes, value: bytes) -> bytes: # <<<<<<<<<<<<<< * if not key in self: * self[key] = value */ __pyx_t_2 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 226, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_key, __pyx_mstate_global->__pyx_n_u_bytes) < (0)) __PYX_ERR(0, 226, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_value, __pyx_mstate_global->__pyx_n_u_bytes) < (0)) __PYX_ERR(0, 226, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bytes) < (0)) __PYX_ERR(0, 226, __pyx_L1_error) __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_9HashTable_9HashTable_17setdefault, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTable_setdefault, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTable, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[3])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 226, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_9HashTable_HashTable, __pyx_mstate_global->__pyx_n_u_setdefault, __pyx_t_4) < (0)) __PYX_ERR(0, 226, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "borghash/HashTable.pyx":231 * return self[key] * * def get(self, key: bytes, default: Any = None) -> bytes|Any: # <<<<<<<<<<<<<< * try: * return self[key] */ __pyx_t_4 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 231, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_key, __pyx_mstate_global->__pyx_n_u_bytes) < (0)) __PYX_ERR(0, 231, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_default, __pyx_mstate_global->__pyx_n_u_Any) < (0)) __PYX_ERR(0, 231, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_bytes_Any) < (0)) __PYX_ERR(0, 231, __pyx_L1_error) __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_9HashTable_9HashTable_19get, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTable_get, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTable, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[4])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 231, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_mstate_global->__pyx_tuple[0]); __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_9HashTable_HashTable, __pyx_mstate_global->__pyx_n_u_get, __pyx_t_2) < (0)) __PYX_ERR(0, 231, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTable.pyx":237 * return default * * def pop(self, key: bytes, default: Any = _NoDefault) -> bytes|Any: # <<<<<<<<<<<<<< * try: * value = self[key] */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_NoDefault); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 237, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_mstate_global->__pyx_k__3 = __pyx_t_2; __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_NoDefault); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 237, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); { PyObject* __pyx_temp[1] = {__pyx_t_2}; __pyx_t_4 = __Pyx_PyTuple_FromArray(__pyx_temp, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 237, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 237, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_key, __pyx_mstate_global->__pyx_n_u_bytes) < (0)) __PYX_ERR(0, 237, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_default, __pyx_mstate_global->__pyx_n_u_Any) < (0)) __PYX_ERR(0, 237, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_bytes_Any) < (0)) __PYX_ERR(0, 237, __pyx_L1_error) __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_9HashTable_9HashTable_21pop, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTable_pop, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTable, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[5])); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 237, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_7); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_4); __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_7, __pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_9HashTable_HashTable, __pyx_mstate_global->__pyx_n_u_pop, __pyx_t_7) < (0)) __PYX_ERR(0, 237, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "borghash/HashTable.pyx":248 * return value * * def items(self, *, prefix_bits: int = 0, prefix: int = 0) -> Iterator[tuple[bytes, bytes]]: # <<<<<<<<<<<<<< * """ * Iterate over items, optionally only over items whose key starts with the given bit prefix. */ __pyx_t_7 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 248, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (PyDict_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_prefix_bits, __pyx_mstate_global->__pyx_int_0) < (0)) __PYX_ERR(0, 248, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_prefix, __pyx_mstate_global->__pyx_int_0) < (0)) __PYX_ERR(0, 248, __pyx_L1_error) __pyx_t_2 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 248, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_prefix_bits, __pyx_mstate_global->__pyx_n_u_int) < (0)) __PYX_ERR(0, 248, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_prefix, __pyx_mstate_global->__pyx_n_u_int) < (0)) __PYX_ERR(0, 248, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_Iterator_tuple_bytes_bytes) < (0)) __PYX_ERR(0, 248, __pyx_L1_error) __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_9HashTable_9HashTable_23items, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTable_items, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTable, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 248, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif __Pyx_CyFunction_SetDefaultsKwDict(__pyx_t_4, __pyx_t_7); __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_9HashTable_HashTable, __pyx_mstate_global->__pyx_n_u_items, __pyx_t_4) < (0)) __PYX_ERR(0, 248, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "borghash/HashTable.pyx":316 * self.kv_capacity = capacity * * def k_to_idx(self, key: bytes) -> int: # <<<<<<<<<<<<<< * """ * Return the key's index in the keys array (index is stable while in memory). */ __pyx_t_4 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 316, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_key, __pyx_mstate_global->__pyx_n_u_bytes) < (0)) __PYX_ERR(0, 316, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_int) < (0)) __PYX_ERR(0, 316, __pyx_L1_error) __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_9HashTable_9HashTable_26k_to_idx, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTable_k_to_idx, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTable, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[6])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 316, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); #endif __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_9HashTable_HashTable, __pyx_mstate_global->__pyx_n_u_k_to_idx, __pyx_t_2) < (0)) __PYX_ERR(0, 316, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTable.pyx":329 * raise KeyError("Key not found") * * def idx_to_k(self, idx: int) -> bytes: # <<<<<<<<<<<<<< * """ * For a given index, return the key stored at that index in the keys array. */ __pyx_t_2 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 329, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_idx, __pyx_mstate_global->__pyx_n_u_int) < (0)) __PYX_ERR(0, 329, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bytes) < (0)) __PYX_ERR(0, 329, __pyx_L1_error) __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_9HashTable_9HashTable_28idx_to_k, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTable_idx_to_k, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTable, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[7])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 329, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_9HashTable_HashTable, __pyx_mstate_global->__pyx_n_u_idx_to_k, __pyx_t_4) < (0)) __PYX_ERR(0, 329, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "borghash/HashTable.pyx":337 * return self.keys[kv_index * self.ksize:(kv_index + 1) * self.ksize] * * def kv_to_idx(self, key: bytes, value: bytes) -> int: # <<<<<<<<<<<<<< * """ * Return the key's/value's index in the keys/values array (index is stable while in memory). */ __pyx_t_4 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 337, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_key, __pyx_mstate_global->__pyx_n_u_bytes) < (0)) __PYX_ERR(0, 337, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_value, __pyx_mstate_global->__pyx_n_u_bytes) < (0)) __PYX_ERR(0, 337, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_int) < (0)) __PYX_ERR(0, 337, __pyx_L1_error) __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_9HashTable_9HashTable_30kv_to_idx, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTable_kv_to_idx, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTable, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[8])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 337, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); #endif __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_9HashTable_HashTable, __pyx_mstate_global->__pyx_n_u_kv_to_idx, __pyx_t_2) < (0)) __PYX_ERR(0, 337, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTable.pyx":355 * raise KeyError("Key/Value not found") * * def idx_to_kv(self, idx: int) -> tuple[bytes, bytes]: # <<<<<<<<<<<<<< * """ * For a given index, return the key/value stored at that index in the keys/values array. */ __pyx_t_2 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 355, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_idx, __pyx_mstate_global->__pyx_n_u_int) < (0)) __PYX_ERR(0, 355, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_tuple_bytes_bytes) < (0)) __PYX_ERR(0, 355, __pyx_L1_error) __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_9HashTable_9HashTable_32idx_to_kv, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTable_idx_to_kv, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTable, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[9])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 355, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_9HashTable_HashTable, __pyx_mstate_global->__pyx_n_u_idx_to_kv, __pyx_t_4) < (0)) __PYX_ERR(0, 355, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "self.table cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_9HashTable_9HashTable_34__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTable___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTable, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[10])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_4) < (0)) __PYX_ERR(2, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError, "self.table cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "self.table cannot be converted to a Python object for pickling" */ __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_9HashTable_9HashTable_36__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTable___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTable, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[11])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 3, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_4) < (0)) __PYX_ERR(2, 3, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "borghash/HashTable.pyx":1 * """ # <<<<<<<<<<<<<< * HashTable: low-level hash table mapping fully random bytes keys to bytes values. * Key and value lengths can be chosen, but are fixed thereafter. */ __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_test, __pyx_t_4) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_7); if (__pyx_m) { if (__pyx_mstate->__pyx_d && stringtab_initialized) { __Pyx_AddTraceback("init borghash.HashTable", __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; __Pyx_PyErr_FetchException(&tp, &value, &tb); __Pyx_State_RemoveModule(&__pyx_moduledef); __Pyx_PyErr_RestoreException(tp, value, tb); } #endif } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init borghash.HashTable"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); #if CYTHON_PEP489_MULTI_PHASE_INIT return (__pyx_m != NULL) ? 0 : -1; #else return __pyx_m; #endif } /* #### Code section: pystring_table ### */ /* #### Code section: cached_builtins ### */ static int __Pyx_InitCachedBuiltins(__pyx_mstatetype *__pyx_mstate) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; CYTHON_UNUSED_VAR(__pyx_mstate); __pyx_builtin_object = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_object); if (!__pyx_builtin_object) __PYX_ERR(0, 28, __pyx_L1_error) /* Cached unbound methods */ __pyx_mstate->__pyx_umethod_PyDict_Type_items.type = (PyObject*)&PyDict_Type; __pyx_mstate->__pyx_umethod_PyDict_Type_items.method_name = &__pyx_mstate->__pyx_n_u_items; __pyx_mstate->__pyx_umethod_PyDict_Type_pop.type = (PyObject*)&PyDict_Type; __pyx_mstate->__pyx_umethod_PyDict_Type_pop.method_name = &__pyx_mstate->__pyx_n_u_pop; __pyx_mstate->__pyx_umethod_PyDict_Type_values.type = (PyObject*)&PyDict_Type; __pyx_mstate->__pyx_umethod_PyDict_Type_values.method_name = &__pyx_mstate->__pyx_n_u_values; return 0; __pyx_L1_error:; return -1; } /* #### Code section: cached_constants ### */ static int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); /* "borghash/HashTable.pyx":231 * return self[key] * * def get(self, key: bytes, default: Any = None) -> bytes|Any: # <<<<<<<<<<<<<< * try: * return self[key] */ { PyObject* __pyx_temp[1] = {Py_None}; __pyx_mstate_global->__pyx_tuple[0] = __Pyx_PyTuple_FromArray(__pyx_temp, 1); if (unlikely(!__pyx_mstate_global->__pyx_tuple[0])) __PYX_ERR(0, 231, __pyx_L1_error) __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[0]); } __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[0]); #if CYTHON_IMMORTAL_CONSTANTS { PyObject **table = __pyx_mstate->__pyx_tuple; for (Py_ssize_t i=0; i<1; ++i) { #if PY_VERSION_HEX >= 0x030F0000 PyUnstable_SetImmortal(table[i]); #elif CYTHON_COMPILING_IN_CPYTHON_FREETHREADING if ((PY_SSIZE_T_MAX <= _Py_IMMORTAL_REFCNT_LOCAL)) break; #if PY_VERSION_HEX < 0x030E0000 if (_Py_IsOwnedByCurrentThread(table[i]) && Py_REFCNT(table[i]) == 1) #else if (PyUnstable_Object_IsUniquelyReferenced(table[i])) #endif { Py_SET_REFCNT(table[i], ((Py_ssize_t)_Py_IMMORTAL_REFCNT_LOCAL + 1)); } #else if ((PY_SSIZE_T_MAX < _Py_IMMORTAL_INITIAL_REFCNT)) break; Py_SET_REFCNT(table[i], _Py_IMMORTAL_INITIAL_REFCNT); #endif } } #endif __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } /* #### Code section: init_constants ### */ static int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; CYTHON_UNUSED_VAR(__pyx_mstate); { const struct { const unsigned int length: 8; } str_length_index[] = {{15},{1},{5},{1},{29},{16},{13},{50},{40},{19},{179},{42},{8},{11},{7},{6},{2},{9},{44},{50},{35},{62},{26},{19},{45},{3},{8},{10},{9},{27},{29},{15},{13},{18},{19},{15},{18},{19},{13},{20},{8},{5},{12},{7},{4},{7},{10},{20},{12},{17},{8},{12},{8},{10},{8},{11},{14},{12},{10},{17},{13},{12},{12},{19},{8},{5},{13},{18},{18},{5},{8},{5},{18},{5},{15},{7},{3},{9},{3},{11},{1},{3},{8},{9},{5},{3},{5},{4},{8},{3},{5},{7},{8},{4},{14},{8},{9},{6},{6},{15},{15},{4},{6},{5},{3},{6},{11},{16},{9},{12},{6},{4},{4},{3},{10},{5},{13},{4},{5},{6},{5},{11},{10},{6},{6}}; const struct { const unsigned int length: 8; } bytes_length_index[] = {{8},{9},{103},{59},{32},{58},{45},{70},{81},{142},{36},{13}}; #ifndef CYTHON_COMPRESS_STRINGS #define CYTHON_COMPRESS_STRINGS 90 #endif #if (CYTHON_COMPRESS_STRINGS) == 1 /* compression: zlib (1319 bytes) */ static const char cstring[] = "x\332\215TKo\0337\020\216\032\267\265S#\261\335\024F\372\002\223\246p\036\215R\333j\220\026}@\261\034[I\255X\262a$\010R\202\332\245$V+R&\271\2626(\212\034u\344q\217{\324QG\035u\314\321G\035\375\023\362\023:\334\225d\265v\201\010\366\222\234\027\277\371f\206\267\264\244\024U$\2516(\327\267\323\077\077T\371\374oyM%\321B\276\324~\323\243/\313\201\246\352;\024/\257^==@DJ\022 \246P\305\367\274\2474@\\hT\021>w\355AH\324\"\236O\221b\257)r\005U\261\276A\264SC\272\006\"Za\234\272\261^Y\217\3671\004\273\373\007q\330\311e\005\241)\330\021\2156\002]\023\334\"r\251\307\312\026=\365 \256\226\314\201\\\254\021G\273\233\273\3672\0173\210p\027I\372\047u\264B\312/;\036Q\n\256\026\025T\366\231\247\031G:hR\225F\371\n\n\204\2178\005\010Z\240&\330M;\000B\216\024\3251\324\025\302\001\027\321Lp\014\356\214WW\220\313$\\\302Z\324z?&\236\242\351\203\367&\206\270.\006-\215YG\177\241,\017\\\246H\331\243\224\333o\325a*\331\271u\032\3408d\303W\032\225!~\223:\254\302 \222\315u,\375\365\027\224I7%\334\321\236\310 YIx\225\242\357\323\351[k\350\316\035\224\030\3402\003v\356\241\325\333\351i\301yn\353kiE\275JZ[,\310\211y\2606\216\340-*u\302\035A\273I\211D\331\022\017\365\223\250\311\234\272\007D)\351\334/\013Y\255\021U\273\277\r\237}\033)\335\014\332\347\264_\334Y\357\225-`\003\316\0361Nd\220\177\266\275\231\315m\226\360\343\235\375\311\r\247Wa,\251\353;\024;1H\214\247UPa\005\205=O\351x\224\310\323c\225\352\323\003s\333X\013\\?+iM\2114m\250\323c\335\352\301lJ\322:#j\212\346\351\001\300A\323\020\337\323\343\231\335\311n\3457v\362\005\274\221\335\315n\344\367_\354\220\246m\307\202\340\364`\263\264\227\177V\300\005\221K\2340\336\r\332\360\237\2031\301\005\332\326%Z\301x\324\312\024\303/nv\014\231Y\250VP\361\271c\327\352\230\026\3705\010\343\361*\\\337\213%\2344\342\025\212\210Gfv\333\212\233\304*\016}\342\215\215F\344\3433e\230\010h\333\036 \331I`5u\375\231\na\014\255\242-X\346y\230)\354\010)|\230lJT\300\035&\322\023\201\032w^zBj\334h\016i\022\207\351 .\261\003mJ1\344\250%qh\2318u\307\023\212:\302\363""\354\200\013\256\322\244\354\214\n\001/\020\\\013\325\000\322\201\244\252\024G\270B\034(\r\203:\216\233`\322\014\214\273\264\315x\314\257\202\217\0347\001L5\374\255\257\331\351nj9\036rX\025t\305TX8\305A&\275b\321\022\351\tQ\367\233\r\322\306\236 \356\310\266\001IL\0359\224<\231H\001\357\217\204\326J\246}j\346%\265\354`]\223T\325\204\347\302\002(\000\370h\023WTR\355Kn\237\001x\223\\[\217I_\252\032\253\300\007\330\250\217.\3255\246 \2348J\336\311x\242\223\261\216_\365\323\t\217w\352\210pxD\036=+mmg\367\266\337\244\2063\227:wM\361\370\302\202\231\017\267\243\354\311\314\307oZ\235=\223\032\316\316\ra\377\332,\232\225pq8;\337\3312\253\303\371\005\2232\313\341\207a1$\303\271\344\220J\224?X\351\277\014N@\276i\256\205\327\307\322\324\361\314\2629\264\342\337\023\257m\223\265K!\274\036f\302C\273}j\306Kx1\\\rs\307h\255w\243\227\353[\327\343\345\225\250\325}\321#\026\333\374\247&\003F\251\341\225\005\273_\235\350q?\033\353\257\232\\\230\002\344V\177\245\3236\np,,\306\266\047\200g\306dMq\344\371\245\315\374\335\245\013s7\242/\272\340}\245\243!\235Tx-\272\021\345\272\263\275\271\376R\177\275_\036\314\014\262\326\370ID\254\361|g\275C:\276\3310:\004f\226\314\2350\033\026Of?\351d:\177C\376\365\356g]\322=L\220\266bB\300\350\026\344\nW~\025>\217\212SW^\356\270\346[\310g.Z\2122Q\273\033\364?\350\177\323/\365\365`u8k\321n\001\033\371\250\024\351\356\303\336\217\375G}g\2604\310\014\016-X\337dm\300?\272?\365\212\377\017l\010\300\254\374\3108\341U[\251\221\374\335G\326\343?\220\227\301\365A\264\030A\351>\017o\206\325\250\030\261\256\354]\355=\357\277\030\224\337^|\273\366v\377\270X\262\314\266\314\036Taa\331\026\356r\247f\2109<\236\371:\344\335\047\266P\226\312uC&\035\220HV-\342\233\321\343\356\335\336A\377\301`\361\037-W\214\214"; PyObject *data = __Pyx_DecompressString(cstring, 1319, 1); #define __Pyx_DecompressString_LZSS_UNUSED if (unlikely(!data)) __PYX_ERR(0, 1, __pyx_L1_error) const char* const bytes = __Pyx_PyBytes_AsString(data); #if !CYTHON_ASSUME_SAFE_MACROS if (likely(bytes)); else { Py_DECREF(data); __PYX_ERR(0, 1, __pyx_L1_error) } #endif #elif (CYTHON_COMPRESS_STRINGS) > 0 && (CYTHON_COMPRESS_STRINGS) <= 90 /* compression: lzss (1692 bytes) */ static const char cstring[] = "\377(tree fr\377agment).\377<8sII?It\377erator[t\377uple[byt\357es, \002\002]]K\377V array \377is fullK\377ey not f\357ound\t\001or \377value si\177ze does\033\002\377match th~\020\000efined\033\0021s;\001\005!d\000/VR\002d\006\357NoteN\000at \277Cython\216\001d\357elib\272\001ely? stric\311\000!\001\377n PEP-48\3774 and re\377jects su\277bclass\241\000o\377f builti\377n types.\377 If you {ne\251\000to p%\000|%\t\310\000n set\317\002\367\047an\202 atio\373n_<\000ing\047 \267dirb\000iv\242\000o\377 False.V^\360\200&add_\324 e\370\"\377 | Anydi\177sableen\002\001\357gcis\004\003dke\373y_\347\"must \375b\366 pecifi\370\340 \350\001\016\005>= 4.\233pr\372 x \"\005\352\000r\377ange 0..\277(2 ** \033\003_\373bi\233 - 1).\374\005\t#\02132.sel7f.t\230\001 c\203\"\201\001\177convert\266#7a P\235Cob\365!\252`\177r pickl\246 \377src/borg\277hash/H\002\000T\036\342\001.pyx\354p\325b\311\200\"\374\320\000\261 Binary\377IOHEADER\317_FMTY\006a\007__\377reduce_c\346\303b__\017\t\337@sta}t\t\021clear\250\007\367get\265\007idx_\257to_k\000\017v\032\010t\027ems\351\007k.\0016\000\007\010\235v\002\016pop\233\047\374`d\277efault\254\206\005M\377AGICMIN_\377CAPACITY\377MappingN\377oneVERSI\277ON_NoD/\003_\357_Pyx\001\000Dic\377t_NextRe\367f__\304\204\004e___\225_\231\205\002_\327\000i\250\000\r\001f\207unc\025\001\352\000\221##\000m\367ain)\001modu\235l2\002nam:\002\302@_\344 \004\007\001v\240bT\001qua\311l\035\005\366$_\366.\217Fex\036\210\001set_Q\005\215F\242\000~\221N__test\274\000\377fill_is_\377coroutin\377easyncio\225.\010\006s\362e.\361f\352\210\002c\177apacity\336B\277cline_\341\000t\377raceback\377closecol\375l\335\206\001ons.ab\335c\202Ddelt\000te\357ring\217`gro\377w_factor\361i\221`\217e\227evind_exint\334!s\342 \375r\375Ekeykey\27332\332\206\001ptr\335\206\005k?eyskv_L\010\013\000\362@\002k\244e\252\001arlo\377okupmax_/load|\004m\246@\004\010\371n\360@\214\206\003other\330\330`\232\207\003\372\206\010re\224\206\001_t\377hreshold~\004\000ize_kv\002\004~\362\206\002return""\203\207\001osend\256\205\001et\221\204\004\177shiftsh\213 \275k\200$thisL\000o\201w\242\211\003\247\213\002\321\206\003\276\213\002\330\206\007\301\213\002s\377wantedBO\377RGHASH\200\001\377\330\004\n\210+\220Q\320\377\000\020\220\014\230H\240A\377\340\004\007\200v\210S\220\337\001\330\010\t\330\t\000z\220\377\021\220\047\230\021\330\010\014\377\210G\2201\330\014\020\220\377\001\220\027\230\005\230Q\230Wa\330\t\007\003\001\027\0035\022\001\372\024\n\3402\000E\220\031\230!~/\005\001\320\004\027\220q\023\001\273L\2301\002H\220AV\001N\277\230!\2304\230qa\001K\375\220\000\004q\230\003\2301\230\377D\320 2\260\"\260D\375\2707\001\320\027\047\240v\250\367Y\260a\230\001\014\023\2204\273\220qD\000\017\020\330\t\0001\334X\000\032\003_\270A\033\002\024\220\347D\230\001\267\000\034\001\017\210x[\220s\205\000\020\021\047\002\340\304\000_\004\220A\220Q3\004\034\366\001\377\360\n\000\t\"\240\033\250\276\217\000\017\210t\2205:\000\031\377\240\"\240D\250\010\260\t\377\270\022\2703\270b\300\004\377\300A\320\004\034\230J\240\375a)\001\014\2103\210a\210\277u\220C\220t\230\227 \022\377\220*\230A\230Q\340\010\337\013\2104\210~\236 k\250\337\025\250a\250q\232\0014\220}v\256!\340\014\022\220(\351\000\276\252\000\035\230X\240Qh\010\016\357\210d\220%\315\000\t\240\022\377\2404\240x\250y\270\002\377\270#\270R\270t\3001\177\330\010\020\220\004\220G\213 \377I\240R\240t\2508\260\3779\270B\270c\300\022\300\3134\300\261 \017\200\000\224\000\035\230_^\250:\260Q\177\027\330\226\000~\255\001w\220c\230\024\230\370\000\276\252\004\360\006\000\t\014\243\r\027\336\321\0006\240\021\240\270@\032\230\377$\230g\240Q\240i\250\377r\260\024\260X\270Y\300\377b\310\003\3102\310T\320\377QR\330\014\017\210v\220\365S\312@\020\326@\330\010\016\210\377h\220a\220q\320\004\036\317\230n\250J\245A\307!3\220ma\371F\330\010\331!1\220\306 \377$\240F\250+\260V\270\0076\300\021"; PyObject *data = __Pyx_DecompressString_LZSS(cstring, 1692, 2361); #define __Pyx_DecompressString_UNUSED if (unlikely(!data)) __PYX_ERR(0, 1, __pyx_L1_error) const char* const bytes = __Pyx_PyBytes_AsString(data); #if !CYTHON_ASSUME_SAFE_MACROS if (likely(bytes)); else { Py_DECREF(data); __PYX_ERR(0, 1, __pyx_L1_error) } #endif #else /* compression: none (2361 bytes) */ static const char bytes[] = "(tree fragment).<8sII?Iterator[tuple[bytes, bytes]]KV array is fullKey not foundKey or value size does not match the defined sizesKey size does not match the defined sizeKey/Value not foundNote that Cython is deliberately stricter than PEP-484 and rejects subclasses of builtin types. If you need to pass subclasses then set the \047annotation_typing\047 directive to False.Value size does not match the defined sizeadd_notebytes | Anydisableenablegcisenabledkey_size must be specified and must be >= 4.prefix must be in range 0..(2 ** prefix_bits - 1).prefix_bits must be in range 0..32.self.table cannot be converted to a Python object for picklingsrc/borghash/HashTable.pyxtuple[bytes, bytes]value_size must be specified and must be > 0.AnyBinaryIOHEADER_FMTHashTableHashTable.__reduce_cython__HashTable.__setstate_cython__HashTable.clearHashTable.getHashTable.idx_to_kHashTable.idx_to_kvHashTable.itemsHashTable.k_to_idxHashTable.kv_to_idxHashTable.popHashTable.setdefaultIteratorMAGICMIN_CAPACITYMappingNoneVERSION_NoDefault__Pyx_PyDict_NextRef__annotate____class_getitem____func____getstate____main____module____name____pyx_state__pyx_vtable____qualname____reduce____reduce_cython____reduce_ex____set_name____setstate____setstate_cython____test___fill_is_coroutineasyncio.coroutinesborghash.HashTablebytescapacityclearcline_in_tracebackclosecollections.abcdefaultdelfilteringgetgrow_factoriidxidx_to_kidx_to_kvindexintitemsiterk_to_idxkeykey32key_ptrkey_sizekeyskv_grow_factorkv_indexkv_to_idxlinearlookupmax_load_factormin_load_factornextobjectotherpopprefixprefix_bitsrehash_thresholdresize_kvresize_tablereturnselfsendsetsetdefaultshiftshrink_factorthisthrowtypingvaluevalue_foundvalue_sizevalueswantedBORGHASH\200\001\330\004\n\210+\220Q\320\000\020\220\014\230H\240A\340\004\007\200v\210S\220\001\330\010\t\330\004\007\200z\220\021\220\047\230\021\330\010\014\210G\2201\330\014\020\220\001\220\027\230\005\230Q\230a\330\t\020\220\001\220\027\230\001\330\010\014\210G\2205\230\005\230Q\330""\014\020\220\001\220\027\230\005\230Q\230a\340\010\014\210E\220\031\230!\330\014\020\220\001\220\027\230\001\320\004\027\220q\340\010\014\210L\230\001\330\010\014\210H\220A\330\010\014\210N\230!\2304\230q\330\010\014\210K\220q\330\010\014\210K\220q\230\003\2301\230D\320 2\260\"\260D\270\001\320\004\027\320\027\047\240v\250Y\260a\330\010\t\330\014\023\2204\220q\230\001\330\017\020\330\014\023\2201\320\004\027\320\027\047\240v\250_\270A\330\010\t\330\014\024\220D\230\001\230\021\330\017\020\330\014\017\210x\220s\230!\330\020\021\330\014\023\2201\340\014\020\220\004\220A\220Q\330\014\023\2201\320\004\034\230H\240A\360\n\000\t\"\240\033\250A\330\010\017\210t\2205\230\001\230\031\240\"\240D\250\010\260\t\270\022\2703\270b\300\004\300A\320\004\034\230J\240a\360\n\000\t\014\2103\210a\210u\220C\220t\2301\330\014\022\220*\230A\230Q\340\010\013\2104\210~\230Q\230k\250\025\250a\250q\330\014\023\2204\220v\230Q\230a\340\014\022\220(\230!\2301\320\004\035\230X\240Q\360\n\000\t\"\240\033\250A\330\010\016\210d\220%\220q\230\t\240\022\2404\240x\250y\270\002\270#\270R\270t\3001\330\010\020\220\004\220G\2301\230I\240R\240t\2508\2609\270B\270c\300\022\3004\300q\330\010\017\210u\220A\320\004\035\230^\250:\260Q\360\n\000\t\014\2103\210a\210u\220C\220t\2301\330\014\022\220*\230A\230Q\330\010\013\2103\210a\210w\220c\230\024\230Q\330\014\022\220*\230A\230Q\360\006\000\t\014\2104\210~\230Q\230k\250\025\250a\250q\330\014\027\220t\2306\240\021\240!\330\014\032\230$\230g\240Q\240i\250r\260\024\260X\270Y\300b\310\003\3102\310T\320QR\330\014\017\210v\220S\230\001\330\020\027\220q\330\010\016\210h\220a\220q\320\004\036\230n\250J\260a\330\010\017\210t\2203\220a\330\014\020\220\001\220\027\230\001\330\010\017\210t\2201\220A\320\004$\240F\250+\260V\2706\300\021"; PyObject *data = NULL; #define __Pyx_DecompressString_UNUSED #define __Pyx_DecompressString_LZSS_UNUSED #endif PyObject **stringtab = __pyx_mstate->__pyx_string_tab; Py_ssize_t pos = 0; for (int i = 0; i < 125; i++) { Py_ssize_t bytes_length = str_length_index[i].length; PyObject *string = PyUnicode_DecodeUTF8(bytes + pos, bytes_length, NULL); if (likely(string) && i >= 25) PyUnicode_InternInPlace(&string); if (unlikely(!string)) { Py_XDECREF(data); __PYX_ERR(0, 1, __pyx_L1_error) } stringtab[i] = string; pos += bytes_length; } for (int i = 125; i < 137; i++) { Py_ssize_t bytes_length = bytes_length_index[i-125].length; PyObject *string = PyBytes_FromStringAndSize(bytes + pos, bytes_length); stringtab[i] = string; pos += bytes_length; if (unlikely(!string)) { Py_XDECREF(data); __PYX_ERR(0, 1, __pyx_L1_error) } } Py_XDECREF(data); for (Py_ssize_t i = 0; i < 137; i++) { if (unlikely(PyObject_Hash(stringtab[i]) == -1)) { __PYX_ERR(0, 1, __pyx_L1_error) } } #if CYTHON_IMMORTAL_CONSTANTS { PyObject **table = stringtab + 125; for (Py_ssize_t i=0; i<12; ++i) { #if PY_VERSION_HEX >= 0x030F0000 PyUnstable_SetImmortal(table[i]); #elif CYTHON_COMPILING_IN_CPYTHON_FREETHREADING if ((PY_SSIZE_T_MAX <= _Py_IMMORTAL_REFCNT_LOCAL)) break; #if PY_VERSION_HEX < 0x030E0000 if (_Py_IsOwnedByCurrentThread(table[i]) && Py_REFCNT(table[i]) == 1) #else if (PyUnstable_Object_IsUniquelyReferenced(table[i])) #endif { Py_SET_REFCNT(table[i], ((Py_ssize_t)_Py_IMMORTAL_REFCNT_LOCAL + 1)); } #else if ((PY_SSIZE_T_MAX < _Py_IMMORTAL_INITIAL_REFCNT)) break; Py_SET_REFCNT(table[i], _Py_IMMORTAL_INITIAL_REFCNT); #endif } } #endif } { PyObject **numbertab = __pyx_mstate->__pyx_number_tab + 0; int8_t const cint_constants_1[] = {0,1,4,32}; int16_t const cint_constants_2[] = {1000}; for (int i = 0; i < 5; i++) { numbertab[i] = PyLong_FromLong((i < 4 ? cint_constants_1[i - 0] : cint_constants_2[i - 4])); if (unlikely(!numbertab[i])) __PYX_ERR(0, 1, __pyx_L1_error) } } #if CYTHON_IMMORTAL_CONSTANTS { PyObject **table = __pyx_mstate->__pyx_number_tab; for (Py_ssize_t i=0; i<5; ++i) { #if PY_VERSION_HEX >= 0x030F0000 PyUnstable_SetImmortal(table[i]); #elif CYTHON_COMPILING_IN_CPYTHON_FREETHREADING if ((PY_SSIZE_T_MAX <= _Py_IMMORTAL_REFCNT_LOCAL)) break; #if PY_VERSION_HEX < 0x030E0000 if (_Py_IsOwnedByCurrentThread(table[i]) && Py_REFCNT(table[i]) == 1) #else if (PyUnstable_Object_IsUniquelyReferenced(table[i])) #endif { Py_SET_REFCNT(table[i], ((Py_ssize_t)_Py_IMMORTAL_REFCNT_LOCAL + 1)); } #else if ((PY_SSIZE_T_MAX < _Py_IMMORTAL_INITIAL_REFCNT)) break; Py_SET_REFCNT(table[i], _Py_IMMORTAL_INITIAL_REFCNT); #endif } } #endif return 0; __pyx_L1_error:; return -1; } /* #### Code section: init_codeobjects ### */ #ifdef __cplusplus namespace { #endif typedef struct { unsigned int argcount : 2; unsigned int num_posonly_args : 1; unsigned int num_kwonly_args : 2; unsigned int nlocals : 4; unsigned int flags : 10; unsigned int first_line : 9; } __Pyx_PyCode_New_function_description; #ifdef __cplusplus } /* anonymous namespace */ #endif /* NewCodeObj.proto */ static PyObject* __Pyx_PyCode_New( const __Pyx_PyCode_New_function_description descr, PyObject * const *varnames, PyObject *filename, PyObject *funcname, PyObject *line_table, PyObject *tuple_dedup_map ); static int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate) { PyObject* tuple_dedup_map = PyDict_New(); if (unlikely(!tuple_dedup_map)) return -1; { const __Pyx_PyCode_New_function_description descr = {1, 0, 2, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_GENERATOR), 248}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_prefix_bits, __pyx_mstate->__pyx_n_u_prefix, __pyx_mstate->__pyx_n_u_i, __pyx_mstate->__pyx_n_u_kv_index, __pyx_mstate->__pyx_n_u_key_ptr, __pyx_mstate->__pyx_n_u_key32, __pyx_mstate->__pyx_n_u_shift, __pyx_mstate->__pyx_n_u_wanted, __pyx_mstate->__pyx_n_u_filtering, __pyx_mstate->__pyx_n_u_key, __pyx_mstate->__pyx_n_u_value}; __pyx_mstate_global->__pyx_codeobj_tab[0] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_borghash_HashTable_pyx, __pyx_mstate->__pyx_n_u_items, __pyx_mstate->__pyx_kp_b_iso88591_F_V6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[0])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 30}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_this, __pyx_mstate->__pyx_n_u_other, __pyx_mstate->__pyx_n_u_key, __pyx_mstate->__pyx_n_u_value}; __pyx_mstate_global->__pyx_codeobj_tab[1] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_borghash_HashTable_pyx, __pyx_mstate->__pyx_n_u_fill, __pyx_mstate->__pyx_kp_b_iso88591_HA_vS_z_G1_Qa_G5_Q_Qa_E, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[1])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 102}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; __pyx_mstate_global->__pyx_codeobj_tab[2] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_borghash_HashTable_pyx, __pyx_mstate->__pyx_n_u_clear, __pyx_mstate->__pyx_kp_b_iso88591_q_L_HA_N_4q_Kq_Kq_1D_2_D, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[2])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 226}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_key, __pyx_mstate->__pyx_n_u_value}; __pyx_mstate_global->__pyx_codeobj_tab[3] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_borghash_HashTable_pyx, __pyx_mstate->__pyx_n_u_setdefault, __pyx_mstate->__pyx_kp_b_iso88591_nJa_t3a_t1A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[3])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 231}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_key, __pyx_mstate->__pyx_n_u_default}; __pyx_mstate_global->__pyx_codeobj_tab[4] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_borghash_HashTable_pyx, __pyx_mstate->__pyx_n_u_get, __pyx_mstate->__pyx_kp_b_iso88591_vYa_4q_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[4])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 237}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_key, __pyx_mstate->__pyx_n_u_default, __pyx_mstate->__pyx_n_u_value}; __pyx_mstate_global->__pyx_codeobj_tab[5] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_borghash_HashTable_pyx, __pyx_mstate->__pyx_n_u_pop, __pyx_mstate->__pyx_kp_b_iso88591_v_A_D_xs_1_AQ_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[5])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 316}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_key, __pyx_mstate->__pyx_n_u_index}; __pyx_mstate_global->__pyx_codeobj_tab[6] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_borghash_HashTable_pyx, __pyx_mstate->__pyx_n_u_k_to_idx, __pyx_mstate->__pyx_kp_b_iso88591_Ja_3auCt1_AQ_4_Qk_aq_4vQa_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[6])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 329}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_idx, __pyx_mstate->__pyx_n_u_kv_index}; __pyx_mstate_global->__pyx_codeobj_tab[7] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_borghash_HashTable_pyx, __pyx_mstate->__pyx_n_u_idx_to_k, __pyx_mstate->__pyx_kp_b_iso88591_HA_A_t5_D_3b_A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[7])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 6, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 337}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_key, __pyx_mstate->__pyx_n_u_value, __pyx_mstate->__pyx_n_u_index, __pyx_mstate->__pyx_n_u_kv_index, __pyx_mstate->__pyx_n_u_value_found}; __pyx_mstate_global->__pyx_codeobj_tab[8] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_borghash_HashTable_pyx, __pyx_mstate->__pyx_n_u_kv_to_idx, __pyx_mstate->__pyx_kp_b_iso88591_Q_3auCt1_AQ_3awc_Q_AQ_4_Qk_aq_t, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[8])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 355}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_idx, __pyx_mstate->__pyx_n_u_kv_index, __pyx_mstate->__pyx_n_u_key, __pyx_mstate->__pyx_n_u_value}; __pyx_mstate_global->__pyx_codeobj_tab[9] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_borghash_HashTable_pyx, __pyx_mstate->__pyx_n_u_idx_to_kv, __pyx_mstate->__pyx_kp_b_iso88591_XQ_A_d_q_4xy_Rt1_G1IRt89Bc_4q_u, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[9])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; __pyx_mstate_global->__pyx_codeobj_tab[10] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_tree_fragment, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_mstate->__pyx_kp_b_iso88591_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[10])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state}; __pyx_mstate_global->__pyx_codeobj_tab[11] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_tree_fragment, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_mstate->__pyx_kp_b_iso88591_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[11])) goto bad; } Py_DECREF(tuple_dedup_map); return 0; bad: Py_DECREF(tuple_dedup_map); return -1; } /* #### Code section: init_globals ### */ static int __Pyx_InitGlobals(void) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; /* PythonCompatibility.init */ if (likely(__Pyx_init_co_variables() == 0 && __Pyx_init_tpflags_variables() == 0)); else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) /* PyFrozenDict.init */ #if CYTHON_COMPILING_IN_LIMITED_API { PyObject *builtins = PyEval_GetBuiltins(); // borrowed if (likely(builtins)) { PyObject *type_name = PyUnicode_FromStringAndSize("frozendict", sizeof("frozendict")-1); if (likely(type_name)) { PyObject *frozendict_type = PyObject_GetItem(builtins, type_name); Py_DECREF(type_name); if (!frozendict_type && PyErr_ExceptionMatches(PyExc_KeyError)) { PyErr_Clear(); frozendict_type = (PyObject*) &PyDict_Type; Py_INCREF(frozendict_type); } __pyx_mstate_global->__Pyx_PyFrozenDictType = frozendict_type; } } } // error handling follows #endif if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) /* AssertionsEnabled.init */ if (likely(__Pyx_init_assertions_enabled() == 0)); else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) /* CommonTypesMetaclass.init */ if (likely(__pyx_CommonTypesMetaclass_init(__pyx_m) == 0)); else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) /* CachedMethodType.init */ #if CYTHON_COMPILING_IN_LIMITED_API { PyObject *typesModule=NULL; typesModule = PyImport_ImportModule("types"); if (typesModule) { __pyx_mstate_global->__Pyx_CachedMethodType = PyObject_GetAttrString(typesModule, "MethodType"); Py_DECREF(typesModule); } } // error handling follows #endif if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) /* Generator.init */ if (likely(__pyx_Generator_init(__pyx_m) == 0)); else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } /* #### Code section: init_after_shared_utility ### */ static int __Pyx_InitAfterSharedUtility(void) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; /* CythonFunctionPerModule.init */ if (likely(__pyx_CyFunction_init(__pyx_m) == 0)); else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } /* #### Code section: cleanup_globals ### */ /* #### Code section: cleanup_module ### */ /* #### Code section: main_method ### */ /* #### Code section: utility_code_pragmas ### */ #ifdef _MSC_VER #pragma warning( push ) /* Warning 4127: conditional expression is constant * Cython uses constant conditional expressions to allow in inline functions to be optimized at * compile-time, so this warning is not useful */ #pragma warning( disable : 4127 ) #endif /* #### Code section: utility_code_def ### */ /* --- Runtime support code --- */ /* Refnanny */ #if CYTHON_REFNANNY static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { PyObject *m = NULL, *p = NULL; void *r = NULL; m = PyImport_ImportModule(modname); if (!m) goto end; p = PyObject_GetAttrString(m, "RefNannyAPI"); if (!p) goto end; r = PyLong_AsVoidPtr(p); end: Py_XDECREF(p); Py_XDECREF(m); return (__Pyx_RefNannyAPIStruct *)r; } #endif /* FastTypeChecks (used by GivenExceptionMatches) */ #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); } #endif /* PyErrFetchRestore (used by GivenExceptionMatches) */ #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 /* GivenExceptionMatches (used by PyErrExceptionMatches) */ #if CYTHON_COMPILING_IN_CPYTHON 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); } } static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; assert(PyExceptionClass_Check(exc_type)); n = PyTuple_GET_SIZE(tuple); for (i=0; i= 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 /* PyObjectGetAttrStr (used by PyObjectGetAttrStrNoError) */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro)) return tp->tp_getattro(obj, attr_name); return PyObject_GetAttr(obj, attr_name); } #endif /* PyObjectGetAttrStrNoError (used by GetBuiltinName) */ #if __PYX_LIMITED_VERSION_HEX < 0x030d0000 static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) __Pyx_PyErr_Clear(); } #endif static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { PyObject *result; #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 (void) PyObject_GetOptionalAttr(obj, attr_name, &result); return result; #else #if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); } #endif result = __Pyx_PyObject_GetAttrStr(obj, attr_name); if (unlikely(!result)) { __Pyx_PyObject_GetAttrStr_ClearAttributeError(); } return result; #endif } /* GetBuiltinName */ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_mstate_global->__pyx_b, name); if (unlikely(!result) && !PyErr_Occurred()) { PyErr_Format(PyExc_NameError, "name '%U' is not defined", name); } return result; } /* CopyObjectArray (used by TupleOrListFromArrayImpl) */ #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); } } #endif /* TupleOrListFromArrayImpl (used by TupleFromArray) */ #if !(PY_VERSION_HEX >= 0x030F0000 && !CYTHON_COMPILING_IN_LIMITED_API) CYTHON_UNUSED static PyObject * __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) { if (n <= 0) { return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_tuple); } PyObject *res = PyTuple_New(n); if (unlikely(res == NULL)) return NULL; #if CYTHON_COMPILING_IN_CPYTHON __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n); #else Py_ssize_t i; for (i = 0; i < n; i++) { Py_INCREF(src[i]); if (unlikely(__Pyx_PyTuple_SET_ITEM(res, i, src[i]) < (0))) { Py_DECREF(res); return NULL; } } #endif return res; } #endif /* PyObjectCompare (used by UnicodeEquals) */ #ifndef __Pyx_DEFINED_PyObject_CompareStrStrBoolEq #define __Pyx_DEFINED_PyObject_CompareStrStrBoolEq static CYTHON_INLINE int __Pyx_PyObject_CompareStrStrBoolEq(PyObject* s1, PyObject* s2) { #if __PYX_LIMITED_VERSION_HEX >= 0x030e0000 int result = PyUnicode_Equal(s1, s2); #if !CYTHON_COMPILING_IN_CPYTHON if (unlikely(result == -1)) return -1; #endif if (result == 0) goto __pyx_return_false; else goto __pyx_return_true; #else int result = PyUnicode_Compare(s1, s2); if (unlikely((result == -1) && PyErr_Occurred())) return -1; if (result == 0) goto __pyx_return_true; else goto __pyx_return_false; #endif __pyx_return_true: return 1; __pyx_return_false: return 0; } #endif static CYTHON_INLINE int __Pyx_PyObject_CompareBoolEq_str_str(PyObject *op1, PyObject *op2, int pyop) { CYTHON_UNUSED_VAR(pyop); if (unlikely(op1 == Py_None)) { if (op2 == Py_None) goto __pyx_return_true; else goto __pyx_return_false; } if (unlikely(op2 == Py_None)) { if (op1 == Py_None) goto __pyx_return_true; else goto __pyx_return_false; } if (likely(op1 != Py_None)) { if (op1 == op2) goto __pyx_return_true; if (likely(op2 != Py_None)) { return __Pyx_PyObject_CompareStrStrBoolEq(op1, op2); } goto __pyx_richcmp; } if ((0)) goto __pyx_richcmp; if ((0)) goto __pyx_return_true; if ((0)) goto __pyx_return_false; __pyx_richcmp: return __Pyx_PyObject_RichCompareBool(op1, op2, Py_EQ); __pyx_return_true: return 1; __pyx_return_false: return 0; } /* fastcall */ #if CYTHON_VECTORCALL static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) { Py_ssize_t i, n = __Pyx_PyTuple_GET_SIZE(kwnames); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely(n == -1)) return NULL; #endif for (i = 0; i < n; i++) { PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely(!namei)) return NULL; #endif if (s == namei) return kwvalues[i]; } for (i = 0; i < n; i++) { PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely(!namei)) return NULL; #endif int eq = __Pyx_PyUnicode_Equals(s, namei); if (unlikely(eq != 0)) { if (unlikely(eq < 0)) return NULL; return kwvalues[i]; } } return NULL; } #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_GRAAL CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { Py_ssize_t i, nkwargs; PyObject *dict; #if !CYTHON_ASSUME_SAFE_SIZE nkwargs = PyTuple_Size(kwnames); if (unlikely(nkwargs < 0)) return NULL; #else nkwargs = PyTuple_GET_SIZE(kwnames); #endif dict = PyDict_New(); if (unlikely(!dict)) return NULL; for (i=0; itp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) return NULL; result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* PyObjectCallMethO (used by PyObjectFastCall) */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { PyObject *self, *result; PyCFunction cfunc; cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); self = __Pyx_CyOrPyCFunction_GET_SELF(func); if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) return NULL; result = cfunc(self, arg); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* PyObjectFastCall (used by PyObjectCallOneArg) */ #if CYTHON_COMPILING_IN_LIMITED_API static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject * const*args, size_t nargs, PyObject *kwargs) { PyObject *argstuple; PyObject *result = 0; size_t i; argstuple = PyTuple_New((Py_ssize_t)nargs); if (unlikely(!argstuple)) return NULL; for (i = 0; i < nargs; i++) { Py_INCREF(args[i]); if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) != (0)) goto bad; } result = __Pyx_PyObject_Call(func, argstuple, kwargs); bad: Py_DECREF(argstuple); return result; } #endif #if CYTHON_VECTORCALL && !(CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY) #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE vectorcallfunc __Pyx_PyVectorcall_Function(PyObject *callable) { PyTypeObject *tp = Py_TYPE(callable); #if defined(__Pyx_CyFunction_USED) if (__Pyx_CyFunction_CheckExact(callable)) { return __Pyx_CyFunction_func_vectorcall(callable); } #endif if (!PyType_HasFeature(tp, Py_TPFLAGS_HAVE_VECTORCALL)) { return NULL; } assert(PyCallable_Check(callable)); Py_ssize_t offset = tp->tp_vectorcall_offset; assert(offset > 0); vectorcallfunc ptr; memcpy(&ptr, (char *) callable + offset, sizeof(ptr)); return ptr; } #else #define __Pyx_PyVectorcall_Function(callable) PyVectorcall_Function(callable) #endif #endif static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwargs) { Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(nargsf); #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 (kwargs == NULL) { #if CYTHON_VECTORCALL #if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY return PyObject_Vectorcall(func, args, nargsf, NULL); #else vectorcallfunc f = __Pyx_PyVectorcall_Function(func); if (f) { return f(func, args, nargsf, NULL); } #endif #endif } if (nargs == 0) { return __Pyx_PyObject_Call(func, __pyx_mstate_global->__pyx_empty_tuple, kwargs); } #if CYTHON_COMPILING_IN_LIMITED_API return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs); #elif CYTHON_COMPILING_IN_PYPY return PyObject_VectorcallDict(func, args, (size_t) nargs, kwargs); #else return PyObject_VectorcallDict(func, args, nargsf, kwargs); #endif } /* PyObjectCallOneArg (used by CallUnboundCMethod0) */ 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); } /* IgnoreException (used by UnpackUnboundCMethod_impl) */ static CYTHON_INLINE int __Pyx_IgnoreGivenException(PyObject *given_exception, PyObject *ignorable_exception) { if (PyErr_GivenExceptionMatches(given_exception ? given_exception : PyErr_Occurred(), ignorable_exception)) { PyErr_Clear(); return 1; } return 0; } /* UnpackUnboundCMethod_impl (used by UnpackUnboundCMethod) */ #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030C0000 static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *args, PyObject *kwargs) { PyObject *result; PyObject *selfless_args = PyTuple_GetSlice(args, 1, PyTuple_Size(args)); if (unlikely(!selfless_args)) return NULL; result = PyObject_Call(method, selfless_args, kwargs); Py_DECREF(selfless_args); return result; } #else static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) { return PyObject_Vectorcall(method, args ? args+1 : NULL, nargs ? (size_t) nargs-1 : 0, kwnames); } #endif static PyMethodDef __Pyx_UnboundCMethod_Def = { "CythonUnboundCMethod", __PYX_REINTERPRET_FUNCION(PyCFunction, __Pyx_SelflessCall), #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030C0000 METH_VARARGS | METH_KEYWORDS, #else METH_FASTCALL | METH_KEYWORDS, #endif NULL }; static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) { PyObject *method, *result=NULL; method = __Pyx_PyObject_GetAttrStr(target->type, *target->method_name); if (unlikely(!method)) return -1; result = method; #if CYTHON_COMPILING_IN_CPYTHON if (likely(__Pyx_TypeCheck(method, &PyMethodDescr_Type))) { PyMethodDescrObject *descr = (PyMethodDescrObject*) method; target->func = descr->d_method->ml_meth; target->flag = descr->d_method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST); } 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 && !__Pyx_IgnoreException(PyExc_AttributeError)) { return -1; } #else self = PyCFunction_GET_SELF(method); #endif self_found = (self && self != Py_None); #if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY Py_XDECREF(self); #endif if (self_found) { PyObject *unbound_method = PyCFunction_New(&__Pyx_UnboundCMethod_Def, method); if (unlikely(!unbound_method)) return -1; Py_DECREF(method); result = unbound_method; } } #if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING if (unlikely(target->method)) { Py_DECREF(result); } else #endif target->method = result; return 0; } /* CallUnboundCMethod0 */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) { int was_initialized = __Pyx_CachedCFunction_GetAndSetInitializing(cfunc); if (likely(was_initialized == 2 && cfunc->func)) { if (likely(cfunc->flag == METH_NOARGS)) return __Pyx_CallCFunction(cfunc, self, NULL); if (likely(cfunc->flag == METH_FASTCALL)) return __Pyx_CallCFunctionFast(cfunc, self, NULL, 0); if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS)) return __Pyx_CallCFunctionFastWithKeywords(cfunc, self, NULL, 0, NULL); if (likely(cfunc->flag == (METH_VARARGS | METH_KEYWORDS))) return __Pyx_CallCFunctionWithKeywords(cfunc, self, __pyx_mstate_global->__pyx_empty_tuple, NULL); if (cfunc->flag == METH_VARARGS) return __Pyx_CallCFunction(cfunc, self, __pyx_mstate_global->__pyx_empty_tuple); return __Pyx__CallUnboundCMethod0(cfunc, self); } #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING else if (unlikely(was_initialized == 1)) { __Pyx_CachedCFunction tmp_cfunc = { #ifndef __cplusplus 0 #endif }; tmp_cfunc.type = cfunc->type; tmp_cfunc.method_name = cfunc->method_name; return __Pyx__CallUnboundCMethod0(&tmp_cfunc, self); } #endif PyObject *result = __Pyx__CallUnboundCMethod0(cfunc, self); __Pyx_CachedCFunction_SetFinishedInitializing(cfunc); return result; } #endif static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) { PyObject *result; if (unlikely(!cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; result = __Pyx_PyObject_CallOneArg(cfunc->method, self); return result; } /* py_dict_items (used by OwnedDictNext) */ static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d) { return __Pyx_CallUnboundCMethod0(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_items, d); } /* py_dict_values (used by OwnedDictNext) */ static CYTHON_INLINE PyObject* __Pyx_PyDict_Values(PyObject* d) { return __Pyx_CallUnboundCMethod0(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_values, d); } /* OwnedDictNext (used by ParseKeywordsImpl) */ #if CYTHON_AVOID_BORROWED_REFS static int __Pyx_PyDict_NextRef(PyObject *p, PyObject **ppos, PyObject **pkey, PyObject **pvalue) { PyObject *next = NULL; if (!*ppos) { if (pvalue) { PyObject *dictview = pkey ? __Pyx_PyDict_Items(p) : __Pyx_PyDict_Values(p); if (unlikely(!dictview)) goto bad; *ppos = PyObject_GetIter(dictview); Py_DECREF(dictview); } else { *ppos = PyObject_GetIter(p); } if (unlikely(!*ppos)) goto bad; } next = PyIter_Next(*ppos); if (!next) { if (PyErr_Occurred()) goto bad; return 0; } if (pkey && pvalue) { *pkey = __Pyx_PySequence_ITEM(next, 0); if (unlikely(*pkey)) goto bad; *pvalue = __Pyx_PySequence_ITEM(next, 1); if (unlikely(*pvalue)) goto bad; Py_DECREF(next); } else if (pkey) { *pkey = next; } else { assert(pvalue); *pvalue = next; } return 1; bad: Py_XDECREF(next); #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d0000 PyErr_FormatUnraisable("Exception ignored in __Pyx_PyDict_NextRef"); #else PyErr_WriteUnraisable(__pyx_mstate_global->__pyx_n_u_Pyx_PyDict_NextRef); #endif if (pkey) *pkey = NULL; if (pvalue) *pvalue = NULL; return 0; } #else // !CYTHON_AVOID_BORROWED_REFS static int __Pyx_PyDict_NextRef(PyObject *p, Py_ssize_t *ppos, PyObject **pkey, PyObject **pvalue) { int result = PyDict_Next(p, ppos, pkey, pvalue); if (likely(result == 1)) { if (pkey) Py_INCREF(*pkey); if (pvalue) Py_INCREF(*pvalue); } return result; } #endif /* RaiseDoubleKeywords (used by ParseKeywordsImpl) */ static void __Pyx_RaiseDoubleKeywordsError( const char* func_name, PyObject* kw_name) { PyErr_Format(PyExc_TypeError, "%s() got multiple values for keyword argument '%U'", func_name, kw_name); } /* CallUnboundCMethod2 */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2) { int was_initialized = __Pyx_CachedCFunction_GetAndSetInitializing(cfunc); if (likely(was_initialized == 2 && cfunc->func)) { PyObject *args[2] = {arg1, arg2}; if (cfunc->flag == METH_FASTCALL) { return __Pyx_CallCFunctionFast(cfunc, self, args, 2); } if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS)) return __Pyx_CallCFunctionFastWithKeywords(cfunc, self, args, 2, NULL); } #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING else if (unlikely(was_initialized == 1)) { __Pyx_CachedCFunction tmp_cfunc = { #ifndef __cplusplus 0 #endif }; tmp_cfunc.type = cfunc->type; tmp_cfunc.method_name = cfunc->method_name; return __Pyx__CallUnboundCMethod2(&tmp_cfunc, self, arg1, arg2); } #endif PyObject *result = __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2); __Pyx_CachedCFunction_SetFinishedInitializing(cfunc); return result; } #endif static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2){ if (unlikely(!cfunc->func && !cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; #if CYTHON_COMPILING_IN_CPYTHON if (cfunc->func && (cfunc->flag & METH_VARARGS)) { PyObject *result = NULL; PyObject *args = PyTuple_New(2); if (unlikely(!args)) return NULL; Py_INCREF(arg1); PyTuple_SET_ITEM(args, 0, arg1); Py_INCREF(arg2); PyTuple_SET_ITEM(args, 1, arg2); if (cfunc->flag & METH_KEYWORDS) result = __Pyx_CallCFunctionWithKeywords(cfunc, self, args, NULL); else result = __Pyx_CallCFunction(cfunc, self, args); Py_DECREF(args); return result; } #endif { PyObject *args[4] = {NULL, self, arg1, arg2}; return __Pyx_PyObject_FastCall(cfunc->method, args+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); } } /* ParseKeywordsImpl (used by ParseKeywords) */ static int __Pyx_ValidateDuplicatePosArgs( PyObject *kwds, PyObject ** const argnames[], PyObject ** const *first_kw_arg, const char* function_name) { PyObject ** const *name = argnames; while (name != first_kw_arg) { PyObject *key = **name; int found = PyDict_Contains(kwds, key); if (unlikely(found)) { if (found == 1) __Pyx_RaiseDoubleKeywordsError(function_name, key); goto bad; } name++; } return 0; bad: return -1; } #if CYTHON_USE_UNICODE_INTERNALS static CYTHON_INLINE int __Pyx_UnicodeKeywordsEqual(PyObject *s1, PyObject *s2) { int kind; Py_ssize_t len = PyUnicode_GET_LENGTH(s1); if (len != PyUnicode_GET_LENGTH(s2)) return 0; kind = PyUnicode_KIND(s1); if (kind != PyUnicode_KIND(s2)) return 0; const void *data1 = PyUnicode_DATA(s1); const void *data2 = PyUnicode_DATA(s2); return (memcmp(data1, data2, (size_t) len * (size_t) kind) == 0); } #endif static int __Pyx_MatchKeywordArg_str( PyObject *key, PyObject ** const argnames[], PyObject ** const *first_kw_arg, size_t *index_found, const char *function_name) { PyObject ** const *name; #if CYTHON_USE_UNICODE_INTERNALS Py_hash_t key_hash = ((PyASCIIObject*)key)->hash; if (unlikely(key_hash == -1)) { key_hash = PyObject_Hash(key); if (unlikely(key_hash == -1)) goto bad; } #endif name = first_kw_arg; while (*name) { PyObject *name_str = **name; #if CYTHON_USE_UNICODE_INTERNALS if (key_hash == ((PyASCIIObject*)name_str)->hash && __Pyx_UnicodeKeywordsEqual(name_str, key)) { *index_found = (size_t) (name - argnames); return 1; } #else #if CYTHON_ASSUME_SAFE_SIZE if (PyUnicode_GET_LENGTH(name_str) == PyUnicode_GET_LENGTH(key)) #endif { int cmp = PyUnicode_Compare(name_str, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) { *index_found = (size_t) (name - argnames); return 1; } } #endif name++; } name = argnames; while (name != first_kw_arg) { PyObject *name_str = **name; #if CYTHON_USE_UNICODE_INTERNALS if (unlikely(key_hash == ((PyASCIIObject*)name_str)->hash)) { if (__Pyx_UnicodeKeywordsEqual(name_str, key)) goto arg_passed_twice; } #else #if CYTHON_ASSUME_SAFE_SIZE if (PyUnicode_GET_LENGTH(name_str) == PyUnicode_GET_LENGTH(key)) #endif { if (unlikely(name_str == key)) goto arg_passed_twice; int cmp = PyUnicode_Compare(name_str, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) goto arg_passed_twice; } #endif name++; } return 0; arg_passed_twice: __Pyx_RaiseDoubleKeywordsError(function_name, key); goto bad; bad: return -1; } static int __Pyx_MatchKeywordArg_nostr( PyObject *key, PyObject ** const argnames[], PyObject ** const *first_kw_arg, size_t *index_found, const char *function_name) { PyObject ** const *name; if (unlikely(!PyUnicode_Check(key))) goto invalid_keyword_type; name = first_kw_arg; while (*name) { int cmp = PyObject_RichCompareBool(**name, key, Py_EQ); if (cmp == 1) { *index_found = (size_t) (name - argnames); return 1; } if (unlikely(cmp == -1)) goto bad; name++; } name = argnames; while (name != first_kw_arg) { int cmp = PyObject_RichCompareBool(**name, key, Py_EQ); if (unlikely(cmp != 0)) { if (cmp == 1) goto arg_passed_twice; else goto bad; } name++; } return 0; arg_passed_twice: __Pyx_RaiseDoubleKeywordsError(function_name, key); goto bad; invalid_keyword_type: PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); goto bad; bad: return -1; } static CYTHON_INLINE int __Pyx_MatchKeywordArg( PyObject *key, PyObject ** const argnames[], PyObject ** const *first_kw_arg, size_t *index_found, const char *function_name) { return likely(PyUnicode_CheckExact(key)) ? __Pyx_MatchKeywordArg_str(key, argnames, first_kw_arg, index_found, function_name) : __Pyx_MatchKeywordArg_nostr(key, argnames, first_kw_arg, index_found, function_name); } static void __Pyx_RejectUnknownKeyword( PyObject *kwds, PyObject ** const argnames[], PyObject ** const *first_kw_arg, const char *function_name) { #if CYTHON_AVOID_BORROWED_REFS PyObject *pos = NULL; #else Py_ssize_t pos = 0; #endif PyObject *key = NULL; __Pyx_BEGIN_CRITICAL_SECTION(kwds); #if CYTHON_AVOID_BORROWED_REFS while (__Pyx_PyDict_NextRef(kwds, &pos, &key, NULL)) #else (void) __Pyx_PyDict_NextRef; while (PyDict_Next(kwds, &pos, &key, NULL)) #endif { PyObject** const *name = first_kw_arg; while (*name && (**name != key)) name++; if (!*name) { size_t index_found = 0; int cmp = __Pyx_MatchKeywordArg(key, argnames, first_kw_arg, &index_found, function_name); if (cmp != 1) { if (cmp == 0) { PyErr_Format(PyExc_TypeError, "%s() got an unexpected keyword argument '%U'", function_name, key); } #if CYTHON_AVOID_BORROWED_REFS Py_DECREF(key); #endif break; } } #if CYTHON_AVOID_BORROWED_REFS Py_DECREF(key); #endif } __Pyx_END_CRITICAL_SECTION(); #if CYTHON_AVOID_BORROWED_REFS Py_XDECREF(pos); #endif assert(PyErr_Occurred()); } static int __Pyx_ParseKeywordDict( PyObject *kwds, PyObject ** const argnames[], PyObject *values[], Py_ssize_t num_pos_args, Py_ssize_t num_kwargs, const char* function_name, int ignore_unknown_kwargs) { PyObject** const *name; PyObject** const *first_kw_arg = argnames + num_pos_args; Py_ssize_t extracted = 0; #if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return -1; #endif name = first_kw_arg; while (*name && num_kwargs > extracted) { PyObject * key = **name; PyObject *value; int found = 0; #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 found = PyDict_GetItemRef(kwds, key, &value); #else value = PyDict_GetItemWithError(kwds, key); if (value) { Py_INCREF(value); found = 1; } else { if (unlikely(PyErr_Occurred())) goto bad; } #endif if (found) { if (unlikely(found < 0)) goto bad; values[name-argnames] = value; extracted++; } name++; } if (num_kwargs > extracted) { if (ignore_unknown_kwargs) { if (unlikely(__Pyx_ValidateDuplicatePosArgs(kwds, argnames, first_kw_arg, function_name) == -1)) goto bad; } else { __Pyx_RejectUnknownKeyword(kwds, argnames, first_kw_arg, function_name); goto bad; } } return 0; bad: return -1; } static int __Pyx_ParseKeywordDictToDict( PyObject *kwds, PyObject ** const argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name) { PyObject** const *name; PyObject** const *first_kw_arg = argnames + num_pos_args; Py_ssize_t len; #if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return -1; #endif if (PyDict_Update(kwds2, kwds) < 0) goto bad; name = first_kw_arg; while (*name) { PyObject *key = **name; PyObject *value; #if !CYTHON_COMPILING_IN_LIMITED_API && (PY_VERSION_HEX >= 0x030d00A2 || defined(PyDict_Pop)) int found = PyDict_Pop(kwds2, key, &value); if (found) { if (unlikely(found < 0)) goto bad; values[name-argnames] = value; } #elif __PYX_LIMITED_VERSION_HEX >= 0x030d0000 int found = PyDict_GetItemRef(kwds2, key, &value); if (found) { if (unlikely(found < 0)) goto bad; values[name-argnames] = value; if (unlikely(PyDict_DelItem(kwds2, key) < 0)) goto bad; } #else #if CYTHON_COMPILING_IN_CPYTHON value = _PyDict_Pop(kwds2, key, kwds2); #else value = __Pyx_CallUnboundCMethod2(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_pop, kwds2, key, kwds2); #endif if (value == kwds2) { Py_DECREF(value); } else { if (unlikely(!value)) goto bad; values[name-argnames] = value; } #endif name++; } len = PyDict_Size(kwds2); if (len > 0) { return __Pyx_ValidateDuplicatePosArgs(kwds, argnames, first_kw_arg, function_name); } else if (unlikely(len == -1)) { goto bad; } return 0; bad: return -1; } static int __Pyx_ParseKeywordsTuple( PyObject *kwds, PyObject * const *kwvalues, PyObject ** const argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, Py_ssize_t num_kwargs, const char* function_name, int ignore_unknown_kwargs) { PyObject *key = NULL; PyObject** const * name; PyObject** const *first_kw_arg = argnames + num_pos_args; for (Py_ssize_t pos = 0; pos < num_kwargs; pos++) { #if CYTHON_AVOID_BORROWED_REFS key = __Pyx_PySequence_ITEM(kwds, pos); #else key = __Pyx_PyTuple_GET_ITEM(kwds, pos); #endif #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely(!key)) goto bad; #endif name = first_kw_arg; while (*name && (**name != key)) name++; if (*name) { PyObject *value = kwvalues[pos]; values[name-argnames] = __Pyx_NewRef(value); } else { size_t index_found = 0; int cmp = __Pyx_MatchKeywordArg(key, argnames, first_kw_arg, &index_found, function_name); if (cmp == 1) { PyObject *value = kwvalues[pos]; values[index_found] = __Pyx_NewRef(value); } else { if (unlikely(cmp == -1)) goto bad; if (kwds2) { PyObject *value = kwvalues[pos]; if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; } else if (!ignore_unknown_kwargs) { goto invalid_keyword; } } } #if CYTHON_AVOID_BORROWED_REFS Py_DECREF(key); key = NULL; #endif } return 0; invalid_keyword: PyErr_Format(PyExc_TypeError, "%s() got an unexpected keyword argument '%U'", function_name, key); goto bad; bad: #if CYTHON_AVOID_BORROWED_REFS Py_XDECREF(key); #endif return -1; } /* ParseKeywords */ static int __Pyx_ParseKeywords( PyObject *kwds, PyObject * const *kwvalues, PyObject ** const argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, Py_ssize_t num_kwargs, const char* function_name, int ignore_unknown_kwargs) { if (CYTHON_VECTORCALL && likely(PyTuple_Check(kwds))) return __Pyx_ParseKeywordsTuple(kwds, kwvalues, argnames, kwds2, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs); else if (kwds2) return __Pyx_ParseKeywordDictToDict(kwds, argnames, kwds2, values, num_pos_args, function_name); else return __Pyx_ParseKeywordDict(kwds, argnames, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs); } /* RaiseArgTupleInvalid */ static void __Pyx_RaiseArgtupleInvalid( const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found) { Py_ssize_t num_expected; const char *more_or_less; if (num_found < num_min) { num_expected = num_min; more_or_less = "at least"; } else { num_expected = num_max; more_or_less = "at most"; } if (exact) { more_or_less = "exactly"; } PyErr_Format(PyExc_TypeError, "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", func_name, more_or_less, num_expected, (num_expected == 1) ? "" : "s", num_found); } /* PyDictVersioning (used by GetModuleGlobalName) */ #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_COMPILING_IN_LIMITED_API if (unlikely(!__pyx_m)) { if (!PyErr_Occurred()) PyErr_SetNone(PyExc_NameError); return NULL; } result = PyObject_GetAttr(__pyx_m, name); if (likely(result)) { return result; } if (!__Pyx_IgnoreException(PyExc_Exception)) { return NULL; // BaseException } #elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS if (unlikely(__Pyx_PyDict_GetItemRef(__pyx_mstate_global->__pyx_d, name, &result) == -1)) { if (!__Pyx_IgnoreException(PyExc_Exception)) { return NULL; // BaseException } } __PYX_UPDATE_DICT_CACHE(__pyx_mstate_global->__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return result; } #else result = _PyDict_GetItem_KnownHash(__pyx_mstate_global->__pyx_d, name, ((PyASCIIObject *) name)->hash); __PYX_UPDATE_DICT_CACHE(__pyx_mstate_global->__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } PyObject *exc = PyErr_Occurred(); if (unlikely(exc) && !__Pyx_IgnoreGivenException(exc, PyExc_Exception)) { return NULL; // BaseException } #endif return __Pyx_GetBuiltinName(name); } /* PyFrozenDict (used by GetItemInt) */ #if CYTHON_COMPILING_IN_LIMITED_API static CYTHON_INLINE PyObject* __Pyx__PyFrozenDict_New(PyObject* frozendict_type, PyObject* it) { return PyObject_CallFunctionObjArgs(frozendict_type, it, NULL); } #endif /* GettItemInt_wraparound (used by GetItemInt) */ #if CYTHON_USE_TYPE_SLOTS && !CYTHON_COMPILING_IN_PYPY static int __Pyx_GetItemInt_wraparound(PyObject *o, PySequenceMethods *sm, Py_ssize_t *i) { assert(*i < 0); if (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 -1; PyErr_Clear(); } } return 0; } #endif /* GetItemInt */ static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { PyObject *r; if (unlikely(!j)) return NULL; r = PyObject_GetItem(o, j); Py_DECREF(j); return r; } static PyObject *__Pyx_GetItemInt_Generic_size(PyObject *o, Py_ssize_t i) { return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i)); } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck, int unsafe_shared) { CYTHON_MAYBE_UNUSED_VAR(unsafe_shared); #if CYTHON_AVOID_BORROWED_REFS CYTHON_UNUSED_VAR(boundscheck); Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { Py_ssize_t size = __Pyx_PyList_GET_SIZE(o); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely(size < 0)) return NULL; #endif wrapped_i += size; } return __Pyx_PyList_GetItemRef(o, wrapped_i); #elif CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS Py_ssize_t wrapped_i = i; Py_ssize_t size = (wraparound | boundscheck) ? PyList_GET_SIZE(o) : -1; if (wraparound & unlikely(i < 0)) { wrapped_i += size; } if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, size))) { return __Pyx_PyList_GET_ITEM_REF(o, wrapped_i, unsafe_shared); } return __Pyx_GetItemInt_Generic_size(o, i); #else (void)wraparound; (void)boundscheck; return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck, int unsafe_shared) { CYTHON_MAYBE_UNUSED_VAR(unsafe_shared); #if CYTHON_AVOID_BORROWED_REFS CYTHON_UNUSED_VAR(boundscheck); Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(o); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely(size < 0)) return NULL; #endif wrapped_i += size; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_COMPILING_IN_LIMITED_API return PySequence_ITEM(o, wrapped_i); #else if (unlikely(wrapped_i < 0)) { PyErr_SetString(PyExc_IndexError, "tuple index out of range"); return NULL; } return PySequence_GetItem(o, wrapped_i); #endif #elif CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS Py_ssize_t wrapped_i = i; Py_ssize_t size = (wraparound | boundscheck) ? PyTuple_GET_SIZE(o) : -1; if (wraparound & unlikely(i < 0)) { wrapped_i += size; } if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, size))) { return __Pyx_NewRef(__Pyx_PyTuple_GET_ITEM(o, wrapped_i)); } return __Pyx_GetItemInt_Generic_size(o, i); #else (void)wraparound; (void)boundscheck; return PySequence_GetItem(o, i); #endif } #if CYTHON_USE_TYPE_SLOTS && !CYTHON_COMPILING_IN_PYPY static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast_mapping(PyObject *o, binaryfunc getitem, Py_ssize_t i) { PyObject *r, *key = PyLong_FromSsize_t(i); if (unlikely(!key)) return NULL; r = getitem(o, key); Py_DECREF(key); return r; } #endif static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck, int unsafe_shared) { CYTHON_MAYBE_UNUSED_VAR(unsafe_shared); #if CYTHON_ASSUME_SAFE_SIZE if (PyList_CheckExact(o)) { return __Pyx_GetItemInt_List_Fast(o, i, wraparound, boundscheck, unsafe_shared); } else #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (PyTuple_CheckExact(o)) { return __Pyx_GetItemInt_Tuple_Fast(o, i, wraparound, boundscheck, unsafe_shared); } else #endif #else if ((!wraparound || i >= 0) & PyList_CheckExact(o)) { return boundscheck ? __Pyx_PyList_GetItemRef(o, i) : __Pyx_PyList_GET_ITEM_REF(o, i, unsafe_shared); } else #endif #if CYTHON_USE_TYPE_SLOTS && !CYTHON_COMPILING_IN_PYPY if (PyDict_CheckExact(o)) { return __Pyx_GetItemInt_Fast_mapping(o, PyDict_Type.tp_as_mapping->mp_subscript, i); #if defined(PyFrozenDict_CheckExact) } else if (PyFrozenDict_CheckExact(o)) { return __Pyx_GetItemInt_Fast_mapping(o, PyFrozenDict_Type.tp_as_mapping->mp_subscript, i); #endif } else { PyTypeObject *obj_type = Py_TYPE(o); int seq_or_mapping = __Pyx_PyType_GetFlags(obj_type) & (Py_TPFLAGS_SEQUENCE|Py_TPFLAGS_MAPPING); if (seq_or_mapping != Py_TPFLAGS_SEQUENCE) { PyMappingMethods *mm = obj_type->tp_as_mapping; if (mm && mm->mp_subscript) return __Pyx_GetItemInt_Fast_mapping(o, mm->mp_subscript, i); } PySequenceMethods *sm = obj_type->tp_as_sequence; if (likely(sm && sm->sq_item)) { if (wraparound && (i < 0) && unlikely(__Pyx_GetItemInt_wraparound(o, sm, &i) == -1)) return NULL; return sm->sq_item(o, i); } if (seq_or_mapping == Py_TPFLAGS_SEQUENCE) { PyMappingMethods *mm = obj_type->tp_as_mapping; if (likely(mm && mm->mp_subscript)) return __Pyx_GetItemInt_Fast_mapping(o, mm->mp_subscript, i); } } #else if (!PyMapping_Check(o)) { return PySequence_GetItem(o, i); } #endif (void)wraparound; (void)boundscheck; return __Pyx_GetItemInt_Generic_size(o, i); } /* FormatTypeName (used by RaiseErrorWithObjectType) */ #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 static __Pyx_TypeName __Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp) { PyObject *module = NULL, *name = NULL, *result = NULL; #if __PYX_LIMITED_VERSION_HEX < 0x030b0000 name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, __pyx_mstate_global->__pyx_n_u_qualname); #else name = PyType_GetQualName(tp); #endif if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) goto bad; module = __Pyx_PyObject_GetAttrStr((PyObject *)tp, __pyx_mstate_global->__pyx_n_u_module); if (unlikely(module == NULL) || unlikely(!PyUnicode_Check(module))) goto bad; if (PyUnicode_CompareWithASCIIString(module, "builtins") == 0) { result = name; name = NULL; goto done; } result = PyUnicode_FromFormat("%U.%U", module, name); if (unlikely(result == NULL)) goto bad; done: Py_XDECREF(name); Py_XDECREF(module); return result; bad: PyErr_Clear(); if (name) { result = name; name = NULL; } else { result = __Pyx_NewRef(__pyx_mstate_global->__pyx_kp_u_); } goto done; } #endif /* RaiseErrorWithObjectType (used by ObjectGetItem) */ static void __Pyx_RaiseErrorWithType(PyObject* exc_type, const char* message, PyTypeObject *type_obj) { __Pyx_TypeName type_name = __Pyx_PyType_GetFullyQualifiedName(type_obj); #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 if (unlikely(!type_name)) return; #endif PyErr_Format(exc_type, message, type_name); __Pyx_DECREF_TypeName(type_name); } /* ObjectGetItem */ #if CYTHON_USE_TYPE_SLOTS static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject *index) { PyObject *runerr = NULL; Py_ssize_t key_value; key_value = __Pyx_PyIndex_AsSsize_t(index); if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) { return __Pyx_GetItemInt_Fast(obj, key_value, 1, 1, 1); } if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { PyErr_Clear(); __Pyx_RaiseErrorWithObjectType( PyExc_IndexError, "cannot fit '" __Pyx_FMT_TYPENAME "' into an index-sized integer", index); } return NULL; } static PyObject *__Pyx_PyObject_GetItem_Slow(PyObject *obj, PyObject *key) { if (likely(PyType_Check(obj))) { if ((PyTypeObject*)obj == &PyType_Type) { return Py_GenericAlias(obj, key); } PyObject *meth = __Pyx_PyObject_GetAttrStrNoError(obj, __pyx_mstate_global->__pyx_n_u_class_getitem); if (!meth) { if (PyErr_Occurred()) { return NULL; } } else { PyObject *result = __Pyx_PyObject_CallOneArg(meth, key); Py_DECREF(meth); return result; } } __Pyx_RaiseTypeErrorWithObjectType( "'" __Pyx_FMT_TYPENAME "' object is not subscriptable", obj); return NULL; } static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key) { PyTypeObject *tp = Py_TYPE(obj); PyMappingMethods *mm = tp->tp_as_mapping; PySequenceMethods *sm = tp->tp_as_sequence; if (likely(mm && mm->mp_subscript)) { return mm->mp_subscript(obj, key); } if (likely(sm && sm->sq_item)) { return __Pyx_PyObject_GetIndex(obj, key); } return __Pyx_PyObject_GetItem_Slow(obj, key); } #endif /* HasAttr */ #if __PYX_LIMITED_VERSION_HEX < 0x030d0000 static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { PyObject *r; if (unlikely(!PyUnicode_Check(n))) { PyErr_SetString(PyExc_TypeError, "hasattr(): attribute name must be string"); return -1; } r = __Pyx_PyObject_GetAttrStrNoError(o, n); if (!r) { return (unlikely(PyErr_Occurred())) ? -1 : 0; } else { Py_DECREF(r); return 1; } } #endif /* IterFinish (used by dict_iter_common) */ 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; } /* PyObjectCallMethod0 (used by dict_iter_common) */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { #if CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || !CYTHON_COMPILING_IN_LIMITED_API) return PyObject_VectorcallMethod(method_name, &obj, 1 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); #elif CYTHON_COMPILING_IN_LIMITED_API return PyObject_CallMethodObjArgs(obj, method_name, NULL); #else return PyObject_CallMethodNoArgs(obj, method_name); #endif } /* RaiseNeedMoreValuesToUnpack (used by UnpackTuple2) */ 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 (used by UnpackItemEndCheck) */ 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 (used by UnpackTuple2) */ 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 (used by UnpackTupleError) */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); } /* UnpackTupleError (used by UnpackTuple2) */ static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) { if (t == Py_None) { __Pyx_RaiseNoneNotIterableError(); } else { Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(t); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely(size < 0)) return; #endif if (size < index) { __Pyx_RaiseNeedMoreValuesError(size); } else { __Pyx_RaiseTooManyValuesError(index); } } } /* UnpackTuple2 (used by dict_iter_common) */ static CYTHON_INLINE int __Pyx_unpack_tuple2( PyObject* tuple, PyObject** value1, PyObject** value2, int is_tuple, int has_known_size, int decref_tuple) { if (likely(is_tuple || PyTuple_Check(tuple))) { Py_ssize_t size; if (has_known_size) { return __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple); } size = __Pyx_PyTuple_GET_SIZE(tuple); if (likely(size == 2)) { return __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple); } if (size >= 0) { __Pyx_UnpackTupleError(tuple, 2); } return -1; } else { return __Pyx_unpack_tuple2_generic(tuple, value1, value2, has_known_size, decref_tuple); } } static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int decref_tuple) { PyObject *value1 = NULL, *value2 = NULL; #if CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS value1 = __Pyx_PySequence_ITEM(tuple, 0); if (unlikely(!value1)) goto bad; value2 = __Pyx_PySequence_ITEM(tuple, 1); if (unlikely(!value2)) goto bad; #else value1 = PyTuple_GET_ITEM(tuple, 0); Py_INCREF(value1); value2 = PyTuple_GET_ITEM(tuple, 1); Py_INCREF(value2); #endif if (decref_tuple) { Py_DECREF(tuple); } *pvalue1 = value1; *pvalue2 = value2; return 0; #if CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS bad: Py_XDECREF(value1); Py_XDECREF(value2); if (decref_tuple) { Py_XDECREF(tuple); } return -1; #endif } static int __Pyx_unpack_tuple2_generic(PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int has_known_size, int decref_tuple) { Py_ssize_t index; PyObject *value1 = NULL, *value2 = NULL, *iter = NULL; iternextfunc iternext; iter = PyObject_GetIter(tuple); if (unlikely(!iter)) goto bad; if (decref_tuple) { Py_DECREF(tuple); tuple = NULL; } iternext = __Pyx_PyObject_GetIterNextFunc(iter); value1 = iternext(iter); if (unlikely(!value1)) { index = 0; goto unpacking_failed; } value2 = iternext(iter); if (unlikely(!value2)) { index = 1; goto unpacking_failed; } if (!has_known_size && unlikely(__Pyx_IternextUnpackEndCheck(iternext(iter), 2))) goto bad; Py_DECREF(iter); *pvalue1 = value1; *pvalue2 = value2; return 0; unpacking_failed: if (!has_known_size && __Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); bad: Py_XDECREF(iter); Py_XDECREF(value1); Py_XDECREF(value2); if (decref_tuple) { Py_XDECREF(tuple); } return -1; } /* dict_iter_common (used by dict_iter) */ static PyObject *__Pyx_dict_call_to_get_iterable(PyObject* iterable, PyObject* method_name) { PyObject* iter; iterable = __Pyx_PyObject_CallMethod0(iterable, method_name); if (!iterable) return NULL; #if !CYTHON_AVOID_BORROWED_REFS if (PyTuple_CheckExact(iterable) || PyList_CheckExact(iterable)) return iterable; #endif iter = PyObject_GetIter(iterable); Py_DECREF(iterable); return iter; } #if !CYTHON_AVOID_BORROWED_REFS static CYTHON_INLINE int __Pyx_dict_iter_next_source_is_dict( PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos, PyObject** pkey, PyObject** pvalue, PyObject** pitem) { PyObject *key, *value; if (unlikely(orig_length != PyDict_Size(iter_obj))) { PyErr_SetString(PyExc_RuntimeError, "dictionary changed size during iteration"); return -1; } if (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); #if CYTHON_ASSUME_SAFE_MACROS PyTuple_SET_ITEM(tuple, 0, key); PyTuple_SET_ITEM(tuple, 1, value); #else if (unlikely(PyTuple_SetItem(tuple, 0, key) < 0)) { Py_DECREF(value); Py_DECREF(tuple); return -1; } if (unlikely(PyTuple_SetItem(tuple, 1, value) < 0)) { Py_DECREF(tuple); return -1; } #endif *pitem = tuple; } else { if (pkey) { Py_INCREF(key); *pkey = key; } if (pvalue) { Py_INCREF(value); *pvalue = value; } } return 1; } #endif static CYTHON_INLINE int __Pyx_dict_iter_next( PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos, PyObject** pkey, PyObject** pvalue, PyObject** pitem, int source_is_dict) { PyObject* next_item; #if !CYTHON_AVOID_BORROWED_REFS if (source_is_dict) { int result; #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API Py_BEGIN_CRITICAL_SECTION(iter_obj); #endif result = __Pyx_dict_iter_next_source_is_dict(iter_obj, orig_length, ppos, pkey, pvalue, pitem); #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API Py_END_CRITICAL_SECTION(); #endif return result; } else if (PyTuple_CheckExact(iter_obj)) { Py_ssize_t pos = *ppos; Py_ssize_t tuple_size = __Pyx_PyTuple_GET_SIZE(iter_obj); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely(tuple_size < 0)) return -1; #endif if (unlikely(pos >= tuple_size)) return 0; *ppos = pos + 1; #if CYTHON_ASSUME_SAFE_MACROS next_item = PyTuple_GET_ITEM(iter_obj, pos); #else next_item = PyTuple_GetItem(iter_obj, pos); if (unlikely(!next_item)) return -1; #endif Py_INCREF(next_item); } else if (PyList_CheckExact(iter_obj)) { Py_ssize_t pos = *ppos; Py_ssize_t list_size = __Pyx_PyList_GET_SIZE(iter_obj); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely(list_size < 0)) return -1; #endif if (unlikely(pos >= list_size)) return 0; *ppos = pos + 1; next_item = __Pyx_PyList_GET_ITEM_REF(iter_obj, pos, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!next_item)) return -1; } 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; } /* 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(__Pyx_PyAnyDict_CheckExact(iterable)); *p_source_is_dict = is_dict; #if !CYTHON_AVOID_BORROWED_REFS if (is_dict) { *p_orig_length = PyDict_Size(iterable); Py_INCREF(iterable); return iterable; } #endif *p_orig_length = 0; if (method_name) { return __Pyx_dict_call_to_get_iterable(iterable, method_name); } else { return PyObject_GetIter(iterable); } } /* pybuiltin_invalid (used by pyint_simplify) */ static void __Pyx_PyBuiltin_Invalid(PyObject *obj, const char *builtin_type_name, const char *argname) { __Pyx_TypeName obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 if (unlikely(!obj_type_name)) return; #endif if (argname) { PyErr_Format(PyExc_TypeError, "Argument '%.200s' has incorrect type (expected %.5s, got " __Pyx_FMT_TYPENAME ")", argname, builtin_type_name, obj_type_name ); } else { PyErr_Format(PyExc_TypeError, "Expected %.5s, got " __Pyx_FMT_TYPENAME, builtin_type_name, obj_type_name ); } __Pyx_DECREF_TypeName(obj_type_name); } /* pyint_simplify */ static int __Pyx__PyInt_FromNumber(PyObject **number_var, const char *argname); static CYTHON_INLINE int __Pyx_PyInt_FromNumber(PyObject **number_var, const char *argname, int accept_none) { PyObject *number = *number_var; if (likely((accept_none && number == Py_None) || PyLong_CheckExact(number))) { return 0; } return __Pyx__PyInt_FromNumber(number_var, argname); } static int __Pyx__PyInt_FromNumber(PyObject **number_var, const char *argname) { PyObject *number = *number_var; PyObject *int_object; if (likely(PyNumber_Check(number))) { int_object = PyNumber_Long(number); if (unlikely(!int_object)) goto bad; } else { __Pyx_PyBuiltin_Invalid(number, "int", argname); goto bad; } *number_var = int_object; Py_DECREF(number); return 0; bad: *number_var = NULL; Py_DECREF(number); return -1; } /* ArgTypeTestError (used by ArgTypeTest) */ static void __Pyx_ArgTypeError(PyObject *obj, PyTypeObject *type, const char *name, int exact) { __Pyx_TypeName type_name; __Pyx_TypeName obj_type_name; PyObject *extra_info = __pyx_mstate_global->__pyx_empty_unicode; int from_annotation_subclass = 0; if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return; } else if (exact == 2) { if (__Pyx_TypeCheck(obj, type)) { from_annotation_subclass = 1; extra_info = __pyx_mstate_global->__pyx_kp_u_Note_that_Cython_is_deliberately; } } type_name = __Pyx_PyType_GetFullyQualifiedName(type); #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 if (unlikely(!type_name)) return; #endif obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 if (unlikely(!obj_type_name)) goto obj_type_name_failed; #endif PyErr_Format(PyExc_TypeError, "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME ", got " __Pyx_FMT_TYPENAME ")" #if __PYX_LIMITED_VERSION_HEX < 0x030C0000 "%s%U" #endif , name, type_name, obj_type_name #if __PYX_LIMITED_VERSION_HEX < 0x030C0000 , (from_annotation_subclass ? ". " : ""), extra_info #endif ); #if __PYX_LIMITED_VERSION_HEX >= 0x030C0000 if (exact == 2 && from_annotation_subclass) { PyObject *res; PyObject *vargs[2]; vargs[0] = PyErr_GetRaisedException(); vargs[1] = extra_info; res = PyObject_VectorcallMethod(__pyx_mstate_global->__pyx_kp_u_add_note, vargs, 2, NULL); Py_XDECREF(res); PyErr_SetRaisedException(vargs[0]); } #endif __Pyx_DECREF_TypeName(obj_type_name); #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 obj_type_name_failed: #endif __Pyx_DECREF_TypeName(type_name); return; } /* ArgTypeTest */ static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, const char *name, int exact) { if (likely(Py_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) return 1; if (!exact && likely(type) && likely(__Pyx_TypeCheck(obj, type))) return 1; __Pyx_ArgTypeError(obj, type, name, exact); return 0; } /* PyObjectCompare */ #ifndef __Pyx_DEFINED_PyObject_CompareIntIntBoolLt #define __Pyx_DEFINED_PyObject_CompareIntIntBoolLt static int __Pyx_PyObject_CompareIntIntBoolLt(PyObject *op1, PyObject *op2) { #if CYTHON_USE_PYLONG_INTERNALS Py_ssize_t cmp = __Pyx_PyLong_CompareSignAndSize(op1, op2); if (cmp == 0) { Py_ssize_t size = __Pyx_PyLong_DigitCount(op1); if (size > 0) { const digit* digits1 = __Pyx_PyLong_Digits(op1); const digit* digits2 = __Pyx_PyLong_Digits(op2); if (size == 1) { cmp = (Py_ssize_t) digits1[0] - (Py_ssize_t) digits2[0]; } else if ((size == 2) && (8 * sizeof(Py_ssize_t) >= 2 * PyLong_SHIFT)) { cmp = (Py_ssize_t) (((((size_t)digits1[1]) << PyLong_SHIFT) | (size_t)digits1[0])) - (Py_ssize_t) (((((size_t)digits2[1]) << PyLong_SHIFT) | (size_t)digits2[0])); } else { for (Py_ssize_t i=size-1; i >= 0 && !cmp; --i) { cmp = (Py_ssize_t) digits1[i] - (Py_ssize_t) digits2[i]; } } } if (cmp == 0) goto __pyx_return_false; if (__Pyx_PyLong_IsNeg(op1)) cmp = -cmp; } if (cmp < 0) goto __pyx_return_true; else goto __pyx_return_false; #else int overflow1, overflow2; long long iop1 = PyLong_AsLongLongAndOverflow(op1, &overflow1); long long iop2 = PyLong_AsLongLongAndOverflow(op2, &overflow2); if (likely(!(overflow1 | overflow2))) { if (iop1 < iop2) goto __pyx_return_true; else goto __pyx_return_false; } else if (overflow1 != overflow2) { if (overflow1 < overflow2) goto __pyx_return_true; else goto __pyx_return_false; } else { return __Pyx_PyObject_RichCompareBool(op1, op2, Py_LT); } #endif __pyx_return_true: return 1; __pyx_return_false: return 0; } #endif static CYTHON_INLINE int __Pyx_PyObject_CompareBoolLt_int_int(PyObject *op1, PyObject *op2, int pyop) { CYTHON_UNUSED_VAR(pyop); if (unlikely(op1 == Py_None)) { goto __pyx_richcmp; } if (unlikely(op2 == Py_None)) { goto __pyx_richcmp; } if (op1 == op2) goto __pyx_return_false; if (likely(op1 != Py_None)) { if (op1 == op2) goto __pyx_return_false; if (likely(op2 != Py_None)) { return __Pyx_PyObject_CompareIntIntBoolLt(op1, op2); } goto __pyx_richcmp; } if ((0)) goto __pyx_richcmp; if ((0)) goto __pyx_return_true; if ((0)) goto __pyx_return_false; __pyx_richcmp: return __Pyx_PyObject_RichCompareBool(op1, op2, Py_LT); __pyx_return_true: return 1; __pyx_return_false: return 0; } /* RaiseException */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { PyObject* owned_instance = NULL; if (tb == Py_None) { tb = 0; } else if (tb && !PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto bad; } if (value == Py_None) value = 0; if (PyExceptionInstance_Check(type)) { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto bad; } value = type; type = (PyObject*) Py_TYPE(value); } else if (PyExceptionClass_Check(type)) { PyObject *instance_class = NULL; if (value && PyExceptionInstance_Check(value)) { instance_class = (PyObject*) Py_TYPE(value); if (instance_class != type) { int is_subclass = PyObject_IsSubclass(instance_class, type); if (!is_subclass) { instance_class = NULL; } else if (unlikely(is_subclass == -1)) { goto bad; } else { type = instance_class; } } } if (!instance_class) { PyObject *args; if (!value) args = PyTuple_New(0); else if (PyTuple_Check(value)) { Py_INCREF(value); args = value; } else args = PyTuple_Pack(1, value); if (!args) goto bad; owned_instance = PyObject_Call(type, args, NULL); Py_DECREF(args); if (!owned_instance) goto bad; value = owned_instance; if (!PyExceptionInstance_Check(value)) { PyErr_Format(PyExc_TypeError, "calling %R should have returned an instance of " "BaseException, not %R", type, Py_TYPE(value)); goto bad; } } } else { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto bad; } if (cause) { PyObject *fixed_cause; if (cause == Py_None) { fixed_cause = NULL; } else if (PyExceptionClass_Check(cause)) { fixed_cause = PyObject_CallObject(cause, NULL); if (fixed_cause == NULL) goto bad; } else if (PyExceptionInstance_Check(cause)) { fixed_cause = cause; Py_INCREF(fixed_cause); } else { PyErr_SetString(PyExc_TypeError, "exception causes must derive from " "BaseException"); goto bad; } PyException_SetCause(value, fixed_cause); } PyErr_SetObject(type, value); if (tb) { #if PY_VERSION_HEX >= 0x030C00A6 PyException_SetTraceback(value, tb); #elif CYTHON_FAST_THREAD_STATE PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* tmp_tb = tstate->curexc_traceback; if (tb != tmp_tb) { Py_INCREF(tb); tstate->curexc_traceback = tb; Py_XDECREF(tmp_tb); } #else PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); Py_INCREF(tb); PyErr_Restore(tmp_type, tmp_value, tb); Py_XDECREF(tmp_tb); #endif } bad: Py_XDECREF(owned_instance); return; } /* RejectKeywords */ static void __Pyx_RejectKeywords(const char* function_name, PyObject *kwds) { PyObject *key = NULL; if (CYTHON_VECTORCALL && likely(PyTuple_Check(kwds))) { key = __Pyx_PySequence_ITEM(kwds, 0); } else { #if CYTHON_AVOID_BORROWED_REFS PyObject *pos = NULL; #else Py_ssize_t pos = 0; #endif #if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return; #endif __Pyx_PyDict_NextRef(kwds, &pos, &key, NULL); #if CYTHON_AVOID_BORROWED_REFS Py_XDECREF(pos); #endif } if (likely(key)) { PyErr_Format(PyExc_TypeError, "%s() got an unexpected keyword argument '%U'", function_name, key); Py_DECREF(key); } } /* PyObjectCompare */ #ifndef __Pyx_DEFINED_PyObject_CompareFloatIntBoolGt #define __Pyx_DEFINED_PyObject_CompareFloatIntBoolGt static int __Pyx_PyObject_CompareFloatIntBoolGt(PyObject *op1, PyObject *op2) { double float_op1 = __Pyx_PyFloat_AS_DOUBLE(op1); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely(float_op1 == -1. && PyErr_Occurred())) return -1; #endif #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsCompact(op2)) { Py_ssize_t iop2 = __Pyx_PyLong_CompactValue(op2); if (float_op1 > ((double)iop2)) goto __pyx_return_true; else goto __pyx_return_false; } if (unlikely(!isfinite(float_op1))) { if (float_op1 > 0.0) goto __pyx_return_true; else goto __pyx_return_false; } else { int sign2 = __Pyx_PyLong_Sign(op2); if (float_op1 >= 0.) { if (sign2 < 0) goto __pyx_return_true; if (float_op1 < (double) (1L << PyLong_SHIFT)) goto __pyx_return_false; } else { if (sign2 > 0) goto __pyx_return_false; if (float_op1 > -(double) (1L << PyLong_SHIFT)) goto __pyx_return_true; } } #else if (unlikely(!isfinite(float_op1))) { if (float_op1 > 0.0) goto __pyx_return_true; else goto __pyx_return_false; } else { int overflow2; long iop2 = PyLong_AsLongAndOverflow(op2, &overflow2); if (likely(!overflow2)) { if ((long long) iop2 >= (1LL << 53)) { overflow2 = 1; } else if ((long long) iop2 <= - (1LL << 53)) { overflow2 = -1; } else { if (float_op1 > ((double) iop2)) goto __pyx_return_true; else goto __pyx_return_false; } } if (overflow2 > 0) { if (float_op1 < ((double) (1LL << 53))) goto __pyx_return_false; } else { if (float_op1 > - ((double) (1LL << 53))) goto __pyx_return_true; } } #endif return __Pyx_PyObject_RichCompareBool(op1, op2, Py_GT); __pyx_return_true: return 1; __pyx_return_false: return 0; } #endif #ifndef __Pyx_DEFINED_PyObject_CompareIntIntBoolGt #define __Pyx_DEFINED_PyObject_CompareIntIntBoolGt static int __Pyx_PyObject_CompareIntIntBoolGt(PyObject *op1, PyObject *op2) { #if CYTHON_USE_PYLONG_INTERNALS Py_ssize_t cmp = __Pyx_PyLong_CompareSignAndSize(op1, op2); if (cmp == 0) { Py_ssize_t size = __Pyx_PyLong_DigitCount(op1); if (size > 0) { const digit* digits1 = __Pyx_PyLong_Digits(op1); const digit* digits2 = __Pyx_PyLong_Digits(op2); if (size == 1) { cmp = (Py_ssize_t) digits1[0] - (Py_ssize_t) digits2[0]; } else if ((size == 2) && (8 * sizeof(Py_ssize_t) >= 2 * PyLong_SHIFT)) { cmp = (Py_ssize_t) (((((size_t)digits1[1]) << PyLong_SHIFT) | (size_t)digits1[0])) - (Py_ssize_t) (((((size_t)digits2[1]) << PyLong_SHIFT) | (size_t)digits2[0])); } else { for (Py_ssize_t i=size-1; i >= 0 && !cmp; --i) { cmp = (Py_ssize_t) digits1[i] - (Py_ssize_t) digits2[i]; } } } if (cmp == 0) goto __pyx_return_false; if (__Pyx_PyLong_IsNeg(op1)) cmp = -cmp; } if (cmp < 0) goto __pyx_return_false; else goto __pyx_return_true; #else int overflow1, overflow2; long long iop1 = PyLong_AsLongLongAndOverflow(op1, &overflow1); long long iop2 = PyLong_AsLongLongAndOverflow(op2, &overflow2); if (likely(!(overflow1 | overflow2))) { if (iop1 > iop2) goto __pyx_return_true; else goto __pyx_return_false; } else if (overflow1 != overflow2) { if (overflow1 > overflow2) goto __pyx_return_true; else goto __pyx_return_false; } else { return __Pyx_PyObject_RichCompareBool(op1, op2, Py_GT); } #endif __pyx_return_true: return 1; __pyx_return_false: return 0; } #endif static CYTHON_INLINE int __Pyx_PyObject_CompareBoolGt_object_int(PyObject *op1, PyObject *op2, int pyop) { CYTHON_UNUSED_VAR(pyop); if (unlikely(op2 == Py_None)) { goto __pyx_richcmp; } if (op1 == op2) goto __pyx_return_false; if (PyFloat_CheckExact(op1)) { if (likely(op2 != Py_None)) { return __Pyx_PyObject_CompareFloatIntBoolGt(op1, op2); } goto __pyx_richcmp; } if (likely(PyLong_CheckExact(op1))) { if (op1 == op2) goto __pyx_return_false; if (likely(op2 != Py_None)) { return __Pyx_PyObject_CompareIntIntBoolGt(op1, op2); } goto __pyx_richcmp; } if ((0)) goto __pyx_richcmp; if ((0)) goto __pyx_return_true; if ((0)) goto __pyx_return_false; __pyx_richcmp: return __Pyx_PyObject_RichCompareBool(op1, op2, Py_GT); __pyx_return_true: return 1; __pyx_return_false: return 0; } /* PyObjectCompare */ #ifndef __Pyx_DEFINED_PyObject_CompareFloatIntBoolLt #define __Pyx_DEFINED_PyObject_CompareFloatIntBoolLt static int __Pyx_PyObject_CompareFloatIntBoolLt(PyObject *op1, PyObject *op2) { double float_op1 = __Pyx_PyFloat_AS_DOUBLE(op1); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely(float_op1 == -1. && PyErr_Occurred())) return -1; #endif #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsCompact(op2)) { Py_ssize_t iop2 = __Pyx_PyLong_CompactValue(op2); if (float_op1 < ((double)iop2)) goto __pyx_return_true; else goto __pyx_return_false; } if (unlikely(!isfinite(float_op1))) { if (float_op1 < 0.0) goto __pyx_return_true; else goto __pyx_return_false; } else { int sign2 = __Pyx_PyLong_Sign(op2); if (float_op1 >= 0.) { if (sign2 < 0) goto __pyx_return_false; if (float_op1 < (double) (1L << PyLong_SHIFT)) goto __pyx_return_true; } else { if (sign2 > 0) goto __pyx_return_true; if (float_op1 > -(double) (1L << PyLong_SHIFT)) goto __pyx_return_false; } } #else if (unlikely(!isfinite(float_op1))) { if (float_op1 < 0.0) goto __pyx_return_true; else goto __pyx_return_false; } else { int overflow2; long iop2 = PyLong_AsLongAndOverflow(op2, &overflow2); if (likely(!overflow2)) { if ((long long) iop2 >= (1LL << 53)) { overflow2 = 1; } else if ((long long) iop2 <= - (1LL << 53)) { overflow2 = -1; } else { if (float_op1 < ((double) iop2)) goto __pyx_return_true; else goto __pyx_return_false; } } if (overflow2 > 0) { if (float_op1 < ((double) (1LL << 53))) goto __pyx_return_true; } else { if (float_op1 > - ((double) (1LL << 53))) goto __pyx_return_false; } } #endif return __Pyx_PyObject_RichCompareBool(op1, op2, Py_LT); __pyx_return_true: return 1; __pyx_return_false: return 0; } #endif #ifndef __Pyx_DEFINED_PyObject_CompareIntIntBoolLt #define __Pyx_DEFINED_PyObject_CompareIntIntBoolLt static int __Pyx_PyObject_CompareIntIntBoolLt(PyObject *op1, PyObject *op2) { #if CYTHON_USE_PYLONG_INTERNALS Py_ssize_t cmp = __Pyx_PyLong_CompareSignAndSize(op1, op2); if (cmp == 0) { Py_ssize_t size = __Pyx_PyLong_DigitCount(op1); if (size > 0) { const digit* digits1 = __Pyx_PyLong_Digits(op1); const digit* digits2 = __Pyx_PyLong_Digits(op2); if (size == 1) { cmp = (Py_ssize_t) digits1[0] - (Py_ssize_t) digits2[0]; } else if ((size == 2) && (8 * sizeof(Py_ssize_t) >= 2 * PyLong_SHIFT)) { cmp = (Py_ssize_t) (((((size_t)digits1[1]) << PyLong_SHIFT) | (size_t)digits1[0])) - (Py_ssize_t) (((((size_t)digits2[1]) << PyLong_SHIFT) | (size_t)digits2[0])); } else { for (Py_ssize_t i=size-1; i >= 0 && !cmp; --i) { cmp = (Py_ssize_t) digits1[i] - (Py_ssize_t) digits2[i]; } } } if (cmp == 0) goto __pyx_return_false; if (__Pyx_PyLong_IsNeg(op1)) cmp = -cmp; } if (cmp < 0) goto __pyx_return_true; else goto __pyx_return_false; #else int overflow1, overflow2; long long iop1 = PyLong_AsLongLongAndOverflow(op1, &overflow1); long long iop2 = PyLong_AsLongLongAndOverflow(op2, &overflow2); if (likely(!(overflow1 | overflow2))) { if (iop1 < iop2) goto __pyx_return_true; else goto __pyx_return_false; } else if (overflow1 != overflow2) { if (overflow1 < overflow2) goto __pyx_return_true; else goto __pyx_return_false; } else { return __Pyx_PyObject_RichCompareBool(op1, op2, Py_LT); } #endif __pyx_return_true: return 1; __pyx_return_false: return 0; } #endif static CYTHON_INLINE int __Pyx_PyObject_CompareBoolLt_object_int(PyObject *op1, PyObject *op2, int pyop) { CYTHON_UNUSED_VAR(pyop); if (unlikely(op2 == Py_None)) { goto __pyx_richcmp; } if (op1 == op2) goto __pyx_return_false; if (PyFloat_CheckExact(op1)) { if (likely(op2 != Py_None)) { return __Pyx_PyObject_CompareFloatIntBoolLt(op1, op2); } goto __pyx_richcmp; } if (likely(PyLong_CheckExact(op1))) { if (op1 == op2) goto __pyx_return_false; if (likely(op2 != Py_None)) { return __Pyx_PyObject_CompareIntIntBoolLt(op1, op2); } goto __pyx_richcmp; } if ((0)) goto __pyx_richcmp; if ((0)) goto __pyx_return_true; if ((0)) goto __pyx_return_false; __pyx_richcmp: return __Pyx_PyObject_RichCompareBool(op1, op2, Py_LT); __pyx_return_true: return 1; __pyx_return_false: return 0; } /* RaiseErrorWithObjectType1 (used by RaiseUnexpectedTypeError) */ static void __Pyx_RaiseErrorWithType1(PyObject* exc_type, const char* message, const char *arg, PyTypeObject *type_obj) { __Pyx_TypeName type_name = __Pyx_PyType_GetFullyQualifiedName(type_obj); #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 if (unlikely(!type_name)) return; #endif PyErr_Format(exc_type, message, arg, type_name); __Pyx_DECREF_TypeName(type_name); } /* RaiseUnexpectedTypeError */ static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj) { __Pyx_RaiseTypeErrorWithObjectType1( "Expected %.42s, got " __Pyx_FMT_TYPENAME, expected, obj); return 0; } /* GetTopmostException (used by SaveResetException) */ #if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate) { _PyErr_StackItem *exc_info = tstate->exc_info; while ((exc_info->exc_value == NULL || exc_info->exc_value == Py_None) && exc_info->previous_item != NULL) { exc_info = exc_info->previous_item; } return exc_info; } #endif /* SaveResetException */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { #if CYTHON_USE_EXC_INFO_STACK && 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; Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); #else *type = tstate->exc_type; *value = tstate->exc_value; *tb = tstate->exc_traceback; Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); #endif } static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 _PyErr_StackItem *exc_info = tstate->exc_info; PyObject *tmp_value = exc_info->exc_value; exc_info->exc_value = value; Py_XDECREF(tmp_value); Py_XDECREF(type); Py_XDECREF(tb); #else PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = type; exc_info->exc_value = value; exc_info->exc_traceback = tb; #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = type; tstate->exc_value = value; tstate->exc_traceback = tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #endif } #endif /* GetException */ #if CYTHON_FAST_THREAD_STATE static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) #endif { PyObject *local_type = NULL, *local_value, *local_tb = NULL; #if CYTHON_FAST_THREAD_STATE PyObject *tmp_type, *tmp_value, *tmp_tb; #if PY_VERSION_HEX >= 0x030C0000 local_value = tstate->current_exception; tstate->current_exception = 0; #else local_type = tstate->curexc_type; local_value = tstate->curexc_value; local_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; #endif #elif __PYX_LIMITED_VERSION_HEX >= 0x030C0000 local_value = PyErr_GetRaisedException(); #else PyErr_Fetch(&local_type, &local_value, &local_tb); #endif #if __PYX_LIMITED_VERSION_HEX >= 0x030C0000 if (likely(local_value)) { local_type = (PyObject*) Py_TYPE(local_value); Py_INCREF(local_type); local_tb = PyException_GetTraceback(local_value); } #else PyErr_NormalizeException(&local_type, &local_value, &local_tb); #if CYTHON_FAST_THREAD_STATE if (unlikely(tstate->curexc_type)) #else if (unlikely(PyErr_Occurred())) #endif goto bad; if (local_tb) { if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) goto bad; } #endif // __PYX_LIMITED_VERSION_HEX >= 0x030C0000 Py_XINCREF(local_tb); Py_XINCREF(local_type); Py_XINCREF(local_value); *type = local_type; *value = local_value; *tb = local_tb; #if CYTHON_FAST_THREAD_STATE #if CYTHON_USE_EXC_INFO_STACK { _PyErr_StackItem *exc_info = tstate->exc_info; #if PY_VERSION_HEX >= 0x030B00a4 tmp_value = exc_info->exc_value; exc_info->exc_value = local_value; tmp_type = NULL; tmp_tb = NULL; Py_XDECREF(local_type); Py_XDECREF(local_tb); #else tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = local_type; exc_info->exc_value = local_value; exc_info->exc_traceback = local_tb; #endif } #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = local_type; tstate->exc_value = local_value; tstate->exc_traceback = local_tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #elif __PYX_LIMITED_VERSION_HEX >= 0x030b0000 PyErr_SetHandledException(local_value); Py_XDECREF(local_value); Py_XDECREF(local_type); Py_XDECREF(local_tb); #else PyErr_SetExcInfo(local_type, local_value, local_tb); #endif return 0; #if __PYX_LIMITED_VERSION_HEX < 0x030C0000 bad: *type = 0; *value = 0; *tb = 0; Py_XDECREF(local_type); Py_XDECREF(local_value); Py_XDECREF(local_tb); return -1; #endif } /* PyObjectCompare */ #ifndef __Pyx_DEFINED_PyObject_CompareIntIntBoolLe #define __Pyx_DEFINED_PyObject_CompareIntIntBoolLe static int __Pyx_PyObject_CompareIntIntBoolLe(PyObject *op1, PyObject *op2) { #if CYTHON_USE_PYLONG_INTERNALS Py_ssize_t cmp = __Pyx_PyLong_CompareSignAndSize(op1, op2); if (cmp == 0) { Py_ssize_t size = __Pyx_PyLong_DigitCount(op1); if (size > 0) { const digit* digits1 = __Pyx_PyLong_Digits(op1); const digit* digits2 = __Pyx_PyLong_Digits(op2); if (size == 1) { cmp = (Py_ssize_t) digits1[0] - (Py_ssize_t) digits2[0]; } else if ((size == 2) && (8 * sizeof(Py_ssize_t) >= 2 * PyLong_SHIFT)) { cmp = (Py_ssize_t) (((((size_t)digits1[1]) << PyLong_SHIFT) | (size_t)digits1[0])) - (Py_ssize_t) (((((size_t)digits2[1]) << PyLong_SHIFT) | (size_t)digits2[0])); } else { for (Py_ssize_t i=size-1; i >= 0 && !cmp; --i) { cmp = (Py_ssize_t) digits1[i] - (Py_ssize_t) digits2[i]; } } } if (cmp == 0) goto __pyx_return_true; if (__Pyx_PyLong_IsNeg(op1)) cmp = -cmp; } if (cmp < 0) goto __pyx_return_true; else goto __pyx_return_false; #else int overflow1, overflow2; long long iop1 = PyLong_AsLongLongAndOverflow(op1, &overflow1); long long iop2 = PyLong_AsLongLongAndOverflow(op2, &overflow2); if (likely(!(overflow1 | overflow2))) { if (iop1 <= iop2) goto __pyx_return_true; else goto __pyx_return_false; } else if (overflow1 != overflow2) { if (overflow1 <= overflow2) goto __pyx_return_true; else goto __pyx_return_false; } else { return __Pyx_PyObject_RichCompareBool(op1, op2, Py_LE); } #endif __pyx_return_true: return 1; __pyx_return_false: return 0; } #endif static CYTHON_INLINE int __Pyx_PyObject_CompareBoolLe_int_int(PyObject *op1, PyObject *op2, int pyop) { CYTHON_UNUSED_VAR(pyop); if (unlikely(op1 == Py_None)) { goto __pyx_richcmp; } if (unlikely(op2 == Py_None)) { goto __pyx_richcmp; } if (op1 == op2) goto __pyx_return_true; if (likely(op1 != Py_None)) { if (op1 == op2) goto __pyx_return_true; if (likely(op2 != Py_None)) { return __Pyx_PyObject_CompareIntIntBoolLe(op1, op2); } goto __pyx_richcmp; } if ((0)) goto __pyx_richcmp; if ((0)) goto __pyx_return_true; if ((0)) goto __pyx_return_false; __pyx_richcmp: return __Pyx_PyObject_RichCompareBool(op1, op2, Py_LE); __pyx_return_true: return 1; __pyx_return_false: return 0; } /* PyLongBinop */ #if !CYTHON_COMPILING_IN_PYPY static PyObject* __Pyx_Fallback___Pyx_PyLong_SubtractCObj(PyObject *op1, PyObject *op2, int inplace) { return (inplace ? PyNumber_InPlaceSubtract : PyNumber_Subtract)(op1, op2); } #if CYTHON_USE_PYLONG_INTERNALS static PyObject* __Pyx_Unpacked___Pyx_PyLong_SubtractCObj(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) { CYTHON_MAYBE_UNUSED_VAR(inplace); CYTHON_UNUSED_VAR(zerodivision_check); const long a = intval; long b; const PY_LONG_LONG lla = intval; PY_LONG_LONG llb; if (unlikely(__Pyx_PyLong_IsZero(op2))) { return __Pyx_NewRef(op1); } const int is_positive = __Pyx_PyLong_IsPos(op2); const digit* digits = __Pyx_PyLong_Digits(op2); const Py_ssize_t size = __Pyx_PyLong_DigitCount(op2); if (likely(size == 1)) { b = (long) digits[0]; if (!is_positive) b *= -1; } else { if (size == 2 && 8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { b = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); if (!is_positive) b *= -1; goto calculate_long; } else if (size == 2 && 8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { llb = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); if (!is_positive) llb *= -1; goto calculate_long_long; } else if (size == 3 && 8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { b = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); if (!is_positive) b *= -1; goto calculate_long; } else if (size == 3 && 8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { llb = (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])); if (!is_positive) llb *= -1; goto calculate_long_long; } else if (size == 4 && 8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { b = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); if (!is_positive) b *= -1; goto calculate_long; } else if (size == 4 && 8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { llb = (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])); if (!is_positive) llb *= -1; goto calculate_long_long; } else {} return PyLong_Type.tp_as_number->nb_subtract(op1, op2); } calculate_long: { long x; x = a - b; return PyLong_FromLong(x); } calculate_long_long: { PY_LONG_LONG llx; llx = lla - llb; return PyLong_FromLongLong(llx); } } #endif static PyObject* __Pyx_Float___Pyx_PyLong_SubtractCObj(PyObject *float_val, long intval, int zerodivision_check) { CYTHON_UNUSED_VAR(zerodivision_check); const long a = intval; double b = __Pyx_PyFloat_AS_DOUBLE(float_val); double result; result = ((double)a) - (double)b; return PyFloat_FromDouble(result); } static CYTHON_INLINE PyObject* __Pyx_PyLong_SubtractCObj(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) { CYTHON_MAYBE_UNUSED_VAR(intval); CYTHON_UNUSED_VAR(zerodivision_check); #if CYTHON_USE_PYLONG_INTERNALS if (likely(PyLong_CheckExact(op2))) { return __Pyx_Unpacked___Pyx_PyLong_SubtractCObj(op1, op2, intval, inplace, zerodivision_check); } #endif if (PyFloat_CheckExact(op2)) { return __Pyx_Float___Pyx_PyLong_SubtractCObj(op2, intval, zerodivision_check); } return __Pyx_Fallback___Pyx_PyLong_SubtractCObj(op1, op2, inplace); } #endif /* PyObjectCompare */ #ifndef __Pyx_DEFINED_PyObject_CompareIntIntGt #define __Pyx_DEFINED_PyObject_CompareIntIntGt static PyObject* __Pyx_PyObject_CompareIntIntGt(PyObject *op1, PyObject *op2) { #if CYTHON_USE_PYLONG_INTERNALS Py_ssize_t cmp = __Pyx_PyLong_CompareSignAndSize(op1, op2); if (cmp == 0) { Py_ssize_t size = __Pyx_PyLong_DigitCount(op1); if (size > 0) { const digit* digits1 = __Pyx_PyLong_Digits(op1); const digit* digits2 = __Pyx_PyLong_Digits(op2); if (size == 1) { cmp = (Py_ssize_t) digits1[0] - (Py_ssize_t) digits2[0]; } else if ((size == 2) && (8 * sizeof(Py_ssize_t) >= 2 * PyLong_SHIFT)) { cmp = (Py_ssize_t) (((((size_t)digits1[1]) << PyLong_SHIFT) | (size_t)digits1[0])) - (Py_ssize_t) (((((size_t)digits2[1]) << PyLong_SHIFT) | (size_t)digits2[0])); } else { for (Py_ssize_t i=size-1; i >= 0 && !cmp; --i) { cmp = (Py_ssize_t) digits1[i] - (Py_ssize_t) digits2[i]; } } } if (cmp == 0) goto __pyx_return_false; if (__Pyx_PyLong_IsNeg(op1)) cmp = -cmp; } if (cmp < 0) goto __pyx_return_false; else goto __pyx_return_true; #else int overflow1, overflow2; long long iop1 = PyLong_AsLongLongAndOverflow(op1, &overflow1); long long iop2 = PyLong_AsLongLongAndOverflow(op2, &overflow2); if (likely(!(overflow1 | overflow2))) { if (iop1 > iop2) goto __pyx_return_true; else goto __pyx_return_false; } else if (overflow1 != overflow2) { if (overflow1 > overflow2) goto __pyx_return_true; else goto __pyx_return_false; } else { return PyObject_RichCompare(op1, op2, Py_GT); } #endif __pyx_return_true: Py_RETURN_TRUE; __pyx_return_false: Py_RETURN_FALSE; } #endif static CYTHON_INLINE PyObject* __Pyx_PyObject_CompareGt_int_int(PyObject *op1, PyObject *op2, int pyop) { CYTHON_UNUSED_VAR(pyop); if (unlikely(op1 == Py_None)) { goto __pyx_richcmp; } if (unlikely(op2 == Py_None)) { goto __pyx_richcmp; } if (op1 == op2) goto __pyx_return_false; if (likely(op1 != Py_None)) { if (op1 == op2) goto __pyx_return_false; if (likely(op2 != Py_None)) { return __Pyx_PyObject_CompareIntIntGt(op1, op2); } goto __pyx_richcmp; } if ((0)) goto __pyx_richcmp; if ((0)) goto __pyx_return_true; if ((0)) goto __pyx_return_false; __pyx_richcmp: return PyObject_RichCompare(op1, op2, Py_GT); __pyx_return_true: Py_RETURN_TRUE; __pyx_return_false: Py_RETURN_FALSE; } /* pep479 */ static void __Pyx_Generator_Replace_StopIteration(int in_async_gen) { PyObject *exc, *val, *tb, *cur_exc, *new_exc; __Pyx_PyThreadState_declare int is_async_stopiteration = 0; CYTHON_MAYBE_UNUSED_VAR(in_async_gen); __Pyx_PyThreadState_assign cur_exc = __Pyx_PyErr_CurrentExceptionType(); if (likely(!__Pyx_PyErr_GivenExceptionMatches(cur_exc, PyExc_StopIteration))) { if (in_async_gen && unlikely(__Pyx_PyErr_GivenExceptionMatches(cur_exc, PyExc_StopAsyncIteration))) { is_async_stopiteration = 1; } else { return; } } __Pyx_GetException(&exc, &val, &tb); Py_XDECREF(exc); Py_XDECREF(tb); new_exc = PyObject_CallFunction(PyExc_RuntimeError, "s", is_async_stopiteration ? "async generator raised StopAsyncIteration" : in_async_gen ? "async generator raised StopIteration" : "generator raised StopIteration"); if (!new_exc) { Py_XDECREF(val); return; } PyException_SetCause(new_exc, val); // steals ref to val PyErr_SetObject(PyExc_RuntimeError, new_exc); Py_DECREF(new_exc); } /* PyObjectCompare */ #if !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_GRAAL) #ifndef __Pyx_DEFINED_PyObject_ComparePyBytesPyBytesBoolEq #define __Pyx_DEFINED_PyObject_ComparePyBytesPyBytesBoolEq static CYTHON_INLINE int __Pyx_PyObject_ComparePyBytesPyBytesBoolEq(PyObject* s1, PyObject* s2) { #if CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS const char *ps1, *ps2; Py_ssize_t length = PyBytes_GET_SIZE(s1); if (length != PyBytes_GET_SIZE(s2)) goto __pyx_return_false; ps1 = PyBytes_AS_STRING(s1); ps2 = PyBytes_AS_STRING(s2); #else char *ps1, *ps2; Py_ssize_t length, length2; if (unlikely(PyBytes_AsStringAndSize(s1, &ps1, &length) == -1)) return -1; if (unlikely(PyBytes_AsStringAndSize(s2, &ps2, &length2) == -1)) return -1; if (length != length2) goto __pyx_return_false; #endif if (ps1[0] != ps2[0]) goto __pyx_return_false; if (length == 1) goto __pyx_return_true; { int cmp; #if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000) Py_hash_t hash1 = ((PyBytesObject*)s1)->ob_shash; Py_hash_t hash2 = ((PyBytesObject*)s2)->ob_shash; if (hash1 != hash2 && hash1 != -1 && hash2 != -1) goto __pyx_return_false; #endif cmp = memcmp(ps1, ps2, (size_t)length); if (cmp == 0) goto __pyx_return_true; else goto __pyx_return_false; } __pyx_return_true: return 1; __pyx_return_false: return 0; } #endif #endif static CYTHON_INLINE int __Pyx_PyObject_CompareBoolEq_bytes_bytes(PyObject *op1, PyObject *op2, int pyop) { CYTHON_UNUSED_VAR(pyop); if (unlikely(op1 == Py_None)) { if (op2 == Py_None) goto __pyx_return_true; else goto __pyx_return_false; } if (unlikely(op2 == Py_None)) { if (op1 == Py_None) goto __pyx_return_true; else goto __pyx_return_false; } #if !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_GRAAL) if (likely(op1 != Py_None)) { if (op1 == op2) goto __pyx_return_true; if (likely(op2 != Py_None)) { return __Pyx_PyObject_ComparePyBytesPyBytesBoolEq(op1, op2); } goto __pyx_richcmp; } #endif if ((0)) goto __pyx_richcmp; if ((0)) goto __pyx_return_true; if ((0)) goto __pyx_return_false; __pyx_richcmp: return __Pyx_PyObject_RichCompareBool(op1, op2, Py_EQ); __pyx_return_true: return 1; __pyx_return_false: return 0; } /* AllocateExtensionType */ static PyObject *__Pyx_AllocateExtensionType(PyTypeObject *t, int is_final) { if (is_final || likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { allocfunc alloc_func = __Pyx_PyType_GetSlot(t, tp_alloc, allocfunc); return alloc_func(t, 0); } else { newfunc tp_new = __Pyx_PyType_TryGetSlot(&PyBaseObject_Type, tp_new, newfunc); #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 if (!tp_new) { PyObject *new_str = PyUnicode_FromString("__new__"); if (likely(new_str)) { PyObject *o = PyObject_CallMethodObjArgs((PyObject *)&PyBaseObject_Type, new_str, t, NULL); Py_DECREF(new_str); return o; } else return NULL; } else #endif return tp_new(t, __pyx_mstate_global->__pyx_empty_tuple, 0); } } /* CallSlotAsVectorcallUnpackDict (used by CallSlotAsVectorcall) */ static CYTHON_INLINE int __Pyx_CallSlotAsVectorcallUnpackDict(Py_ssize_t args_size, PyObject *keys_dict, PyObject **args, PyObject *kwnames) { Py_ssize_t pos = 0, i = 0; PyObject *key, *value; while (PyDict_Next(keys_dict, &pos, &key, &value)) { Py_INCREF(value); args[args_size+i] = value; Py_INCREF(key); if (unlikely(__Pyx_PyTuple_SET_ITEM(kwnames, i, key) == -1)) { return -1; } ++i; } return 0; } /* CallSlotAsVectorcall */ #if CYTHON_VECTORCALL_TPNEW static PyObject * __Pyx_CallTpnewAsVectorcall(__Pyx_tpnewvectorcallfunc f, PyTypeObject* o, PyObject *a, PyObject *k) { Py_ssize_t k_size = k ? __Pyx_PyDict_GET_SIZE(k) : 0; #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely(k_size < 0)) return NULL; #endif Py_ssize_t a_size = __Pyx_PyTuple_GET_SIZE(a); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely(a_size < 0)) return NULL; #endif #if CYTHON_ASSUME_SAFE_MACROS if (k_size == 0) { return f(o, &PyTuple_GET_ITEM(a, 0), a_size, NULL); } #else if (k_size == 0 && a_size == 0) { return f(o, NULL, 0, NULL); } #endif PyObject *stack_args[5]; PyObject **args = stack_args; Py_ssize_t maxnargs = PY_SSIZE_T_MAX / sizeof(PyObject*) - 1; if (a_size > maxnargs - k_size) { PyErr_NoMemory(); return NULL; } Py_ssize_t total_size = a_size + k_size; if (total_size > 5) { args = (PyObject**)PyMem_Malloc(((size_t)total_size)*sizeof(PyObject*)); if (unlikely(!args)) { PyErr_NoMemory(); return NULL; } } PyObject * result = NULL; PyObject *kwnames = NULL; int unpack_dict_result; Py_ssize_t i = 0; for (; i < a_size; ++i) { args[i] = __Pyx_PyTuple_GET_ITEM(a, i); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely(!args[i])) goto cleanup; #endif } #if !CYTHON_ASSUME_SAFE_MACROS if (k) // There's a specific shortcut earlier for ASSUME_SAFE_MACROS with no keywords #endif { kwnames = PyTuple_New(k_size); if (unlikely(!kwnames)) goto cleanup; __Pyx_BEGIN_CRITICAL_SECTION(k); unpack_dict_result = __Pyx_CallSlotAsVectorcallUnpackDict(a_size, k, args, kwnames); __Pyx_END_CRITICAL_SECTION(); if (unlikely(unpack_dict_result == -1)) goto cleanup; } result = f(o, args, a_size, kwnames); cleanup: Py_XDECREF(kwnames); for (i=a_size; i__pyx_empty_tuple); } result = tp_new(t, args_tuple, kwds_dict); if (unlikely(!result)) { goto end; } if (PyObject_TypeCheck(result, t)) { initproc tp_init = __Pyx_PyObject_GetSlot(result, tp_init, initproc); if (tp_init && unlikely(tp_init(result, args_tuple, kwds_dict) < 0)) { Py_CLEAR(result); } } end: Py_XDECREF(args_tuple); Py_XDECREF(kwds_dict); return result; } #endif /* CallSlotAsVectorcall */ #if CYTHON_VECTORCALL_TPNEW static int __Pyx_CallTpinitAsVectorcall(__Pyx_tpinitvectorcallfunc f, PyObject* o, PyObject *a, PyObject *k) { Py_ssize_t k_size = k ? __Pyx_PyDict_GET_SIZE(k) : 0; #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely(k_size < 0)) return -1; #endif Py_ssize_t a_size = __Pyx_PyTuple_GET_SIZE(a); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely(a_size < 0)) return -1; #endif #if CYTHON_ASSUME_SAFE_MACROS if (k_size == 0) { return f(o, &PyTuple_GET_ITEM(a, 0), a_size, NULL); } #else if (k_size == 0 && a_size == 0) { return f(o, NULL, 0, NULL); } #endif PyObject *stack_args[5]; PyObject **args = stack_args; Py_ssize_t maxnargs = PY_SSIZE_T_MAX / sizeof(PyObject*) - 1; if (a_size > maxnargs - k_size) { PyErr_NoMemory(); return -1; } Py_ssize_t total_size = a_size + k_size; if (total_size > 5) { args = (PyObject**)PyMem_Malloc(((size_t)total_size)*sizeof(PyObject*)); if (unlikely(!args)) { PyErr_NoMemory(); return -1; } } int result = -1; PyObject *kwnames = NULL; int unpack_dict_result; Py_ssize_t i = 0; for (; i < a_size; ++i) { args[i] = __Pyx_PyTuple_GET_ITEM(a, i); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely(!args[i])) goto cleanup; #endif } #if !CYTHON_ASSUME_SAFE_MACROS if (k) // There's a specific shortcut earlier for ASSUME_SAFE_MACROS with no keywords #endif { kwnames = PyTuple_New(k_size); if (unlikely(!kwnames)) goto cleanup; __Pyx_BEGIN_CRITICAL_SECTION(k); unpack_dict_result = __Pyx_CallSlotAsVectorcallUnpackDict(a_size, k, args, kwnames); __Pyx_END_CRITICAL_SECTION(); if (unlikely(unpack_dict_result == -1)) goto cleanup; } result = f(o, args, a_size, kwnames); cleanup: Py_XDECREF(kwnames); for (i=a_size; itp_dictoffset != 0; #else Py_ssize_t dictoffset = __Pyx_GetTypeDictOffset(b, 0); has_dictoffset = dictoffset != 0; #endif #if CYTHON_AVOID_BORROWED_REFS Py_DECREF(b); #endif #if !CYTHON_USE_TYPE_SLOTS if (dictoffset == -1 && PyErr_Occurred()) return -1; #endif } for (i = 1; i < n; i++) { PyTypeObject *b; #if CYTHON_AVOID_BORROWED_REFS PyObject *b0 = PySequence_GetItem(bases, i); if (!b0) return -1; #elif CYTHON_ASSUME_SAFE_MACROS PyObject *b0 = PyTuple_GET_ITEM(bases, i); #else PyObject *b0 = PyTuple_GetItem(bases, i); if (!b0) return -1; #endif b = (PyTypeObject*) b0; if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) { __Pyx_RaiseErrorWithType( PyExc_TypeError, "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b); #if CYTHON_AVOID_BORROWED_REFS Py_DECREF(b0); #endif return -1; } if (!has_dictoffset) { Py_ssize_t b_dictoffset = 0; #if CYTHON_USE_TYPE_SLOTS b_dictoffset = b->tp_dictoffset; #else b_dictoffset = __Pyx_GetTypeDictOffset((PyObject*)b, 0); if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return; #endif if (b_dictoffset) { __Pyx_RaiseErrorWithType1( 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); #if !CYTHON_USE_TYPE_SLOTS dictoffset_return: #endif #if CYTHON_AVOID_BORROWED_REFS Py_DECREF(b0); #endif return -1; } } #if CYTHON_AVOID_BORROWED_REFS Py_DECREF(b0); #endif } return 0; } #endif /* PyType_Ready */ CYTHON_UNUSED static int __Pyx_PyType_HasMultipleInheritance(PyTypeObject *t) { while (t) { PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); if (bases) { return 1; } t = __Pyx_PyType_GetSlot(t, tp_base, PyTypeObject*); } return 0; } static int __Pyx_PyType_Ready(PyTypeObject *t) { #if CYTHON_USE_TYPE_SPECS || !CYTHON_COMPILING_IN_CPYTHON (void)__Pyx_PyObject_CallMethod0; #if CYTHON_USE_TYPE_SPECS (void)__Pyx_validate_bases_tuple; #endif return PyType_Ready(t); #else int r; if (!__Pyx_PyType_HasMultipleInheritance(t)) { return PyType_Ready(t); } PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset != 0, bases) == -1)) return -1; { int gc_was_enabled; #if PY_VERSION_HEX >= 0x030A00b1 gc_was_enabled = PyGC_Disable(); (void)__Pyx_PyObject_CallMethod0; #else PyObject *ret, *py_status; PyObject *gc = NULL; #if (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) &&\ !CYTHON_COMPILING_IN_GRAAL gc = PyImport_GetModule(__pyx_mstate_global->__pyx_kp_u_gc); #endif if (unlikely(!gc)) gc = PyImport_Import(__pyx_mstate_global->__pyx_kp_u_gc); if (unlikely(!gc)) return -1; py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_isenabled); if (unlikely(!py_status)) { Py_DECREF(gc); return -1; } gc_was_enabled = __Pyx_PyObject_IsTrue(py_status); Py_DECREF(py_status); if (gc_was_enabled > 0) { ret = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_disable); if (unlikely(!ret)) { Py_DECREF(gc); return -1; } Py_DECREF(ret); } else if (unlikely(gc_was_enabled == -1)) { Py_DECREF(gc); return -1; } #endif t->tp_flags |= Py_TPFLAGS_HEAPTYPE; #if PY_VERSION_HEX >= 0x030A0000 t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE; #endif r = PyType_Ready(t); t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE; #if PY_VERSION_HEX >= 0x030A00b1 if (gc_was_enabled) PyGC_Enable(); #else if (gc_was_enabled) { PyObject *tp, *v, *tb; PyErr_Fetch(&tp, &v, &tb); ret = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_enable); if (likely(ret || r == -1)) { Py_XDECREF(ret); PyErr_Restore(tp, v, tb); } else { Py_XDECREF(tp); Py_XDECREF(v); Py_XDECREF(tb); r = -1; } } Py_DECREF(gc); #endif } return r; #endif } /* GetVTable (used by MergeVTables) */ static int __Pyx_GetVtable(PyTypeObject *type, void** table) { void* ptr; *table = NULL; #if CYTHON_COMPILING_IN_LIMITED_API PyObject *ob = PyObject_GetAttr((PyObject *)type, __pyx_mstate_global->__pyx_n_u_pyx_vtable); #else PyObject *ob = PyObject_GetItem(type->tp_dict, __pyx_mstate_global->__pyx_n_u_pyx_vtable); #endif if (!ob) goto no_attr; ptr = PyCapsule_GetPointer(ob, 0); if (!ptr && !PyErr_Occurred()) PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type"); Py_DECREF(ob); *table = ptr; return 1; no_attr: if (PyErr_ExceptionMatches(CYTHON_COMPILING_IN_LIMITED_API ? PyExc_AttributeError : PyExc_KeyError)) { return 0; } Py_XDECREF(ob); return -1; } /* RaiseErrorWithObjectTypes (used by MergeVTables) */ static void __Pyx_RaiseErrorWithTypes1(PyObject* exc_type, const char *message, const char *arg, PyTypeObject *type_obj1, PyTypeObject *type_obj2) { __Pyx_TypeName type_name1 = __Pyx_PyType_GetFullyQualifiedName(type_obj1); #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 if (unlikely(!type_name1)) return; #endif __Pyx_TypeName type_name2 = __Pyx_PyType_GetFullyQualifiedName(type_obj2); #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 if (unlikely(!type_name2)) goto type2_failed; #endif PyErr_Format(exc_type, message, arg, type_name1, type_name2); __Pyx_DECREF_TypeName(type_name2); #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 type2_failed: #endif __Pyx_DECREF_TypeName(type_name1); } /* MergeVTables (used by SetVTable) */ static int __Pyx_MergeVtables(PyTypeObject *type) { int i=0; Py_ssize_t size; void** base_vtables; void* unknown = (void*)-1; PyObject* bases = __Pyx_PyType_GetSlot(type, tp_bases, PyObject*); int base_depth = 0; { PyTypeObject* base = __Pyx_PyType_GetSlot(type, tp_base, PyTypeObject*); while (base) { base_depth += 1; base = __Pyx_PyType_TryGetSlot(base, tp_base, PyTypeObject*); } } base_vtables = (void**) PyMem_Malloc(sizeof(void*) * (size_t)(base_depth + 1)); if (unlikely(!base_vtables)) { PyErr_NoMemory(); return -1; } base_vtables[0] = unknown; #if CYTHON_COMPILING_IN_LIMITED_API size = PyTuple_Size(bases); if (size < 0) goto other_failure; #else size = PyTuple_GET_SIZE(bases); #endif for (i = 1; i < size; i++) { PyObject *basei; void* base_vtable; #if CYTHON_AVOID_BORROWED_REFS basei = PySequence_GetItem(bases, i); if (unlikely(!basei)) goto other_failure; #elif !CYTHON_ASSUME_SAFE_MACROS basei = PyTuple_GetItem(bases, i); if (unlikely(!basei)) goto other_failure; #else basei = PyTuple_GET_ITEM(bases, i); #endif int get_vtable_result = __Pyx_GetVtable((PyTypeObject*)basei, &base_vtable); #if CYTHON_AVOID_BORROWED_REFS Py_DECREF(basei); #endif if (get_vtable_result != 1) { if (get_vtable_result == -1) { goto other_failure; } PyErr_Clear(); // Class doesn't have a vtable. } else { assert(base_vtable != NULL); int j; PyTypeObject* base = __Pyx_PyType_TryGetSlot(type, tp_base, PyTypeObject*); #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 if (!base) goto bad; #endif for (j = 0; j < base_depth; j++) { if (base_vtables[j] == unknown) { switch (__Pyx_GetVtable(base, &base_vtables[j])) { case 1: assert(base_vtables[j] == NULL); break; case 0: goto bad; case -1: default: goto other_failure; } base_vtables[j + 1] = unknown; } if (base_vtables[j] == base_vtable) { break; } base = __Pyx_PyType_TryGetSlot(base, tp_base, PyTypeObject*); #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 if (!base) goto bad; #endif } } } PyMem_Free(base_vtables); return 0; bad: { PyTypeObject* tp_base = __Pyx_PyType_GetSlot(type, tp_base, PyTypeObject*); PyTypeObject* basei; #if CYTHON_AVOID_BORROWED_REFS basei = (PyTypeObject*)PySequence_GetItem(bases, i); if (unlikely(!basei)) goto other_failure; #elif !CYTHON_ASSUME_SAFE_MACROS basei = (PyTypeObject*)PyTuple_GetItem(bases, i); if (unlikely(!basei)) goto other_failure; #else basei = (PyTypeObject*)PyTuple_GET_ITEM(bases, i); #endif __Pyx_RaiseTypeErrorWithTypes( "multiple bases have vtable conflict: '" __Pyx_FMT_TYPENAME "' and '" __Pyx_FMT_TYPENAME "'", tp_base, basei); #if CYTHON_AVOID_BORROWED_REFS Py_DECREF(basei); #endif } other_failure: PyMem_Free(base_vtables); return -1; } /* SetVTable */ static int __Pyx_SetVtable(PyTypeObject *type, void *vtable) { PyObject *ob = PyCapsule_New(vtable, 0, 0); if (unlikely(!ob)) goto bad; #if CYTHON_COMPILING_IN_LIMITED_API if (unlikely(PyObject_SetAttr((PyObject *) type, __pyx_mstate_global->__pyx_n_u_pyx_vtable, ob) < 0)) #else if (unlikely(PyDict_SetItem(type->tp_dict, __pyx_mstate_global->__pyx_n_u_pyx_vtable, ob) < 0)) #endif goto bad; Py_DECREF(ob); return __Pyx_MergeVtables(type); bad: Py_XDECREF(ob); return -1; } /* LimitedApiGetTypeTypeDict (used by DelItemOnTypeDict) */ #if CYTHON_COMPILING_IN_LIMITED_API static PyObject *__Pyx_GetTypeTypeDict(PyTypeObject *tp) { static Py_ssize_t tp_dictoffset = 0; if (unlikely(tp_dictoffset == 0)) { tp_dictoffset = __Pyx_GetTypeDictOffset((PyObject*)(&PyType_Type), 1); if (unlikely(tp_dictoffset == -1 && PyErr_Occurred())) { tp_dictoffset = 0; // try again next time? return NULL; } } return *(PyObject**)((char*)tp + tp_dictoffset); } #endif /* DelItemOnTypeDict (used by SetupReduce) */ static int __Pyx__DelItemOnTypeDict(PyTypeObject *tp, PyObject *k) { int result; PyObject *tp_dict; #if CYTHON_COMPILING_IN_LIMITED_API tp_dict = __Pyx_GetTypeTypeDict(tp); if (unlikely(!tp_dict)) return -1; #else tp_dict = tp->tp_dict; #endif result = PyDict_DelItem(tp_dict, k); if (likely(!result)) PyType_Modified(tp); return result; } /* SetItemOnTypeDict (used by SetupReduce) */ static int __Pyx__SetItemOnTypeDict(PyTypeObject *tp, PyObject *k, PyObject *v) { int result; PyObject *tp_dict; #if CYTHON_COMPILING_IN_LIMITED_API tp_dict = __Pyx_GetTypeTypeDict(tp); if (unlikely(!tp_dict)) return -1; #else tp_dict = tp->tp_dict; #endif result = PyDict_SetItem(tp_dict, k, v); if (likely(!result)) { PyType_Modified(tp); if (unlikely(PyObject_HasAttr(v, __pyx_mstate_global->__pyx_n_u_set_name))) { PyObject *setNameResult = PyObject_CallMethodObjArgs(v, __pyx_mstate_global->__pyx_n_u_set_name, (PyObject *) tp, k, NULL); if (!setNameResult) return -1; Py_DECREF(setNameResult); } } return result; } /* SetupReduce */ static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { int ret; PyObject *name_attr; name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_mstate_global->__pyx_n_u_name); if (likely(name_attr)) { ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); } else { ret = -1; } if (unlikely(ret < 0) && __Pyx_IgnoreException(PyExc_Exception)) { ret = 0; // But BaseException is still propagated. } Py_XDECREF(name_attr); return ret; } static PyObject *__Pyx_setup_reduce_get_reduce_attribute(PyObject *type_obj, PyObject *name, int allow_not_present) { #if CYTHON_USE_PYTYPE_LOOKUP CYTHON_UNUSED_VAR(allow_not_present); return _PyType_Lookup((PyTypeObject*)type_obj, name); #else if (allow_not_present) { return __Pyx_PyObject_GetAttrStrNoError(type_obj, name); } else { return __Pyx_PyObject_GetAttrStr(type_obj, name); } #endif } 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; getstate = __Pyx_setup_reduce_get_reduce_attribute(type_obj, __pyx_mstate_global->__pyx_n_u_getstate, 1); if (!getstate && PyErr_Occurred()) { goto __PYX_BAD; } if (getstate) { object_getstate = __Pyx_setup_reduce_get_reduce_attribute((PyObject*)&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_getstate, 1); if (!object_getstate && PyErr_Occurred()) { goto __PYX_BAD; } if (object_getstate != getstate) { goto __PYX_GOOD; } } object_reduce_ex = __Pyx_setup_reduce_get_reduce_attribute((PyObject*)&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_reduce_ex, 0); if (unlikely(!object_reduce_ex)) goto __PYX_BAD; reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_mstate_global->__pyx_n_u_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; if (reduce_ex == object_reduce_ex) { object_reduce = __Pyx_setup_reduce_get_reduce_attribute((PyObject*)&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_reduce, 0); if (!object_reduce) goto __PYX_BAD; reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_mstate_global->__pyx_n_u_reduce); if (unlikely(!reduce)) goto __PYX_BAD; int try_to_replace_reduce = (reduce == object_reduce); if (!try_to_replace_reduce) { try_to_replace_reduce = __Pyx_setup_reduce_is_named(reduce, __pyx_mstate_global->__pyx_n_u_reduce_cython); if (unlikely(try_to_replace_reduce < 0)) { goto __PYX_BAD; } } if (try_to_replace_reduce) { reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_reduce_cython); if (likely(reduce_cython)) { ret = __Pyx_SetItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; ret = __Pyx_DelItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; } else if (reduce == object_reduce || PyErr_Occurred()) { goto __PYX_BAD; } setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_setstate); int try_to_replace_setstate; if (!setstate) { PyObject *exc = PyErr_Occurred(); if (exc && !__Pyx_IgnoreGivenException(exc, PyExc_Exception)) { goto __PYX_BAD; } try_to_replace_setstate = 1; } else { try_to_replace_setstate = __Pyx_setup_reduce_is_named(setstate, __pyx_mstate_global->__pyx_n_u_setstate_cython); if (unlikely(try_to_replace_setstate < 0)) { goto __PYX_BAD; } } if (try_to_replace_setstate) { setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_setstate_cython); if (likely(setstate_cython)) { ret = __Pyx_SetItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; ret = __Pyx_DelItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; } else if (!setstate || PyErr_Occurred()) { goto __PYX_BAD; } } PyType_Modified((PyTypeObject*)type_obj); } } goto __PYX_GOOD; __PYX_BAD: if (!PyErr_Occurred()) { __Pyx_RaiseErrorWithType( PyExc_RuntimeError, "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, (PyTypeObject*)type_obj); } 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; } /* TupleOrListFromArrayImpl (used by ListFromArray) */ CYTHON_UNUSED static PyObject * __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n) { PyObject *res = PyList_New(n); if (unlikely(res == NULL)) return NULL; #if CYTHON_COMPILING_IN_CPYTHON __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n); #else Py_ssize_t i; for (i = 0; i < n; i++) { Py_INCREF(src[i]); if (unlikely(__Pyx_PyList_SET_ITEM(res, i, src[i]) < (0))) { Py_DECREF(res); return NULL; } } #endif return res; } /* ImportImpl (used by Import) */ static int __Pyx__Import_GetModule(PyObject *qualname, PyObject **module) { PyObject *imported_module = PyImport_GetModule(qualname); if (unlikely(!imported_module)) { *module = NULL; if (PyErr_Occurred()) { return -1; } return 0; } *module = imported_module; return 1; } static int __Pyx__Import_Lookup(PyObject *qualname, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject **module) { PyObject *imported_module; PyObject *top_level_package_name; Py_ssize_t i; int status, module_found; Py_ssize_t dot_index; module_found = __Pyx__Import_GetModule(qualname, &imported_module); if (unlikely(!module_found || module_found == -1)) { *module = NULL; return module_found; } if (imported_names) { for (i = 0; i < len_imported_names; i++) { PyObject *imported_name = imported_names[i]; #if __PYX_LIMITED_VERSION_HEX < 0x030d0000 int has_imported_attribute = PyObject_HasAttr(imported_module, imported_name); #else int has_imported_attribute = PyObject_HasAttrWithError(imported_module, imported_name); if (unlikely(has_imported_attribute == -1)) goto error; #endif if (!has_imported_attribute) { goto not_found; } } *module = imported_module; return 1; } dot_index = PyUnicode_FindChar(qualname, '.', 0, PY_SSIZE_T_MAX, 1); if (dot_index == -1) { *module = imported_module; return 1; } if (unlikely(dot_index == -2)) goto error; top_level_package_name = PyUnicode_Substring(qualname, 0, dot_index); if (unlikely(!top_level_package_name)) goto error; Py_DECREF(imported_module); status = __Pyx__Import_GetModule(top_level_package_name, module); Py_DECREF(top_level_package_name); return status; error: Py_DECREF(imported_module); *module = NULL; return -1; not_found: Py_DECREF(imported_module); *module = NULL; return 0; } static PyObject *__Pyx__Import(PyObject *name, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject *qualname, PyObject *moddict, int level) { PyObject *module = 0; PyObject *empty_dict = 0; PyObject *from_list = 0; int module_found; if (!qualname) { qualname = name; } module_found = __Pyx__Import_Lookup(qualname, imported_names, len_imported_names, &module); if (likely(module_found == 1)) { return module; } else if (unlikely(module_found == -1)) { return NULL; } #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030f00a6 empty_dict = PyFrozenDict_New(NULL); #else empty_dict = PyDict_New(); #endif if (unlikely(!empty_dict)) goto bad; if (imported_names) { from_list = __Pyx_PyList_FromArray(imported_names, len_imported_names); if (unlikely(!from_list)) goto bad; } if (level == -1) { const char* package_sep = strchr(__Pyx_MODULE_NAME, '.'); if (package_sep != (0)) { module = PyImport_ImportModuleLevelObject( name, moddict, empty_dict, from_list, 1); if (unlikely(!module)) { if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError))) goto bad; PyErr_Clear(); } } level = 0; } if (!module) { module = PyImport_ImportModuleLevelObject( name, moddict, empty_dict, from_list, level); } bad: Py_XDECREF(from_list); Py_XDECREF(empty_dict); return module; } /* Import */ static PyObject *__Pyx_Import(PyObject *name, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject *qualname, int level) { return __Pyx__Import(name, imported_names, len_imported_names, qualname, __pyx_mstate_global->__pyx_d, level); } /* ImportFrom */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { const char* module_name_str = 0; PyObject* module_name = 0; PyObject* module_dot = 0; PyObject* full_name = 0; PyErr_Clear(); module_name_str = PyModule_GetName(module); if (unlikely(!module_name_str)) { goto modbad; } module_name = PyUnicode_FromString(module_name_str); if (unlikely(!module_name)) { goto modbad; } module_dot = PyUnicode_Concat(module_name, __pyx_mstate_global->__pyx_kp_u__4); if (unlikely(!module_dot)) { goto modbad; } full_name = PyUnicode_Concat(module_dot, name); if (unlikely(!full_name)) { goto modbad; } #if (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) ||\ CYTHON_COMPILING_IN_GRAAL { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) goto modbad; value = PyObject_GetItem(modules, full_name); } #else value = PyImport_GetModule(full_name); #endif modbad: Py_XDECREF(full_name); Py_XDECREF(module_dot); Py_XDECREF(module_name); } if (unlikely(!value)) { PyErr_Format(PyExc_ImportError, "cannot import name %S", name); } return value; } /* dict_setdefault (used by FetchCommonType) */ static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value) { PyObject* value; #if __PYX_LIMITED_VERSION_HEX >= 0x030F0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4) PyDict_SetDefaultRef(d, key, default_value, &value); #elif CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX >= 0x030C0000 PyObject *args[] = {d, key, default_value}; value = PyObject_VectorcallMethod(__pyx_mstate_global->__pyx_n_u_setdefault, args, 3 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); #elif CYTHON_COMPILING_IN_LIMITED_API value = PyObject_CallMethodObjArgs(d, __pyx_mstate_global->__pyx_n_u_setdefault, key, default_value, NULL); #else value = PyDict_SetDefault(d, key, default_value); if (unlikely(!value)) return NULL; Py_INCREF(value); #endif return value; } /* AddModuleRef (used by FetchSharedCythonModule) */ #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && PY_VERSION_HEX < 0x030F00a3 static PyObject *__Pyx_PyImport_AddModuleObjectRef(PyObject *name) { PyObject *module_dict = PyImport_GetModuleDict(); PyObject *m; if (PyMapping_GetOptionalItem(module_dict, name, &m) < 0) { return NULL; } if (m != NULL && PyModule_Check(m)) { return m; } Py_XDECREF(m); m = PyModule_NewObject(name); if (m == NULL) return NULL; if (PyDict_CheckExact(module_dict)) { PyObject *new_m; (void)PyDict_SetDefaultRef(module_dict, name, m, &new_m); Py_DECREF(m); return new_m; } else { if (PyObject_SetItem(module_dict, name, m) != 0) { Py_DECREF(m); return NULL; } return m; } } static PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { if ((PY_VERSION_HEX >= 0x030E0000) && Py_Version >= 0x030E0100) { return PyImport_AddModuleRef(name); } PyObject *py_name = PyUnicode_FromString(name); if (!py_name) return NULL; PyObject *module = __Pyx_PyImport_AddModuleObjectRef(py_name); Py_DECREF(py_name); return module; } #elif __PYX_LIMITED_VERSION_HEX < 0x030d0000 static PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { PyObject *module = PyImport_AddModule(name); Py_XINCREF(module); return module; } #endif /* FetchSharedCythonModule (used by FetchCommonType) */ static PyObject *__Pyx_FetchSharedCythonABIModule(void) { return __Pyx_PyImport_AddModuleRef(__PYX_ABI_MODULE_NAME); } /* VerifyCachedType (used by FetchCommonType) */ static int __Pyx_VerifyCachedType(PyObject *cached_type, const char *name, Py_ssize_t expected_basicsize) { Py_ssize_t basicsize; if (!PyType_Check(cached_type)) { PyErr_Format(PyExc_TypeError, "Shared Cython type %.200s is not a type object", name); return -1; } if (expected_basicsize == 0) { return 0; // size is inherited, nothing useful to check } #if CYTHON_COMPILING_IN_LIMITED_API && CYTHON_OPAQUE_OBJECTS if (expected_basicsize < 0) { basicsize = PyType_GetTypeDataSize((PyTypeObject*)cached_type); } else #endif { #if CYTHON_COMPILING_IN_LIMITED_API PyObject *py_basicsize; py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); if (unlikely(!py_basicsize)) return -1; basicsize = PyLong_AsSsize_t(py_basicsize); Py_DECREF(py_basicsize); py_basicsize = NULL; if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) return -1; #else basicsize = ((PyTypeObject*) cached_type)->tp_basicsize; #endif } if ((expected_basicsize >= 0) ? (basicsize != expected_basicsize) : (basicsize < -expected_basicsize)) { PyErr_Format(PyExc_TypeError, "Shared Cython type %.200s has the wrong size, try recompiling", name); return -1; } return 0; } /* FetchCommonType (used by CommonTypesMetaclass) */ #if __PYX_LIMITED_VERSION_HEX < 0x030C0000 static PyObject* __Pyx_PyType_FromMetaclass(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases) { PyObject *result = __Pyx_PyType_FromModuleAndSpec(module, spec, bases); if (result && metaclass) { PyObject *old_tp = (PyObject*)Py_TYPE(result); Py_INCREF((PyObject*)metaclass); Py_SET_TYPE(result, metaclass); Py_DECREF(old_tp); PyType_Modified((PyTypeObject*)result); } return result; } #else #define __Pyx_PyType_FromMetaclass(me, mo, s, b) PyType_FromMetaclass(me, mo, s, b) #endif static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases) { PyObject *abi_module = NULL, *cached_type = NULL, *abi_module_dict, *new_cached_type, *py_object_name; int get_item_ref_result; const char* object_name = strrchr(spec->name, '.'); object_name = object_name ? object_name+1 : spec->name; py_object_name = PyUnicode_FromString(object_name); if (!py_object_name) return NULL; abi_module = __Pyx_FetchSharedCythonABIModule(); if (!abi_module) goto done; abi_module_dict = PyModule_GetDict(abi_module); if (!abi_module_dict) goto done; get_item_ref_result = __Pyx_PyDict_GetItemRef(abi_module_dict, py_object_name, &cached_type); if (get_item_ref_result == 1) { if (__Pyx_VerifyCachedType( cached_type, object_name, spec->basicsize) < 0) { goto bad; } goto done; } else if (unlikely(get_item_ref_result == -1)) { goto bad; } cached_type = __Pyx_PyType_FromMetaclass( metaclass, CYTHON_USE_MODULE_STATE ? module : abi_module, spec, bases); if (unlikely(!cached_type)) goto bad; new_cached_type = __Pyx_PyDict_SetDefault(abi_module_dict, py_object_name, cached_type); if (unlikely(new_cached_type != cached_type)) { if (unlikely(!new_cached_type)) goto bad; Py_DECREF(cached_type); cached_type = new_cached_type; if (__Pyx_VerifyCachedType( cached_type, object_name, spec->basicsize) < 0) { goto bad; } goto done; } else { Py_DECREF(new_cached_type); } done: Py_XDECREF(abi_module); Py_DECREF(py_object_name); assert(cached_type == NULL || PyType_Check(cached_type)); return (PyTypeObject *) cached_type; bad: Py_XDECREF(cached_type); cached_type = NULL; goto done; } /* CommonTypesMetaclass (used by CythonFunctionShared) */ static PyObject* __pyx_CommonTypesMetaclass_get_module(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED void* context) { return PyUnicode_FromString(__PYX_ABI_MODULE_NAME); } #if __PYX_LIMITED_VERSION_HEX < 0x030A0000 static PyObject* __pyx_CommonTypesMetaclass_call(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED PyObject *args, CYTHON_UNUSED PyObject *kwds) { PyErr_SetString(PyExc_TypeError, "Cannot instantiate Cython internal types"); return NULL; } static int __pyx_CommonTypesMetaclass_setattr(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED PyObject *attr, CYTHON_UNUSED PyObject *value) { PyErr_SetString(PyExc_TypeError, "Cython internal types are immutable"); return -1; } #endif static PyGetSetDef __pyx_CommonTypesMetaclass_getset[] = { {"__module__", __pyx_CommonTypesMetaclass_get_module, NULL, NULL, NULL}, {0, 0, 0, 0, 0} }; static PyType_Slot __pyx_CommonTypesMetaclass_slots[] = { {Py_tp_getset, (void *)__pyx_CommonTypesMetaclass_getset}, #if __PYX_LIMITED_VERSION_HEX < 0x030A0000 {Py_tp_call, (void*)__pyx_CommonTypesMetaclass_call}, {Py_tp_new, (void*)__pyx_CommonTypesMetaclass_call}, {Py_tp_setattro, (void*)__pyx_CommonTypesMetaclass_setattr}, #endif {0, 0} }; static PyType_Spec __pyx_CommonTypesMetaclass_spec = { __PYX_TYPE_MODULE_PREFIX "_common_types_metatype", 0, 0, Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION | Py_TPFLAGS_DEFAULT, __pyx_CommonTypesMetaclass_slots }; static int __pyx_CommonTypesMetaclass_init(PyObject *module) { __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module); PyObject *bases = PyTuple_Pack(1, &PyType_Type); if (unlikely(!bases)) { return -1; } mstate->__pyx_CommonTypesMetaclassType = __Pyx_FetchCommonTypeFromSpec(NULL, module, &__pyx_CommonTypesMetaclass_spec, bases); Py_DECREF(bases); if (unlikely(mstate->__pyx_CommonTypesMetaclassType == NULL)) { return -1; } return 0; } /* CythonFunctionPerModule (used by CythonFunctionShared) */ #if CYTHON_COMPILING_IN_LIMITED_API static CYTHON_INLINE int __Pyx__IsSameCyOrCFunctionNoMethod(PyObject *func, void (*cfunc)(void)) { if (__Pyx_CyFunction_Check(func)) { return __Pyx_as_CyFunctionObject(func)->func_methoddef->ml_meth == (PyCFunction) cfunc; } else if (PyCFunction_Check(func)) { return PyCFunction_GetFunction(func) == (PyCFunction) cfunc; } return 0; } static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) { if ((PyObject*)Py_TYPE(func) == __pyx_mstate_global->__Pyx_CachedMethodType) { int result; PyObject *newFunc = PyObject_GetAttr(func, __pyx_mstate_global->__pyx_n_u_func); if (unlikely(!newFunc)) { PyErr_Clear(); // It's only an optimization, so don't throw an error return 0; } result = __Pyx__IsSameCyOrCFunctionNoMethod(newFunc, cfunc); Py_DECREF(newFunc); return result; } return __Pyx__IsSameCyOrCFunctionNoMethod(func, cfunc); } #else static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) { if (PyMethod_Check(func)) { func = PyMethod_GET_FUNCTION(func); } return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; } #endif static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) { #if 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 CYTHON_INLINE PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func, PyTypeObject *defaults_type) { __pyx_CyFunctionObject *m = __Pyx_as_CyFunctionObject(func); m->defaults = PyObject_CallObject((PyObject*)defaults_type, NULL); // _PyObject_New(defaults_type); if (unlikely(!m->defaults)) return NULL; return m->defaults; } static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { __pyx_CyFunctionObject *m = __Pyx_as_CyFunctionObject(func); m->defaults_tuple = tuple; Py_INCREF(tuple); } static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { __pyx_CyFunctionObject *m = __Pyx_as_CyFunctionObject(func); m->defaults_kwdict = dict; Py_INCREF(dict); } static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { __pyx_CyFunctionObject *m = __Pyx_as_CyFunctionObject(func); m->func_annotations = dict; Py_INCREF(dict); } /* PyMethodNew (used by CythonFunctionShared) */ #if CYTHON_COMPILING_IN_LIMITED_API static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { PyObject *result; CYTHON_UNUSED_VAR(typ); if (!self) return __Pyx_NewRef(func); #if __PYX_LIMITED_VERSION_HEX >= 0x030C0000 { PyObject *args[] = {func, self}; result = PyObject_Vectorcall(__pyx_mstate_global->__Pyx_CachedMethodType, args, 2, NULL); } #else result = PyObject_CallFunctionObjArgs(__pyx_mstate_global->__Pyx_CachedMethodType, func, self, NULL); #endif return result; } #else static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { CYTHON_UNUSED_VAR(typ); if (!self) return __Pyx_NewRef(func); return PyMethod_New(func, self); } #endif /* PyVectorcallFastCallDict (used by CythonFunctionShared) */ #if CYTHON_VECTORCALL static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) { PyObject *res = NULL; PyObject *kwnames; PyObject **newargs; PyObject **kwvalues; Py_ssize_t i; #if CYTHON_AVOID_BORROWED_REFS PyObject *pos; #else Py_ssize_t pos; #endif size_t j; PyObject *key, *value; unsigned long keys_are_strings; #if !CYTHON_ASSUME_SAFE_SIZE Py_ssize_t nkw = PyDict_Size(kw); if (unlikely(nkw == -1)) return NULL; #else Py_ssize_t nkw = PyDict_GET_SIZE(kw); #endif newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0])); if (unlikely(newargs == NULL)) { PyErr_NoMemory(); return NULL; } for (j = 0; j < nargs; j++) newargs[j] = args[j]; kwnames = PyTuple_New(nkw); if (unlikely(kwnames == NULL)) { PyMem_Free(newargs); return NULL; } kwvalues = newargs + nargs; pos = 0; i = 0; keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS; while (__Pyx_PyDict_NextRef(kw, &pos, &key, &value)) { keys_are_strings &= #if CYTHON_COMPILING_IN_LIMITED_API PyType_GetFlags(Py_TYPE(key)); #else Py_TYPE(key)->tp_flags; #endif #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely(PyTuple_SetItem(kwnames, i, key) < 0)) goto cleanup; #else PyTuple_SET_ITEM(kwnames, i, key); #endif kwvalues[i] = value; i++; } if (unlikely(!keys_are_strings)) { PyErr_SetString(PyExc_TypeError, "keywords must be strings"); goto cleanup; } res = vc(func, newargs, nargs, kwnames); cleanup: #if CYTHON_AVOID_BORROWED_REFS Py_DECREF(pos); #endif Py_DECREF(kwnames); for (i = 0; i < nkw; i++) Py_DECREF(kwvalues[i]); PyMem_Free(newargs); return res; } static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) { Py_ssize_t kw_size = likely(kw == NULL) ? 0 : #if !CYTHON_ASSUME_SAFE_SIZE PyDict_Size(kw); #else PyDict_GET_SIZE(kw); #endif if (kw_size == 0) { return vc(func, args, nargs, NULL); } #if !CYTHON_ASSUME_SAFE_SIZE else if (unlikely(kw_size == -1)) { return NULL; } #endif return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); } #endif /* CythonFunctionShared (used by CythonFunction) */ static PyObject * __Pyx_CyFunction_get_doc_locked(__pyx_CyFunctionObject *op) { if (unlikely(op->func_doc == NULL)) { #if CYTHON_COMPILING_IN_LIMITED_API const char *doc = op->func_methoddef->ml_doc; #else const char *doc = ((PyCFunctionObject*)op)->m_ml->ml_doc; #endif if (doc) { op->func_doc = PyUnicode_FromString(doc); if (unlikely(op->func_doc == NULL)) return NULL; } else { Py_INCREF(Py_None); return Py_None; } } Py_INCREF(op->func_doc); return op->func_doc; } static PyObject * __Pyx_CyFunction_get_doc(PyObject *op_in, void *closure) { PyObject *result; __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); CYTHON_UNUSED_VAR(closure); __Pyx_BEGIN_CRITICAL_SECTION(op_in); result = __Pyx_CyFunction_get_doc_locked(op); __Pyx_END_CRITICAL_SECTION(); return result; } static int __Pyx_CyFunction_set_doc(PyObject *op_in, PyObject *value, void *context) { __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); CYTHON_UNUSED_VAR(context); if (value == NULL) { value = Py_None; } Py_INCREF(value); __Pyx_BEGIN_CRITICAL_SECTION(op_in); __Pyx_Py_XDECREF_SET(op->func_doc, value); __Pyx_END_CRITICAL_SECTION(); return 0; } static PyObject * __Pyx_CyFunction_get_name_locked(__pyx_CyFunctionObject *op) { if (unlikely(op->func_name == NULL)) { #if CYTHON_COMPILING_IN_LIMITED_API const char *name = op->func_methoddef->ml_name; #else const char *name = ((PyCFunctionObject*)op)->m_ml->ml_name; #endif op->func_name = PyUnicode_InternFromString(name); if (unlikely(op->func_name == NULL)) return NULL; } Py_INCREF(op->func_name); return op->func_name; } static PyObject * __Pyx_CyFunction_get_name(PyObject *op, void *context) { PyObject *result = NULL; CYTHON_UNUSED_VAR(context); __Pyx_BEGIN_CRITICAL_SECTION(op); result = __Pyx_CyFunction_get_name_locked(__Pyx_as_CyFunctionObject(op)); __Pyx_END_CRITICAL_SECTION(); return result; } static int __Pyx_CyFunction_set_name(PyObject *op_in, PyObject *value, void *context) { CYTHON_UNUSED_VAR(context); if (unlikely(value == NULL || !PyUnicode_Check(value))) { PyErr_SetString(PyExc_TypeError, "__name__ must be set to a string object"); return -1; } __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); Py_INCREF(value); __Pyx_BEGIN_CRITICAL_SECTION(op_in); __Pyx_Py_XDECREF_SET(op->func_name, value); __Pyx_END_CRITICAL_SECTION(); return 0; } static PyObject * __Pyx_CyFunction_get_qualname(PyObject *op_in, void *context) { CYTHON_UNUSED_VAR(context); __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); PyObject *result; __Pyx_BEGIN_CRITICAL_SECTION(op_in); Py_INCREF(op->func_qualname); result = op->func_qualname; __Pyx_END_CRITICAL_SECTION(); return result; } static int __Pyx_CyFunction_set_qualname(PyObject *op_in, PyObject *value, void *context) { CYTHON_UNUSED_VAR(context); if (unlikely(value == NULL || !PyUnicode_Check(value))) { PyErr_SetString(PyExc_TypeError, "__qualname__ must be set to a string object"); return -1; } __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); Py_INCREF(value); __Pyx_BEGIN_CRITICAL_SECTION(op_in); __Pyx_Py_XDECREF_SET(op->func_qualname, value); __Pyx_END_CRITICAL_SECTION(); return 0; } #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 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; } #endif static PyObject * __Pyx_CyFunction_get_globals(PyObject *op_in, void *context) { CYTHON_UNUSED_VAR(context); __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); Py_INCREF(op->func_globals); return op->func_globals; } static PyObject * __Pyx_CyFunction_get_closure(PyObject *op, void *context) { CYTHON_UNUSED_VAR(op); CYTHON_UNUSED_VAR(context); Py_INCREF(Py_None); return Py_None; } static PyObject * __Pyx_CyFunction_get_code(PyObject *op_in, void *context) { __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); 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, PyObject *op_obj) { int result = 0; PyObject *res = op->defaults_getter(op_obj); 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(PyObject *op_in, PyObject* value, void *context) { __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); CYTHON_UNUSED_VAR(context); if (!value) { value = Py_None; } else if (unlikely(value != Py_None && !PyTuple_Check(value))) { PyErr_SetString(PyExc_TypeError, "__defaults__ must be set to a tuple object"); return -1; } PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not " "currently affect the values used in function calls", 1); Py_INCREF(value); __Pyx_BEGIN_CRITICAL_SECTION(op_in); __Pyx_Py_XDECREF_SET(op->defaults_tuple, value); __Pyx_END_CRITICAL_SECTION(); return 0; } static PyObject * __Pyx_CyFunction_get_defaults_locked(PyObject *op_in) { __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); PyObject* result = op->defaults_tuple; if (unlikely(!result)) { if (op->defaults_getter) { if (unlikely(__Pyx_CyFunction_init_defaults(op, op_in) < 0)) return NULL; result = op->defaults_tuple; } else { result = Py_None; } } Py_INCREF(result); return result; } static PyObject * __Pyx_CyFunction_get_defaults(PyObject *op, void *context) { PyObject* result = NULL; CYTHON_UNUSED_VAR(context); __Pyx_BEGIN_CRITICAL_SECTION(op); result = __Pyx_CyFunction_get_defaults_locked(op); __Pyx_END_CRITICAL_SECTION(); return result; } static int __Pyx_CyFunction_set_kwdefaults(PyObject *op_in, PyObject* value, void *context) { __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); CYTHON_UNUSED_VAR(context); if (!value) { value = Py_None; } else if (unlikely(value != Py_None && !PyDict_Check(value))) { PyErr_SetString(PyExc_TypeError, "__kwdefaults__ must be set to a dict object"); return -1; } PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not " "currently affect the values used in function calls", 1); Py_INCREF(value); __Pyx_BEGIN_CRITICAL_SECTION(op_in); __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value); __Pyx_END_CRITICAL_SECTION(); return 0; } static PyObject * __Pyx_CyFunction_get_kwdefaults_locked(PyObject *op_in) { __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); PyObject* result = op->defaults_kwdict; if (unlikely(!result)) { if (op->defaults_getter) { if (unlikely(__Pyx_CyFunction_init_defaults(op, op_in) < 0)) return NULL; result = op->defaults_kwdict; } else { result = Py_None; } } Py_INCREF(result); return result; } static PyObject * __Pyx_CyFunction_get_kwdefaults(PyObject *op, void *context) { PyObject* result; CYTHON_UNUSED_VAR(context); __Pyx_BEGIN_CRITICAL_SECTION(op); result = __Pyx_CyFunction_get_kwdefaults_locked(op); __Pyx_END_CRITICAL_SECTION(); return result; } static int __Pyx_CyFunction_set_annotate_in_dict_if_exists(PyObject *op_in, PyObject *value); static int __Pyx_CyFunction_set_annotations(PyObject *op_in, 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; } __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); Py_XINCREF(value); __Pyx_BEGIN_CRITICAL_SECTION(op_in); __Pyx_Py_XDECREF_SET(op->func_annotations, value); __Pyx_END_CRITICAL_SECTION(); if (unlikely(__Pyx_CyFunction_set_annotate_in_dict_if_exists(op_in, Py_None) < 0)) return -1; return 0; } static int __Pyx_CyFunction_get_dict_if_exists(PyObject *op_in, PyObject **dict) { /* Return 1 if the function dict exists, 0 otherwise. This cannot fail: * _PyObject_GetDictPtr() may clear errors internally, but never reports them. */ #if CYTHON_COMPILING_IN_PYPY *dict = PyObject_GenericGetDict(op_in, NULL); #elif CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX < 0x030C0000 *dict = __Pyx_as_CyFunctionObject(op_in)->func_dict; #else PyObject **dictptr = _PyObject_GetDictPtr(op_in); *dict = likely(dictptr) ? *dictptr : NULL; #endif return *dict ? 1 : 0; } static int __Pyx_CyFunction_get_annotate_from_dict_if_exists(PyObject *op_in, PyObject **annotate) { PyObject *dict; int dict_found; *annotate = NULL; dict_found = __Pyx_CyFunction_get_dict_if_exists(op_in, &dict); if (!dict_found) return 0; return __Pyx_PyDict_GetItemRef(dict, __pyx_mstate_global->__pyx_n_u_annotate, annotate); } static int __Pyx_CyFunction_set_annotate_in_dict_if_exists(PyObject *op_in, PyObject *value) { PyObject *dict; int dict_found; dict_found = __Pyx_CyFunction_get_dict_if_exists(op_in, &dict); if (!dict_found) return 0; if (value) { return PyDict_SetItem(dict, __pyx_mstate_global->__pyx_n_u_annotate, value); } else { #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d0000 return PyDict_Pop(dict, __pyx_mstate_global->__pyx_n_u_annotate, NULL); #else int result = PyDict_Contains(dict, __pyx_mstate_global->__pyx_n_u_annotate); if (result == 1) { result = PyDict_DelItem(dict, __pyx_mstate_global->__pyx_n_u_annotate); } return result; #endif } } static int __Pyx_CyFunction_set_annotate_in_dict(PyObject *op_in, PyObject *value) { PyObject *dict; int result; #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 dict = __Pyx_CyFunction_get_dict(__Pyx_as_CyFunctionObject(op_in), NULL); #else dict = PyObject_GenericGetDict(op_in, NULL); #endif if (unlikely(!dict)) return -1; result = PyDict_SetItem(dict, __pyx_mstate_global->__pyx_n_u_annotate, value); Py_DECREF(dict); return result; } static PyObject * __Pyx_CyFunction_get_annotations_locked(__pyx_CyFunctionObject *op) { PyObject* result = op->func_annotations; if (unlikely(!result)) { result = PyDict_New(); if (unlikely(!result)) return NULL; op->func_annotations = result; } Py_INCREF(result); return result; } static PyObject * __Pyx_CyFunction_get_annotations(PyObject *op_in, void *context) { PyObject *annotate = NULL; PyObject *result = NULL; __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); CYTHON_UNUSED_VAR(context); __Pyx_BEGIN_CRITICAL_SECTION(op_in); result = __Pyx_XNewRef(op->func_annotations); __Pyx_END_CRITICAL_SECTION(); if (result) return result; if (unlikely(__Pyx_CyFunction_get_annotate_from_dict_if_exists(op_in, &annotate) < 0)) return NULL; if (!annotate || annotate == Py_None) { Py_XDECREF(annotate); __Pyx_BEGIN_CRITICAL_SECTION(op_in); result = __Pyx_CyFunction_get_annotations_locked(op); __Pyx_END_CRITICAL_SECTION(); return result; } PyObject *format = PyLong_FromLong(1L); // annotationlib.Format.VALUE if (likely(format)) { if (!Py_EnterRecursiveCall(" cyfunction __annotations__.__get__")) { result = __Pyx_PyObject_CallOneArg(annotate, format); Py_LeaveRecursiveCall(); Py_DECREF(format); } } Py_DECREF(annotate); if (unlikely(!result)) return NULL; if (unlikely(!PyDict_Check(result))) { PyErr_SetString(PyExc_TypeError, "__annotate__ must return a dict"); Py_DECREF(result); return NULL; } __Pyx_BEGIN_CRITICAL_SECTION(op_in); __Pyx_Py_XDECREF_SET(op->func_annotations, __Pyx_NewRef(result)); __Pyx_END_CRITICAL_SECTION(); return result; } static PyObject *__Pyx_CyFunction_annotate_impl(PyObject *self, PyObject *arg) { CYTHON_UNUSED_VAR(arg); if (unlikely(!self)) { PyErr_SetString(PyExc_SystemError, "cython __annotate__ called without 'self' argument"); return NULL; } PyObject *result; if (Py_EnterRecursiveCall(" in cyfunction annotate")) { return NULL; } result = __Pyx_CyFunction_get_annotations(self, NULL); Py_LeaveRecursiveCall(); return result; } static PyObject * __Pyx_CyFunction_get_annotate(PyObject *op_in, void *context); static int __Pyx_CyFunction_set_annotate(PyObject *op_in, PyObject* value, void *context) { CYTHON_UNUSED_VAR(context); if (value == NULL) { PyErr_SetString(PyExc_TypeError, "__annotate__ cannot be deleted"); return -1; } if (unlikely(value != Py_None && !PyCallable_Check(value))) { PyErr_SetString(PyExc_TypeError, "__annotate__ must be callable or None"); return -1; } if (unlikely(__Pyx_TypeCheck(value, &PyCFunction_Type))) { #if !CYTHON_ASSUME_SAFE_MACROS && !CYTHON_COMPILING_IN_PYPY PyCFunction cfunction = PyCFunction_GetFunction(value); if (unlikely(!cfunction)) return -1; PyObject *value_self = PyCFunction_GetSelf(value); if (unlikely(!value_self && PyErr_Occurred())) return -1; #else PyCFunction cfunction = PyCFunction_GET_FUNCTION(value); PyObject *value_self = PyCFunction_GET_SELF(value); #endif if (cfunction == __Pyx_CyFunction_annotate_impl && value_self == op_in) { return __Pyx_CyFunction_set_annotate_in_dict_if_exists(op_in, NULL); } } if (value != Py_None) { __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); __Pyx_BEGIN_CRITICAL_SECTION(op_in); Py_CLEAR(op->func_annotations); __Pyx_END_CRITICAL_SECTION(); } return __Pyx_CyFunction_set_annotate_in_dict(op_in, value); } #if __PYX_LIMITED_VERSION_HEX < 0x030B0000 static PyObject * __Pyx_CyFunction_get_is_coroutine_value(__pyx_CyFunctionObject *op) { int is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; if (is_coroutine) { PyObject *is_coroutine_value, *module, *fromlist, *marker = __pyx_mstate_global->__pyx_n_u_is_coroutine; fromlist = PyList_New(1); if (unlikely(!fromlist)) return NULL; Py_INCREF(marker); #if CYTHON_ASSUME_SAFE_MACROS PyList_SET_ITEM(fromlist, 0, marker); #else if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) { Py_DECREF(fromlist); return NULL; } #endif module = PyImport_ImportModuleLevelObject(__pyx_mstate_global->__pyx_n_u_asyncio_coroutines, NULL, NULL, fromlist, 0); Py_DECREF(fromlist); if (unlikely(!module)) { goto ignore_or_error; } is_coroutine_value = __Pyx_PyObject_GetAttrStr(module, marker); Py_DECREF(module); if (likely(is_coroutine_value)) { return is_coroutine_value; } ignore_or_error: if (!__Pyx_IgnoreException(PyExc_Exception)) { return NULL; } } return __Pyx_PyBool_FromLong(is_coroutine); } static PyObject * __Pyx_CyFunction_get_is_coroutine(PyObject *op_in, void *context) { __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); PyObject *result; CYTHON_UNUSED_VAR(context); if (op->func_is_coroutine) { return __Pyx_NewRef(op->func_is_coroutine); } result = __Pyx_CyFunction_get_is_coroutine_value(op); if (unlikely(!result)) return NULL; __Pyx_BEGIN_CRITICAL_SECTION(op_in); if (op->func_is_coroutine) { Py_DECREF(result); result = __Pyx_NewRef(op->func_is_coroutine); } else { op->func_is_coroutine = __Pyx_NewRef(result); } __Pyx_END_CRITICAL_SECTION(); return result; } #endif static void __Pyx_CyFunction_raise_argument_count_error(PyObject *func, const char* message, Py_ssize_t size) { #if CYTHON_COMPILING_IN_LIMITED_API PyObject *py_name = __Pyx_CyFunction_get_name(func, NULL); if (!py_name) return; PyErr_Format(PyExc_TypeError, "%.200S() %s (%" CYTHON_FORMAT_SSIZE_T "d given)", py_name, message, size); Py_DECREF(py_name); #else const char* name = ((PyCFunctionObject*)func)->m_ml->ml_name; PyErr_Format(PyExc_TypeError, "%.200s() %s (%" CYTHON_FORMAT_SSIZE_T "d given)", name, message, size); #endif } static void __Pyx_CyFunction_raise_type_error(PyObject *func, const char* message) { #if CYTHON_COMPILING_IN_LIMITED_API PyObject *py_name = __Pyx_CyFunction_get_name(func, NULL); if (!py_name) return; PyErr_Format(PyExc_TypeError, "%.200S() %s", py_name, message); Py_DECREF(py_name); #else const char* name = ((PyCFunctionObject*)func)->m_ml->ml_name; PyErr_Format(PyExc_TypeError, "%.200s() %s", name, message); #endif } #if CYTHON_COMPILING_IN_LIMITED_API static PyObject * __Pyx_CyFunction_get_module(PyObject *op_in, void *context) { CYTHON_UNUSED_VAR(context); __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); Py_INCREF(op->func_module); return op->func_module; } static int __Pyx_CyFunction_set_module(PyObject *op_in, PyObject* value, void *context) { CYTHON_UNUSED_VAR(context); __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); if (value == NULL) { value = Py_None; } Py_INCREF(value); PyObject *old = op->func_module; op->func_module = value; Py_DECREF(old); return 0; } #endif static PyGetSetDef __pyx_CyFunction_getsets[] = { {"func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, {"__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, {"func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, {"__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, {"__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 {"func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)PyObject_GenericSetDict, 0, 0}, {"__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)PyObject_GenericSetDict, 0, 0}, #else {"func_dict", (getter)PyObject_GenericGetDict, (setter)PyObject_GenericSetDict, 0, 0}, {"__dict__", (getter)PyObject_GenericGetDict, (setter)PyObject_GenericSetDict, 0, 0}, #endif {"func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, {"__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, {"func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, {"__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, {"func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, {"__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, {"func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, {"__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, {"__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, {"__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, {"__annotate__", (getter)__Pyx_CyFunction_get_annotate, (setter)__Pyx_CyFunction_set_annotate, 0, 0}, #if __PYX_LIMITED_VERSION_HEX < 0x030B0000 {"_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0}, #endif #if CYTHON_COMPILING_IN_LIMITED_API {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0}, #endif {0, 0, 0, 0, 0} }; static PyMemberDef __pyx_CyFunction_members[] = { #if !CYTHON_COMPILING_IN_LIMITED_API {"__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, #endif #if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API {"__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), __PYX_SHARED_RELATIVE_OFFSET | READONLY, 0}, #endif #if CYTHON_VECTORCALL #if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY {"__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), __PYX_SHARED_RELATIVE_OFFSET | READONLY, 0}, #else {"__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, #endif #if CYTHON_COMPILING_IN_LIMITED_API {"__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), __PYX_SHARED_RELATIVE_OFFSET | READONLY, 0}, #else {"__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, #endif #endif {0, 0, 0, 0, 0} }; static PyObject * __Pyx_CyFunction_reduce(PyObject *m_in, PyObject *args) { PyObject *result = NULL; __pyx_CyFunctionObject *m = __Pyx_as_CyFunctionObject(m_in); CYTHON_UNUSED_VAR(args); __Pyx_BEGIN_CRITICAL_SECTION(m_in); Py_INCREF(m->func_qualname); result = m->func_qualname; __Pyx_END_CRITICAL_SECTION(); return result; } static PyMethodDef __pyx_CyFunction_methods[] = { {"__annotate_cython__", __Pyx_CyFunction_annotate_impl, METH_O, "Placeholder __annotate__ function to allow 'functools.wraps' to work " "on Cython functions."}, {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_NOARGS, 0}, {0, 0, 0, 0} }; static PyObject * __Pyx_CyFunction_get_annotate(PyObject *op_in, void *context) { PyObject *annotate = NULL; CYTHON_UNUSED_VAR(context); if (unlikely(__Pyx_CyFunction_get_annotate_from_dict_if_exists(op_in, &annotate) < 0)) return NULL; if (annotate) return annotate; PyObject *method = PyCFunction_New( &__pyx_CyFunction_methods[0], op_in); return method; } #if CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) #else #define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist) #endif static PyObject *__Pyx_CyFunction_Init(PyObject *op_in, PyMethodDef *ml, int flags, PyObject* qualname, PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { __pyx_CyFunctionObject* op = __Pyx_as_CyFunctionObject(op_in); #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_methoddef = ml; Py_INCREF(module); op->func_module = module; #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 #if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API op->func_dict = NULL; #endif op->func_name = NULL; Py_INCREF(qualname); op->func_qualname = qualname; op->func_doc = NULL; #if CYTHON_COMPILING_IN_LIMITED_API op->func_classobj = NULL; #else ((PyCMethodObject*)op)->mm_class = NULL; #endif op->func_globals = globals; Py_INCREF(op->func_globals); Py_XINCREF(code); op->func_code = code; op->defaults = NULL; op->defaults_tuple = NULL; op->defaults_kwdict = NULL; op->defaults_getter = NULL; op->func_annotations = NULL; #if __PYX_LIMITED_VERSION_HEX < 0x030B0000 op->func_is_coroutine = NULL; #endif #if CYTHON_VECTORCALL 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_in); return NULL; } #endif return op_in; } static int __Pyx__CyFunction_clear(__pyx_CyFunctionObject *m) { Py_CLEAR(m->func_closure); #if CYTHON_COMPILING_IN_LIMITED_API Py_CLEAR(m->func_module); #else Py_CLEAR(((PyCFunctionObject*)m)->m_module); #endif #if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API Py_CLEAR(m->func_dict); #elif PY_VERSION_HEX < 0x030d0000 _PyObject_ClearManagedDict((PyObject*)m); #else PyObject_ClearManagedDict((PyObject*)m); #endif 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 Py_CLEAR(m->func_classobj); #else { PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class; ((PyCMethodObject *) (m))->mm_class = NULL; Py_XDECREF(cls); } #endif Py_CLEAR(m->defaults_tuple); Py_CLEAR(m->defaults_kwdict); Py_CLEAR(m->func_annotations); #if __PYX_LIMITED_VERSION_HEX < 0x030B0000 Py_CLEAR(m->func_is_coroutine); #endif Py_CLEAR(m->defaults); return 0; } static int __Pyx_CyFunction_clear(PyObject *m) { return __Pyx__CyFunction_clear(__Pyx_as_CyFunctionObject(m)); } static void __Pyx__CyFunction_dealloc(PyObject *m) { __pyx_CyFunctionObject *cyfunc = __Pyx_as_CyFunctionObject(m); if (__Pyx_CyFunction_weakreflist(cyfunc) != NULL) PyObject_ClearWeakRefs(m); __Pyx__CyFunction_clear(cyfunc); __Pyx_PyHeapTypeObject_GC_Del(m); } static void __Pyx_CyFunction_dealloc(PyObject *m) { PyObject_GC_UnTrack(m); __Pyx__CyFunction_dealloc(m); } static int __Pyx_CyFunction_traverse(PyObject *m_in, visitproc visit, void *arg) { __pyx_CyFunctionObject *m = __Pyx_as_CyFunctionObject(m_in); { int e = __Pyx_call_type_traverse(m_in, 1, visit, arg); if (e) return e; } Py_VISIT(m->func_closure); #if CYTHON_COMPILING_IN_LIMITED_API Py_VISIT(m->func_module); #else Py_VISIT(((PyCFunctionObject*)m)->m_module); #endif #if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API Py_VISIT(m->func_dict); #else { int e = #if PY_VERSION_HEX < 0x030d0000 _PyObject_VisitManagedDict #else PyObject_VisitManagedDict #endif ((PyObject*)m, visit, arg); if (e != 0) return e; } #endif __Pyx_VISIT_CONST(m->func_name); __Pyx_VISIT_CONST(m->func_qualname); Py_VISIT(m->func_doc); Py_VISIT(m->func_globals); __Pyx_VISIT_CONST(m->func_code); Py_VISIT(__Pyx__CyFunction_GetClassObj(m)); Py_VISIT(m->defaults_tuple); Py_VISIT(m->defaults_kwdict); Py_VISIT(m->func_annotations); #if __PYX_LIMITED_VERSION_HEX < 0x030B0000 Py_VISIT(m->func_is_coroutine); #endif Py_VISIT(m->defaults); return 0; } static PyObject* __Pyx_CyFunction_repr(PyObject *op_in) { __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); PyObject *repr; __Pyx_BEGIN_CRITICAL_SECTION(op_in); repr = PyUnicode_FromFormat("", op->func_qualname, (void *)op); __Pyx_END_CRITICAL_SECTION(); return repr; } static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { #if CYTHON_COMPILING_IN_LIMITED_API __pyx_CyFunctionObject *cyfunc = __Pyx_as_CyFunctionObject(func); PyCFunction meth = cyfunc->func_methoddef->ml_meth; int flags = cyfunc->func_methoddef->ml_flags; #else PyCFunctionObject* f = (PyCFunctionObject*)func; PyCFunction meth = f->m_ml->ml_meth; int flags = f->m_ml->ml_flags; #endif Py_ssize_t size; switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { case METH_VARARGS: if (likely(kw == NULL || PyDict_Size(kw) == 0)) return (*meth)(self, arg); break; case METH_VARARGS | METH_KEYWORDS: return (*(PyCFunctionWithKeywords)(void(*)(void))meth)(self, arg, kw); case METH_NOARGS: if (likely(kw == NULL || PyDict_Size(kw) == 0)) { #if CYTHON_ASSUME_SAFE_SIZE size = PyTuple_GET_SIZE(arg); #else size = PyTuple_Size(arg); if (unlikely(size < 0)) return NULL; #endif if (likely(size == 0)) return (*meth)(self, NULL); __Pyx_CyFunction_raise_argument_count_error( func, "takes no arguments", size); return NULL; } break; case METH_O: if (likely(kw == NULL || PyDict_Size(kw) == 0)) { #if CYTHON_ASSUME_SAFE_SIZE size = PyTuple_GET_SIZE(arg); #else size = PyTuple_Size(arg); if (unlikely(size < 0)) return NULL; #endif if (likely(size == 1)) { PyObject *result, *arg0; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS arg0 = PyTuple_GET_ITEM(arg, 0); #else arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL; #endif result = (*meth)(self, arg0); #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) Py_DECREF(arg0); #endif return result; } __Pyx_CyFunction_raise_argument_count_error( func, "takes exactly one argument", size); return NULL; } break; default: PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); return NULL; } __Pyx_CyFunction_raise_type_error( func, "takes no keyword arguments"); return NULL; } static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *result; result = __Pyx_CyFunction_CallMethod(func, func, arg, kw); return result; } static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { PyObject *result; __pyx_CyFunctionObject *cyfunc = __Pyx_as_CyFunctionObject(func); #if CYTHON_VECTORCALL __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); if (vc) { #if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw); #else (void) &__Pyx_PyVectorcall_FastCallDict; return PyVectorcall_Call(func, args, kw); #endif } #endif if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { Py_ssize_t argc; PyObject *new_args; PyObject *self; #if CYTHON_ASSUME_SAFE_SIZE argc = PyTuple_GET_SIZE(args); #else argc = PyTuple_Size(args); if (unlikely(argc < 0)) return NULL; #endif new_args = PyTuple_GetSlice(args, 1, argc); if (unlikely(!new_args)) return NULL; self = PyTuple_GetItem(args, 0); if (unlikely(!self)) { Py_DECREF(new_args); PyErr_Format(PyExc_TypeError, "unbound method %.200S() needs an argument", cyfunc->func_qualname); return NULL; } result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); Py_DECREF(new_args); } else { result = __Pyx_CyFunction_Call(func, args, kw); } return result; } #if CYTHON_VECTORCALL static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(PyObject *func, __pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames) { int ret = 0; if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { if (unlikely(nargs < 1)) { __Pyx_CyFunction_raise_type_error( func, "needs an argument"); return -1; } ret = 1; } if (unlikely(kwnames) && unlikely(__Pyx_PyTuple_GET_SIZE(kwnames))) { __Pyx_CyFunction_raise_type_error( func, "takes no keyword arguments"); return -1; } return ret; } static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) { __pyx_CyFunctionObject *cyfunc = __Pyx_as_CyFunctionObject(func); Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); PyObject *self; #if CYTHON_COMPILING_IN_LIMITED_API PyCFunction meth = cyfunc->func_methoddef->ml_meth; if (unlikely(!meth)) return NULL; #else PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; #endif switch (__Pyx_CyFunction_Vectorcall_CheckArgs(func, cyfunc, nargs, kwnames)) { case 1: self = args[0]; args += 1; nargs -= 1; break; case 0: self = func; break; default: return NULL; } if (unlikely(nargs != 0)) { __Pyx_CyFunction_raise_argument_count_error( func, "takes no arguments", nargs); return NULL; } return meth(self, NULL); } static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) { __pyx_CyFunctionObject *cyfunc = __Pyx_as_CyFunctionObject(func); Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); PyObject *self; #if CYTHON_COMPILING_IN_LIMITED_API PyCFunction meth = cyfunc->func_methoddef->ml_meth; if (unlikely(!meth)) return NULL; #else PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; #endif switch (__Pyx_CyFunction_Vectorcall_CheckArgs(func, cyfunc, nargs, kwnames)) { case 1: self = args[0]; args += 1; nargs -= 1; break; case 0: self = func; break; default: return NULL; } if (unlikely(nargs != 1)) { __Pyx_CyFunction_raise_argument_count_error( func, "takes exactly one argument", nargs); return NULL; } return meth(self, args[0]); } static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) { __pyx_CyFunctionObject *cyfunc = __Pyx_as_CyFunctionObject(func); Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); PyObject *self; #if CYTHON_COMPILING_IN_LIMITED_API PyCFunction meth = cyfunc->func_methoddef->ml_meth; if (unlikely(!meth)) return NULL; #else PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; #endif switch (__Pyx_CyFunction_Vectorcall_CheckArgs(func, cyfunc, nargs, NULL)) { case 1: self = args[0]; args += 1; nargs -= 1; break; case 0: self = func; break; default: return NULL; } return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))meth)(self, args, nargs, kwnames); } static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) { __pyx_CyFunctionObject *cyfunc = __Pyx_as_CyFunctionObject(func); PyTypeObject *cls = (PyTypeObject *) __Pyx__CyFunction_GetClassObj(cyfunc); Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); PyObject *self; #if CYTHON_COMPILING_IN_LIMITED_API PyCFunction meth = cyfunc->func_methoddef->ml_meth; if (unlikely(!meth)) return NULL; #else PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; #endif switch (__Pyx_CyFunction_Vectorcall_CheckArgs(func, cyfunc, nargs, NULL)) { case 1: self = args[0]; args += 1; nargs -= 1; break; case 0: self = func; break; default: return NULL; } #if PY_VERSION_HEX < 0x030e00A6 size_t nargs_value = (size_t) nargs; #else Py_ssize_t nargs_value = nargs; #endif return ((__Pyx_PyCMethod)(void(*)(void))meth)(self, cls, args, nargs_value, kwnames); } #endif static PyType_Slot __pyx_CyFunctionType_slots[] = { {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc}, {Py_tp_repr, (void *)__Pyx_CyFunction_repr}, {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod}, {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse}, {Py_tp_clear, (void *)__Pyx_CyFunction_clear}, {Py_tp_methods, (void *)__pyx_CyFunction_methods}, {Py_tp_members, (void *)__pyx_CyFunction_members}, {Py_tp_getset, (void *)__pyx_CyFunction_getsets}, {Py_tp_descr_get, (void *)__Pyx_PyMethod_New}, {0, 0}, }; static PyType_Spec __pyx_CyFunctionType_spec = { __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", __PYX_SHARED_SIZEOF(__pyx_CyFunctionObject), 0, #ifdef Py_TPFLAGS_METHOD_DESCRIPTOR Py_TPFLAGS_METHOD_DESCRIPTOR | #endif #if CYTHON_VECTORCALL #if defined(Py_TPFLAGS_HAVE_VECTORCALL) Py_TPFLAGS_HAVE_VECTORCALL | #elif defined(_Py_TPFLAGS_HAVE_VECTORCALL) _Py_TPFLAGS_HAVE_VECTORCALL | #endif #endif // CYTHON_VECTORCALL #if PY_VERSION_HEX >= 0x030C0000 && !CYTHON_COMPILING_IN_LIMITED_API Py_TPFLAGS_MANAGED_DICT | #endif Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION | Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, __pyx_CyFunctionType_slots }; static int __pyx_CyFunction_init(PyObject *module) { __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module); mstate->__pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec( mstate->__pyx_CommonTypesMetaclassType, module, &__pyx_CyFunctionType_spec, NULL); if (unlikely(mstate->__pyx_CyFunctionType == NULL)) { return -1; } return 0; } /* CythonFunction */ static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { (void)&__Pyx_Get_CyFunction_Type; PyObject *op = __Pyx_CyFunction_Init( PyObject_GC_New(PyObject, __pyx_mstate_global->__pyx_CyFunctionType), ml, flags, qualname, closure, module, globals, code ); if (likely(op)) { PyObject_GC_Track(op); } return op; } static PyTypeObject *__Pyx_Get_CyFunction_Type(void) { PyTypeObject *tp = __pyx_mstate_global->__pyx_CyFunctionType; Py_INCREF((PyObject*)tp); return tp; } /* CLineInTraceback (used by AddTraceback) */ #if CYTHON_CLINE_IN_TRACEBACK && CYTHON_CLINE_IN_TRACEBACK_RUNTIME #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 #define __Pyx_PyProbablyModule_GetDict(o) __Pyx_XNewRef(PyModule_GetDict(o)) #elif !CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_CPYTHON_FREETHREADING #define __Pyx_PyProbablyModule_GetDict(o) PyObject_GenericGetDict(o, NULL); #else PyObject* __Pyx_PyProbablyModule_GetDict(PyObject *o) { PyObject **dict_ptr = _PyObject_GetDictPtr(o); return dict_ptr ? __Pyx_XNewRef(*dict_ptr) : NULL; } #endif static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { PyObject *use_cline = NULL; PyObject *ptype, *pvalue, *ptraceback; PyObject *cython_runtime_dict; CYTHON_MAYBE_UNUSED_VAR(tstate); if (unlikely(!__pyx_mstate_global->__pyx_cython_runtime)) { return c_line; } __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); cython_runtime_dict = __Pyx_PyProbablyModule_GetDict(__pyx_mstate_global->__pyx_cython_runtime); if (likely(cython_runtime_dict)) { __PYX_PY_DICT_LOOKUP_IF_MODIFIED( use_cline, cython_runtime_dict, __Pyx_PyDict_SetDefault(cython_runtime_dict, __pyx_mstate_global->__pyx_n_u_cline_in_traceback, Py_False)) } if (use_cline == NULL || use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { c_line = 0; } Py_XDECREF(use_cline); Py_XDECREF(cython_runtime_dict); __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); return c_line; } #endif /* CodeObjectCache (used by AddTraceback) */ 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 __Pyx_CachedCodeObjectType *__pyx__find_code_object(struct __Pyx_CodeObjectCache *code_cache, int code_line) { __Pyx_CachedCodeObjectType* code_object; int pos; if (unlikely(!code_line) || unlikely(!code_cache->entries)) { return NULL; } pos = __pyx_bisect_code_objects(code_cache->entries, code_cache->count, code_line); if (unlikely(pos >= code_cache->count) || unlikely(code_cache->entries[pos].code_line != code_line)) { return NULL; } code_object = code_cache->entries[pos].code_object; Py_INCREF(code_object); return code_object; } static __Pyx_CachedCodeObjectType *__pyx_find_code_object(int code_line) { #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && !CYTHON_ATOMICS (void)__pyx__find_code_object; return NULL; // Most implementation should have atomics. But otherwise, don't make it thread-safe, just miss. #else struct __Pyx_CodeObjectCache *code_cache = &__pyx_mstate_global->__pyx_code_cache; #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING __pyx_nonatomic_int_type old_count = __pyx_atomic_incr_acq_rel(&code_cache->accessor_count); if (old_count < 0) { __pyx_atomic_decr_acq_rel(&code_cache->accessor_count); return NULL; } #endif __Pyx_CachedCodeObjectType *result = __pyx__find_code_object(code_cache, code_line); #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING __pyx_atomic_decr_acq_rel(&code_cache->accessor_count); #endif return result; #endif } static void __pyx__insert_code_object(struct __Pyx_CodeObjectCache *code_cache, int code_line, __Pyx_CachedCodeObjectType* code_object) { int pos, i; __Pyx_CodeObjectCacheEntry* entries = code_cache->entries; if (unlikely(!code_line)) { return; } if (unlikely(!entries)) { entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); if (likely(entries)) { code_cache->entries = entries; code_cache->max_count = 64; code_cache->count = 1; entries[0].code_line = code_line; entries[0].code_object = code_object; Py_INCREF(code_object); } return; } pos = __pyx_bisect_code_objects(code_cache->entries, code_cache->count, code_line); if ((pos < code_cache->count) && unlikely(code_cache->entries[pos].code_line == code_line)) { __Pyx_CachedCodeObjectType* tmp = entries[pos].code_object; entries[pos].code_object = code_object; Py_INCREF(code_object); Py_DECREF(tmp); return; } if (code_cache->count == code_cache->max_count) { int new_max = code_cache->max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( code_cache->entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } code_cache->entries = entries; code_cache->max_count = new_max; } for (i=code_cache->count; i>pos; i--) { entries[i] = entries[i-1]; } entries[pos].code_line = code_line; entries[pos].code_object = code_object; code_cache->count++; Py_INCREF(code_object); } static void __pyx_insert_code_object(int code_line, __Pyx_CachedCodeObjectType* code_object) { #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && !CYTHON_ATOMICS (void)__pyx__insert_code_object; return; // Most implementation should have atomics. But otherwise, don't make it thread-safe, just fail. #else struct __Pyx_CodeObjectCache *code_cache = &__pyx_mstate_global->__pyx_code_cache; #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING __pyx_nonatomic_int_type expected = 0; if (!__pyx_atomic_int_cmp_exchange(&code_cache->accessor_count, &expected, INT_MIN)) { return; } #endif __pyx__insert_code_object(code_cache, code_line, code_object); #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING __pyx_atomic_sub(&code_cache->accessor_count, INT_MIN); #endif #endif } /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" #if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API && !defined(PYPY_VERSION) #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif #if CYTHON_COMPILING_IN_LIMITED_API static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict, PyObject *firstlineno, PyObject *name) { PyObject *replace = NULL; if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL; if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL; replace = PyObject_GetAttrString(code, "replace"); if (likely(replace)) { PyObject *result = PyObject_Call(replace, __pyx_mstate_global->__pyx_empty_tuple, scratch_dict); Py_DECREF(replace); return result; } return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL; PyObject *replace = NULL, *getframe = NULL, *frame = NULL; PyObject *exc_type, *exc_value, *exc_traceback; int success = 0; if (c_line) { c_line = __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); } __Pyx_PyErr_FetchException(&exc_type, &exc_value, &exc_traceback); code_object = __pyx_find_code_object(c_line ? -c_line : py_line); if (!code_object) { code_object = Py_CompileString("_getframe()", filename, Py_eval_input); if (unlikely(!code_object)) goto bad; py_py_line = PyLong_FromLong(py_line); if (unlikely(!py_py_line)) goto bad; if (c_line) { py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); } else { py_funcname = PyUnicode_FromString(funcname); } if (unlikely(!py_funcname)) goto bad; dict = PyDict_New(); if (unlikely(!dict)) goto bad; { PyObject *old_code_object = code_object; code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname); Py_DECREF(old_code_object); } if (unlikely(!code_object)) goto bad; __pyx_insert_code_object(c_line ? -c_line : py_line, code_object); } else { dict = PyDict_New(); } getframe = PySys_GetObject("_getframe"); if (unlikely(!getframe)) goto bad; if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad; frame = PyEval_EvalCode(code_object, dict, dict); if (unlikely(!frame) || frame == Py_None) goto bad; success = 1; bad: __Pyx_PyErr_RestoreException(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 (c_line) { 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; } py_code = PyCode_NewEmpty(filename, funcname, py_line); Py_XDECREF(py_funcname); return py_code; bad: Py_XDECREF(py_funcname); return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyFrameObject *py_frame = 0; PyThreadState *tstate = __Pyx_PyThreadState_Current; 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_mstate_global->__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 int __Pyx_LargePyLong___Pyx_PyLong_As_int(PyObject *x); static int __Pyx_raise_neg_overflow___Pyx_PyLong_As_int(void) { const char* type_name = "int"; PyErr_Format(PyExc_OverflowError, "can't convert negative value to %.200s", type_name); return (int) -1; } static int __Pyx_raise_overflow___Pyx_PyLong_As_int(void) { const char* type_name = "int"; PyErr_Format(PyExc_OverflowError, "value too large to convert to %.200s", type_name); return (int) -1; } static CYTHON_INLINE int __Pyx_PyULong___Pyx_PyLong_As_int(PyObject *x) { const int is_unsigned = 1; #if CYTHON_USE_PYLONG_INTERNALS { const digit* digits = __Pyx_PyLong_Digits(x); const Py_ssize_t size = __Pyx_PyLong_DigitCount(x); if (size == 2 && (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])); } } else if (size == 3 && (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])); } } else if (size == 4 && (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])); } } else {} } #elif 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)) } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) } return __Pyx_LargePyLong___Pyx_PyLong_As_int(x); raise_neg_overflow: return __Pyx_raise_neg_overflow___Pyx_PyLong_As_int(); raise_overflow: return __Pyx_raise_overflow___Pyx_PyLong_As_int(); } static CYTHON_INLINE int __Pyx_PySLong___Pyx_PyLong_As_int(PyObject *x) { const int is_unsigned = 0; #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsNeg(x)) { const Py_ssize_t size = __Pyx_PyLong_DigitCount(x); const digit* digits = __Pyx_PyLong_Digits(x); if (size == 2 && (8 * sizeof(int) > 1 * PyLong_SHIFT)) { if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { long ival = - (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); __PYX_VERIFY_RETURN_INT(int, long, ival) } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { return (int) (((int) -1) * (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } else if (size == 3 && (8 * sizeof(int) > 2 * PyLong_SHIFT)) { if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { long ival = - (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); __PYX_VERIFY_RETURN_INT(int, long, ival) } 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]))); } } else if (size == 4 && (8 * sizeof(int) > 3 * PyLong_SHIFT)) { if ((8 * sizeof(long) > 4 * PyLong_SHIFT)) { long ival = - (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); __PYX_VERIFY_RETURN_INT(int, long, ival) } 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]))); } } else {} } else { const Py_ssize_t size = __Pyx_PyLong_DigitCount(x); const digit* digits = __Pyx_PyLong_Digits(x); if (size == 2 && (8 * sizeof(int) > 1 * PyLong_SHIFT)) { if ((8 * sizeof(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])); } } else if (size == 3 && (8 * sizeof(int) > 2 * PyLong_SHIFT)) { if ((8 * sizeof(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])); } } else if (size == 4 && (8 * sizeof(int) > 3 * PyLong_SHIFT)) { if ((8 * sizeof(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])); } } else {} } #endif #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 if ((sizeof(int) <= sizeof(int)) && (sizeof(int) < sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(int, int, PyLong_AsInt(x)) } else #endif if ((sizeof(int) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) } return __Pyx_LargePyLong___Pyx_PyLong_As_int(x); raise_neg_overflow: return __Pyx_raise_neg_overflow___Pyx_PyLong_As_int(); raise_overflow: return __Pyx_raise_overflow___Pyx_PyLong_As_int(); } static int __Pyx_LargePyLong___Pyx_PyLong_As_int(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const int neg_one = (int) -1, const_zero = (int) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; int val; int ret = -1; #if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API Py_ssize_t bytes_copied = PyLong_AsNativeBytes( x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); if (unlikely(bytes_copied == -1)) { } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { goto raise_overflow; } else { ret = 0; } #elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; ret = _PyLong_AsByteArray((PyLongObject *)x, bytes, sizeof(val), is_little, !is_unsigned); if ((0)) goto raise_overflow; #else PyObject *v; PyObject *stepval = NULL, *mask = NULL, *shift = NULL; int bits, remaining_bits, is_negative = 0; int chunk_size = (sizeof(long) < 8) ? 30 : 62; if (likely(PyLong_CheckExact(x))) { v = __Pyx_NewRef(x); } else { v = PyNumber_Long(x); if (unlikely(!v)) return (int) -1; assert(PyLong_CheckExact(v)); } { int result = PyObject_RichCompareBool(v, Py_False, Py_LT); if (unlikely(result < 0)) { Py_DECREF(v); return (int) -1; } is_negative = result == 1; } if (is_unsigned && unlikely(is_negative)) { Py_DECREF(v); PyErr_SetString(PyExc_OverflowError, "can't convert negative value to int"); return (int) -1; } else if (is_negative) { stepval = PyNumber_Invert(v); Py_DECREF(v); if (unlikely(!stepval)) return (int) -1; } else { stepval = v; } v = NULL; val = (int) 0; mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) { PyObject *tmp, *digit; long idigit; digit = PyNumber_And(stepval, mask); if (unlikely(!digit)) goto done; idigit = PyLong_AsLong(digit); Py_DECREF(digit); if (unlikely(idigit < 0)) goto done; val |= ((int) idigit) << bits; tmp = PyNumber_Rshift(stepval, shift); if (unlikely(!tmp)) goto done; Py_DECREF(stepval); stepval = tmp; } Py_DECREF(shift); shift = NULL; Py_DECREF(mask); mask = NULL; { long idigit = PyLong_AsLong(stepval); if (unlikely(idigit < 0)) goto done; remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); if (unlikely(idigit >= (1L << remaining_bits))) goto raise_overflow; val |= ((int) idigit) << bits; } if (!is_unsigned) { if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1)))) goto raise_overflow; if (is_negative) val = ~val; } ret = 0; done: Py_XDECREF(shift); Py_XDECREF(mask); Py_XDECREF(stepval); #endif if (unlikely(ret)) return (int) -1; return val; raise_overflow: return __Pyx_raise_overflow___Pyx_PyLong_As_int(); } static CYTHON_INLINE int __Pyx_PyLong___Pyx_PyLong_As_int(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const int neg_one = (int) -1, const_zero = (int) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (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 #endif { return __Pyx_PyULong___Pyx_PyLong_As_int(x); } } else { #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) } else #endif { return __Pyx_PySLong___Pyx_PyLong_As_int(x); } } #if CYTHON_USE_PYLONG_INTERNALS raise_neg_overflow: return __Pyx_raise_neg_overflow___Pyx_PyLong_As_int(); raise_overflow: return __Pyx_raise_overflow___Pyx_PyLong_As_int(); #endif } static int __Pyx_NonPyLong___Pyx_PyLong_As_int(PyObject *x) { int val; PyObject *tmp = __Pyx_PyNumber_Long(x); if (!tmp) return (int) -1; val = __Pyx_PyLong_As_int(tmp); Py_DECREF(tmp); return val; } static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *x) { if (likely(PyLong_Check(x))) { return __Pyx_PyLong___Pyx_PyLong_As_int(x); } else { return __Pyx_NonPyLong___Pyx_PyLong_As_int(x); } } /* CIntFromPy */ static size_t __Pyx_LargePyLong___Pyx_PyLong_As_size_t(PyObject *x); static size_t __Pyx_raise_neg_overflow___Pyx_PyLong_As_size_t(void) { const char* type_name = "size_t"; PyErr_Format(PyExc_OverflowError, "can't convert negative value to %.200s", type_name); return (size_t) -1; } static size_t __Pyx_raise_overflow___Pyx_PyLong_As_size_t(void) { const char* type_name = "size_t"; PyErr_Format(PyExc_OverflowError, "value too large to convert to %.200s", type_name); return (size_t) -1; } static CYTHON_INLINE size_t __Pyx_PyULong___Pyx_PyLong_As_size_t(PyObject *x) { const int is_unsigned = 1; #if CYTHON_USE_PYLONG_INTERNALS { const digit* digits = __Pyx_PyLong_Digits(x); const Py_ssize_t size = __Pyx_PyLong_DigitCount(x); if (size == 2 && (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])); } } else if (size == 3 && (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])); } } else if (size == 4 && (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])); } } else {} } #elif 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)) } else if ((sizeof(size_t) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) } return __Pyx_LargePyLong___Pyx_PyLong_As_size_t(x); raise_neg_overflow: return __Pyx_raise_neg_overflow___Pyx_PyLong_As_size_t(); raise_overflow: return __Pyx_raise_overflow___Pyx_PyLong_As_size_t(); } static CYTHON_INLINE size_t __Pyx_PySLong___Pyx_PyLong_As_size_t(PyObject *x) { const int is_unsigned = 0; #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsNeg(x)) { const Py_ssize_t size = __Pyx_PyLong_DigitCount(x); const digit* digits = __Pyx_PyLong_Digits(x); if (size == 2 && (8 * sizeof(size_t) > 1 * PyLong_SHIFT)) { if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { long ival = - (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); __PYX_VERIFY_RETURN_INT(size_t, long, ival) } 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]))); } } else if (size == 3 && (8 * sizeof(size_t) > 2 * PyLong_SHIFT)) { if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { long ival = - (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); __PYX_VERIFY_RETURN_INT(size_t, long, ival) } 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]))); } } else if (size == 4 && (8 * sizeof(size_t) > 3 * PyLong_SHIFT)) { if ((8 * sizeof(long) > 4 * PyLong_SHIFT)) { long ival = - (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); __PYX_VERIFY_RETURN_INT(size_t, long, ival) } 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]))); } } else {} } else { const Py_ssize_t size = __Pyx_PyLong_DigitCount(x); const digit* digits = __Pyx_PyLong_Digits(x); if (size == 2 && (8 * sizeof(size_t) > 1 * PyLong_SHIFT)) { if ((8 * sizeof(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])); } } else if (size == 3 && (8 * sizeof(size_t) > 2 * PyLong_SHIFT)) { if ((8 * sizeof(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])); } } else if (size == 4 && (8 * sizeof(size_t) > 3 * PyLong_SHIFT)) { if ((8 * sizeof(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])); } } else {} } #endif #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 if ((sizeof(size_t) <= sizeof(int)) && (sizeof(int) < sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(size_t, int, PyLong_AsInt(x)) } else #endif if ((sizeof(size_t) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(size_t, long, PyLong_AsLong(x)) } else if ((sizeof(size_t) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(size_t, PY_LONG_LONG, PyLong_AsLongLong(x)) } return __Pyx_LargePyLong___Pyx_PyLong_As_size_t(x); raise_neg_overflow: return __Pyx_raise_neg_overflow___Pyx_PyLong_As_size_t(); raise_overflow: return __Pyx_raise_overflow___Pyx_PyLong_As_size_t(); } static size_t __Pyx_LargePyLong___Pyx_PyLong_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; size_t val; int ret = -1; #if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API Py_ssize_t bytes_copied = PyLong_AsNativeBytes( x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); if (unlikely(bytes_copied == -1)) { } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { goto raise_overflow; } else { ret = 0; } #elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; ret = _PyLong_AsByteArray((PyLongObject *)x, bytes, sizeof(val), is_little, !is_unsigned); if ((0)) goto raise_overflow; #else PyObject *v; PyObject *stepval = NULL, *mask = NULL, *shift = NULL; int bits, remaining_bits, is_negative = 0; int chunk_size = (sizeof(long) < 8) ? 30 : 62; if (likely(PyLong_CheckExact(x))) { v = __Pyx_NewRef(x); } else { v = PyNumber_Long(x); if (unlikely(!v)) return (size_t) -1; assert(PyLong_CheckExact(v)); } { int result = PyObject_RichCompareBool(v, Py_False, Py_LT); if (unlikely(result < 0)) { Py_DECREF(v); return (size_t) -1; } is_negative = result == 1; } if (is_unsigned && unlikely(is_negative)) { Py_DECREF(v); PyErr_SetString(PyExc_OverflowError, "can't convert negative value to size_t"); return (size_t) -1; } else if (is_negative) { stepval = PyNumber_Invert(v); Py_DECREF(v); if (unlikely(!stepval)) return (size_t) -1; } else { stepval = v; } v = NULL; 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; long idigit; digit = PyNumber_And(stepval, mask); if (unlikely(!digit)) goto done; idigit = PyLong_AsLong(digit); Py_DECREF(digit); if (unlikely(idigit < 0)) goto done; val |= ((size_t) idigit) << bits; tmp = PyNumber_Rshift(stepval, shift); if (unlikely(!tmp)) goto done; Py_DECREF(stepval); stepval = tmp; } Py_DECREF(shift); shift = NULL; Py_DECREF(mask); mask = NULL; { long idigit = PyLong_AsLong(stepval); if (unlikely(idigit < 0)) goto done; remaining_bits = ((int) sizeof(size_t) * 8) - bits - (is_unsigned ? 0 : 1); if (unlikely(idigit >= (1L << remaining_bits))) goto raise_overflow; val |= ((size_t) idigit) << bits; } 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 if (unlikely(ret)) return (size_t) -1; return val; raise_overflow: return __Pyx_raise_overflow___Pyx_PyLong_As_size_t(); } static CYTHON_INLINE size_t __Pyx_PyLong___Pyx_PyLong_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 (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 #endif { return __Pyx_PyULong___Pyx_PyLong_As_size_t(x); } } 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 #endif { return __Pyx_PySLong___Pyx_PyLong_As_size_t(x); } } #if CYTHON_USE_PYLONG_INTERNALS raise_neg_overflow: return __Pyx_raise_neg_overflow___Pyx_PyLong_As_size_t(); raise_overflow: return __Pyx_raise_overflow___Pyx_PyLong_As_size_t(); #endif } static size_t __Pyx_NonPyLong___Pyx_PyLong_As_size_t(PyObject *x) { size_t val; PyObject *tmp = __Pyx_PyNumber_Long(x); if (!tmp) return (size_t) -1; val = __Pyx_PyLong_As_size_t(tmp); Py_DECREF(tmp); return val; } static CYTHON_INLINE size_t __Pyx_PyLong_As_size_t(PyObject *x) { if (likely(PyLong_Check(x))) { return __Pyx_PyLong___Pyx_PyLong_As_size_t(x); } else { return __Pyx_NonPyLong___Pyx_PyLong_As_size_t(x); } } /* PyObjectVectorcallKwds (used by PyObjectVectorcallMethodKwds) */ #if CYTHON_VECTORCALL CYTHON_UNUSED static int __Pyx_CheckVectorcallKwarg(PyObject *kwnames, Py_ssize_t i) { PyObject *key = __Pyx_PyTuple_GET_ITEM(kwnames, i); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely(!key)) return -1; #endif if (unlikely(!PyUnicode_Check(key))) { PyErr_SetString(PyExc_TypeError, "keywords must be strings"); return -1; } return 0; } #else CYTHON_UNUSED static PyObject *__Pyx_MakeKwargDict(PyObject **keys, PyObject **values, Py_ssize_t n) { PyObject *out = PyDict_New(); if (unlikely(!out)) return NULL; for (Py_ssize_t i=0; i const_zero; if (is_unsigned) { if (sizeof(int) < sizeof(long)) { return PyLong_FromLong((long) value); } else if (sizeof(int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #if !CYTHON_COMPILING_IN_PYPY } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(int) <= sizeof(long)) { return PyLong_FromLong((long) value); } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); } } { unsigned char *bytes = (unsigned char *)&value; #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 if (is_unsigned) { return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); } else { return PyLong_FromNativeBytes(bytes, sizeof(value), -1); } #elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 int one = 1; int little = (int)*(unsigned char *)&one; return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); #else int one = 1; int little = (int)*(unsigned char *)&one; PyObject *result = NULL, *kwds = NULL; PyObject *py_bytes = NULL, *order_str = NULL, *from_bytes_str = NULL;; py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int)); if (!py_bytes) goto limited_bad; from_bytes_str = PyUnicode_FromStringAndSize("from_bytes", 10); if (!from_bytes_str) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; { PyObject *args[] = { (PyObject*)&PyLong_Type, py_bytes, order_str, Py_True }; if (!is_unsigned) { PyObject *signed_str = PyUnicode_FromStringAndSize("signed", 6); if (!signed_str) goto limited_bad; #if CYTHON_VECTORCALL kwds = PyTuple_Pack(1, signed_str); #else { PyObject *keys[] = {signed_str}; PyObject *values[] = {Py_True}; kwds = __Pyx_MakeKwargDict(keys, values, 1); } #endif Py_DECREF(signed_str); if (unlikely(!kwds)) goto limited_bad; } result = __Pyx_Object_VectorcallMethodKwds(from_bytes_str, args, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); } limited_bad: Py_XDECREF(kwds); Py_XDECREF(order_str); Py_XDECREF(py_bytes); Py_XDECREF(from_bytes_str); return result; #endif } } /* CIntFromPy */ static uint32_t __Pyx_LargePyLong___Pyx_PyLong_As_uint32_t(PyObject *x); static uint32_t __Pyx_raise_neg_overflow___Pyx_PyLong_As_uint32_t(void) { const char* type_name = "uint32_t"; PyErr_Format(PyExc_OverflowError, "can't convert negative value to %.200s", type_name); return (uint32_t) -1; } static uint32_t __Pyx_raise_overflow___Pyx_PyLong_As_uint32_t(void) { const char* type_name = "uint32_t"; PyErr_Format(PyExc_OverflowError, "value too large to convert to %.200s", type_name); return (uint32_t) -1; } static CYTHON_INLINE uint32_t __Pyx_PyULong___Pyx_PyLong_As_uint32_t(PyObject *x) { const int is_unsigned = 1; #if CYTHON_USE_PYLONG_INTERNALS { const digit* digits = __Pyx_PyLong_Digits(x); const Py_ssize_t size = __Pyx_PyLong_DigitCount(x); if (size == 2 && (8 * sizeof(uint32_t) > 1 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(uint32_t) >= 2 * PyLong_SHIFT)) { return (uint32_t) (((((uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0])); } } else if (size == 3 && (8 * sizeof(uint32_t) > 2 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(uint32_t) >= 3 * PyLong_SHIFT)) { return (uint32_t) (((((((uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0])); } } else if (size == 4 && (8 * sizeof(uint32_t) > 3 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(uint32_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(uint32_t) >= 4 * PyLong_SHIFT)) { return (uint32_t) (((((((((uint32_t)digits[3]) << PyLong_SHIFT) | (uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0])); } } else {} } #elif 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 (uint32_t) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if ((sizeof(uint32_t) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(uint32_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if ((sizeof(uint32_t) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(uint32_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) } return __Pyx_LargePyLong___Pyx_PyLong_As_uint32_t(x); raise_neg_overflow: return __Pyx_raise_neg_overflow___Pyx_PyLong_As_uint32_t(); raise_overflow: return __Pyx_raise_overflow___Pyx_PyLong_As_uint32_t(); } static CYTHON_INLINE uint32_t __Pyx_PySLong___Pyx_PyLong_As_uint32_t(PyObject *x) { const int is_unsigned = 0; #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsNeg(x)) { const Py_ssize_t size = __Pyx_PyLong_DigitCount(x); const digit* digits = __Pyx_PyLong_Digits(x); if (size == 2 && (8 * sizeof(uint32_t) > 1 * PyLong_SHIFT)) { if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { long ival = - (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); __PYX_VERIFY_RETURN_INT(uint32_t, long, ival) } else if ((8 * sizeof(uint32_t) - 1 > 2 * PyLong_SHIFT)) { return (uint32_t) (((uint32_t) -1) * (((((uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); } } else if (size == 3 && (8 * sizeof(uint32_t) > 2 * PyLong_SHIFT)) { if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { long ival = - (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); __PYX_VERIFY_RETURN_INT(uint32_t, long, ival) } else if ((8 * sizeof(uint32_t) - 1 > 3 * PyLong_SHIFT)) { return (uint32_t) (((uint32_t) -1) * (((((((uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); } } else if (size == 4 && (8 * sizeof(uint32_t) > 3 * PyLong_SHIFT)) { if ((8 * sizeof(long) > 4 * PyLong_SHIFT)) { long ival = - (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); __PYX_VERIFY_RETURN_INT(uint32_t, long, ival) } else if ((8 * sizeof(uint32_t) - 1 > 4 * PyLong_SHIFT)) { return (uint32_t) (((uint32_t) -1) * (((((((((uint32_t)digits[3]) << PyLong_SHIFT) | (uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); } } else {} } else { const Py_ssize_t size = __Pyx_PyLong_DigitCount(x); const digit* digits = __Pyx_PyLong_Digits(x); if (size == 2 && (8 * sizeof(uint32_t) > 1 * PyLong_SHIFT)) { if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(uint32_t) - 1 > 2 * PyLong_SHIFT)) { return (uint32_t) (((((uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0])); } } else if (size == 3 && (8 * sizeof(uint32_t) > 2 * PyLong_SHIFT)) { if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(uint32_t) - 1 > 3 * PyLong_SHIFT)) { return (uint32_t) (((((((uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0])); } } else if (size == 4 && (8 * sizeof(uint32_t) > 3 * PyLong_SHIFT)) { if ((8 * sizeof(long) > 4 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(uint32_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(uint32_t) - 1 > 4 * PyLong_SHIFT)) { return (uint32_t) (((((((((uint32_t)digits[3]) << PyLong_SHIFT) | (uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0])); } } else {} } #endif #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 if ((sizeof(uint32_t) <= sizeof(int)) && (sizeof(int) < sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(uint32_t, int, PyLong_AsInt(x)) } else #endif if ((sizeof(uint32_t) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(uint32_t, long, PyLong_AsLong(x)) } else if ((sizeof(uint32_t) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(uint32_t, PY_LONG_LONG, PyLong_AsLongLong(x)) } return __Pyx_LargePyLong___Pyx_PyLong_As_uint32_t(x); raise_neg_overflow: return __Pyx_raise_neg_overflow___Pyx_PyLong_As_uint32_t(); raise_overflow: return __Pyx_raise_overflow___Pyx_PyLong_As_uint32_t(); } static uint32_t __Pyx_LargePyLong___Pyx_PyLong_As_uint32_t(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const uint32_t neg_one = (uint32_t) -1, const_zero = (uint32_t) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; uint32_t val; int ret = -1; #if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API Py_ssize_t bytes_copied = PyLong_AsNativeBytes( x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); if (unlikely(bytes_copied == -1)) { } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { goto raise_overflow; } else { ret = 0; } #elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; ret = _PyLong_AsByteArray((PyLongObject *)x, bytes, sizeof(val), is_little, !is_unsigned); if ((0)) goto raise_overflow; #else PyObject *v; PyObject *stepval = NULL, *mask = NULL, *shift = NULL; int bits, remaining_bits, is_negative = 0; int chunk_size = (sizeof(long) < 8) ? 30 : 62; if (likely(PyLong_CheckExact(x))) { v = __Pyx_NewRef(x); } else { v = PyNumber_Long(x); if (unlikely(!v)) return (uint32_t) -1; assert(PyLong_CheckExact(v)); } { int result = PyObject_RichCompareBool(v, Py_False, Py_LT); if (unlikely(result < 0)) { Py_DECREF(v); return (uint32_t) -1; } is_negative = result == 1; } if (is_unsigned && unlikely(is_negative)) { Py_DECREF(v); PyErr_SetString(PyExc_OverflowError, "can't convert negative value to uint32_t"); return (uint32_t) -1; } else if (is_negative) { stepval = PyNumber_Invert(v); Py_DECREF(v); if (unlikely(!stepval)) return (uint32_t) -1; } else { stepval = v; } v = NULL; val = (uint32_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(uint32_t) * 8 - chunk_size; bits += chunk_size) { PyObject *tmp, *digit; long idigit; digit = PyNumber_And(stepval, mask); if (unlikely(!digit)) goto done; idigit = PyLong_AsLong(digit); Py_DECREF(digit); if (unlikely(idigit < 0)) goto done; val |= ((uint32_t) idigit) << bits; tmp = PyNumber_Rshift(stepval, shift); if (unlikely(!tmp)) goto done; Py_DECREF(stepval); stepval = tmp; } Py_DECREF(shift); shift = NULL; Py_DECREF(mask); mask = NULL; { long idigit = PyLong_AsLong(stepval); if (unlikely(idigit < 0)) goto done; remaining_bits = ((int) sizeof(uint32_t) * 8) - bits - (is_unsigned ? 0 : 1); if (unlikely(idigit >= (1L << remaining_bits))) goto raise_overflow; val |= ((uint32_t) idigit) << bits; } if (!is_unsigned) { if (unlikely(val & (((uint32_t) 1) << (sizeof(uint32_t) * 8 - 1)))) goto raise_overflow; if (is_negative) val = ~val; } ret = 0; done: Py_XDECREF(shift); Py_XDECREF(mask); Py_XDECREF(stepval); #endif if (unlikely(ret)) return (uint32_t) -1; return val; raise_overflow: return __Pyx_raise_overflow___Pyx_PyLong_As_uint32_t(); } static CYTHON_INLINE uint32_t __Pyx_PyLong___Pyx_PyLong_As_uint32_t(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const uint32_t neg_one = (uint32_t) -1, const_zero = (uint32_t) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; 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(uint32_t, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) } else #endif { return __Pyx_PyULong___Pyx_PyLong_As_uint32_t(x); } } else { #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(uint32_t, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) } else #endif { return __Pyx_PySLong___Pyx_PyLong_As_uint32_t(x); } } #if CYTHON_USE_PYLONG_INTERNALS raise_neg_overflow: return __Pyx_raise_neg_overflow___Pyx_PyLong_As_uint32_t(); raise_overflow: return __Pyx_raise_overflow___Pyx_PyLong_As_uint32_t(); #endif } static uint32_t __Pyx_NonPyLong___Pyx_PyLong_As_uint32_t(PyObject *x) { uint32_t val; PyObject *tmp = __Pyx_PyNumber_Long(x); if (!tmp) return (uint32_t) -1; val = __Pyx_PyLong_As_uint32_t(tmp); Py_DECREF(tmp); return val; } static CYTHON_INLINE uint32_t __Pyx_PyLong_As_uint32_t(PyObject *x) { if (likely(PyLong_Check(x))) { return __Pyx_PyLong___Pyx_PyLong_As_uint32_t(x); } else { return __Pyx_NonPyLong___Pyx_PyLong_As_uint32_t(x); } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_uint32_t(uint32_t value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const uint32_t neg_one = (uint32_t) -1, const_zero = (uint32_t) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(uint32_t) < sizeof(long)) { return PyLong_FromLong((long) value); } else if (sizeof(uint32_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #if !CYTHON_COMPILING_IN_PYPY } else if (sizeof(uint32_t) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(uint32_t) <= sizeof(long)) { return PyLong_FromLong((long) value); } else if (sizeof(uint32_t) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); } } { unsigned char *bytes = (unsigned char *)&value; #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 if (is_unsigned) { return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); } else { return PyLong_FromNativeBytes(bytes, sizeof(value), -1); } #elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 int one = 1; int little = (int)*(unsigned char *)&one; return _PyLong_FromByteArray(bytes, sizeof(uint32_t), little, !is_unsigned); #else int one = 1; int little = (int)*(unsigned char *)&one; PyObject *result = NULL, *kwds = NULL; PyObject *py_bytes = NULL, *order_str = NULL, *from_bytes_str = NULL;; py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(uint32_t)); if (!py_bytes) goto limited_bad; from_bytes_str = PyUnicode_FromStringAndSize("from_bytes", 10); if (!from_bytes_str) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; { PyObject *args[] = { (PyObject*)&PyLong_Type, py_bytes, order_str, Py_True }; if (!is_unsigned) { PyObject *signed_str = PyUnicode_FromStringAndSize("signed", 6); if (!signed_str) goto limited_bad; #if CYTHON_VECTORCALL kwds = PyTuple_Pack(1, signed_str); #else { PyObject *keys[] = {signed_str}; PyObject *values[] = {Py_True}; kwds = __Pyx_MakeKwargDict(keys, values, 1); } #endif Py_DECREF(signed_str); if (unlikely(!kwds)) goto limited_bad; } result = __Pyx_Object_VectorcallMethodKwds(from_bytes_str, args, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); } limited_bad: Py_XDECREF(kwds); Py_XDECREF(order_str); Py_XDECREF(py_bytes); Py_XDECREF(from_bytes_str); return result; #endif } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const long neg_one = (long) -1, const_zero = (long) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { return PyLong_FromLong((long) value); } else if (sizeof(long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #if !CYTHON_COMPILING_IN_PYPY } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(long) <= sizeof(long)) { return PyLong_FromLong((long) value); } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); } } { unsigned char *bytes = (unsigned char *)&value; #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 if (is_unsigned) { return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); } else { return PyLong_FromNativeBytes(bytes, sizeof(value), -1); } #elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 int one = 1; int little = (int)*(unsigned char *)&one; return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); #else int one = 1; int little = (int)*(unsigned char *)&one; PyObject *result = NULL, *kwds = NULL; PyObject *py_bytes = NULL, *order_str = NULL, *from_bytes_str = NULL;; py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); if (!py_bytes) goto limited_bad; from_bytes_str = PyUnicode_FromStringAndSize("from_bytes", 10); if (!from_bytes_str) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; { PyObject *args[] = { (PyObject*)&PyLong_Type, py_bytes, order_str, Py_True }; if (!is_unsigned) { PyObject *signed_str = PyUnicode_FromStringAndSize("signed", 6); if (!signed_str) goto limited_bad; #if CYTHON_VECTORCALL kwds = PyTuple_Pack(1, signed_str); #else { PyObject *keys[] = {signed_str}; PyObject *values[] = {Py_True}; kwds = __Pyx_MakeKwargDict(keys, values, 1); } #endif Py_DECREF(signed_str); if (unlikely(!kwds)) goto limited_bad; } result = __Pyx_Object_VectorcallMethodKwds(from_bytes_str, args, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); } limited_bad: Py_XDECREF(kwds); Py_XDECREF(order_str); Py_XDECREF(py_bytes); Py_XDECREF(from_bytes_str); return result; #endif } } /* CIntFromPy */ static long __Pyx_LargePyLong___Pyx_PyLong_As_long(PyObject *x); static long __Pyx_raise_neg_overflow___Pyx_PyLong_As_long(void) { const char* type_name = "long"; PyErr_Format(PyExc_OverflowError, "can't convert negative value to %.200s", type_name); return (long) -1; } static long __Pyx_raise_overflow___Pyx_PyLong_As_long(void) { const char* type_name = "long"; PyErr_Format(PyExc_OverflowError, "value too large to convert to %.200s", type_name); return (long) -1; } static CYTHON_INLINE long __Pyx_PyULong___Pyx_PyLong_As_long(PyObject *x) { const int is_unsigned = 1; #if CYTHON_USE_PYLONG_INTERNALS { const digit* digits = __Pyx_PyLong_Digits(x); const Py_ssize_t size = __Pyx_PyLong_DigitCount(x); if (size == 2 && (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])); } } else if (size == 3 && (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])); } } else if (size == 4 && (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])); } } else {} } #elif 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)) } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) } return __Pyx_LargePyLong___Pyx_PyLong_As_long(x); raise_neg_overflow: return __Pyx_raise_neg_overflow___Pyx_PyLong_As_long(); raise_overflow: return __Pyx_raise_overflow___Pyx_PyLong_As_long(); } static CYTHON_INLINE long __Pyx_PySLong___Pyx_PyLong_As_long(PyObject *x) { const int is_unsigned = 0; #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsNeg(x)) { const Py_ssize_t size = __Pyx_PyLong_DigitCount(x); const digit* digits = __Pyx_PyLong_Digits(x); if (size == 2 && (8 * sizeof(long) > 1 * PyLong_SHIFT)) { if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { long ival = - (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); __PYX_VERIFY_RETURN_INT(long, long, ival) } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { return (long) (((long) -1) * (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } else if (size == 3 && (8 * sizeof(long) > 2 * PyLong_SHIFT)) { if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { long ival = - (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); __PYX_VERIFY_RETURN_INT(long, long, ival) } 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]))); } } else if (size == 4 && (8 * sizeof(long) > 3 * PyLong_SHIFT)) { if ((8 * sizeof(long) > 4 * PyLong_SHIFT)) { long ival = - (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); __PYX_VERIFY_RETURN_INT(long, long, ival) } 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]))); } } else {} } else { const Py_ssize_t size = __Pyx_PyLong_DigitCount(x); const digit* digits = __Pyx_PyLong_Digits(x); if (size == 2 && (8 * sizeof(long) > 1 * PyLong_SHIFT)) { if ((8 * sizeof(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])); } } else if (size == 3 && (8 * sizeof(long) > 2 * PyLong_SHIFT)) { if ((8 * sizeof(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])); } } else if (size == 4 && (8 * sizeof(long) > 3 * PyLong_SHIFT)) { if ((8 * sizeof(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])); } } else {} } #endif #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 if ((sizeof(long) <= sizeof(int)) && (sizeof(int) < sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(long, int, PyLong_AsInt(x)) } else #endif if ((sizeof(long) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) } return __Pyx_LargePyLong___Pyx_PyLong_As_long(x); raise_neg_overflow: return __Pyx_raise_neg_overflow___Pyx_PyLong_As_long(); raise_overflow: return __Pyx_raise_overflow___Pyx_PyLong_As_long(); } static long __Pyx_LargePyLong___Pyx_PyLong_As_long(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const long neg_one = (long) -1, const_zero = (long) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; long val; int ret = -1; #if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API Py_ssize_t bytes_copied = PyLong_AsNativeBytes( x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); if (unlikely(bytes_copied == -1)) { } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { goto raise_overflow; } else { ret = 0; } #elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; ret = _PyLong_AsByteArray((PyLongObject *)x, bytes, sizeof(val), is_little, !is_unsigned); if ((0)) goto raise_overflow; #else PyObject *v; PyObject *stepval = NULL, *mask = NULL, *shift = NULL; int bits, remaining_bits, is_negative = 0; int chunk_size = (sizeof(long) < 8) ? 30 : 62; if (likely(PyLong_CheckExact(x))) { v = __Pyx_NewRef(x); } else { v = PyNumber_Long(x); if (unlikely(!v)) return (long) -1; assert(PyLong_CheckExact(v)); } { int result = PyObject_RichCompareBool(v, Py_False, Py_LT); if (unlikely(result < 0)) { Py_DECREF(v); return (long) -1; } is_negative = result == 1; } if (is_unsigned && unlikely(is_negative)) { Py_DECREF(v); PyErr_SetString(PyExc_OverflowError, "can't convert negative value to long"); return (long) -1; } else if (is_negative) { stepval = PyNumber_Invert(v); Py_DECREF(v); if (unlikely(!stepval)) return (long) -1; } else { stepval = v; } v = NULL; val = (long) 0; mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) { PyObject *tmp, *digit; long idigit; digit = PyNumber_And(stepval, mask); if (unlikely(!digit)) goto done; idigit = PyLong_AsLong(digit); Py_DECREF(digit); if (unlikely(idigit < 0)) goto done; val |= ((long) idigit) << bits; tmp = PyNumber_Rshift(stepval, shift); if (unlikely(!tmp)) goto done; Py_DECREF(stepval); stepval = tmp; } Py_DECREF(shift); shift = NULL; Py_DECREF(mask); mask = NULL; { long idigit = PyLong_AsLong(stepval); if (unlikely(idigit < 0)) goto done; remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); if (unlikely(idigit >= (1L << remaining_bits))) goto raise_overflow; val |= ((long) idigit) << bits; } if (!is_unsigned) { if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1)))) goto raise_overflow; if (is_negative) val = ~val; } ret = 0; done: Py_XDECREF(shift); Py_XDECREF(mask); Py_XDECREF(stepval); #endif if (unlikely(ret)) return (long) -1; return val; raise_overflow: return __Pyx_raise_overflow___Pyx_PyLong_As_long(); } static CYTHON_INLINE long __Pyx_PyLong___Pyx_PyLong_As_long(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const long neg_one = (long) -1, const_zero = (long) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (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 #endif { return __Pyx_PyULong___Pyx_PyLong_As_long(x); } } else { #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) } else #endif { return __Pyx_PySLong___Pyx_PyLong_As_long(x); } } #if CYTHON_USE_PYLONG_INTERNALS raise_neg_overflow: return __Pyx_raise_neg_overflow___Pyx_PyLong_As_long(); raise_overflow: return __Pyx_raise_overflow___Pyx_PyLong_As_long(); #endif } static long __Pyx_NonPyLong___Pyx_PyLong_As_long(PyObject *x) { long val; PyObject *tmp = __Pyx_PyNumber_Long(x); if (!tmp) return (long) -1; val = __Pyx_PyLong_As_long(tmp); Py_DECREF(tmp); return val; } static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *x) { if (likely(PyLong_Check(x))) { return __Pyx_PyLong___Pyx_PyLong_As_long(x); } else { return __Pyx_NonPyLong___Pyx_PyLong_As_long(x); } } /* GetRuntimeVersion */ #if __PYX_LIMITED_VERSION_HEX < 0x030b0000 void __Pyx_init_runtime_version(void) { if (__Pyx_cached_runtime_version == 0) { const char* rt_version = Py_GetVersion(); unsigned long version = 0; unsigned long factor = 0x01000000UL; unsigned int digit = 0; int i = 0; while (factor) { while ('0' <= rt_version[i] && rt_version[i] <= '9') { digit = digit * 10 + (unsigned int) (rt_version[i] - '0'); ++i; } version += factor * digit; if (rt_version[i] != '.') break; digit = 0; factor >>= 8; ++i; } __Pyx_cached_runtime_version = version; } } #endif static unsigned long __Pyx_get_runtime_version(void) { #if __PYX_LIMITED_VERSION_HEX >= 0x030b0000 return Py_Version & ~0xFFUL; #else return __Pyx_cached_runtime_version; #endif } /* SwapException (used by CoroutineBase) */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 _PyErr_StackItem *exc_info = tstate->exc_info; tmp_value = exc_info->exc_value; exc_info->exc_value = *value; if (tmp_value == NULL || tmp_value == Py_None) { Py_XDECREF(tmp_value); tmp_value = NULL; tmp_type = NULL; tmp_tb = NULL; } else { tmp_type = (PyObject*) Py_TYPE(tmp_value); Py_INCREF(tmp_type); #if CYTHON_COMPILING_IN_CPYTHON tmp_tb = ((PyBaseExceptionObject*) tmp_value)->traceback; Py_XINCREF(tmp_tb); #else tmp_tb = PyException_GetTraceback(tmp_value); #endif } #elif CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = *type; exc_info->exc_value = *value; exc_info->exc_traceback = *tb; #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = *type; tstate->exc_value = *value; tstate->exc_traceback = *tb; #endif *type = tmp_type; *value = tmp_value; *tb = tmp_tb; } #else static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); PyErr_SetExcInfo(*type, *value, *tb); *type = tmp_type; *value = tmp_value; *tb = tmp_tb; } #endif /* IterNextPlain (used by CoroutineBase) */ #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 static PyObject *__Pyx_GetBuiltinNext_LimitedAPI(void) { if (unlikely(!__pyx_mstate_global->__Pyx_GetBuiltinNext_LimitedAPI_cache)) __pyx_mstate_global->__Pyx_GetBuiltinNext_LimitedAPI_cache = __Pyx_GetBuiltinName(__pyx_mstate_global->__pyx_n_u_next); return __pyx_mstate_global->__Pyx_GetBuiltinNext_LimitedAPI_cache; } #endif static CYTHON_INLINE PyObject *__Pyx_PyIter_Next_Plain(PyObject *iterator) { #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 PyObject *result; PyObject *next = __Pyx_GetBuiltinNext_LimitedAPI(); if (unlikely(!next)) return NULL; result = PyObject_CallFunctionObjArgs(next, iterator, NULL); return result; #else (void)__Pyx_GetBuiltinName; // only for early limited API iternextfunc iternext = __Pyx_PyObject_GetIterNextFunc(iterator); assert(iternext); return iternext(iterator); #endif } /* PyObjectCallMethod1 (used by CoroutineBase) */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) { #if CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || !CYTHON_COMPILING_IN_LIMITED_API) PyObject *args[2] = {obj, arg}; return PyObject_VectorcallMethod(method_name, args, 2 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); #elif CYTHON_COMPILING_IN_LIMITED_API return PyObject_CallMethodObjArgs(obj, method_name, arg, NULL); #else return PyObject_CallMethodOneArg(obj, method_name, arg); #endif } /* PyObjectCallNoArg (used by CoroutineBase) */ 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); } /* ReturnWithStopIteration (used by CoroutineBase) */ static void __Pyx__ReturnWithStopIteration(PyObject* value, int async); static CYTHON_INLINE void __Pyx_ReturnWithStopIteration(PyObject* value, int async, int iternext) { if (value == Py_None) { if (async || !iternext) PyErr_SetNone(async ? PyExc_StopAsyncIteration : PyExc_StopIteration); return; } __Pyx__ReturnWithStopIteration(value, async); } static void __Pyx__ReturnWithStopIteration(PyObject* value, int async) { #if CYTHON_COMPILING_IN_CPYTHON __Pyx_PyThreadState_declare #endif PyObject *exc; PyObject *exc_type = async ? PyExc_StopAsyncIteration : PyExc_StopIteration; #if CYTHON_COMPILING_IN_CPYTHON if ((PY_VERSION_HEX >= (0x030C00A6)) || unlikely(PyTuple_Check(value) || PyExceptionInstance_Check(value))) { if (PY_VERSION_HEX >= (0x030e00A1)) { exc = __Pyx_PyObject_CallOneArg(exc_type, value); } else { PyObject *args_tuple = PyTuple_New(1); if (unlikely(!args_tuple)) return; Py_INCREF(value); PyTuple_SET_ITEM(args_tuple, 0, value); exc = PyObject_Call(exc_type, args_tuple, NULL); Py_DECREF(args_tuple); } if (unlikely(!exc)) return; } else { Py_INCREF(value); exc = value; } #if CYTHON_FAST_THREAD_STATE __Pyx_PyThreadState_assign #if CYTHON_USE_EXC_INFO_STACK if (!__pyx_tstate->exc_info->exc_value) #else if (!__pyx_tstate->exc_type) #endif { Py_INCREF(exc_type); __Pyx_ErrRestore(exc_type, exc, NULL); return; } #endif #else exc = __Pyx_PyObject_CallOneArg(exc_type, value); if (unlikely(!exc)) return; #endif PyErr_SetObject(exc_type, exc); Py_DECREF(exc); } /* CoroutineBase (used by Generator) */ #if !CYTHON_COMPILING_IN_LIMITED_API #include #if PY_VERSION_HEX >= 0x030b00a6 && !defined(PYPY_VERSION) #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif #endif // CYTHON_COMPILING_IN_LIMITED_API static CYTHON_INLINE void __Pyx_Coroutine_Undelegate(__pyx_CoroutineObject *gen) { #if CYTHON_USE_AM_SEND gen->yieldfrom_am_send = NULL; #endif Py_CLEAR(gen->yieldfrom); } static int __Pyx_PyGen__FetchStopIterationValue(PyThreadState *__pyx_tstate, PyObject **pvalue) { PyObject *et, *ev, *tb; PyObject *value = NULL; CYTHON_UNUSED_VAR(__pyx_tstate); __Pyx_ErrFetch(&et, &ev, &tb); if (!et) { Py_XDECREF(tb); Py_XDECREF(ev); Py_INCREF(Py_None); *pvalue = Py_None; return 0; } if (likely(et == PyExc_StopIteration)) { if (!ev) { Py_INCREF(Py_None); value = Py_None; } else if (likely(Py_IS_TYPE(ev, (PyTypeObject*)PyExc_StopIteration))) { #if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL value = PyObject_GetAttr(ev, __pyx_mstate_global->__pyx_n_u_value); if (unlikely(!value)) goto limited_api_failure; #else value = ((PyStopIterationObject *)ev)->value; Py_INCREF(value); #endif Py_DECREF(ev); } else if (unlikely(PyTuple_Check(ev))) { Py_ssize_t tuple_size = __Pyx_PyTuple_GET_SIZE(ev); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely(tuple_size < 0)) { Py_XDECREF(tb); Py_DECREF(ev); Py_DECREF(et); return -1; } #endif if (tuple_size >= 1) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS value = PyTuple_GET_ITEM(ev, 0); Py_INCREF(value); #elif CYTHON_ASSUME_SAFE_MACROS value = PySequence_ITEM(ev, 0); #else value = PySequence_GetItem(ev, 0); if (!value) goto limited_api_failure; #endif } else { Py_INCREF(Py_None); value = Py_None; } Py_DECREF(ev); } else if (!__Pyx_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration)) { value = ev; } if (likely(value)) { Py_XDECREF(tb); Py_DECREF(et); *pvalue = value; return 0; } } else if (!__Pyx_PyErr_GivenExceptionMatches(et, PyExc_StopIteration)) { __Pyx_ErrRestore(et, ev, tb); return -1; } PyErr_NormalizeException(&et, &ev, &tb); if (unlikely(!PyObject_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration))) { __Pyx_ErrRestore(et, ev, tb); return -1; } Py_XDECREF(tb); Py_DECREF(et); #if CYTHON_COMPILING_IN_LIMITED_API value = PyObject_GetAttr(ev, __pyx_mstate_global->__pyx_n_u_value); #else value = ((PyStopIterationObject *)ev)->value; Py_INCREF(value); #endif Py_DECREF(ev); #if CYTHON_COMPILING_IN_LIMITED_API if (unlikely(!value)) return -1; #endif *pvalue = value; return 0; #if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL || !CYTHON_ASSUME_SAFE_MACROS limited_api_failure: Py_XDECREF(et); Py_XDECREF(tb); Py_XDECREF(ev); return -1; #endif } static CYTHON_INLINE __Pyx_PySendResult __Pyx_Coroutine_status_from_result(PyObject **retval) { if (*retval) { return PYGEN_NEXT; } else if (likely(__Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, retval) == 0)) { return PYGEN_RETURN; } else { return PYGEN_ERROR; } } static CYTHON_INLINE void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *exc_state) { #if PY_VERSION_HEX >= 0x030B00a4 Py_CLEAR(exc_state->exc_value); #else PyObject *t, *v, *tb; t = exc_state->exc_type; v = exc_state->exc_value; tb = exc_state->exc_traceback; exc_state->exc_type = NULL; exc_state->exc_value = NULL; exc_state->exc_traceback = NULL; 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(__pyx_CoroutineObject *gen) { const char *msg; CYTHON_MAYBE_UNUSED_VAR(gen); if ((0)) { #ifdef __Pyx_Coroutine_USED } else if (__Pyx_Coroutine_Check((PyObject*)gen)) { msg = "coroutine already executing"; #endif #ifdef __Pyx_AsyncGen_USED } else if (__Pyx_AsyncGen_CheckExact((PyObject*)gen)) { msg = "async generator already executing"; #endif } else { msg = "generator already executing"; } PyErr_SetString(PyExc_ValueError, msg); } 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"); } else #endif if (value) { #ifdef __Pyx_AsyncGen_USED if (__Pyx_AsyncGen_CheckExact(gen)) PyErr_SetNone(PyExc_StopAsyncIteration); else #endif PyErr_SetNone(PyExc_StopIteration); } } static __Pyx_PySendResult __Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value, PyObject **result, int closing) { __Pyx_PyThreadState_declare PyThreadState *tstate; __Pyx_ExcInfoStruct *exc_state; PyObject *retval; assert(__Pyx_Coroutine_get_is_running(self)); // Callers should ensure is_running if (unlikely(self->resume_label == -1)) { __Pyx_Coroutine_AlreadyTerminatedError((PyObject*)self, value, closing); return PYGEN_ERROR; } #if CYTHON_FAST_THREAD_STATE __Pyx_PyThreadState_assign tstate = __pyx_tstate; #else tstate = __Pyx_PyThreadState_Current; #endif exc_state = &self->gi_exc_state; if (exc_state->exc_value) { #if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY #else PyObject *exc_tb; #if PY_VERSION_HEX >= 0x030B00a4 && !CYTHON_COMPILING_IN_CPYTHON exc_tb = PyException_GetTraceback(exc_state->exc_value); #elif PY_VERSION_HEX >= 0x030B00a4 exc_tb = ((PyBaseExceptionObject*) exc_state->exc_value)->traceback; #else exc_tb = exc_state->exc_traceback; #endif if (exc_tb) { PyTracebackObject *tb = (PyTracebackObject *) exc_tb; PyFrameObject *f = tb->tb_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 } #if CYTHON_USE_EXC_INFO_STACK exc_state->previous_item = tstate->exc_info; tstate->exc_info = exc_state; #else if (exc_state->exc_type) { __Pyx_ExceptionSwap(&exc_state->exc_type, &exc_state->exc_value, &exc_state->exc_traceback); } else { __Pyx_Coroutine_ExceptionClear(exc_state); __Pyx_ExceptionSave(&exc_state->exc_type, &exc_state->exc_value, &exc_state->exc_traceback); } #endif retval = self->body(self, tstate, value); #if CYTHON_USE_EXC_INFO_STACK exc_state = &self->gi_exc_state; tstate->exc_info = exc_state->previous_item; exc_state->previous_item = NULL; __Pyx_Coroutine_ResetFrameBackpointer(exc_state); #endif *result = retval; if (self->resume_label == -1) { return likely(retval) ? PYGEN_RETURN : PYGEN_ERROR; } return PYGEN_NEXT; } static CYTHON_INLINE void __Pyx_Coroutine_ResetFrameBackpointer(__Pyx_ExcInfoStruct *exc_state) { #if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API CYTHON_UNUSED_VAR(exc_state); #else PyObject *exc_tb; #if PY_VERSION_HEX >= 0x030B00a4 if (!exc_state->exc_value) return; exc_tb = PyException_GetTraceback(exc_state->exc_value); #else exc_tb = exc_state->exc_traceback; #endif if (likely(exc_tb)) { PyTracebackObject *tb = (PyTracebackObject *) exc_tb; PyFrameObject *f = tb->tb_frame; Py_CLEAR(f->f_back); #if PY_VERSION_HEX >= 0x030B00a4 Py_DECREF(exc_tb); #endif } #endif } #define __Pyx_Coroutine_MethodReturnFromResult(gen, result, retval, iternext)\ ((result) == PYGEN_NEXT ? (retval) : __Pyx__Coroutine_MethodReturnFromResult(gen, result, retval, iternext)) static PyObject * __Pyx__Coroutine_MethodReturnFromResult(PyObject* gen, __Pyx_PySendResult result, PyObject *retval, int iternext) { CYTHON_MAYBE_UNUSED_VAR(gen); if (likely(result == PYGEN_RETURN)) { int is_async = 0; #ifdef __Pyx_AsyncGen_USED is_async = __Pyx_AsyncGen_CheckExact(gen); #endif __Pyx_ReturnWithStopIteration(retval, is_async, iternext); Py_XDECREF(retval); } return NULL; } #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject *__Pyx_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 __Pyx_PySendResult __Pyx_Coroutine_FinishDelegation(__pyx_CoroutineObject *gen, PyObject** retval) { __Pyx_PySendResult result; PyObject *val = NULL; assert(__Pyx_Coroutine_get_is_running(gen)); __Pyx_Coroutine_Undelegate(gen); __Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, &val); result = __Pyx_Coroutine_SendEx(gen, val, retval, 0); Py_XDECREF(val); return result; } #if CYTHON_USE_AM_SEND static __Pyx_PySendResult __Pyx_Coroutine_SendToDelegate(__pyx_CoroutineObject *gen, __Pyx_pyiter_sendfunc gen_am_send, PyObject *value, PyObject **retval) { PyObject *ret = NULL; __Pyx_PySendResult delegate_result, result; assert(__Pyx_Coroutine_get_is_running(gen)); delegate_result = gen_am_send(gen->yieldfrom, value, &ret); if (delegate_result == PYGEN_NEXT) { assert (ret != NULL); *retval = ret; return PYGEN_NEXT; } assert (delegate_result != PYGEN_ERROR || ret == NULL); __Pyx_Coroutine_Undelegate(gen); result = __Pyx_Coroutine_SendEx(gen, ret, retval, 0); Py_XDECREF(ret); return result; } #endif static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value) { PyObject *retval = NULL; __Pyx_PySendResult result = __Pyx_Coroutine_AmSend(self, value, &retval); return __Pyx_Coroutine_MethodReturnFromResult(self, result, retval, 0); } static __Pyx_PySendResult __Pyx_Coroutine_AmSend(PyObject *self, PyObject *value, PyObject **retval) { __Pyx_PySendResult result; __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) { *retval = __Pyx_Coroutine_AlreadyRunningError(gen); return PYGEN_ERROR; } #if CYTHON_USE_AM_SEND if (gen->yieldfrom_am_send) { result = __Pyx_Coroutine_SendToDelegate(gen, gen->yieldfrom_am_send, value, retval); } else #endif if (gen->yieldfrom) { PyObject *yf = gen->yieldfrom; PyObject *ret; #if !CYTHON_USE_AM_SEND #ifdef __Pyx_Generator_USED if (__Pyx_Generator_CheckExact(yf)) { ret = __Pyx_Coroutine_Send(yf, value); } else #endif #ifdef __Pyx_Coroutine_USED if (__Pyx_Coroutine_Check(yf)) { ret = __Pyx_Coroutine_Send(yf, value); } else #endif #ifdef __Pyx_AsyncGen_USED if (__pyx_PyAsyncGenASend_CheckExact(yf)) { ret = __Pyx_async_gen_asend_send(yf, value); } else #endif #if CYTHON_COMPILING_IN_CPYTHON if (PyGen_CheckExact(yf)) { ret = __Pyx_PyGen_Send((PyGenObject*)yf, value == Py_None ? NULL : value); } else if (PyCoro_CheckExact(yf)) { ret = __Pyx_PyGen_Send((PyGenObject*)yf, value == Py_None ? NULL : value); } else #endif #endif { if (value == Py_None && PyIter_Check(yf)) ret = __Pyx_PyIter_Next_Plain(yf); else ret = __Pyx_PyObject_CallMethod1(yf, __pyx_mstate_global->__pyx_n_u_send, value); } if (likely(ret)) { __Pyx_Coroutine_unset_is_running(gen); *retval = ret; return PYGEN_NEXT; } result = __Pyx_Coroutine_FinishDelegation(gen, retval); } else { result = __Pyx_Coroutine_SendEx(gen, value, retval, 0); } __Pyx_Coroutine_unset_is_running(gen); return result; } static int __Pyx_Coroutine_CloseIter(__pyx_CoroutineObject *gen, PyObject *yf) { __Pyx_PySendResult result; PyObject *retval = NULL; CYTHON_UNUSED_VAR(gen); assert(__Pyx_Coroutine_get_is_running(gen)); #ifdef __Pyx_Generator_USED if (__Pyx_Generator_CheckExact(yf)) { result = __Pyx_Coroutine_Close(yf, &retval); } else #endif #ifdef __Pyx_Coroutine_USED if (__Pyx_Coroutine_Check(yf)) { result = __Pyx_Coroutine_Close(yf, &retval); } else if (__Pyx_CoroutineAwait_CheckExact(yf)) { result = __Pyx_CoroutineAwait_Close((__pyx_CoroutineAwaitObject*)yf); } else #endif #ifdef __Pyx_AsyncGen_USED if (__pyx_PyAsyncGenASend_CheckExact(yf)) { retval = __Pyx_async_gen_asend_close(yf, NULL); result = PYGEN_RETURN; } else if (__pyx_PyAsyncGenAThrow_CheckExact(yf)) { retval = __Pyx_async_gen_athrow_close(yf, NULL); result = PYGEN_RETURN; } else #endif { PyObject *meth; result = PYGEN_RETURN; meth = __Pyx_PyObject_GetAttrStrNoError(yf, __pyx_mstate_global->__pyx_n_u_close); if (unlikely(!meth)) { if (unlikely(PyErr_Occurred())) { PyErr_WriteUnraisable(yf); } } else { retval = __Pyx_PyObject_CallNoArg(meth); Py_DECREF(meth); if (unlikely(!retval)) { result = PYGEN_ERROR; } } } Py_XDECREF(retval); return result == PYGEN_ERROR ? -1 : 0; } static PyObject *__Pyx_Generator_Next(PyObject *self) { __Pyx_PySendResult result; PyObject *retval = NULL; __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) { return __Pyx_Coroutine_AlreadyRunningError(gen); } #if CYTHON_USE_AM_SEND if (gen->yieldfrom_am_send) { result = __Pyx_Coroutine_SendToDelegate(gen, gen->yieldfrom_am_send, Py_None, &retval); } else #endif if (gen->yieldfrom) { PyObject *yf = gen->yieldfrom; PyObject *ret; #ifdef __Pyx_Generator_USED if (__Pyx_Generator_CheckExact(yf)) { ret = __Pyx_Generator_Next(yf); } else #endif #ifdef __Pyx_Coroutine_USED if (__Pyx_Coroutine_CheckExact(yf)) { ret = __Pyx_Coroutine_Send(yf, Py_None); } else #endif #if CYTHON_COMPILING_IN_CPYTHON && (PY_VERSION_HEX < 0x030A00A3 || !CYTHON_USE_AM_SEND) if (PyGen_CheckExact(yf)) { ret = __Pyx_PyGen_Send((PyGenObject*)yf, NULL); } else #endif ret = __Pyx_PyIter_Next_Plain(yf); if (likely(ret)) { __Pyx_Coroutine_unset_is_running(gen); return ret; } result = __Pyx_Coroutine_FinishDelegation(gen, &retval); } else { result = __Pyx_Coroutine_SendEx(gen, Py_None, &retval, 0); } __Pyx_Coroutine_unset_is_running(gen); return __Pyx_Coroutine_MethodReturnFromResult(self, result, retval, 1); } static PyObject *__Pyx_Coroutine_Close_Method(PyObject *self, PyObject *arg) { PyObject *retval = NULL; __Pyx_PySendResult result; CYTHON_UNUSED_VAR(arg); result = __Pyx_Coroutine_Close(self, &retval); if (unlikely(result == PYGEN_ERROR)) return NULL; Py_XDECREF(retval); Py_RETURN_NONE; } static __Pyx_PySendResult __Pyx_Coroutine_Close(PyObject *self, PyObject **retval) { __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; __Pyx_PySendResult result; PyObject *yf; int err = 0; if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) { *retval = __Pyx_Coroutine_AlreadyRunningError(gen); return PYGEN_ERROR; } yf = gen->yieldfrom; if (yf) { Py_INCREF(yf); err = __Pyx_Coroutine_CloseIter(gen, yf); __Pyx_Coroutine_Undelegate(gen); Py_DECREF(yf); } if (err == 0) PyErr_SetNone(PyExc_GeneratorExit); result = __Pyx_Coroutine_SendEx(gen, NULL, retval, 1); if (result == PYGEN_ERROR) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_Coroutine_unset_is_running(gen); if (!__Pyx_PyErr_Occurred()) { return PYGEN_RETURN; } else if (likely(__Pyx_PyErr_ExceptionMatches2(PyExc_GeneratorExit, PyExc_StopIteration))) { __Pyx_PyErr_Clear(); return PYGEN_RETURN; } return PYGEN_ERROR; } else if (likely(result == PYGEN_RETURN && *retval == Py_None)) { __Pyx_Coroutine_unset_is_running(gen); return PYGEN_RETURN; } else { const char *msg; Py_DECREF(*retval); *retval = NULL; if ((0)) { #ifdef __Pyx_Coroutine_USED } else if (__Pyx_Coroutine_Check(self)) { msg = "coroutine ignored GeneratorExit"; #endif #ifdef __Pyx_AsyncGen_USED } else if (__Pyx_AsyncGen_CheckExact(self)) { msg = "async generator ignored GeneratorExit"; #endif } else { msg = "generator ignored GeneratorExit"; } PyErr_SetString(PyExc_RuntimeError, msg); __Pyx_Coroutine_unset_is_running(gen); return PYGEN_ERROR; } } static PyObject *__Pyx__Coroutine_Throw(PyObject *self, PyObject *typ, PyObject *val, PyObject *tb, PyObject *args, int close_on_genexit) { __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; PyObject *yf; if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) return __Pyx_Coroutine_AlreadyRunningError(gen); yf = gen->yieldfrom; if (yf) { __Pyx_PySendResult result; PyObject *ret; Py_INCREF(yf); if (__Pyx_PyErr_GivenExceptionMatches(typ, PyExc_GeneratorExit) && close_on_genexit) { int err = __Pyx_Coroutine_CloseIter(gen, yf); Py_DECREF(yf); __Pyx_Coroutine_Undelegate(gen); if (err < 0) goto propagate_exception; goto throw_here; } if (0 #ifdef __Pyx_Generator_USED || __Pyx_Generator_CheckExact(yf) #endif #ifdef __Pyx_Coroutine_USED || __Pyx_Coroutine_Check(yf) #endif ) { ret = __Pyx__Coroutine_Throw(yf, typ, val, tb, args, close_on_genexit); #ifdef __Pyx_Coroutine_USED } else if (__Pyx_CoroutineAwait_CheckExact(yf)) { ret = __Pyx__Coroutine_Throw(((__pyx_CoroutineAwaitObject*)yf)->coroutine, typ, val, tb, args, close_on_genexit); #endif } else { PyObject *meth = __Pyx_PyObject_GetAttrStrNoError(yf, __pyx_mstate_global->__pyx_n_u_throw); if (unlikely(!meth)) { Py_DECREF(yf); if (unlikely(PyErr_Occurred())) { __Pyx_Coroutine_unset_is_running(gen); return NULL; } __Pyx_Coroutine_Undelegate(gen); goto throw_here; } if (args) { ret = __Pyx_PyObject_Call(meth, args, NULL); } else { PyObject *cargs[4] = {NULL, typ, val, tb}; size_t nargs = 1U + (val != NULL) + (tb != NULL); ret = __Pyx_PyObject_FastCall(meth, cargs+1, nargs | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); } Py_DECREF(meth); } Py_DECREF(yf); if (ret) { __Pyx_Coroutine_unset_is_running(gen); return ret; } result = __Pyx_Coroutine_FinishDelegation(gen, &ret); __Pyx_Coroutine_unset_is_running(gen); return __Pyx_Coroutine_MethodReturnFromResult(self, result, ret, 0); } throw_here: __Pyx_Raise(typ, val, tb, NULL); propagate_exception: { PyObject *retval = NULL; __Pyx_PySendResult result = __Pyx_Coroutine_SendEx(gen, NULL, &retval, 0); __Pyx_Coroutine_unset_is_running(gen); return __Pyx_Coroutine_MethodReturnFromResult(self, result, retval, 0); } } static PyObject *__Pyx_Coroutine_Throw(PyObject *self, #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 PyObject *args #else PyObject *const *args, Py_ssize_t nargs #endif ) { PyObject *typ; PyObject *val = NULL; PyObject *tb = NULL; #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 if (unlikely(!PyArg_UnpackTuple(args, "throw", 1, 3, &typ, &val, &tb))) return NULL; #else switch (nargs) { case 3: tb = args[2]; CYTHON_FALLTHROUGH; case 2: val = args[1]; CYTHON_FALLTHROUGH; case 1: typ = args[0]; break; default: PyErr_SetString(PyExc_TypeError, "throw takes between 1 and 3 positional arguments"); return NULL; } #endif return __Pyx__Coroutine_Throw(self, typ, val, tb, #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 args, #else NULL, #endif 1); } static CYTHON_INLINE int __Pyx_Coroutine_traverse_excstate(__Pyx_ExcInfoStruct *exc_state, visitproc visit, void *arg) { #if PY_VERSION_HEX >= 0x030B00a4 Py_VISIT(exc_state->exc_value); #else Py_VISIT(exc_state->exc_type); Py_VISIT(exc_state->exc_value); Py_VISIT(exc_state->exc_traceback); #endif return 0; } static int __Pyx_Coroutine_traverse(__pyx_CoroutineObject *gen, visitproc visit, void *arg) { { int e = __Pyx_call_type_traverse((PyObject*)gen, 1, visit, arg); if (e) return e; } Py_VISIT(gen->closure); Py_VISIT(gen->classobj); Py_VISIT(gen->yieldfrom); return __Pyx_Coroutine_traverse_excstate(&gen->gi_exc_state, visit, arg); } static int __Pyx_Coroutine_clear(PyObject *self) { __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; Py_CLEAR(gen->closure); Py_CLEAR(gen->classobj); __Pyx_Coroutine_Undelegate(gen); __Pyx_Coroutine_ExceptionClear(&gen->gi_exc_state); #ifdef __Pyx_AsyncGen_USED if (__Pyx_AsyncGen_CheckExact(self)) { Py_CLEAR(((__pyx_PyAsyncGenObject*)gen)->ag_finalizer); } #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); return 0; } static void __Pyx_Coroutine_dealloc(PyObject *self) { __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; PyObject_GC_UnTrack(gen); #if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API if (gen->gi_weakreflist != NULL) #endif PyObject_ClearWeakRefs(self); if (gen->resume_label >= 0) { #if CYTHON_USE_TP_FINALIZE PyObject_GC_Track(self); if (unlikely(PyObject_CallFinalizerFromDealloc(self))) { return; } PyObject_GC_UnTrack(self); #endif } #ifdef __Pyx_AsyncGen_USED if (__Pyx_AsyncGen_CheckExact(self)) { /* We have to handle this case for asynchronous generators right here, because this code has to be between UNTRACK and GC_Del. */ Py_CLEAR(((__pyx_PyAsyncGenObject*)self)->ag_finalizer); } #endif __Pyx_Coroutine_clear(self); __Pyx_PyHeapTypeObject_GC_Del(gen); } #if CYTHON_USE_TP_FINALIZE static void __Pyx_Coroutine_del(PyObject *self) { PyObject *error_type, *error_value, *error_traceback; __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; __Pyx_PyThreadState_declare if (gen->resume_label < 0) { return; } __Pyx_PyThreadState_assign __Pyx_ErrFetch(&error_type, &error_value, &error_traceback); #ifdef __Pyx_AsyncGen_USED if (__Pyx_AsyncGen_CheckExact(self)) { __pyx_PyAsyncGenObject *agen = (__pyx_PyAsyncGenObject*)self; PyObject *finalizer = agen->ag_finalizer; if (finalizer && !agen->ag_closed) { PyObject *res = __Pyx_PyObject_CallOneArg(finalizer, self); if (unlikely(!res)) { PyErr_WriteUnraisable(self); } else { Py_DECREF(res); } __Pyx_ErrRestore(error_type, error_value, error_traceback); return; } } #endif if (unlikely(gen->resume_label == 0 && !error_value)) { #ifdef __Pyx_Coroutine_USED #ifdef __Pyx_Generator_USED if (!__Pyx_Generator_CheckExact(self)) #endif { PyObject_GC_UnTrack(self); if (unlikely(PyErr_WarnFormat(PyExc_RuntimeWarning, 1, "coroutine '%.50S' was never awaited", gen->gi_qualname) < 0)) PyErr_WriteUnraisable(self); PyObject_GC_Track(self); } #endif } else { PyObject *retval = NULL; __Pyx_PySendResult result = __Pyx_Coroutine_Close(self, &retval); if (result == PYGEN_ERROR) { PyErr_WriteUnraisable(self); } else { Py_XDECREF(retval); } } __Pyx_ErrRestore(error_type, error_value, error_traceback); } #endif static PyObject * __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, void *context) { CYTHON_UNUSED_VAR(context); if (unlikely(value == NULL || !PyUnicode_Check(value))) { PyErr_SetString(PyExc_TypeError, "__name__ must be set to a string object"); return -1; } Py_INCREF(value); __Pyx_Py_XDECREF_SET(self->gi_name, value); return 0; } static PyObject * __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, void *context) { CYTHON_UNUSED_VAR(context); if (unlikely(value == NULL || !PyUnicode_Check(value))) { PyErr_SetString(PyExc_TypeError, "__qualname__ must be set to a string object"); return -1; } Py_INCREF(value); __Pyx_Py_XDECREF_SET(self->gi_qualname, value); return 0; } #if !CYTHON_COMPILING_IN_LIMITED_API static PyObject * __Pyx__Coroutine_get_frame_locked(__pyx_CoroutineObject *self) { PyObject *frame; frame = self->gi_frame; if (!frame) { if (unlikely(!self->gi_code)) { Py_RETURN_NONE; } PyObject *globals = PyDict_New(); if (unlikely(!globals)) return NULL; frame = (PyObject *) PyFrame_New( PyThreadState_Get(), /*PyThreadState *tstate,*/ (PyCodeObject*) self->gi_code, /*PyCodeObject *code,*/ globals, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); Py_DECREF(globals); if (unlikely(!frame)) return NULL; if (unlikely(self->gi_frame)) { Py_DECREF(frame); frame = self->gi_frame; } else { self->gi_frame = frame; } } Py_INCREF(frame); return frame; } #endif static PyObject * __Pyx__Coroutine_get_frame(__pyx_CoroutineObject *self) { #if !CYTHON_COMPILING_IN_LIMITED_API PyObject *frame; __Pyx_BEGIN_CRITICAL_SECTION((PyObject*)self); frame = __Pyx__Coroutine_get_frame_locked(self); __Pyx_END_CRITICAL_SECTION(); return frame; #else CYTHON_UNUSED_VAR(self); Py_RETURN_NONE; #endif } static PyObject * __Pyx_Coroutine_get_frame(__pyx_CoroutineObject *self, void *context) { CYTHON_UNUSED_VAR(context); PyObject *frame = self->gi_frame; if (frame) return __Pyx_NewRef(frame); return __Pyx__Coroutine_get_frame(self); } static __pyx_CoroutineObject *__Pyx__Coroutine_New( PyTypeObject* type, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, PyObject *name, PyObject *qualname, PyObject *module_name) { __pyx_CoroutineObject *gen = PyObject_GC_New(__pyx_CoroutineObject, type); if (unlikely(!gen)) return NULL; return __Pyx__Coroutine_NewInit(gen, body, code, closure, name, qualname, module_name); } static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit( __pyx_CoroutineObject *gen, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, PyObject *name, PyObject *qualname, PyObject *module_name) { gen->body = body; gen->closure = closure; Py_XINCREF(closure); gen->is_running = 0; gen->resume_label = 0; gen->classobj = NULL; gen->yieldfrom = NULL; gen->yieldfrom_am_send = NULL; #if PY_VERSION_HEX >= 0x030B00a4 && !CYTHON_COMPILING_IN_LIMITED_API gen->gi_exc_state.exc_value = NULL; #else gen->gi_exc_state.exc_type = NULL; gen->gi_exc_state.exc_value = NULL; gen->gi_exc_state.exc_traceback = NULL; #endif #if CYTHON_USE_EXC_INFO_STACK gen->gi_exc_state.previous_item = NULL; #endif #if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API gen->gi_weakreflist = NULL; #endif Py_XINCREF(qualname); gen->gi_qualname = qualname; Py_XINCREF(name); gen->gi_name = name; Py_XINCREF(module_name); gen->gi_modulename = module_name; Py_XINCREF(code); gen->gi_code = code; gen->gi_frame = NULL; #if CYTHON_USE_SYS_MONITORING && (CYTHON_PROFILE || CYTHON_TRACE) memset(gen->__pyx_pymonitoring_state, 0, sizeof(gen->__pyx_pymonitoring_state)); gen->__pyx_pymonitoring_version = 0; #endif PyObject_GC_Track(gen); return gen; } static char __Pyx_Coroutine_test_and_set_is_running(__pyx_CoroutineObject *gen) { char result; __Pyx_BEGIN_CRITICAL_SECTION((PyObject*)gen); result = gen->is_running; gen->is_running = 1; __Pyx_END_CRITICAL_SECTION(); return result; } static void __Pyx_Coroutine_unset_is_running(__pyx_CoroutineObject *gen) { __Pyx_BEGIN_CRITICAL_SECTION((PyObject*)gen); assert(gen->is_running); gen->is_running = 0; __Pyx_END_CRITICAL_SECTION(); } static char __Pyx_Coroutine_get_is_running(__pyx_CoroutineObject *gen) { char result; __Pyx_BEGIN_CRITICAL_SECTION((PyObject*)gen); result = gen->is_running; __Pyx_END_CRITICAL_SECTION(); return result; } static PyObject *__Pyx_Coroutine_get_is_running_getter(PyObject *gen, void *closure) { CYTHON_UNUSED_VAR(closure); char result = __Pyx_Coroutine_get_is_running((__pyx_CoroutineObject*)gen); if (result) Py_RETURN_TRUE; else Py_RETURN_FALSE; } #if __PYX_HAS_PY_AM_SEND == 2 static void __Pyx_SetBackportTypeAmSend(PyTypeObject *type, __Pyx_PyAsyncMethodsStruct *static_amsend_methods, __Pyx_pyiter_sendfunc am_send) { Py_ssize_t ptr_offset = (char*)(type->tp_as_async) - (char*)type; if (ptr_offset < 0 || ptr_offset > type->tp_basicsize) { return; } memcpy((void*)static_amsend_methods, (void*)(type->tp_as_async), sizeof(*type->tp_as_async)); static_amsend_methods->am_send = am_send; type->tp_as_async = __Pyx_SlotTpAsAsync(static_amsend_methods); } #endif static PyObject *__Pyx_Coroutine_fail_reduce_ex(PyObject *self, PyObject *arg) { CYTHON_UNUSED_VAR(arg); __Pyx_RaiseTypeErrorWithObjectType( "cannot pickle '" __Pyx_FMT_TYPENAME "' object", self); return NULL; } /* Generator */ static PyMethodDef __pyx_Generator_methods[] = { {"send", (PyCFunction) __Pyx_Coroutine_Send, METH_O, PyDoc_STR("send(arg) -> send 'arg' into generator,\nreturn next yielded value or raise StopIteration.")}, {"throw", __PYX_REINTERPRET_FUNCION(PyCFunction, __Pyx_Coroutine_Throw), #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 METH_VARARGS, #else METH_FASTCALL, #endif PyDoc_STR("throw(typ[,val[,tb]]) -> raise exception in generator,\nreturn next yielded value or raise StopIteration.")}, {"close", (PyCFunction) __Pyx_Coroutine_Close_Method, METH_NOARGS, PyDoc_STR("close() -> raise GeneratorExit inside generator.")}, {"__reduce_ex__", (PyCFunction) __Pyx_Coroutine_fail_reduce_ex, METH_O, 0}, {"__reduce__", (PyCFunction) __Pyx_Coroutine_fail_reduce_ex, METH_NOARGS, 0}, {0, 0, 0, 0} }; static PyMemberDef __pyx_Generator_memberlist[] = { {"gi_yieldfrom", T_OBJECT, offsetof(__pyx_CoroutineObject, yieldfrom), READONLY, PyDoc_STR("object being iterated by 'yield from', or None")}, {"gi_code", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_code), READONLY, NULL}, {"__module__", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_modulename), 0, 0}, #if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API {"__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CoroutineObject, gi_weakreflist), READONLY, 0}, #endif {0, 0, 0, 0, 0} }; static PyGetSetDef __pyx_Generator_getsets[] = { {"__name__", (getter)__Pyx_Coroutine_get_name, (setter)__Pyx_Coroutine_set_name, PyDoc_STR("name of the generator"), 0}, {"__qualname__", (getter)__Pyx_Coroutine_get_qualname, (setter)__Pyx_Coroutine_set_qualname, PyDoc_STR("qualified name of the generator"), 0}, {"gi_frame", (getter)__Pyx_Coroutine_get_frame, NULL, PyDoc_STR("Frame of the generator"), 0}, {"gi_running", __Pyx_Coroutine_get_is_running_getter, NULL, NULL, NULL}, {0, 0, 0, 0, 0} }; static PyType_Slot __pyx_GeneratorType_slots[] = { {Py_tp_dealloc, (void *)__Pyx_Coroutine_dealloc}, {Py_tp_traverse, (void *)__Pyx_Coroutine_traverse}, {Py_tp_iter, (void *)PyObject_SelfIter}, {Py_tp_iternext, (void *)__Pyx_Generator_Next}, {Py_tp_methods, (void *)__pyx_Generator_methods}, {Py_tp_members, (void *)__pyx_Generator_memberlist}, {Py_tp_getset, (void *)__pyx_Generator_getsets}, {Py_tp_getattro, (void *) PyObject_GenericGetAttr}, #if CYTHON_USE_TP_FINALIZE {Py_tp_finalize, (void *)__Pyx_Coroutine_del}, #endif #if __PYX_HAS_PY_AM_SEND == 1 {Py_am_send, (void *)__Pyx_Coroutine_AmSend}, #endif {0, 0}, }; static PyType_Spec __pyx_GeneratorType_spec = { __PYX_TYPE_MODULE_PREFIX "generator", sizeof(__pyx_CoroutineObject), 0, #if PY_VERSION_HEX >= 0x030C0000 && !CYTHON_COMPILING_IN_LIMITED_API Py_TPFLAGS_MANAGED_WEAKREF | #endif Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION | Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | __Pyx_TPFLAGS_HAVE_AM_SEND, __pyx_GeneratorType_slots }; #if __PYX_HAS_PY_AM_SEND == 2 static __Pyx_PyAsyncMethodsStruct __pyx_Generator_as_async; #endif static int __pyx_Generator_init(PyObject *module) { __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module); mstate->__pyx_GeneratorType = __Pyx_FetchCommonTypeFromSpec( mstate->__pyx_CommonTypesMetaclassType, module, &__pyx_GeneratorType_spec, NULL); if (unlikely(!mstate->__pyx_GeneratorType)) { return -1; } #if __PYX_HAS_PY_AM_SEND == 2 __Pyx_SetBackportTypeAmSend(mstate->__pyx_GeneratorType, &__pyx_Generator_as_async, &__Pyx_Coroutine_AmSend); #endif return 0; } static PyObject *__Pyx_Generator_GetInlinedResult(PyObject *self) { __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; PyObject *retval = NULL; if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) { return __Pyx_Coroutine_AlreadyRunningError(gen); } __Pyx_PySendResult result = __Pyx_Coroutine_SendEx(gen, Py_None, &retval, 0); __Pyx_Coroutine_unset_is_running(gen); (void) result; assert (result == PYGEN_RETURN || result == PYGEN_ERROR); assert ((result == PYGEN_RETURN && retval != NULL) || (result == PYGEN_ERROR && retval == NULL)); return retval; } /* CheckBinaryVersion */ 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); } } /* NewCodeObj */ #if CYTHON_COMPILING_IN_LIMITED_API static PyObject* __Pyx__PyCode_New(int a, int p, int k, int l, int s, int f, PyObject *code, PyObject *c, PyObject* n, PyObject *v, PyObject *fv, PyObject *cell, PyObject* fn, PyObject *name, int fline, PyObject *lnos) { PyObject *exception_table = NULL; PyObject *types_module=NULL, *code_type=NULL, *result=NULL; #if __PYX_LIMITED_VERSION_HEX < 0x030b0000 PyObject *version_info; PyObject *py_minor_version = NULL; #endif long minor_version = 0; #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 <= 10) { result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOOO", 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, "iiiiiiOOOOOOOiOOOO", 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 (!result) { PyObject *exc_type, *exc_value, *exc_tb; PyErr_Fetch(&exc_type, &exc_value, &exc_tb); if (PyErr_WarnFormat( PyExc_RuntimeWarning, 1, "Code object creation failed in Cython module: %S\nTry recompiling with a more recent version of Cython.", exc_value ? exc_value : exc_type) == 0) { result = Py_None; Py_INCREF(result); } Py_DECREF(exc_type); Py_XDECREF(exc_value); Py_XDECREF(exc_tb); } return result; } #elif PY_VERSION_HEX >= 0x030B0000 static PyCodeObject* __Pyx__PyCode_New(int a, int p, int k, int l, int s, int f, PyObject *code, PyObject *c, PyObject* n, PyObject *v, PyObject *fv, PyObject *cell, PyObject* fn, PyObject *name, int fline, PyObject *lnos) { PyCodeObject *result; result = #if PY_VERSION_HEX >= 0x030C0000 PyUnstable_Code_NewWithPosOnlyArgs #else PyCode_NewWithPosOnlyArgs #endif (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, __pyx_mstate_global->__pyx_empty_bytes); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030c00A1 if (likely(result)) result->_co_firsttraceable = 0; #endif return result; } #elif !CYTHON_COMPILING_IN_PYPY #define __Pyx__PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else #define __Pyx__PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #endif static PyObject* __Pyx_PyCode_New( const __Pyx_PyCode_New_function_description descr, PyObject * const *varnames, PyObject *filename, PyObject *funcname, PyObject *line_table, PyObject *tuple_dedup_map ) { PyObject *code_obj = NULL, *varnames_tuple_dedup = NULL, *code_bytes = NULL; Py_ssize_t var_count = (Py_ssize_t) descr.nlocals; PyObject *varnames_tuple = PyTuple_New(var_count); if (unlikely(!varnames_tuple)) return NULL; for (Py_ssize_t i=0; i < var_count; i++) { Py_INCREF(varnames[i]); if (__Pyx_PyTuple_SET_ITEM(varnames_tuple, i, varnames[i]) != (0)) goto done; } #if CYTHON_COMPILING_IN_LIMITED_API varnames_tuple_dedup = PyDict_GetItem(tuple_dedup_map, varnames_tuple); if (!varnames_tuple_dedup) { if (unlikely(PyDict_SetItem(tuple_dedup_map, varnames_tuple, varnames_tuple) < 0)) goto done; varnames_tuple_dedup = varnames_tuple; } #else varnames_tuple_dedup = PyDict_SetDefault(tuple_dedup_map, varnames_tuple, varnames_tuple); if (unlikely(!varnames_tuple_dedup)) goto done; #endif #if CYTHON_AVOID_BORROWED_REFS Py_INCREF(varnames_tuple_dedup); #endif if (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table != NULL && !CYTHON_COMPILING_IN_GRAAL) { Py_ssize_t line_table_length = __Pyx_PyBytes_GET_SIZE(line_table); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely(line_table_length == -1)) goto done; #endif Py_ssize_t code_len = (line_table_length * 2 + 4) & ~3LL; code_bytes = PyBytes_FromStringAndSize(NULL, code_len); if (unlikely(!code_bytes)) goto done; char* c_code_bytes = PyBytes_AsString(code_bytes); if (unlikely(!c_code_bytes)) goto done; memset(c_code_bytes, 0, (size_t) code_len); } code_obj = (PyObject*) __Pyx__PyCode_New( (int) descr.argcount, (int) descr.num_posonly_args, (int) descr.num_kwonly_args, (int) descr.nlocals, 0, (int) descr.flags, code_bytes ? code_bytes : __pyx_mstate_global->__pyx_empty_bytes, __pyx_mstate_global->__pyx_empty_tuple, __pyx_mstate_global->__pyx_empty_tuple, varnames_tuple_dedup, __pyx_mstate_global->__pyx_empty_tuple, __pyx_mstate_global->__pyx_empty_tuple, filename, funcname, (int) descr.first_line, (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table) ? line_table : __pyx_mstate_global->__pyx_empty_bytes ); done: Py_XDECREF(code_bytes); #if CYTHON_AVOID_BORROWED_REFS Py_XDECREF(varnames_tuple_dedup); #endif Py_DECREF(varnames_tuple); return code_obj; } /* DecompressString */ CYTHON_UNUSED static CYTHON_SMALL_CODE PyObject *__Pyx_DecompressString(const char *s, Py_ssize_t length, int algo) { #ifdef __Pyx_DecompressString_UNUSED CYTHON_UNUSED_VAR(s); CYTHON_UNUSED_VAR(length); CYTHON_UNUSED_VAR(algo); return NULL; #else PyObject *module = NULL, *decompress, *compressed_bytes, *decompressed; const char* module_name = algo == 3 ? "compression.zstd" : algo == 2 ? "bz2" : "zlib"; PyObject *methodname = PyUnicode_FromString("decompress"); if (unlikely(!methodname)) return NULL; #if __PYX_LIMITED_VERSION_HEX >= 0x030e0000 if (algo == 3) { PyObject *fromlist = Py_BuildValue("[O]", methodname); if (unlikely(!fromlist)) goto bad; module = PyImport_ImportModuleLevel("compression.zstd", NULL, NULL, fromlist, 0); Py_DECREF(fromlist); } else #endif module = PyImport_ImportModule(module_name); if (unlikely(!module)) goto import_failed; decompress = PyObject_GetAttr(module, methodname); if (unlikely(!decompress)) goto import_failed; { #ifdef __cplusplus char *memview_bytes = const_cast(s); #else #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wcast-qual" #elif !defined(__INTEL_COMPILER) && defined(__GNUC__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wcast-qual" #endif char *memview_bytes = (char*) s; #if defined(__clang__) #pragma clang diagnostic pop #elif !defined(__INTEL_COMPILER) && defined(__GNUC__) #pragma GCC diagnostic pop #endif #endif #if CYTHON_COMPILING_IN_LIMITED_API && !defined(PyBUF_READ) int memview_flags = 0x100; #else int memview_flags = PyBUF_READ; #endif compressed_bytes = PyMemoryView_FromMemory(memview_bytes, length, memview_flags); } if (unlikely(!compressed_bytes)) { Py_DECREF(decompress); goto bad; } decompressed = PyObject_CallFunctionObjArgs(decompress, compressed_bytes, NULL); Py_DECREF(compressed_bytes); Py_DECREF(decompress); Py_DECREF(module); Py_DECREF(methodname); return decompressed; import_failed: PyErr_Format(PyExc_ImportError, "Failed to import '%.20s.decompress' - cannot initialise module strings. " "String compression was configured with the C macro 'CYTHON_COMPRESS_STRINGS=%d'.", module_name, algo); bad: Py_XDECREF(module); Py_DECREF(methodname); return NULL; #endif } /* DecompressString_LZSS */ #ifndef __Pyx_DecompressString_LZSS_UNUSED CYTHON_UNUSED static CYTHON_SMALL_CODE size_t __pyx_lzss_decompress(const uint8_t* src, uint8_t* dst, size_t dst_len) { size_t pos = 0, out_pos = 0; while (1) { uint32_t flags = src[pos++] | 0xFF00; while (flags & 0x100) { if (flags & 1) { dst[out_pos++] = src[pos++]; } else { uint32_t lo = src[pos++], hi = src[pos++]; uint32_t end_offset_of_last_occurrence, match_length; if (!(lo & 0x80)) { end_offset_of_last_occurrence = lo; match_length = hi; } else if (!(hi & 0x80)) { end_offset_of_last_occurrence = 0x80 + (((hi << 2) & 0x180) | (lo & 0x7F)); match_length = hi & 0x1F; } else { end_offset_of_last_occurrence = 0x80 + ((hi & 0x7F) << 7 | (lo & 0x7F)); match_length = src[pos++]; } match_length += 3; size_t ref_pos = out_pos - end_offset_of_last_occurrence - match_length; memcpy(dst + out_pos, dst + ref_pos, match_length); out_pos += match_length; } if (out_pos >= dst_len) return pos; flags >>= 1; } } } #endif static CYTHON_SMALL_CODE PyObject *__Pyx_DecompressString_LZSS(const char *s, size_t compressed_length, size_t uncompressed_length) { #ifdef __Pyx_DecompressString_LZSS_UNUSED CYTHON_UNUSED_VAR(s); CYTHON_UNUSED_VAR(compressed_length); CYTHON_UNUSED_VAR(uncompressed_length); return NULL; #else PyObject *result; unsigned char *result_data; size_t src_length; result = PyBytes_FromStringAndSize(NULL, (Py_ssize_t) uncompressed_length); if (unlikely(!result)) return NULL; result_data = __Pyx_PyBytes_AsWritableUString(result); if (unlikely(!result_data)) goto bad; src_length = __pyx_lzss_decompress((const uint8_t*) s, result_data, uncompressed_length); if (unlikely(src_length != compressed_length)) goto decompression_failed; return result; decompression_failed: PyErr_SetString(PyExc_RuntimeError, "LZSS string data decompression failed"); bad: Py_DECREF(result); return NULL; #endif } #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_UTF8 static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; #if CYTHON_COMPILING_IN_LIMITED_API { const char* result; Py_ssize_t unicode_length; CYTHON_MAYBE_UNUSED_VAR(unicode_length); // only for __PYX_DEFAULT_STRING_ENCODING_IS_ASCII #if __PYX_LIMITED_VERSION_HEX < 0x030A0000 if (unlikely(PyArg_Parse(o, "s#", &result, length) < 0)) return NULL; #else result = PyUnicode_AsUTF8AndSize(o, length); #endif #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII unicode_length = PyUnicode_GetLength(o); if (unlikely(unicode_length < 0)) return NULL; if (unlikely(unicode_length != *length)) { PyUnicode_AsASCIIString(o); return NULL; } #endif return result; } #else #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_UTF8 if (PyUnicode_Check(o)) { return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif if (PyByteArray_Check(o)) { #if (CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS) || (CYTHON_COMPILING_IN_PYPY && (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))) *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); #else *length = PyByteArray_Size(o); if (*length == -1) return NULL; return PyByteArray_AsString(o); #endif } else { 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_LongWrongResultType(PyObject* result) { __Pyx_TypeName result_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(result)); #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 if (unlikely(!result_type_name)) goto bad; #endif 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); goto bad; } __Pyx_DECREF_TypeName(result_type_name); return result; } PyErr_Format(PyExc_TypeError, "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ")", result_type_name); __Pyx_DECREF_TypeName(result_type_name); bad: Py_DECREF(result); return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyNumber_Long(PyObject* x) { #if CYTHON_USE_TYPE_SLOTS PyNumberMethods *m; #endif PyObject *res = NULL; if (likely(PyLong_Check(x))) return __Pyx_NewRef(x); #if CYTHON_USE_TYPE_SLOTS m = Py_TYPE(x)->tp_as_number; if (likely(m && m->nb_int)) { res = m->nb_int(x); } #else if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { res = PyNumber_Long(x); } #endif if (likely(res)) { if (unlikely(!PyLong_CheckExact(res))) { return __Pyx_PyNumber_LongWrongResultType(res); } } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, "an integer is required"); } return res; } static CYTHON_INLINE Py_ssize_t __Pyx_PyLong_AsSsize_t(PyObject* b) { #if CYTHON_USE_PYLONG_INTERNALS Py_ssize_t ival; const Py_ssize_t size = __Pyx_PyLong_DigitCount(b); const int is_neg = __Pyx_PyLong_IsNeg(b); const digit* digits = __Pyx_PyLong_Digits(b); if (size == 0) return 0; #if SIZEOF_SIZE_T * 8 > 1 * PyLong_SHIFT if (size == 1) { ival = (Py_ssize_t) (((size_t)digits[0])); } else #endif #if SIZEOF_SIZE_T * 8 > 2 * PyLong_SHIFT if (size == 2) { ival = (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } else #endif #if SIZEOF_SIZE_T * 8 > 3 * PyLong_SHIFT if (size == 3) { ival = (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } else #endif #if SIZEOF_SIZE_T * 8 > 4 * PyLong_SHIFT if (size == 4) { ival = (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])); } else #endif return PyLong_AsSsize_t(b); return is_neg ? -ival : ival; #else return PyLong_AsSsize_t(b); #endif } static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { if (likely(PyLong_Check(b))) { return __Pyx_PyLong_AsSsize_t(b); } else { Py_ssize_t ival; PyObject *x = PyNumber_Index(b); if (unlikely(!x)) return -1; ival = __Pyx_PyLong_AsSsize_t(x); Py_DECREF(x); return ival; } } static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o); } else { Py_ssize_t ival; PyObject *x; x = PyNumber_Index(o); if (!x) return -1; ival = PyLong_AsLong(x); Py_DECREF(x); return ival; } } static CYTHON_INLINE PyObject *__Pyx_Owned_Py_None(int b) { CYTHON_UNUSED_VAR(b); return __Pyx_NewRef(Py_None); } static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { return __Pyx_NewRef(b ? Py_True: Py_False); } static CYTHON_INLINE PyObject * __Pyx_PyLong_FromSize_t(size_t ival) { return PyLong_FromSize_t(ival); } /* MultiPhaseInitModuleState */ #if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE #ifndef CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE #if (CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX >= 0x030C0000) #define CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE 1 #else #define CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE 0 #endif #endif #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE && !CYTHON_ATOMICS #error "Module state with PEP489 requires atomics. Currently that's one of\ C11, C++11, gcc atomic intrinsics or MSVC atomic intrinsics" #endif #if !CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE #define __Pyx_ModuleStateLookup_Lock() #define __Pyx_ModuleStateLookup_Unlock() #elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d0000 static PyMutex __Pyx_ModuleStateLookup_mutex = {0}; #define __Pyx_ModuleStateLookup_Lock() PyMutex_Lock(&__Pyx_ModuleStateLookup_mutex) #define __Pyx_ModuleStateLookup_Unlock() PyMutex_Unlock(&__Pyx_ModuleStateLookup_mutex) #elif defined(__cplusplus) && __cplusplus >= 201103L #include static std::mutex __Pyx_ModuleStateLookup_mutex; #define __Pyx_ModuleStateLookup_Lock() __Pyx_ModuleStateLookup_mutex.lock() #define __Pyx_ModuleStateLookup_Unlock() __Pyx_ModuleStateLookup_mutex.unlock() #elif defined(__STDC_VERSION__) && (__STDC_VERSION__ > 201112L) && !defined(__STDC_NO_THREADS__) #include static mtx_t __Pyx_ModuleStateLookup_mutex; static once_flag __Pyx_ModuleStateLookup_mutex_once_flag = ONCE_FLAG_INIT; static void __Pyx_ModuleStateLookup_initialize_mutex(void) { mtx_init(&__Pyx_ModuleStateLookup_mutex, mtx_plain); } #define __Pyx_ModuleStateLookup_Lock()\ call_once(&__Pyx_ModuleStateLookup_mutex_once_flag, __Pyx_ModuleStateLookup_initialize_mutex);\ mtx_lock(&__Pyx_ModuleStateLookup_mutex) #define __Pyx_ModuleStateLookup_Unlock() mtx_unlock(&__Pyx_ModuleStateLookup_mutex) #elif defined(HAVE_PTHREAD_H) #include static pthread_mutex_t __Pyx_ModuleStateLookup_mutex = PTHREAD_MUTEX_INITIALIZER; #define __Pyx_ModuleStateLookup_Lock() pthread_mutex_lock(&__Pyx_ModuleStateLookup_mutex) #define __Pyx_ModuleStateLookup_Unlock() pthread_mutex_unlock(&__Pyx_ModuleStateLookup_mutex) #elif defined(_WIN32) #include // synchapi.h on its own doesn't work static SRWLOCK __Pyx_ModuleStateLookup_mutex = SRWLOCK_INIT; #define __Pyx_ModuleStateLookup_Lock() AcquireSRWLockExclusive(&__Pyx_ModuleStateLookup_mutex) #define __Pyx_ModuleStateLookup_Unlock() ReleaseSRWLockExclusive(&__Pyx_ModuleStateLookup_mutex) #else #error "No suitable lock available for CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE.\ Requires C standard >= C11, or C++ standard >= C++11,\ or pthreads, or the Windows 32 API, or Python >= 3.13." #endif typedef struct { int64_t id; PyObject *module; } __Pyx_InterpreterIdAndModule; typedef struct { char interpreter_id_as_index; Py_ssize_t count; Py_ssize_t allocated; __Pyx_InterpreterIdAndModule table[1]; } __Pyx_ModuleStateLookupData; #define __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE 32 #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE static __pyx_atomic_int_type __Pyx_ModuleStateLookup_read_counter = 0; #endif #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE static __pyx_atomic_ptr_type __Pyx_ModuleStateLookup_data = 0; #else static __Pyx_ModuleStateLookupData* __Pyx_ModuleStateLookup_data = NULL; #endif static __Pyx_InterpreterIdAndModule* __Pyx_State_FindModuleStateLookupTableLowerBound( __Pyx_InterpreterIdAndModule* table, Py_ssize_t count, int64_t interpreterId) { __Pyx_InterpreterIdAndModule* begin = table; __Pyx_InterpreterIdAndModule* end = begin + count; if (begin->id == interpreterId) { return begin; } while ((end - begin) > __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE) { __Pyx_InterpreterIdAndModule* halfway = begin + (end - begin)/2; if (halfway->id == interpreterId) { return halfway; } if (halfway->id < interpreterId) { begin = halfway; } else { end = halfway; } } for (; begin < end; ++begin) { if (begin->id >= interpreterId) return begin; } return begin; } static PyObject *__Pyx_State_FindModule(CYTHON_UNUSED void* dummy) { int64_t interpreter_id = PyInterpreterState_GetID(PyInterpreterState_Get()); if (interpreter_id == -1) return NULL; #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE __Pyx_ModuleStateLookupData* data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data); { __pyx_atomic_incr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); if (likely(data)) { __Pyx_ModuleStateLookupData* new_data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_acquire(&__Pyx_ModuleStateLookup_data); if (likely(data == new_data)) { goto read_finished; } } __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); __Pyx_ModuleStateLookup_Lock(); __pyx_atomic_incr_relaxed(&__Pyx_ModuleStateLookup_read_counter); data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data); __Pyx_ModuleStateLookup_Unlock(); } read_finished:; #else __Pyx_ModuleStateLookupData* data = __Pyx_ModuleStateLookup_data; #endif __Pyx_InterpreterIdAndModule* found = NULL; if (unlikely(!data)) goto end; if (data->interpreter_id_as_index) { if (interpreter_id < data->count) { found = data->table+interpreter_id; } } else { found = __Pyx_State_FindModuleStateLookupTableLowerBound( data->table, data->count, interpreter_id); } end: { PyObject *result=NULL; if (found && found->id == interpreter_id) { result = found->module; } #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); #endif return result; } } #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE static void __Pyx_ModuleStateLookup_wait_until_no_readers(void) { while (__pyx_atomic_load(&__Pyx_ModuleStateLookup_read_counter) != 0); } #else #define __Pyx_ModuleStateLookup_wait_until_no_readers() #endif static int __Pyx_State_AddModuleInterpIdAsIndex(__Pyx_ModuleStateLookupData **old_data, PyObject* module, int64_t interpreter_id) { Py_ssize_t to_allocate = (*old_data)->allocated; while (to_allocate <= interpreter_id) { if (to_allocate == 0) to_allocate = 1; else to_allocate *= 2; } __Pyx_ModuleStateLookupData *new_data = *old_data; if (to_allocate != (*old_data)->allocated) { new_data = (__Pyx_ModuleStateLookupData *)realloc( *old_data, sizeof(__Pyx_ModuleStateLookupData)+(to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule)); if (!new_data) { PyErr_NoMemory(); return -1; } for (Py_ssize_t i = new_data->allocated; i < to_allocate; ++i) { new_data->table[i].id = i; new_data->table[i].module = NULL; } new_data->allocated = to_allocate; } new_data->table[interpreter_id].module = module; if (new_data->count < interpreter_id+1) { new_data->count = interpreter_id+1; } *old_data = new_data; return 0; } static void __Pyx_State_ConvertFromInterpIdAsIndex(__Pyx_ModuleStateLookupData *data) { __Pyx_InterpreterIdAndModule *read = data->table; __Pyx_InterpreterIdAndModule *write = data->table; __Pyx_InterpreterIdAndModule *end = read + data->count; for (; readmodule) { write->id = read->id; write->module = read->module; ++write; } } data->count = write - data->table; for (; writeid = 0; write->module = NULL; } data->interpreter_id_as_index = 0; } static int __Pyx_State_AddModule(PyObject* module, CYTHON_UNUSED void* dummy) { int64_t interpreter_id = PyInterpreterState_GetID(PyInterpreterState_Get()); if (interpreter_id == -1) return -1; int result = 0; __Pyx_ModuleStateLookup_Lock(); #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE __Pyx_ModuleStateLookupData *old_data = (__Pyx_ModuleStateLookupData *) __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0); #else __Pyx_ModuleStateLookupData *old_data = __Pyx_ModuleStateLookup_data; #endif __Pyx_ModuleStateLookupData *new_data = old_data; if (!new_data) { new_data = (__Pyx_ModuleStateLookupData *)calloc(1, sizeof(__Pyx_ModuleStateLookupData)); if (!new_data) { result = -1; PyErr_NoMemory(); goto end; } new_data->allocated = 1; new_data->interpreter_id_as_index = 1; } __Pyx_ModuleStateLookup_wait_until_no_readers(); if (new_data->interpreter_id_as_index) { if (interpreter_id < __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE) { result = __Pyx_State_AddModuleInterpIdAsIndex(&new_data, module, interpreter_id); goto end; } __Pyx_State_ConvertFromInterpIdAsIndex(new_data); } { Py_ssize_t insert_at = 0; { __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound( new_data->table, new_data->count, interpreter_id); assert(lower_bound); insert_at = lower_bound - new_data->table; if (unlikely(insert_at < new_data->count && lower_bound->id == interpreter_id)) { lower_bound->module = module; goto end; // already in table, nothing more to do } } if (new_data->count+1 >= new_data->allocated) { Py_ssize_t to_allocate = (new_data->count+1)*2; new_data = (__Pyx_ModuleStateLookupData*)realloc( new_data, sizeof(__Pyx_ModuleStateLookupData) + (to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule)); if (!new_data) { result = -1; new_data = old_data; PyErr_NoMemory(); goto end; } new_data->allocated = to_allocate; } ++new_data->count; int64_t last_id = interpreter_id; PyObject *last_module = module; for (Py_ssize_t i=insert_at; icount; ++i) { int64_t current_id = new_data->table[i].id; new_data->table[i].id = last_id; last_id = current_id; PyObject *current_module = new_data->table[i].module; new_data->table[i].module = last_module; last_module = current_module; } } end: #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, new_data); #else __Pyx_ModuleStateLookup_data = new_data; #endif __Pyx_ModuleStateLookup_Unlock(); return result; } static int __Pyx_State_RemoveModule(CYTHON_UNUSED void* dummy) { int64_t interpreter_id = PyInterpreterState_GetID(PyInterpreterState_Get()); if (interpreter_id == -1) return -1; __Pyx_ModuleStateLookup_Lock(); #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE __Pyx_ModuleStateLookupData *data = (__Pyx_ModuleStateLookupData *) __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0); #else __Pyx_ModuleStateLookupData *data = __Pyx_ModuleStateLookup_data; #endif if (data->interpreter_id_as_index) { if (interpreter_id < data->count) { data->table[interpreter_id].module = NULL; } goto done; } { __Pyx_ModuleStateLookup_wait_until_no_readers(); __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound( data->table, data->count, interpreter_id); if (!lower_bound) goto done; if (lower_bound->id != interpreter_id) goto done; __Pyx_InterpreterIdAndModule *end = data->table+data->count; for (;lower_boundid = (lower_bound+1)->id; lower_bound->module = (lower_bound+1)->module; } } --data->count; if (data->count == 0) { free(data); data = NULL; } done: #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, data); #else __Pyx_ModuleStateLookup_data = data; #endif __Pyx_ModuleStateLookup_Unlock(); return 0; } #endif /* #### Code section: utility_code_pragmas_end ### */ #ifdef _MSC_VER #pragma warning( pop ) #endif /* #### Code section: end ### */ #endif /* Py_PYTHON_H */ ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788210425.9466078 borghash-0.2.1/src/borghash/HashTable.pxd0000644000175100017510000000143715245366372017733 0ustar00runnerrunnerfrom libc.stdint cimport uint8_t, uint32_t cdef class HashTable: cdef int ksize, vsize cdef readonly size_t capacity, used cdef size_t initial_capacity, tombstones cdef float max_load_factor, min_load_factor, shrink_factor, grow_factor, rehash_threshold cdef uint32_t* table cdef uint32_t kv_capacity, kv_used cdef float kv_grow_factor cdef uint8_t* keys cdef uint8_t* values cdef int stats_get, stats_set, stats_del, stats_iter, stats_lookup, stats_linear cdef int stats_resize_table, stats_resize_kv cdef size_t _get_index(self, uint8_t* key) cdef int _lookup_index(self, uint8_t* key_ptr, size_t* index_ptr, size_t* tombstone_ptr = *) cdef void _resize_table(self, size_t new_capacity) cdef void _resize_kv(self, size_t new_capacity) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788210425.9466708 borghash-0.2.1/src/borghash/HashTable.pyx0000644000175100017510000004011015245366372017747 0ustar00runnerrunner""" HashTable: low-level hash table mapping fully random bytes keys to bytes values. Key and value lengths can be chosen, but are fixed thereafter. The keys and values are stored in arrays separate from the hashtable. The hashtable only stores the 32-bit indices into the key/value arrays. """ from __future__ import annotations from typing import BinaryIO, Iterator, Any from libc.stdlib cimport malloc, free, realloc from libc.string cimport memcpy, memset, memcmp from libc.stdint cimport uint8_t, uint32_t from collections.abc import Mapping MAGIC = b"BORGHASH" assert len(MAGIC) == 8 VERSION = 1 # version of the on-disk (serialized) format produced by .write(). HEADER_FMT = "<8sII" # magic, version, meta length MIN_CAPACITY = 1000 # never shrink the hash table below this capacity cdef uint32_t FREE_BUCKET = 0xFFFFFFFF cdef uint32_t TOMBSTONE_BUCKET = 0xFFFFFFFE # ... cdef uint32_t RESERVED = 0xFFFFFF00 # all >= this is reserved _NoDefault = object() def _fill(this: Any, other: Any) -> None: """fill this mapping from other""" if other is None: return if isinstance(other, Mapping): for key in other: this[key] = other[key] elif hasattr(other, "keys"): for key in other.keys(): this[key] = other[key] else: for key, value in other: this[key] = value cdef class HashTable: def __init__(self, items=None, *, key_size: int = 0, value_size: int = 0, capacity: int = MIN_CAPACITY, max_load_factor: float = 0.5, min_load_factor: float = 0.10, shrink_factor: float = 0.4, grow_factor: float = 2.0, rehash_threshold: float = 0.75, kv_grow_factor: float = 1.3) -> None: # the load of the ht (.table) shall be between 0.25 and 0.5, so it is fast and has few collisions. # it is cheap to have a low hash table load, because .table only stores uint32_t indices into the # .keys and .values array. # the keys/values arrays have bigger elements and are not hash tables, thus collisions and load # factor are no concern there. the kv_grow_factor can be relatively small. # tombstones count towards the load of the ht, but unlike used entries they can be dropped by # rehashing at the same capacity. rehash_threshold decides between the two: only grow the ht if # the used entries alone occupy more than that fraction of the load budget. if key_size < 4: raise ValueError("key_size must be specified and must be >= 4.") if not value_size: raise ValueError("value_size must be specified and must be > 0.") self.ksize = key_size self.vsize = value_size # vvv hash table vvv self.max_load_factor = max_load_factor self.min_load_factor = min_load_factor self.shrink_factor = shrink_factor self.grow_factor = grow_factor self.rehash_threshold = rehash_threshold self.initial_capacity = capacity self.capacity = 0 self.used = 0 self.tombstones = 0 self.table = NULL self._resize_table(self.initial_capacity) # ^^^ hash table ^^^ # vvv kv arrays vvv self.kv_grow_factor = kv_grow_factor self.kv_used = 0 self.keys = NULL self.values = NULL self._resize_kv(int(self.initial_capacity * self.max_load_factor)) # ^^^ kv arrays ^^^ # vvv stats vvv self.stats_get = 0 self.stats_set = 0 self.stats_del = 0 self.stats_iter = 0 # .items() calls self.stats_lookup = 0 # _lookup_index calls self.stats_linear = 0 # how many steps the linear search inside _lookup_index needed self.stats_resize_table = 0 self.stats_resize_kv = 0 # ^^^ stats ^^^ _fill(self, items) def __del__(self) -> None: free(self.table) free(self.keys) free(self.values) def clear(self) -> None: """Empty the HashTable and start from scratch.""" self.capacity = 0 self.used = 0 self._resize_table(self.initial_capacity) self.kv_used = 0 self._resize_kv(int(self.initial_capacity * self.max_load_factor)) def __len__(self) -> int: return self.used cdef size_t _get_index(self, uint8_t* key): """Key must be perfectly random bytes, so we don't need a hash function here.""" cdef uint32_t key32 = (key[0] << 24) | (key[1] << 16) | (key[2] << 8) | key[3] return key32 % self.capacity cdef int _lookup_index(self, uint8_t* key_ptr, size_t* index_ptr, size_t* tombstone_ptr = NULL): """ search for a specific key. if found, return 1 and set *index_ptr to the index of the bucket in self.table. if not found, return 0 and set *index_ptr to the index of a free bucket in self.table. if not found and tombstone_ptr is given, set *tombstone_ptr to the index of the first tombstone bucket that was passed on the way, or to self.capacity if there was none. """ cdef size_t index = self._get_index(key_ptr) cdef size_t first_tombstone = self.capacity # == "none", indices are < self.capacity cdef uint32_t kv_index self.stats_lookup += 1 while (kv_index := self.table[index]) != FREE_BUCKET: self.stats_linear += 1 if kv_index == TOMBSTONE_BUCKET: if first_tombstone == self.capacity: first_tombstone = index elif memcmp(self.keys + kv_index * self.ksize, key_ptr, self.ksize) == 0: if index_ptr: index_ptr[0] = index return 1 # found index = (index + 1) % self.capacity if index_ptr: index_ptr[0] = index if tombstone_ptr: tombstone_ptr[0] = first_tombstone return 0 # not found def __setitem__(self, key: bytes, value: bytes) -> None: if len(key) != self.ksize or len(value) != self.vsize: raise ValueError("Key or value size does not match the defined sizes") cdef uint8_t* key_ptr = key cdef uint8_t* value_ptr = value cdef uint32_t kv_index cdef size_t index, tombstone_index self.stats_set += 1 if self._lookup_index(key_ptr, &index, &tombstone_index): kv_index = self.table[index] memcpy(self.values + kv_index * self.vsize, value_ptr, self.vsize) return if self.kv_used >= self.kv_capacity: self._resize_kv(int(self.kv_capacity * self.kv_grow_factor)) if self.kv_used >= self.kv_capacity: # Should never happen. See "RESERVED" constant - we allow almost 4Gi kv entries. # For a typical 256-bit key and a small 32-bit value that would already consume 176GiB+ # memory (plus spikes to even more when hashtable or kv arrays get resized). raise RuntimeError("KV array is full") kv_index = self.kv_used memcpy(self.keys + kv_index * self.ksize, key_ptr, self.ksize) memcpy(self.values + kv_index * self.vsize, value_ptr, self.vsize) self.kv_used += 1 self.used += 1 if tombstone_index < self.capacity: # prefer a tombstone bucket, it is dead weight otherwise index = tombstone_index self.tombstones -= 1 self.table[index] = kv_index # _lookup_index has set index to a free bucket if self.used + self.tombstones > self.capacity * self.max_load_factor: if self.used > self.capacity * self.max_load_factor * self.rehash_threshold: self._resize_table(int(self.capacity * self.grow_factor)) else: # mostly tombstones: rehashing at the same capacity drops them self._resize_table(self.capacity) def __contains__(self, key: bytes) -> bool: if len(key) != self.ksize: raise ValueError("Key size does not match the defined size") return bool(self._lookup_index( key, NULL)) def __getitem__(self, key: bytes) -> bytes: if len(key) != self.ksize: raise ValueError("Key size does not match the defined size") cdef uint32_t kv_index cdef size_t index self.stats_get += 1 if self._lookup_index( key, &index): kv_index = self.table[index] return self.values[kv_index * self.vsize:(kv_index + 1) * self.vsize] else: raise KeyError("Key not found") def __delitem__(self, key: bytes) -> None: if len(key) != self.ksize: raise ValueError("Key size does not match the defined size") cdef uint8_t* key_ptr = key cdef size_t index cdef uint32_t kv_index self.stats_del += 1 if self._lookup_index(key_ptr, &index): kv_index = self.table[index] memset(self.keys + kv_index * self.ksize, 0, self.ksize) memset(self.values + kv_index * self.vsize, 0, self.vsize) self.table[index] = TOMBSTONE_BUCKET self.used -= 1 self.tombstones += 1 # Resize down if necessary if self.used < self.capacity * self.min_load_factor: new_capacity = max(int(self.capacity * self.shrink_factor), MIN_CAPACITY) if new_capacity < self.capacity: # at the MIN_CAPACITY floor, this would rehash per delete self._resize_table(new_capacity) else: raise KeyError("Key not found") def setdefault(self, key: bytes, value: bytes) -> bytes: if not key in self: self[key] = value return self[key] def get(self, key: bytes, default: Any = None) -> bytes|Any: try: return self[key] except KeyError: return default def pop(self, key: bytes, default: Any = _NoDefault) -> bytes|Any: try: value = self[key] except KeyError: if default is _NoDefault: raise return default else: del self[key] return value def items(self, *, prefix_bits: int = 0, prefix: int = 0) -> Iterator[tuple[bytes, bytes]]: """ Iterate over items, optionally only over items whose key starts with the given bit prefix. prefix_bits: number of leading key bits to compare, 0..32 (0 means: no filtering). prefix: expected value of these leading key bits, given in the integer's low bits, thus: 0 <= prefix < 2 ** prefix_bits. As the keys are expected to be random bytes, this partitions the keys into 2 ** prefix_bits roughly equally sized, disjoint sets, while only creating bytes objects for the matching keys/values. As the prefix compares the keys' leading bits, each set is a contiguous range of the sorted key space. """ if not 0 <= prefix_bits <= 32: raise ValueError("prefix_bits must be in range 0..32.") if not 0 <= prefix < (1 << prefix_bits): raise ValueError("prefix must be in range 0..(2 ** prefix_bits - 1).") cdef size_t i cdef uint32_t kv_index cdef uint8_t* key_ptr cdef uint32_t key32 cdef int shift = 32 - prefix_bits cdef uint32_t wanted = prefix cdef bint filtering = prefix_bits > 0 self.stats_iter += 1 for i in range(self.capacity): kv_index = self.table[i] if kv_index not in (FREE_BUCKET, TOMBSTONE_BUCKET): if filtering: key_ptr = self.keys + kv_index * self.ksize key32 = (key_ptr[0] << 24) | (key_ptr[1] << 16) | (key_ptr[2] << 8) | key_ptr[3] if (key32 >> shift) != wanted: continue key = self.keys[kv_index * self.ksize:(kv_index + 1) * self.ksize] value = self.values[kv_index * self.vsize:(kv_index + 1) * self.vsize] yield key, value cdef void _resize_table(self, size_t new_capacity): cdef size_t i, index cdef uint32_t kv_index cdef uint32_t* new_table = malloc(new_capacity * sizeof(uint32_t)) for i in range(new_capacity): new_table[i] = FREE_BUCKET self.stats_resize_table += 1 current_capacity = self.capacity self.capacity = new_capacity for i in range(current_capacity): kv_index = self.table[i] if kv_index not in (FREE_BUCKET, TOMBSTONE_BUCKET): index = self._get_index(self.keys + kv_index * self.ksize) while new_table[index] != FREE_BUCKET: index = (index + 1) % new_capacity new_table[index] = kv_index free(self.table) self.table = new_table self.tombstones = 0 cdef void _resize_kv(self, size_t new_capacity): # We must never use kv indices >= RESERVED; thus, we'll never need more capacity either. cdef size_t capacity = min(new_capacity, RESERVED - 1) self.stats_resize_kv += 1 # realloc is already highly optimized (in Linux). By using mremap internally only the peak address space usage is "old size" + "new size", while the peak memory usage is only "new size". self.keys = realloc(self.keys, capacity * self.ksize * sizeof(uint8_t)) self.values = realloc(self.values, capacity * self.vsize * sizeof(uint8_t)) self.kv_capacity = capacity def k_to_idx(self, key: bytes) -> int: """ Return the key's index in the keys array (index is stable while in memory). This can be used to "abbreviate" a known key (e.g., 256-bit key -> 32-bit index). """ if len(key) != self.ksize: raise ValueError("Key size does not match the defined size") cdef size_t index if self._lookup_index( key, &index): return self.table[index] # == uint32_t kv_index else: raise KeyError("Key not found") def idx_to_k(self, idx: int) -> bytes: """ For a given index, return the key stored at that index in the keys array. This is the reverse of k_to_idx (e.g., 32-bit index -> 256-bit key). """ cdef uint32_t kv_index = idx return self.keys[kv_index * self.ksize:(kv_index + 1) * self.ksize] def kv_to_idx(self, key: bytes, value: bytes) -> int: """ Return the key's/value's index in the keys/values array (index is stable while in memory). This can be used to "abbreviate" a known key/value pair (e.g., 256-bit key + 32-bit value -> 32-bit index). """ if len(key) != self.ksize: raise ValueError("Key size does not match the defined size") if len(value) != self.vsize: raise ValueError("Value size does not match the defined size") cdef size_t index cdef uint32_t kv_index if self._lookup_index( key, &index): kv_index = self.table[index] value_found = self.values[kv_index * self.vsize:(kv_index + 1) * self.vsize] if value == value_found: return kv_index raise KeyError("Key/Value not found") def idx_to_kv(self, idx: int) -> tuple[bytes, bytes]: """ For a given index, return the key/value stored at that index in the keys/values array. This is the reverse of kv_to_idx (e.g., 32-bit index -> 256-bit key + 32-bit value). """ cdef uint32_t kv_index = idx key = self.keys[kv_index * self.ksize:(kv_index + 1) * self.ksize] value = self.values[kv_index * self.vsize:(kv_index + 1) * self.vsize] return key, value @property def stats(self) -> dict[str, int]: return { "get": self.stats_get, "set": self.stats_set, "del": self.stats_del, "iter": self.stats_iter, "lookup": self.stats_lookup, "linear": self.stats_linear, "resize_table": self.stats_resize_table, "resize_kv": self.stats_resize_kv, } ././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1788210436.452205 borghash-0.2.1/src/borghash/HashTableNT.c0000644000175100017510000370245015245366404017626 0ustar00runnerrunner/* Generated by Cython 3.3.0 */ /* BEGIN: Cython Metadata { "distutils": { "name": "borghash.HashTableNT", "sources": [ "src/borghash/HashTableNT.pyx" ] }, "module_name": "borghash.HashTableNT" } END: Cython Metadata */ #ifndef PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN #endif /* PY_SSIZE_T_CLEAN */ /* InitLimitedAPI */ #if defined(Py_LIMITED_API) #if !defined(CYTHON_LIMITED_API) #define CYTHON_LIMITED_API 1 #endif #elif defined(CYTHON_LIMITED_API) #ifdef _MSC_VER #pragma message ("Limited API usage is enabled with 'CYTHON_LIMITED_API' but 'Py_LIMITED_API' does not define a Python target version. Consider setting 'Py_LIMITED_API' instead.") #else #warning Limited API usage is enabled with 'CYTHON_LIMITED_API' but 'Py_LIMITED_API' does not define a Python target version. Consider setting 'Py_LIMITED_API' instead. #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 < 0x03090000 #error Cython requires Python 3.9+. #elif defined(Py_LIMITED_API) && (Py_LIMITED_API & 0xFFFF0000) > (PY_VERSION_HEX & 0xFFFF0000) #error 'Py_LIMITED_API' can only select past Python X.Y versions, not future ones. #else #define __PYX_ABI_VERSION "3_3_0" #define CYTHON_HEX_VERSION 0x030300F0 #define CYTHON_FUTURE_DIVISION 1 /* CModulePreamble */ #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 #ifdef __has_builtin #define __Pyx_has_cbuiltin(name) __has_builtin(name) #else #define __Pyx_has_cbuiltin(name) (0) #endif #ifndef DL_IMPORT #define DL_IMPORT(t) t #endif #ifndef DL_EXPORT #define DL_EXPORT(t) t #endif #define __PYX_COMMA , #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(CYTHON_LIMITED_API) #ifdef Py_LIMITED_API #undef __PYX_LIMITED_VERSION_HEX #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API #if Py_LIMITED_API < 0x03090000 #error "Cython 3.3 requires the Python Limited API version to be 3.9 or greater." #endif #endif #if defined(GRAALVM_PYTHON) || defined(PYPY_VERSION) #ifdef _MSC_VER #pragma message ("Py_LIMITED_API is defined on PyPy or GraalPy. This takes precedence over Cython's specialized\ code for PyPy and GraalPy and is unlikely to work.") #else #warning "Py_LIMITED_API is defined on PyPy or GraalPy. This takes precedence over Cython's specialized\ code for PyPy and GraalPy and is unlikely to work." #endif #endif #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_LIMITED_API 1 #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #undef CYTHON_USE_TYPE_SPECS #define CYTHON_USE_TYPE_SPECS 1 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #endif #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0 #endif #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 #undef CYTHON_ASSUME_SAFE_SIZE #define CYTHON_ASSUME_SAFE_SIZE 0 #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_GIL #define CYTHON_FAST_GIL 0 #undef CYTHON_VECTORCALL #define CYTHON_VECTORCALL (__PYX_LIMITED_VERSION_HEX >= 0x030C0000) #ifndef CYTHON_VECTORCALL_TPNEW #define CYTHON_VECTORCALL_TPNEW (CYTHON_VECTORCALL && __PYX_LIMITED_VERSION_HEX >= 0x030E0000) #endif #ifndef CYTHON_PEP487_INIT_SUBCLASS #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif #ifndef CYTHON_USE_MODULE_STATE #define CYTHON_USE_MODULE_STATE 0 #endif #undef CYTHON_USE_SYS_MONITORING #define CYTHON_USE_SYS_MONITORING 0 #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE (__PYX_LIMITED_VERSION_HEX >= 0x030F0000 && PY_VERSION_HEX > 0x030F00A8) #endif #ifndef CYTHON_USE_AM_SEND #define CYTHON_USE_AM_SEND (__PYX_LIMITED_VERSION_HEX >= 0x030A0000) #endif #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif #ifndef CYTHON_USE_OWN_PREP_RERAISE_STAR #define CYTHON_USE_OWN_PREP_RERAISE_STAR 1 #endif #ifndef CYTHON_USE_FREELISTS #define CYTHON_USE_FREELISTS 1 #endif #undef CYTHON_IMMORTAL_CONSTANTS #define CYTHON_IMMORTAL_CONSTANTS 0 #if __PYX_LIMITED_VERSION_HEX < 0x030E0000 #undef CYTHON_OPAQUE_OBJECTS #define CYTHON_OPAQUE_OBJECTS 0 #elif !defined(CYTHON_OPAQUE_OBJECTS) #define CYTHON_OPAQUE_OBJECTS (__PYX_LIMITED_VERSION_HEX >= 0x030F0000) #endif #elif defined(GRAALVM_PYTHON) /* For very preliminary testing purposes. Most variables are set the same as PyPy. The existence of this section does not imply that anything works or is even tested */ #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_LIMITED_API 0 #define CYTHON_COMPILING_IN_GRAAL 1 #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #endif #undef CYTHON_USE_TYPE_SPECS #define CYTHON_USE_TYPE_SPECS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #undef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 1 #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0 #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 #undef CYTHON_ASSUME_SAFE_SIZE #define CYTHON_ASSUME_SAFE_SIZE 0 #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_GIL #define CYTHON_FAST_GIL 0 #ifndef CYTHON_VECTORCALL #define CYTHON_VECTORCALL 1 #endif #if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX < 0x030E0000 #undef CYTHON_VECTORCALL_TPNEW #define CYTHON_VECTORCALL_TPNEW 0 #elif !defined(CYTHON_VECTORCALL_TPNEW) #define CYTHON_VECTORCALL_TPNEW CYTHON_VECTORCALL #endif #ifndef CYTHON_PEP487_INIT_SUBCLASS #define CYTHON_PEP487_INIT_SUBCLASS 1 #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_SYS_MONITORING #define CYTHON_USE_SYS_MONITORING 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_AM_SEND #define CYTHON_USE_AM_SEND 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 1 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif #ifndef CYTHON_USE_OWN_PREP_RERAISE_STAR #define CYTHON_USE_OWN_PREP_RERAISE_STAR 1 #endif #undef CYTHON_USE_FREELISTS #define CYTHON_USE_FREELISTS 0 #undef CYTHON_IMMORTAL_CONSTANTS #define CYTHON_IMMORTAL_CONSTANTS 0 #undef CYTHON_OPAQUE_OBJECTS #define CYTHON_OPAQUE_OBJECTS 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_CPYTHON_FREETHREADING 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #ifndef CYTHON_USE_TYPE_SPECS #define CYTHON_USE_TYPE_SPECS 0 #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_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_AVOID_THREAD_UNSAFE_BORROWED_REFS #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1 #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 #ifndef CYTHON_ASSUME_SAFE_SIZE #define CYTHON_ASSUME_SAFE_SIZE 1 #endif #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_GIL #define CYTHON_FAST_GIL 0 #ifndef CYTHON_VECTORCALL #define CYTHON_VECTORCALL 1 #endif #if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX < 0x030E0000 #undef CYTHON_VECTORCALL_TPNEW #define CYTHON_VECTORCALL_TPNEW 0 #elif !defined(CYTHON_VECTORCALL_TPNEW) #define CYTHON_VECTORCALL_TPNEW (PYPY_VERSION_NUM >= 0x07030800 && CYTHON_VECTORCALL) #endif #ifndef CYTHON_PEP487_INIT_SUBCLASS #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif #undef CYTHON_USE_MODULE_STATE #define CYTHON_USE_MODULE_STATE 0 #undef CYTHON_USE_SYS_MONITORING #define CYTHON_USE_SYS_MONITORING 0 #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE (PYPY_VERSION_NUM >= 0x07030C00) #endif #undef CYTHON_USE_AM_SEND #define CYTHON_USE_AM_SEND 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_NUM >= 0x07031100) #endif #ifndef CYTHON_USE_OWN_PREP_RERAISE_STAR #define CYTHON_USE_OWN_PREP_RERAISE_STAR 1 #endif #undef CYTHON_USE_FREELISTS #define CYTHON_USE_FREELISTS 0 #undef CYTHON_IMMORTAL_CONSTANTS #define CYTHON_IMMORTAL_CONSTANTS 0 #undef CYTHON_OPAQUE_OBJECTS #define CYTHON_OPAQUE_OBJECTS 0 #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 #ifdef Py_GIL_DISABLED #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 1 #else #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 #endif #if PY_VERSION_HEX < 0x030A0000 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #elif !defined(CYTHON_USE_TYPE_SLOTS) #define CYTHON_USE_TYPE_SLOTS 1 #endif #ifndef CYTHON_USE_TYPE_SPECS #define CYTHON_USE_TYPE_SPECS 0 #endif #ifndef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #ifndef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #elif !defined(CYTHON_USE_PYLIST_INTERNALS) #define CYTHON_USE_PYLIST_INTERNALS 1 #endif #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING || PY_VERSION_HEX >= 0x030B00A2 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #elif !defined(CYTHON_USE_UNICODE_WRITER) #define CYTHON_USE_UNICODE_WRITER 1 #endif #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1 #elif !defined(CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS) #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_ASSUME_SAFE_SIZE #define CYTHON_ASSUME_SAFE_SIZE 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING #undef CYTHON_FAST_GIL #define CYTHON_FAST_GIL 0 #elif !defined(CYTHON_FAST_GIL) #define CYTHON_FAST_GIL (PY_VERSION_HEX < 0x030C00A6) #endif #ifndef CYTHON_VECTORCALL #define CYTHON_VECTORCALL 1 #endif #if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX < 0x030E0000 #undef CYTHON_VECTORCALL_TPNEW #define CYTHON_VECTORCALL_TPNEW 0 #elif !defined(CYTHON_VECTORCALL_TPNEW) #define CYTHON_VECTORCALL_TPNEW CYTHON_VECTORCALL #endif #ifndef CYTHON_PEP487_INIT_SUBCLASS #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif #ifndef CYTHON_USE_MODULE_STATE #define CYTHON_USE_MODULE_STATE 0 #endif #ifndef CYTHON_USE_SYS_MONITORING #define CYTHON_USE_SYS_MONITORING (PY_VERSION_HEX >= 0x030d00B1) #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 1 #endif #ifndef CYTHON_USE_AM_SEND #define CYTHON_USE_AM_SEND 1 #endif #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #elif !defined(CYTHON_USE_DICT_VERSIONS) #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5 && !CYTHON_USE_MODULE_STATE) #endif #ifndef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 1 #endif #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 #endif #ifndef CYTHON_USE_OWN_PREP_RERAISE_STAR #define CYTHON_USE_OWN_PREP_RERAISE_STAR (PY_VERSION_HEX < 0x030C00B2) #endif #ifndef CYTHON_USE_FREELISTS #define CYTHON_USE_FREELISTS (!CYTHON_COMPILING_IN_CPYTHON_FREETHREADING) #endif #if defined(CYTHON_IMMORTAL_CONSTANTS) && PY_VERSION_HEX < 0x030C0000 #undef CYTHON_IMMORTAL_CONSTANTS #define CYTHON_IMMORTAL_CONSTANTS 0 // definitely won't work #elif !defined(CYTHON_IMMORTAL_CONSTANTS) #define CYTHON_IMMORTAL_CONSTANTS (PY_VERSION_HEX >= 0x030C0000 && !CYTHON_USE_MODULE_STATE && CYTHON_COMPILING_IN_CPYTHON_FREETHREADING) #endif #ifndef CYTHON_OPAQUE_OBJECTS #define CYTHON_OPAQUE_OBJECTS 0 #endif #endif #if CYTHON_USE_PYLONG_INTERNALS #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 #elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L #define CYTHON_UNUSED [[maybe_unused]] #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 && !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING # define CYTHON_NCP_UNUSED # else # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif #ifndef CYTHON_USE_CPP_STD_MOVE #if defined(__cplusplus) && (\ __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) #define CYTHON_USE_CPP_STD_MOVE 1 #else #define CYTHON_USE_CPP_STD_MOVE 0 #endif #endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) #include typedef uintptr_t __pyx_uintptr_t; #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 Py_UNREACHABLE #define __Pyx_UNREACHABLE() Py_UNREACHABLE() #elif __Pyx_has_cbuiltin(__builtin_unreachable) #define __Pyx_UNREACHABLE() __builtin_unreachable() #elif defined(__clang__) || defined(__INTEL_COMPILER) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5))) #define __Pyx_UNREACHABLE() __builtin_unreachable() #elif defined(_MSC_VER) #define __Pyx_UNREACHABLE() __assume(0) #else #define __Pyx_UNREACHABLE() Py_FatalError("Unreachable C code path reached") #endif #ifndef Py_UNREACHABLE #define Py_UNREACHABLE() __Pyx_UNREACHABLE() #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 < 0x030A0000) #else #define __PYX_NEED_TP_PRINT_SLOT 0 #endif #define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) #if __PYX_LIMITED_VERSION_HEX < 0x030C0000 #define __Pyx_PyErr_FetchException(petype, peval, petb) PyErr_Fetch(petype, peval, petb) #define __Pyx_PyErr_RestoreException(etype, eval, etb) PyErr_Restore(etype, eval, etb) #else #define __Pyx_PyErr_FetchException(petype, peval, petb) *(petype)=NULL; *(peval)=PyErr_GetRaisedException(); *(petb)=NULL #define __Pyx_PyErr_RestoreException(etype, eval, etb) PyErr_SetRaisedException(eval) #endif /* CInitCode */ #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 /* PythonCompatibility */ #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_DefaultClassType PyType_Type #if CYTHON_COMPILING_IN_LIMITED_API #ifndef CO_OPTIMIZED static int CO_OPTIMIZED; #endif #ifndef CO_NEWLOCALS static int CO_NEWLOCALS; #endif #ifndef CO_VARARGS static int CO_VARARGS; #endif #ifndef CO_VARKEYWORDS static int CO_VARKEYWORDS; #endif #ifndef CO_ASYNC_GENERATOR static int CO_ASYNC_GENERATOR; #endif #ifndef CO_GENERATOR static int CO_GENERATOR; #endif #ifndef CO_COROUTINE static int CO_COROUTINE; #endif #else #ifndef CO_COROUTINE #define CO_COROUTINE 0x80 #endif #ifndef CO_ASYNC_GENERATOR #define CO_ASYNC_GENERATOR 0x200 #endif #endif static int __Pyx_init_co_variables(void); #if PY_VERSION_HEX >= 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 CYTHON_COMPILING_IN_PYPY #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) #else #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) #endif #if CYTHON_COMPILING_IN_LIMITED_API static unsigned long __Pyx_Runtime_TPFLAGS_SEQUENCE; static unsigned long __Pyx_Runtime_TPFLAGS_MAPPING; #else #define __Pyx_Runtime_TPFLAGS_SEQUENCE Py_TPFLAGS_SEQUENCE #define __Pyx_Runtime_TPFLAGS_MAPPING Py_TPFLAGS_MAPPING #endif static int __Pyx_init_tpflags_variables(void); #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif #ifndef Py_TPFLAGS_SEQUENCE #define Py_TPFLAGS_SEQUENCE (CYTHON_COMPILING_IN_LIMITED_API ? 0 : 1 << 5) #endif #ifndef Py_TPFLAGS_MAPPING #define Py_TPFLAGS_MAPPING (CYTHON_COMPILING_IN_LIMITED_API ? 0 : 1 << 6) #endif #ifndef Py_TPFLAGS_IMMUTABLETYPE #define Py_TPFLAGS_IMMUTABLETYPE (1UL << 8) #endif #ifndef Py_TPFLAGS_DISALLOW_INSTANTIATION #define Py_TPFLAGS_DISALLOW_INSTANTIATION (1UL << 7) #endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif #if !defined(METH_FASTCALL) || CYTHON_COMPILING_IN_PYPY #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_VECTORCALL #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)) #else #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) #endif #define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) #define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) #elif !CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) #endif #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; } #endif static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void (*cfunc)(void)) { #if CYTHON_COMPILING_IN_LIMITED_API return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; #else return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; #endif } #define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) #else #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) #endif #if CYTHON_COMPILING_IN_PYPY typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); #else #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_PyFrame_SetLineNumber(frame, lineno) #elif CYTHON_COMPILING_IN_GRAAL && defined(GRAALPY_VERSION_NUM) && GRAALPY_VERSION_NUM > 0x19000000 #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) GraalPyFrame_SetLineNumber((frame), (lineno)) #elif CYTHON_COMPILING_IN_GRAAL #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) _PyFrame_SetLineNumber((frame), (lineno)) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif #if CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_PyThreadState_Current PyThreadState_Get() #elif !CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_Current PyThreadState_GET() #elif PY_VERSION_HEX >= 0x030d00A1 #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() #else #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #endif #if CYTHON_OPAQUE_OBJECTS && CYTHON_COMPILING_IN_LIMITED_API #define __PYX_SHARED_SIZEOF(T) -((int)sizeof(T)) #define __PYX_SHARED_RELATIVE_OFFSET Py_RELATIVE_OFFSET #define CYTHON_OPAQUE_SHARED_TYPES 1 #else #define __PYX_SHARED_SIZEOF(T) sizeof(T) #define __PYX_SHARED_RELATIVE_OFFSET 0 #define CYTHON_OPAQUE_SHARED_TYPES 0 #endif #if CYTHON_USE_MODULE_STATE static CYTHON_INLINE void *__Pyx__PyModule_GetState(PyObject *op) { void *result; result = PyModule_GetState(op); if (!result) Py_FatalError("Couldn't find the module state"); return result; } #define __Pyx_PyModule_GetState(o) (__pyx_mstatetype *)__Pyx__PyModule_GetState(o) #else #define __Pyx_PyModule_GetState(op) ((void)op,__pyx_mstate_global) #endif #define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE((PyObject *) obj), name, func_ctype) #define __Pyx_PyObject_TryGetSlot(obj, name, func_ctype) __Pyx_PyType_TryGetSlot(Py_TYPE(obj), name, func_ctype) #define __Pyx_PyObject_GetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_GetSubSlot(Py_TYPE(obj), sub, name, func_ctype) #define __Pyx_PyObject_TryGetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_TryGetSubSlot(Py_TYPE(obj), sub, name, func_ctype) #if CYTHON_USE_TYPE_SLOTS #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) #define __Pyx_PyType_TryGetSlot(type, name, func_ctype) __Pyx_PyType_GetSlot(type, name, func_ctype) #define __Pyx_PyType_GetSubSlot(type, sub, name, func_ctype) (((type)->sub) ? ((type)->sub->name) : NULL) #define __Pyx_PyType_TryGetSubSlot(type, sub, name, func_ctype) __Pyx_PyType_GetSubSlot(type, sub, name, func_ctype) #else #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) #define __Pyx_PyType_TryGetSlot(type, name, func_ctype)\ ((__PYX_LIMITED_VERSION_HEX >= 0x030A0000 ||\ (PyType_GetFlags(type) & Py_TPFLAGS_HEAPTYPE) || __Pyx_get_runtime_version() >= 0x030A0000) ?\ __Pyx_PyType_GetSlot(type, name, func_ctype) : NULL) #define __Pyx_PyType_GetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_GetSlot(obj, name, func_ctype) #define __Pyx_PyType_TryGetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_TryGetSlot(obj, name, func_ctype) #endif #if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() #endif #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) #if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_UNICODE_INTERNALS #define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); if (res == NULL && PyErr_Occurred()) { PyErr_WriteUnraisable(NULL); } return res; } #elif !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000 #define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError #define __Pyx_PyDict_GetItemStr PyDict_GetItem #else static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { #if CYTHON_COMPILING_IN_PYPY return PyDict_GetItem(dict, name); #else PyDictEntry *ep; PyDictObject *mp = (PyDictObject*) dict; long hash = ((PyStringObject *) name)->ob_shash; assert(hash != -1); ep = (mp->ma_lookup)(mp, name, hash); if (ep == NULL) { return NULL; } return ep->me_value; #endif } #define __Pyx_PyDict_GetItemStr PyDict_GetItem #endif #if CYTHON_USE_TYPE_SLOTS #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) #else #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) #endif #define __Pyx_PyObject_GetIterNextFunc(iterator) __Pyx_PyObject_GetSlot(iterator, tp_iternext, iternextfunc) #if CYTHON_USE_TYPE_SPECS #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 __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) #define __Pyx_PyUnicode_KIND_04(u) __Pyx_PyUnicode_KIND(u) #define __Pyx_PyUnicode_DATA(u) ((void*)u) #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) #else #if PY_VERSION_HEX >= 0x030C0000 #define __Pyx_PyUnicode_READY(op) (0) #else #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ 0 : _PyUnicode_Ready((PyObject *)(op))) #endif #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) #define __Pyx_PyUnicode_KIND(u) ((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 #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 static CYTHON_INLINE int __Pyx_PyUnicode_KIND_04(PyObject *o) { return __Pyx_PyUnicode_KIND(o) - (int) !!PyUnicode_IS_ASCII(o); } #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) #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_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 #define __Pyx_PySequence_ListKeepNew(obj)\ (likely(PyList_CheckExact(obj) && PyUnstable_Object_IsUniquelyReferenced(obj)) ? __Pyx_NewRef(obj) : PySequence_List(obj)) #elif 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_IS_TYPE(obj, &PySet_Type) #endif enum __Pyx_ReferenceSharing { __Pyx_ReferenceSharing_DefinitelyUnique, // We created it so we know it's unshared - no need to check __Pyx_ReferenceSharing_OwnStrongReference, __Pyx_ReferenceSharing_FunctionArgument, __Pyx_ReferenceSharing_SharedReference, // Never trust it to be unshared because it's a global or similar }; #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && PY_VERSION_HEX >= 0x030E0000 #define __Pyx_IS_UNIQUELY_REFERENCED(o, sharing)\ (sharing == __Pyx_ReferenceSharing_DefinitelyUnique ? 1 :\ (sharing == __Pyx_ReferenceSharing_FunctionArgument ? PyUnstable_Object_IsUniqueReferencedTemporary(o) :\ (sharing == __Pyx_ReferenceSharing_OwnStrongReference ? PyUnstable_Object_IsUniquelyReferenced(o) : 0))) #elif (CYTHON_COMPILING_IN_CPYTHON && !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING) || CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_IS_UNIQUELY_REFERENCED(o, sharing) (((void)sharing), Py_REFCNT(o) == 1) #else #define __Pyx_IS_UNIQUELY_REFERENCED(o, sharing) (((void)o), ((void)sharing), 0) #endif #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 #define __Pyx_PyList_GetItemRef(o, i) PyList_GetItemRef(o, i) #elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS #if CYTHON_COMPILING_IN_LIMITED_API || !CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PyList_GetItemRef(o, i) (likely((i) >= 0) ? PySequence_GetItem(o, i) : (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) #else #define __Pyx_PyList_GetItemRef(o, i) PySequence_ITEM(o, i) #endif #elif CYTHON_COMPILING_IN_LIMITED_API || !(CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE) #define __Pyx_PyList_GetItemRef(o, i) __Pyx_XNewRef(PyList_GetItem(o, i)) #else #define __Pyx_PyList_GetItemRef(o, i) (likely(__Pyx_is_valid_index(i, PyList_GET_SIZE(o))) ?\ __Pyx_NewRef(PyList_GET_ITEM(o, i)) : (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) #endif #if CYTHON_AVOID_BORROWED_REFS || CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_PyList_GET_ITEM_REF(o, i, unsafe_shared) ((void)(unsafe_shared),\ __Pyx_PyList_GetItemRef(o, i)) #elif CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS #if CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PyList_GET_ITEM_REF(o, i, unsafe_shared) (\ __Pyx_IS_UNIQUELY_REFERENCED(o, unsafe_shared) ?\ __Pyx_NewRef(PyList_GET_ITEM(o, i)) : __Pyx_PyList_GetItemRef(o, i)) #else #define __Pyx_PyList_GET_ITEM_REF(o, i, unsafe_shared) (\ __Pyx_IS_UNIQUELY_REFERENCED(o, unsafe_shared) ?\ __Pyx_XNewRef(PyList_GetItem(o, i)) : __Pyx_PyList_GetItemRef(o, i)) #endif #elif CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PyList_GET_ITEM_REF(o, i, unsafe_shared) ((void)(unsafe_shared),\ __Pyx_NewRef(PyList_GET_ITEM(o, i))) #else #define __Pyx_PyList_GET_ITEM_REF(o, i, unsafe_shared) ((void)(unsafe_shared),\ __Pyx_XNewRef(PyList_GetItem(o, i))) #endif #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 #define __Pyx_PyDict_GetItemRef(dict, key, result) PyDict_GetItemRef(dict, key, result) #elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key, PyObject **result) { *result = PyObject_GetItem(dict, key); if (*result == NULL) { if (PyErr_ExceptionMatches(PyExc_KeyError)) { PyErr_Clear(); return 0; } return -1; } return 1; } #else static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key, PyObject **result) { *result = PyDict_GetItemWithError(dict, key); if (*result == NULL) { return PyErr_Occurred() ? -1 : 0; } Py_INCREF(*result); return 1; } #endif #if defined(CYTHON_DEBUG_VISIT_CONST) && CYTHON_DEBUG_VISIT_CONST #define __Pyx_VISIT_CONST(obj) Py_VISIT(obj) #else #define __Pyx_VISIT_CONST(obj) #endif #if CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i) #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) #define __Pyx_PyTuple_GET_ITEM(o, i) PyTuple_GET_ITEM(o, i) #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) #define __Pyx_PyList_GET_ITEM(o, i) PyList_GET_ITEM(o, i) #else #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) #define __Pyx_PyTuple_GET_ITEM(o, i) PyTuple_GetItem(o, i) #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) #define __Pyx_PyList_GET_ITEM(o, i) PyList_GetItem(o, i) #endif #if CYTHON_ASSUME_SAFE_SIZE #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) #define __Pyx_PyDict_GET_SIZE(o) PyDict_GET_SIZE(o) #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GET_LENGTH(o) #else #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) #define __Pyx_PyDict_GET_SIZE(o) PyDict_Size(o) #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GetLength(o) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_InternFromString) #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) #endif #define __Pyx_PyLong_FromHash_t PyLong_FromSsize_t #define __Pyx_PyLong_AsHash_t __Pyx_PyIndex_AsSsize_t #if __PYX_LIMITED_VERSION_HEX >= 0x030A0000 #define __Pyx_PySendResult PySendResult #else typedef enum { PYGEN_RETURN = 0, PYGEN_ERROR = -1, PYGEN_NEXT = 1, } __Pyx_PySendResult; #endif #if CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX < 0x030A00A3 typedef __Pyx_PySendResult (*__Pyx_pyiter_sendfunc)(PyObject *iter, PyObject *value, PyObject **result); #else #define __Pyx_pyiter_sendfunc sendfunc #endif #if !CYTHON_USE_AM_SEND #define __PYX_HAS_PY_AM_SEND 0 #elif __PYX_LIMITED_VERSION_HEX >= 0x030A0000 #define __PYX_HAS_PY_AM_SEND 1 #else #define __PYX_HAS_PY_AM_SEND 2 // our own backported implementation #endif #if __PYX_HAS_PY_AM_SEND < 2 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods #else typedef struct { unaryfunc am_await; unaryfunc am_aiter; unaryfunc am_anext; __Pyx_pyiter_sendfunc am_send; } __Pyx_PyAsyncMethodsStruct; #define __Pyx_SlotTpAsAsync(s) ((PyAsyncMethods*)(s)) #endif #if CYTHON_USE_AM_SEND && PY_VERSION_HEX < 0x030A00F0 #define __Pyx_TPFLAGS_HAVE_AM_SEND (1UL << 21) #else #define __Pyx_TPFLAGS_HAVE_AM_SEND (0) #endif #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030A0000 #ifdef __cplusplus extern "C" #endif PyAPI_FUNC(void *) PyMem_Calloc(size_t nelem, size_t elsize); #endif #if CYTHON_COMPILING_IN_LIMITED_API static int __Pyx_init_co_variable(PyObject *inspect, const char* name, int *write_to) { int value; PyObject *py_value = PyObject_GetAttrString(inspect, name); if (!py_value) return 0; value = (int) PyLong_AsLong(py_value); Py_DECREF(py_value); *write_to = value; return value != -1 || !PyErr_Occurred(); } static int __Pyx_init_co_variables(void) { PyObject *inspect; int result; inspect = PyImport_ImportModule("inspect"); result = #if !defined(CO_OPTIMIZED) __Pyx_init_co_variable(inspect, "CO_OPTIMIZED", &CO_OPTIMIZED) && #endif #if !defined(CO_NEWLOCALS) __Pyx_init_co_variable(inspect, "CO_NEWLOCALS", &CO_NEWLOCALS) && #endif #if !defined(CO_VARARGS) __Pyx_init_co_variable(inspect, "CO_VARARGS", &CO_VARARGS) && #endif #if !defined(CO_VARKEYWORDS) __Pyx_init_co_variable(inspect, "CO_VARKEYWORDS", &CO_VARKEYWORDS) && #endif #if !defined(CO_ASYNC_GENERATOR) __Pyx_init_co_variable(inspect, "CO_ASYNC_GENERATOR", &CO_ASYNC_GENERATOR) && #endif #if !defined(CO_GENERATOR) __Pyx_init_co_variable(inspect, "CO_GENERATOR", &CO_GENERATOR) && #endif #if !defined(CO_COROUTINE) __Pyx_init_co_variable(inspect, "CO_COROUTINE", &CO_COROUTINE) && #endif 1; Py_DECREF(inspect); return result ? 0 : -1; } static int __Pyx_init_tpflags_bitcount(unsigned long flag) { int count = 0; while (flag) { count += (int) (flag & 1); flag >>= 1; } return count; } static int __Pyx_init_tpflags_variables(void) { if (__Pyx_Runtime_TPFLAGS_SEQUENCE != 0 && __Pyx_Runtime_TPFLAGS_MAPPING != 0) { return 0; } PyObject *collections_abc = PyImport_ImportModule("collections.abc"); if (!collections_abc) return -1; int result = 0; PyObject *sequence = NULL, *mapping = NULL; #if __PYX_LIMITED_VERSION_HEX >= 0x030D0000 if (PyObject_GetOptionalAttrString(collections_abc, "Sequence", &sequence) != 1) goto fail; if (PyObject_GetOptionalAttrString(collections_abc, "Mapping", &mapping) != 1) goto fail; #else sequence = PyObject_GetAttrString(collections_abc, "Sequence"); if (!sequence) goto fail_attr_lookup; mapping = PyObject_GetAttrString(collections_abc, "Mapping"); if (!mapping) goto fail_attr_lookup; #endif if (!PyType_Check(sequence) || !PyType_Check(mapping)) goto fail; { unsigned long sequence_flags = PyType_GetFlags((PyTypeObject*)sequence); unsigned long mapping_flags = PyType_GetFlags((PyTypeObject*)mapping); unsigned long mutual_flags = sequence_flags & mapping_flags; sequence_flags = sequence_flags ^ mutual_flags; mapping_flags = mapping_flags ^ mutual_flags; if (__Pyx_Runtime_TPFLAGS_SEQUENCE == 0 && __Pyx_init_tpflags_bitcount(sequence_flags) == 1) { __Pyx_Runtime_TPFLAGS_SEQUENCE = sequence_flags; } if (__Pyx_Runtime_TPFLAGS_MAPPING == 0 && __Pyx_init_tpflags_bitcount(mapping_flags) == 1) { __Pyx_Runtime_TPFLAGS_MAPPING = mapping_flags; } } cleanup: Py_XDECREF(mapping); Py_XDECREF(sequence); Py_DECREF(collections_abc); return result; #if __PYX_LIMITED_VERSION_HEX < 0x030D0000 fail_attr_lookup: if (PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Clear(); } #endif fail: result = PyErr_Occurred() ? -1 : 0; goto cleanup; } #else static int __Pyx_init_co_variables(void) { return 0; // It's a limited API-only feature } static int __Pyx_init_tpflags_variables(void) { return 0; // It's a limited API-only feature } #endif /* MathInitCode */ #if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) #ifndef _USE_MATH_DEFINES #define _USE_MATH_DEFINES #endif #endif #include #if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) #define __Pyx_truncl trunc #else #define __Pyx_truncl truncl #endif #ifndef CYTHON_CLINE_IN_TRACEBACK_RUNTIME #define CYTHON_CLINE_IN_TRACEBACK_RUNTIME 0 #endif #ifndef CYTHON_CLINE_IN_TRACEBACK #define CYTHON_CLINE_IN_TRACEBACK CYTHON_CLINE_IN_TRACEBACK_RUNTIME #endif #if CYTHON_CLINE_IN_TRACEBACK #define __PYX_MARK_ERR_POS(f_index, lineno) { __pyx_filename = __pyx_f[f_index]; (void) __pyx_filename; __pyx_lineno = lineno; (void) __pyx_lineno; __pyx_clineno = __LINE__; (void) __pyx_clineno; } #else #define __PYX_MARK_ERR_POS(f_index, lineno) { __pyx_filename = __pyx_f[f_index]; (void) __pyx_filename; __pyx_lineno = lineno; (void) __pyx_lineno; (void) __pyx_clineno; } #endif #define __PYX_ERR(f_index, lineno, Ln_error) \ { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } #ifdef CYTHON_EXTERN_C #undef __PYX_EXTERN_C #define __PYX_EXTERN_C CYTHON_EXTERN_C #elif defined(__PYX_EXTERN_C) #ifdef _MSC_VER #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") #else #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. #endif #else #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else #define __PYX_EXTERN_C extern #endif #endif #define __PYX_HAVE__borghash__HashTableNT #define __PYX_HAVE_API__borghash__HashTableNT /* Early includes */ #ifdef _OPENMP #include #endif /* _OPENMP */ #if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) #define CYTHON_WITHOUT_ASSERTIONS #endif #ifdef CYTHON_FREETHREADING_COMPATIBLE #if CYTHON_FREETHREADING_COMPATIBLE #define __Pyx_FREETHREADING_COMPATIBLE Py_MOD_GIL_NOT_USED #else #define __Pyx_FREETHREADING_COMPATIBLE Py_MOD_GIL_USED #endif #else #define __Pyx_FREETHREADING_COMPATIBLE Py_MOD_GIL_USED #endif #define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #define __Pyx_uchar_cast(c) ((unsigned char)c) #define __Pyx_long_cast(x) ((long)x) #define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ (sizeof(type) < sizeof(Py_ssize_t)) ||\ (sizeof(type) > sizeof(Py_ssize_t) &&\ likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX) &&\ (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ v == (type)PY_SSIZE_T_MIN))) ||\ (sizeof(type) == sizeof(Py_ssize_t) &&\ (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX))) ) 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 CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyByteArray_AsString(s) PyByteArray_AS_STRING(s) #else #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AsString(s)) #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AsString(s)) #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AsString(s)) #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AsString(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AsString(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AsString(s)) #define __Pyx_PyByteArray_AsString(s) PyByteArray_AsString(s) #endif #define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) #define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) #define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode static CYTHON_INLINE PyObject *__Pyx_NewRef(PyObject *obj) { #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030a0000 || defined(Py_NewRef) return Py_NewRef(obj); #else Py_INCREF(obj); return obj; #endif } static CYTHON_INLINE PyObject *__Pyx_XNewRef(PyObject *obj) { #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030a0000 || defined(Py_XNewRef) return Py_XNewRef(obj); #else Py_XINCREF(obj); return obj; #endif } static CYTHON_INLINE PyObject *__Pyx_Owned_Py_None(int b); static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); static CYTHON_INLINE PyObject* __Pyx_PyNumber_Long(PyObject* x); #define __Pyx_PyObject_RichCompareBool(a,b,cmp) __Pyx_PyObject_IsTrueAndDecref(PyObject_RichCompare((a),(b),(cmp))) #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_PyLong_FromSize_t(size_t); static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); #if CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) #define __Pyx_PyFloat_AS_DOUBLE(x) PyFloat_AS_DOUBLE(x) #define __Pyx_PyFloat_IsNonZero(x) (PyFloat_AS_DOUBLE(x) != 0.0) #else #define __Pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) #define __Pyx_PyFloat_AS_DOUBLE(x) PyFloat_AsDouble(x) #define __Pyx_PyFloat_IsNonZero(x) PyObject_IsTrue(x) #endif #define __Pyx_PyFloat_AsFloat(x) ((float) __Pyx_PyFloat_AsDouble(x)) #define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(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_SignBits(x) ((int) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK)) #define __Pyx_PyLong_Sign(x) (1 - __Pyx_PyLong_SignBits(x)) #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_SignBits(x) & 2) != 0) #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_SignBits(x) & 1) #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_SignBits(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)\ (((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) (((Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) #endif static CYTHON_INLINE Py_ssize_t __Pyx_PyLong_CompareSignAndSize(PyObject *a, PyObject *b) { uintptr_t tag_a = ((PyLongObject*)a)->long_value.lv_tag; uintptr_t tag_b = ((PyLongObject*)b)->long_value.lv_tag; if (tag_a == tag_b) return 0; int sign_a = (int) (tag_a & _PyLong_SIGN_MASK); int sign_b = (int) (tag_b & _PyLong_SIGN_MASK); if (sign_a > sign_b) return -1; if (sign_a < sign_b) return 1; Py_ssize_t size_a = (Py_ssize_t) (tag_a >> _PyLong_NON_SIZE_BITS); Py_ssize_t size_b = (Py_ssize_t) (tag_b >> _PyLong_NON_SIZE_BITS); return (1 - sign_a) * (size_a - size_b); } typedef Py_ssize_t __Pyx_compact_pylong; typedef size_t __Pyx_compact_upylong; #else #define __Pyx_PyLong_Sign(x) ((int) ((Py_SIZE(x) == 0) ? 0 : (Py_SIZE(x) < 0) ? -1 : 1)) #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])) #define __Pyx_PyLong_CompareSignAndSize(a, b) (Py_SIZE(a) - Py_SIZE(b)) 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 #define __Pyx_PyLong_IsNonZero(x) (!__Pyx_PyLong_IsZero(x)) #else #define __Pyx_PyLong_IsNonZero(x) PyObject_IsTrue(x) #endif #if __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) #elif __PYX_DEFAULT_STRING_ENCODING_IS_ASCII #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeASCII(c_str, size, NULL) #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #endif /* 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__ */ /* PretendToInitialize */ #ifdef __cplusplus #if __cplusplus > 201103L #include #endif template static void __Pyx_pretend_to_initialize(T* ptr) { #if __cplusplus > 201103L if ((std::is_trivially_default_constructible::value)) #endif *ptr = T(); (void)ptr; } #else static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } #endif #if !CYTHON_USE_MODULE_STATE static PyObject *__pyx_m = NULL; #endif static const char * const __pyx_cfilenm = __FILE__; /* #### Code section: filename_table ### */ static const char* const __pyx_f[] = { "src/borghash/HashTableNT.pyx", "(tree fragment)", }; /* #### Code section: utility_code_proto_before_types ### */ /* Atomics.proto (used by UnpackUnboundCMethod) */ #include #ifndef CYTHON_ATOMICS #define CYTHON_ATOMICS 1 #endif #define __PYX_CYTHON_ATOMICS_ENABLED() CYTHON_ATOMICS #define __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING() CYTHON_COMPILING_IN_CPYTHON_FREETHREADING #define __pyx_atomic_int_type int #define __pyx_nonatomic_int_type int #if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\ (__STDC_VERSION__ >= 201112L) &&\ !defined(__STDC_NO_ATOMICS__)) #include #elif CYTHON_ATOMICS && (defined(__cplusplus) && (\ (__cplusplus >= 201103L) ||\ (defined(_MSC_VER) && _MSC_VER >= 1700))) #include #endif #if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\ (__STDC_VERSION__ >= 201112L) &&\ !defined(__STDC_NO_ATOMICS__) &&\ ATOMIC_INT_LOCK_FREE == 2) #undef __pyx_atomic_int_type #define __pyx_atomic_int_type atomic_int #define __pyx_atomic_ptr_type atomic_uintptr_t #define __pyx_nonatomic_ptr_type uintptr_t #define __pyx_atomic_incr_relaxed(value) atomic_fetch_add_explicit(value, 1, memory_order_relaxed) #define __pyx_atomic_incr_acq_rel(value) atomic_fetch_add_explicit(value, 1, memory_order_acq_rel) #define __pyx_atomic_decr_acq_rel(value) atomic_fetch_sub_explicit(value, 1, memory_order_acq_rel) #define __pyx_atomic_sub(value, arg) atomic_fetch_sub(value, arg) #define __pyx_atomic_int_cmp_exchange(value, expected, desired) atomic_compare_exchange_strong(value, expected, desired) #define __pyx_atomic_load(value) atomic_load(value) #define __pyx_atomic_store(value, new_value) atomic_store(value, new_value) #define __pyx_atomic_pointer_load_relaxed(value) atomic_load_explicit(value, memory_order_relaxed) #define __pyx_atomic_pointer_load_acquire(value) atomic_load_explicit(value, memory_order_acquire) #define __pyx_atomic_pointer_exchange(value, new_value) atomic_exchange(value, (__pyx_nonatomic_ptr_type)new_value) #define __pyx_atomic_pointer_cmp_exchange(value, expected, desired) atomic_compare_exchange_strong(value, expected, desired) #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) #pragma message ("Using standard C atomics") #elif defined(__PYX_DEBUG_ATOMICS) #warning "Using standard C atomics" #endif #elif CYTHON_ATOMICS && (defined(__cplusplus) && (\ (__cplusplus >= 201103L) ||\ \ (defined(_MSC_VER) && _MSC_VER >= 1700)) &&\ ATOMIC_INT_LOCK_FREE == 2) #undef __pyx_atomic_int_type #define __pyx_atomic_int_type std::atomic_int #define __pyx_atomic_ptr_type std::atomic_uintptr_t #define __pyx_nonatomic_ptr_type uintptr_t #define __pyx_atomic_incr_relaxed(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_relaxed) #define __pyx_atomic_incr_acq_rel(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_acq_rel) #define __pyx_atomic_decr_acq_rel(value) std::atomic_fetch_sub_explicit(value, 1, std::memory_order_acq_rel) #define __pyx_atomic_sub(value, arg) std::atomic_fetch_sub(value, arg) #define __pyx_atomic_int_cmp_exchange(value, expected, desired) std::atomic_compare_exchange_strong(value, expected, desired) #define __pyx_atomic_load(value) std::atomic_load(value) #define __pyx_atomic_store(value, new_value) std::atomic_store(value, new_value) #define __pyx_atomic_pointer_load_relaxed(value) std::atomic_load_explicit(value, std::memory_order_relaxed) #define __pyx_atomic_pointer_load_acquire(value) std::atomic_load_explicit(value, std::memory_order_acquire) #define __pyx_atomic_pointer_exchange(value, new_value) std::atomic_exchange(value, (__pyx_nonatomic_ptr_type)new_value) #define __pyx_atomic_pointer_cmp_exchange(value, expected, desired) std::atomic_compare_exchange_strong(value, expected, desired) #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) #pragma message ("Using standard C++ atomics") #elif defined(__PYX_DEBUG_ATOMICS) #warning "Using standard C++ atomics" #endif #elif CYTHON_ATOMICS && (__GNUC__ >= 5 || (__GNUC__ == 4 &&\ (__GNUC_MINOR__ > 1 ||\ (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ >= 2)))) #define __pyx_atomic_ptr_type void* #define __pyx_nonatomic_ptr_type void* #define __pyx_atomic_incr_relaxed(value) __sync_fetch_and_add(value, 1) #define __pyx_atomic_incr_acq_rel(value) __sync_fetch_and_add(value, 1) #define __pyx_atomic_decr_acq_rel(value) __sync_fetch_and_sub(value, 1) #define __pyx_atomic_sub(value, arg) __sync_fetch_and_sub(value, arg) static CYTHON_INLINE int __pyx_atomic_int_cmp_exchange(__pyx_atomic_int_type* value, __pyx_nonatomic_int_type* expected, __pyx_nonatomic_int_type desired) { __pyx_nonatomic_int_type old = __sync_val_compare_and_swap(value, *expected, desired); int result = old == *expected; *expected = old; return result; } #define __pyx_atomic_load(value) __sync_fetch_and_add(value, 0) #define __pyx_atomic_store(value, new_value) __sync_lock_test_and_set(value, new_value) #define __pyx_atomic_pointer_load_relaxed(value) __sync_fetch_and_add(value, 0) #define __pyx_atomic_pointer_load_acquire(value) __sync_fetch_and_add(value, 0) #define __pyx_atomic_pointer_exchange(value, new_value) __sync_lock_test_and_set(value, (__pyx_atomic_ptr_type)new_value) static CYTHON_INLINE int __pyx_atomic_pointer_cmp_exchange(__pyx_atomic_ptr_type* value, __pyx_nonatomic_ptr_type* expected, __pyx_nonatomic_ptr_type desired) { __pyx_nonatomic_ptr_type old = __sync_val_compare_and_swap(value, *expected, desired); int result = old == *expected; *expected = old; return result; } #ifdef __PYX_DEBUG_ATOMICS #warning "Using GNU atomics" #endif #elif CYTHON_ATOMICS && defined(_MSC_VER) #include #undef __pyx_atomic_int_type #define __pyx_atomic_int_type long #define __pyx_atomic_ptr_type void* #undef __pyx_nonatomic_int_type #define __pyx_nonatomic_int_type long #define __pyx_nonatomic_ptr_type void* #pragma intrinsic (_InterlockedExchangeAdd, _InterlockedExchange, _InterlockedCompareExchange, _InterlockedCompareExchangePointer, _InterlockedExchangePointer) #define __pyx_atomic_incr_relaxed(value) _InterlockedExchangeAdd(value, 1) #define __pyx_atomic_incr_acq_rel(value) _InterlockedExchangeAdd(value, 1) #define __pyx_atomic_decr_acq_rel(value) _InterlockedExchangeAdd(value, -1) #define __pyx_atomic_sub(value, arg) _InterlockedExchangeAdd(value, -arg) static CYTHON_INLINE int __pyx_atomic_int_cmp_exchange(__pyx_atomic_int_type* value, __pyx_nonatomic_int_type* expected, __pyx_nonatomic_int_type desired) { __pyx_nonatomic_int_type old = _InterlockedCompareExchange(value, desired, *expected); int result = old == *expected; *expected = old; return result; } #define __pyx_atomic_load(value) _InterlockedExchangeAdd(value, 0) #define __pyx_atomic_store(value, new_value) _InterlockedExchange(value, new_value) #define __pyx_atomic_pointer_load_relaxed(value) *(void * volatile *)value #define __pyx_atomic_pointer_load_acquire(value) _InterlockedCompareExchangePointer(value, 0, 0) #define __pyx_atomic_pointer_exchange(value, new_value) _InterlockedExchangePointer(value, (__pyx_atomic_ptr_type)new_value) static CYTHON_INLINE int __pyx_atomic_pointer_cmp_exchange(__pyx_atomic_ptr_type* value, __pyx_nonatomic_ptr_type* expected, __pyx_nonatomic_ptr_type desired) { __pyx_atomic_ptr_type old = _InterlockedCompareExchangePointer(value, desired, *expected); int result = old == *expected; *expected = old; return result; } #ifdef __PYX_DEBUG_ATOMICS #pragma message ("Using MSVC atomics") #endif #else #undef CYTHON_ATOMICS #define CYTHON_ATOMICS 0 #ifdef __PYX_DEBUG_ATOMICS #warning "Not using atomics" #endif #endif /* CriticalSectionsDefinition.proto (used by CriticalSections) */ #if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING #define __Pyx_PyCriticalSection void* #define __Pyx_PyCriticalSection2 void* #define __Pyx_PyCriticalSection_End(cs) #define __Pyx_PyCriticalSection2_End(cs) #else #define __Pyx_PyCriticalSection PyCriticalSection #define __Pyx_PyCriticalSection2 PyCriticalSection2 #define __Pyx_PyCriticalSection_End PyCriticalSection_End #define __Pyx_PyCriticalSection2_End PyCriticalSection2_End #endif /* CriticalSections.proto (used by ParseKeywordsImpl) */ #if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING #define __Pyx_PyCriticalSection_Begin(cs, arg) (void)(cs) #define __Pyx_PyCriticalSection2_Begin(cs, arg1, arg2) (void)(cs) #else #define __Pyx_PyCriticalSection_Begin PyCriticalSection_Begin #define __Pyx_PyCriticalSection2_Begin PyCriticalSection2_Begin #endif #if PY_VERSION_HEX < 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_BEGIN_CRITICAL_SECTION(o) { #define __Pyx_END_CRITICAL_SECTION() } #else #define __Pyx_BEGIN_CRITICAL_SECTION Py_BEGIN_CRITICAL_SECTION #define __Pyx_END_CRITICAL_SECTION Py_END_CRITICAL_SECTION #endif /* IncludeStructmemberH.proto (used by CythonFunctionShared) */ #include /* #### Code section: numeric_typedefs ### */ /* #### Code section: complex_type_declarations ### */ /* #### Code section: type_declarations ### */ /*--- Type declarations ---*/ struct __pyx_obj_8borghash_11HashTableNT_HashTableNT; struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct__genexpr; struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct_1_items; /* "borghash/HashTableNT.pxd":1 * cdef class HashTableNT: # <<<<<<<<<<<<<< * cdef int key_size * cdef object byte_order */ struct __pyx_obj_8borghash_11HashTableNT_HashTableNT { PyObject_HEAD int key_size; PyObject *byte_order; PyObject *value_type; PyObject *value_format; PyObject *value_struct; int value_size; PyObject *inner; }; /* "borghash/HashTableNT.pyx":36 * if value_format._fields != value_type._fields: * raise TypeError("value_format's and value_type's element names must correspond.") * if not all(isinstance(fmt, str) and len(fmt) > 0 for fmt in value_format): # <<<<<<<<<<<<<< * raise ValueError("value_format's elements must be str and non-empty.") * if byte_order not in BYTE_ORDER: */ struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct__genexpr { PyObject_HEAD PyObject *__pyx_genexpr_arg_0; PyObject *__pyx_v_fmt; }; /* "borghash/HashTableNT.pyx":93 * return key in self.inner * * def items(self, *, prefix_bits: int = 0, prefix: int = 0) -> Iterator[tuple[bytes, Any]]: # <<<<<<<<<<<<<< * """ * Iterate over items, optionally only over items whose key starts with the given bit prefix. */ struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct_1_items { PyObject_HEAD PyObject *__pyx_v_binary_value; PyObject *__pyx_v_key; PyObject *__pyx_v_prefix; PyObject *__pyx_v_prefix_bits; struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self; PyObject *__pyx_t_0; Py_ssize_t __pyx_t_1; PyObject *(*__pyx_t_2)(PyObject *); }; /* #### 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; #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);\ } #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) /* FastTypeChecks.proto (used by GivenExceptionMatches) */ #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); #define __Pyx_PyAnySet_Check(obj) __Pyx_TypeCheck2(obj, &PySet_Type, &PyFrozenSet_Type) #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_PyAnySet_Check(obj) PyAnySet_Check(obj) #endif /* PyThreadStateGet.proto (used by PyErrFetchRestore) */ #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 (used by GivenExceptionMatches) */ #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 /* GivenExceptionMatches.proto (used by PyErrExceptionMatches) */ #if CYTHON_COMPILING_IN_CPYTHON 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_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2) { return PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2); } #endif #define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) /* PyErrExceptionMatches.proto (used by PyObjectGetAttrStrNoError) */ #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 /* PyObjectGetAttrStr.proto (used by PyObjectGetAttrStrNoError) */ #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 (used by GetBuiltinName) */ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); /* CopyObjectArray.proto (used by TupleOrListFromArrayImpl) */ #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); #endif /* TupleOrListFromArrayImpl.proto (used by TupleFromArray) */ #if PY_VERSION_HEX >= 0x030F0000 && !CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_PyTuple_FromArray(src, n) PyTuple_FromArray(src, ((n)<0) ? 0 : (n)) #else CYTHON_UNUSED static PyObject * __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); #endif /* TupleFromArray.proto (used by fastcall) */ /* IncludeStringH.proto (used by PyObjectCompare) */ #include /* PyObjectCompare.proto (used by UnicodeEquals) */ static CYTHON_INLINE int __Pyx_PyObject_CompareBoolEq_str_str(PyObject *op1, PyObject *op2, int pyop); /* UnicodeEquals.proto (used by fastcall) */ #define __Pyx_PyUnicode_Equals(s1, s2) __Pyx_PyObject_CompareBoolEq_str_str(s1, s2, Py_EQ) /* fastcall.proto */ #if CYTHON_AVOID_BORROWED_REFS #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_PySequence_ITEM(args, i) #elif CYTHON_ASSUME_SAFE_MACROS #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_NewRef(__Pyx_PyTuple_GET_ITEM(args, i)) #else #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_XNewRef(PyTuple_GetItem(args, i)) #endif #define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) #define __Pyx_KwValues_VARARGS(args, nargs) NULL #define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) #define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) #if CYTHON_VECTORCALL #define __Pyx_ArgRef_FASTCALL(args, i) __Pyx_NewRef(args[i]) #define __Pyx_NumKwargs_FASTCALL(kwds) __Pyx_PyTuple_GET_SIZE(kwds) #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_GRAAL CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); #else #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) #endif #else #define __Pyx_ArgRef_FASTCALL __Pyx_ArgRef_VARARGS #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS #endif #if CYTHON_VECTORCALL_TPNEW #if !CYTHON_VECTORCALL #error Enabling CYTHON_VECTORCALL_TPNEW without CYTHON_VECTORCALL is not supported #endif #define __Pyx_ArgRef_FASTCALL_TPNEW __Pyx_ArgRef_FASTCALL #define __Pyx_NumKwargs_FASTCALL_TPNEW __Pyx_NumKwargs_FASTCALL #define __Pyx_KwValues_FASTCALL_TPNEW __Pyx_KwValues_FASTCALL #define __Pyx_GetKwValue_FASTCALL_TPNEW __Pyx_GetKwValue_FASTCALL #define __Pyx_KwargsAsDict_FASTCALL_TPNEW __Pyx_KwargsAsDict_FASTCALL #else #define __Pyx_ArgRef_FASTCALL_TPNEW __Pyx_ArgRef_VARARGS #define __Pyx_NumKwargs_FASTCALL_TPNEW __Pyx_NumKwargs_VARARGS #define __Pyx_KwValues_FASTCALL_TPNEW __Pyx_KwValues_VARARGS #define __Pyx_GetKwValue_FASTCALL_TPNEW __Pyx_GetKwValue_VARARGS #define __Pyx_KwargsAsDict_FASTCALL_TPNEW __Pyx_KwargsAsDict_VARARGS #endif #define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) #if CYTHON_VECTORCALL #define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(args + start, stop - start) #else #define __Pyx_ArgsSlice_FASTCALL __Pyx_ArgsSlice_VARARGS #endif /* py_dict_items.proto (used by OwnedDictNext) */ #define __Pyx_PyDict_items_TypePtr (&PyDictKeys_Type) #define __Pyx_PyDict_items_Check(obj) PyObject_TypeCheck((obj), __Pyx_PyDictItems_TypePtr) #define __Pyx_PyDict_items_CheckExact(obj) Py_IS_TYPE((obj), __Pyx_PyDictItems_TypePtr) static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d); /* CallCFunction.proto (used by CallUnboundCMethod0) */ #define __Pyx_CallCFunction(cfunc, self, args)\ ((PyCFunction)(void(*)(void))(cfunc)->func)(self, args) #define __Pyx_CallCFunctionWithKeywords(cfunc, self, args, kwargs)\ ((PyCFunctionWithKeywords)(void(*)(void))(cfunc)->func)(self, args, kwargs) #define __Pyx_CallCFunctionFast(cfunc, self, args, nargs)\ ((__Pyx_PyCFunctionFast)(void(*)(void))(PyCFunction)(cfunc)->func)(self, args, nargs) #define __Pyx_CallCFunctionFastWithKeywords(cfunc, self, args, nargs, kwnames)\ ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))(PyCFunction)(cfunc)->func)(self, args, nargs, kwnames) /* PyObjectCall.proto (used by PyObjectFastCall) */ #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 (used by PyObjectFastCall) */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif /* PyObjectFastCall.proto (used by PyObjectCallOneArg) */ #define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject * const*args, size_t nargsf, PyObject *kwargs); /* PyObjectCallOneArg.proto (used by CallUnboundCMethod0) */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); /* UnpackUnboundCMethod_decl.proto (used by UnpackUnboundCMethod) */ typedef struct { PyObject *type; PyObject **method_name; PyCFunction func; PyObject *method; int flag; #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && CYTHON_ATOMICS __pyx_atomic_int_type initialized; #endif } __Pyx_CachedCFunction; /* IgnoreException.proto (used by UnpackUnboundCMethod_impl) */ static CYTHON_INLINE int __Pyx_IgnoreGivenException(PyObject *given_exception, PyObject *ignorable_exception); #define __Pyx_IgnoreException(ignorable_exception) __Pyx_IgnoreGivenException(NULL, ignorable_exception) /* UnpackUnboundCMethod_impl.export */ static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target); /* UnpackUnboundCMethod.proto (used by CallUnboundCMethod0) */ #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING static CYTHON_INLINE int __Pyx_CachedCFunction_GetAndSetInitializing(__Pyx_CachedCFunction *cfunc) { #if !CYTHON_ATOMICS return 1; #else __pyx_nonatomic_int_type expected = 0; if (__pyx_atomic_int_cmp_exchange(&cfunc->initialized, &expected, 1)) { return 0; } return expected; #endif } static CYTHON_INLINE void __Pyx_CachedCFunction_SetFinishedInitializing(__Pyx_CachedCFunction *cfunc) { #if CYTHON_ATOMICS __pyx_atomic_store(&cfunc->initialized, 2); #endif } #else #define __Pyx_CachedCFunction_GetAndSetInitializing(cfunc) 2 #define __Pyx_CachedCFunction_SetFinishedInitializing(cfunc) #endif /* CallUnboundCMethod0.proto */ CYTHON_UNUSED static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self); #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self); #else #define __Pyx_CallUnboundCMethod0(cfunc, self) __Pyx__CallUnboundCMethod0(cfunc, self) #endif /* py_dict_values.proto (used by OwnedDictNext) */ #define __Pyx_PyDict_values_TypePtr (&PyDictKeys_Type) #define __Pyx_PyDict_values_Check(obj) PyObject_TypeCheck((obj), __Pyx_PyDictValues_TypePtr) #define __Pyx_PyDict_values_CheckExact(obj) Py_IS_TYPE((obj), __Pyx_PyDictValues_TypePtr) static CYTHON_INLINE PyObject* __Pyx_PyDict_Values(PyObject* d); /* OwnedDictNext.proto (used by ParseKeywordsImpl) */ #if CYTHON_AVOID_BORROWED_REFS static int __Pyx_PyDict_NextRef(PyObject *p, PyObject **ppos, PyObject **pkey, PyObject **pvalue); #else CYTHON_INLINE static int __Pyx_PyDict_NextRef(PyObject *p, Py_ssize_t *ppos, PyObject **pkey, PyObject **pvalue); #endif /* RaiseDoubleKeywords.proto (used by ParseKeywordsImpl) */ static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); /* ParseKeywordsImpl.export */ static int __Pyx_ParseKeywordsTuple( PyObject *kwds, PyObject * const *kwvalues, PyObject ** const argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, Py_ssize_t num_kwargs, const char* function_name, int ignore_unknown_kwargs ); static int __Pyx_ParseKeywordDictToDict( PyObject *kwds, PyObject ** const argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name ); static int __Pyx_ParseKeywordDict( PyObject *kwds, PyObject ** const argnames[], PyObject *values[], Py_ssize_t num_pos_args, Py_ssize_t num_kwargs, const char* function_name, int ignore_unknown_kwargs ); /* CallUnboundCMethod2.proto */ CYTHON_UNUSED static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2); #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2); #else #define __Pyx_CallUnboundCMethod2(cfunc, self, arg1, arg2) __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2) #endif /* ParseKeywords.proto */ static CYTHON_INLINE int __Pyx_ParseKeywords( PyObject *kwds, PyObject *const *kwvalues, PyObject ** const argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, Py_ssize_t num_kwargs, const char* function_name, int ignore_unknown_kwargs ); /* RaiseKeywordRequired.proto */ static void __Pyx_RaiseKeywordRequired(const char* func_name, PyObject* kw_name); /* FormatTypeName.proto (used by pybuiltin_invalid) */ #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX >= 0x030d0000 typedef PyObject *__Pyx_TypeName; #define __Pyx_FMT_TYPENAME "%N" #define __Pyx_PyType_GetFullyQualifiedName(tp) Py_NewRef((PyObject*)tp) #define __Pyx_DECREF_TypeName(obj) Py_DECREF(obj) #elif CYTHON_COMPILING_IN_LIMITED_API typedef PyObject *__Pyx_TypeName; #define __Pyx_FMT_TYPENAME "%U" #define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) static __Pyx_TypeName __Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp); #else // !LIMITED_API typedef const char *__Pyx_TypeName; #define __Pyx_FMT_TYPENAME "%.200s" #define __Pyx_PyType_GetFullyQualifiedName(tp) ((tp)->tp_name) #define __Pyx_DECREF_TypeName(obj) #endif /* pybuiltin_invalid.export */ static void __Pyx_PyBuiltin_Invalid(PyObject *obj, const char *builtin_type_name, const char *argname); /* pyint_simplify.proto */ static CYTHON_INLINE int __Pyx_PyInt_FromNumber(PyObject **number_var, const char *argname, int accept_none); /* RaiseArgTupleInvalid.export */ 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); /* ArgTypeTestError.export */ static void __Pyx_ArgTypeError(PyObject *obj, PyTypeObject *type, const char *name, int exact); /* ArgTypeTest.proto */ static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, const char *name, int exact); /* RaiseUnboundLocalError.proto */ static void __Pyx_RaiseUnboundLocalError(const char *varname); /* GetException.proto (used by pep479) */ #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); /* PyObjectCompare.proto */ static CYTHON_INLINE int __Pyx_PyObject_CompareBoolGe_int_int(PyObject *op1, PyObject *op2, int pyop); /* PyValueError_Check.proto */ #define __Pyx_PyExc_ValueError_Check(obj) __Pyx_TypeCheck(obj, PyExc_ValueError) /* RaiseException.export */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); /* PyTypeError_Check.proto */ #define __Pyx_PyExc_TypeError_Check(obj) __Pyx_TypeCheck(obj, PyExc_TypeError) /* PyObjectCompare.proto */ static CYTHON_INLINE int __Pyx_PyObject_CompareBoolNe_object_object(PyObject *op1, PyObject *op2, int pyop); /* PyDictVersioning.proto (used by GetModuleGlobalName) */ #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_XNewRef(__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_mstate_global->__pyx_d))) ?\ (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } while(0) #define __Pyx_GetModuleGlobalNameUncached(var, name) do {\ PY_UINT64_T __pyx_dict_version;\ PyObject *__pyx_dict_cached_value;\ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } while(0) static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); #else #define __Pyx_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 /* 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)); } /* PyFrozenDict.proto (used by GetItemInt) */ #if CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_PyFrozenDict_TypePtr ((PyTypeObject*) __pyx_mstate_global->__Pyx_PyFrozenDictType) #define __Pyx_PyFrozenDict_New(it) __Pyx__PyFrozenDict_New(__pyx_mstate_global->__Pyx_PyFrozenDictType, it) static CYTHON_INLINE PyObject* __Pyx__PyFrozenDict_New(PyObject* frozendict_type, PyObject* it); #define __Pyx_PyFrozenDict_NewEmpty() __Pyx_PyFrozenDict_New(NULL) #define __Pyx_PyFrozenDict_Check(obj) PyObject_TypeCheck((obj), __Pyx_PyFrozenDict_TypePtr) #define __Pyx_PyFrozenDict_CheckExact(obj) Py_IS_TYPE((obj), __Pyx_PyFrozenDict_TypePtr) #define __Pyx_PyAnyDict_Check(obj) __Pyx__PyAnyDict_Check(obj, __Pyx_PyFrozenDict_TypePtr) static CYTHON_INLINE int __Pyx__PyAnyDict_Check(PyObject *obj, PyTypeObject* frozendict_type) { return PyObject_TypeCheck(obj, &PyDict_Type) || PyObject_TypeCheck(obj, frozendict_type); } #define __Pyx_PyAnyDict_CheckExact(obj) __Pyx__PyAnyDict_CheckExact(obj, __Pyx_PyFrozenDict_TypePtr) static CYTHON_INLINE int __Pyx__PyAnyDict_CheckExact(PyObject *obj, PyTypeObject* frozendict_type) { return Py_IS_TYPE(obj, &PyDict_Type) || Py_IS_TYPE(obj, frozendict_type); } #elif PY_VERSION_HEX >= 0x030f00a6 ||\ (defined(PyFrozenDict_Check) && defined(PyAnyDict_Check) && defined(PyFrozenDict_New)) #define __Pyx_PyFrozenDict_TypePtr (&PyFrozenDict_Type) #define __Pyx_PyFrozenDict_New(it) PyFrozenDict_New(it) #define __Pyx_PyFrozenDict_NewEmpty() PyFrozenDict_New(NULL) #define __Pyx_PyFrozenDict_Check(obj) PyFrozenDict_Check(obj) #define __Pyx_PyFrozenDict_CheckExact(obj) PyFrozenDict_CheckExact(obj) #define __Pyx_PyAnyDict_Check(obj) PyAnyDict_Check(obj) #define __Pyx_PyAnyDict_CheckExact(obj) PyAnyDict_CheckExact(obj) #else #define __Pyx_PyFrozenDict_TypePtr (&PyDict_Type) static CYTHON_INLINE PyObject* __Pyx_PyFrozenDict_New(PyObject* it) { if (!it) { return PyDict_New(); } else if (PyDict_Check(it)) { return PyDict_Copy(it); } else { PyObject *dict = PyDict_New(); if (!dict) return NULL; PyObject *result = PyNumber_InPlaceOr(dict, it); Py_DECREF(dict); return result; } } #define __Pyx_PyFrozenDict_NewEmpty() PyDict_New() #define __Pyx_PyFrozenDict_Check(obj) PyDict_Check(obj) #define __Pyx_PyFrozenDict_CheckExact(obj) PyDict_CheckExact(obj) #define __Pyx_PyAnyDict_Check(obj) PyDict_Check(obj) #define __Pyx_PyAnyDict_CheckExact(obj) PyDict_CheckExact(obj) #endif /* GetItemInt.proto */ #define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, wraparound, boundscheck, has_gil, unsafe_shared)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, wraparound, boundscheck, unsafe_shared) :\ __Pyx_GetItemInt_Generic(o, to_py_func(i))) #define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, wraparound, boundscheck, has_gil, unsafe_shared)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck, unsafe_shared) :\ (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, int unsafe_shared); #define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, wraparound, boundscheck, has_gil, unsafe_shared)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck, unsafe_shared) :\ (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, int unsafe_shared); static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck, int unsafe_shared); /* RaiseErrorWithObjectType.proto (used by ObjectGetItem) */ #define __Pyx_RaiseTypeErrorWithObjectType(message, obj) __Pyx_RaiseErrorWithObjectType(PyExc_TypeError, message, obj) #define __Pyx_RaiseErrorWithObjectType(exc_type, message, obj) __Pyx_RaiseErrorWithType(exc_type, message, Py_TYPE(obj)) CYTHON_UNUSED static void __Pyx_RaiseErrorWithType(PyObject* exc_type, const char* message, PyTypeObject *type_obj); /* ObjectGetItem.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key); #else #define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key) #endif /* PyObjectVectorcallKwds.proto */ #if CYTHON_VECTORCALL #define __Pyx_Object_VectorcallKwds PyObject_Vectorcall CYTHON_UNUSED static int __Pyx_CheckVectorcallKwarg(PyObject *kwnames, Py_ssize_t i); #else #define __Pyx_Object_VectorcallKwds __Pyx_PyObject_FastCallDict CYTHON_UNUSED static PyObject *__Pyx_MakeKwargDict(PyObject **keys, PyObject **values, Py_ssize_t n); CYTHON_UNUSED static int __Pyx_CheckVectorcallKwarg(PyObject **kwnames, Py_ssize_t i); #endif /* RejectKeywords.export */ static void __Pyx_RejectKeywords(const char* function_name, PyObject *kwds); /* PyObjectFastCallMethod.proto */ #if CYTHON_VECTORCALL #define __Pyx_PyObject_FastCallMethod(name, args, nargsf) PyObject_VectorcallMethod(name, args, nargsf, NULL) #else static PyObject *__Pyx_PyObject_FastCallMethod(PyObject *name, PyObject *const *args, size_t nargsf); #endif /* PyObjectFormatSimple.proto */ #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyObject_FormatSimple(s, f) (\ likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ PyObject_Format(s, f)) #elif CYTHON_USE_TYPE_SLOTS #define __Pyx_PyObject_FormatSimple(s, f) (\ likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ likely(PyLong_CheckExact(s)) ? PyLong_Type.tp_repr(s) :\ likely(PyFloat_CheckExact(s)) ? PyFloat_Type.tp_repr(s) :\ PyObject_Format(s, f)) #else #define __Pyx_PyObject_FormatSimple(s, f) (\ likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ PyObject_Format(s, f)) #endif /* BuildPyUnicode.proto (used by COrdinalToPyUnicode) */ static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, const char* chars, int clength, int prepend_sign, char padding_char); /* COrdinalToPyUnicode.proto (used by CIntToPyUnicode) */ static CYTHON_INLINE int __Pyx_CheckUnicodeValue(int value); static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromOrdinal_Padded(int value, Py_ssize_t width, char padding_char); /* GCCDiagnostics.proto (used by CIntToPyUnicode) */ #if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) #define __Pyx_HAS_GCC_DIAGNOSTIC #endif /* IncludeStdlibH.proto (used by CIntToPyUnicode) */ #include /* CIntToPyUnicode.proto */ #define __Pyx_PyUnicode_From_int(value, width, padding_char, format_char) (\ ((format_char) == ('c')) ?\ __Pyx_uchar___Pyx_PyUnicode_From_int(value, width, padding_char) :\ __Pyx____Pyx_PyUnicode_From_int(value, width, padding_char, format_char)\ ) static CYTHON_INLINE PyObject* __Pyx_uchar___Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char); static CYTHON_INLINE PyObject* __Pyx____Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char, char format_char); /* JoinPyUnicode.proto */ #define __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH\ (!CYTHON_COMPILING_IN_GRAAL && !CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) /* JoinPyUnicode.export */ static PyObject* __Pyx_PyUnicode_Join(PyObject** values, Py_ssize_t value_count, Py_ssize_t result_ulength, int kind); /* RaiseErrorWithObjectType1.proto (used by RaiseUnexpectedTypeError) */ #define __Pyx_RaiseTypeErrorWithObjectType1(message, arg, obj) __Pyx_RaiseErrorWithObjectType1(PyExc_TypeError, message, arg, obj) #define __Pyx_RaiseErrorWithObjectType1(exc_type, message, arg, obj) __Pyx_RaiseErrorWithType1(exc_type, message, arg, Py_TYPE(obj)) CYTHON_UNUSED static void __Pyx_RaiseErrorWithType1(PyObject* exc_type, const char* message, const char *arg, PyTypeObject *type_obj); /* RaiseUnexpectedTypeError.proto */ CYTHON_UNUSED static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj); /* PyObjectVectorcallMethodKwds.proto */ #if CYTHON_VECTORCALL #define __Pyx_Object_VectorcallMethodKwds PyObject_VectorcallMethod #else static PyObject *__Pyx_Object_VectorcallMethodKwds(PyObject *name, PyObject *const *args, size_t nargsf, PyObject *kwnames); #endif /* RaiseTooManyValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); /* RaiseNeedMoreValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); /* IterFinish.proto */ static CYTHON_INLINE int __Pyx_IterFinish(void); /* UnpackItemEndCheck.proto */ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); /* GetTopmostException.proto (used by SaveResetException) */ #if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); #endif /* SaveResetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); #else #define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) #define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) #endif /* PyKeyError_Check.proto */ #define __Pyx_PyExc_KeyError_Check(obj) __Pyx_TypeCheck(obj, PyExc_KeyError) /* PyObjectCallMethod0.proto (used by dict_iter_common) */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); /* RaiseNoneIterError.proto (used by UnpackTupleError) */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); /* UnpackTupleError.proto (used by UnpackTuple2) */ static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index); /* UnpackTuple2.proto (used by dict_iter_common) */ static CYTHON_INLINE int __Pyx_unpack_tuple2( PyObject* tuple, PyObject** value1, PyObject** value2, int is_tuple, int has_known_size, int decref_tuple); static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( PyObject* tuple, PyObject** value1, PyObject** value2, int decref_tuple); static int __Pyx_unpack_tuple2_generic( PyObject* tuple, PyObject** value1, PyObject** value2, int has_known_size, int decref_tuple); /* dict_iter_common.proto (used by dict_iter) */ static PyObject *__Pyx_dict_call_to_get_iterable(PyObject* iterable, PyObject* method_name); 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); /* 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); /* HasAttr.proto */ #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 #define __Pyx_HasAttr(o, n) PyObject_HasAttrWithError(o, n) #else static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); #endif /* PyObjectLookupSpecial.proto */ #if CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS #define __Pyx_PyObject_LookupSpecialNoError(obj, attr_name) __Pyx__PyObject_LookupSpecial(obj, attr_name, 0) #define __Pyx_PyObject_LookupSpecial(obj, attr_name) __Pyx__PyObject_LookupSpecial(obj, attr_name, 1) static CYTHON_INLINE PyObject* __Pyx__PyObject_LookupSpecial(PyObject* obj, PyObject* attr_name, int with_error); #else #define __Pyx_PyObject_LookupSpecialNoError(o,n) __Pyx_PyObject_GetAttrStrNoError(o,n) #define __Pyx_PyObject_LookupSpecial(o,n) __Pyx_PyObject_GetAttrStr(o,n) #endif /* PyLongBinop.proto */ #if !CYTHON_COMPILING_IN_PYPY static CYTHON_INLINE PyObject* __Pyx_PyLong_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); #else #define __Pyx_PyLong_AddObjC(op1, op2, intval, inplace, zerodivision_check)\ (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2)) #endif /* AssertionsEnabled.proto */ #if CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX >= 0x030C0000 static int __pyx_assertions_enabled_flag; #define __pyx_assertions_enabled() (__pyx_assertions_enabled_flag) #if __clang__ || __GNUC__ __attribute__((no_sanitize("thread"))) #endif 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 /* PyObjectCompare.proto */ static CYTHON_INLINE int __Pyx_PyObject_CompareBoolEq_int_object(PyObject *op1, PyObject *op2, int pyop); /* PyAssertionError_Check.proto */ #define __Pyx_PyExc_AssertionError_Check(obj) __Pyx_TypeCheck(obj, PyExc_AssertionError) /* PyObjectCompare.proto */ static CYTHON_INLINE int __Pyx_PyObject_CompareBoolLt_int_object(PyObject *op1, PyObject *op2, int pyop); /* PyObjectCallNoArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); /* DictGetItem.proto */ #if !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); #define __Pyx_PyObject_Dict_GetItem(obj, name)\ (likely(__Pyx_PyAnyDict_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 /* PyRange_Check.proto */ #if CYTHON_COMPILING_IN_PYPY && !defined(PyRange_Check) #define PyRange_Check(obj) __Pyx_TypeCheck((obj), &PyRange_Type) #endif /* RaiseErrorWithObjectTypes.proto (used by PyNumberBinop) */ #define __Pyx_RaiseErrorWithObjectTypes1(exc_type, message, arg, obj1, obj2) __Pyx_RaiseErrorWithTypes1(exc_type, message, arg, Py_TYPE(obj1), Py_TYPE(obj2)) #define __Pyx_RaiseTypeErrorWithObjectTypes(message, obj1, obj2) __Pyx_RaiseTypeErrorWithTypes(message, Py_TYPE(obj1), Py_TYPE(obj2)) #define __Pyx_RaiseTypeErrorWithTypes(message, type_obj1, type_obj2) __Pyx_RaiseErrorWithTypes1(PyExc_TypeError, "%.1s" message, "", type_obj1, type_obj2) CYTHON_UNUSED static void __Pyx_RaiseErrorWithTypes1(PyObject* exc_type, const char *message, const char *arg, PyTypeObject *type_obj1, PyTypeObject *type_obj2); /* PyNumberBinop.proto */ #if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_GRAAL || CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_PyNumber_Multiply_object_int(op1, op2) PyNumber_Multiply(op1, op2) #define __Pyx_PyNumber_InPlaceMultiply_object_int(op1, op2) PyNumber_InPlaceMultiply(op1, op2) #else #define __Pyx_PyNumber_Multiply_object_int(op1, op2) __Pyx__PyNumber_Multiply_object_int(op1, op2, 0) #define __Pyx_PyNumber_InPlaceMultiply_object_int(op1, op2) __Pyx__PyNumber_Multiply_object_int(op1, op2, 1) static CYTHON_INLINE PyObject* __Pyx__PyNumber_Multiply_object_int(PyObject *op1, PyObject *op2, int inplace); #endif /* PyNumberBinop.proto */ #if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_GRAAL || CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_PyNumber_Add_object_int(op1, op2) PyNumber_Add(op1, op2) #define __Pyx_PyNumber_InPlaceAdd_object_int(op1, op2) PyNumber_InPlaceAdd(op1, op2) #else #define __Pyx_PyNumber_Add_object_int(op1, op2) __Pyx__PyNumber_Add_object_int(op1, op2, 0) #define __Pyx_PyNumber_InPlaceAdd_object_int(op1, op2) __Pyx__PyNumber_Add_object_int(op1, op2, 1) static CYTHON_INLINE PyObject* __Pyx__PyNumber_Add_object_int(PyObject *op1, PyObject *op2, int inplace); #endif /* GetAttr3.proto */ static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); /* AllocateExtensionType.proto */ static PyObject *__Pyx_AllocateExtensionType(PyTypeObject *t, int is_final); /* CallSlotAsVectorcall.proto */ #if CYTHON_VECTORCALL_TPNEW typedef PyObject * (*__Pyx_tpnewvectorcallfunc)(PyTypeObject* o, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); static PyObject * __Pyx_CallTpnewAsVectorcall(__Pyx_tpnewvectorcallfunc f, PyTypeObject* o, PyObject *a, PyObject *k); #endif /* CallNewInitFromVectorcall.proto */ #if CYTHON_VECTORCALL_TPNEW static PyObject *__Pyx_CallNewInitFromVectorcall(PyTypeObject *t, PyObject *const *args, size_t nargsf, PyObject *kwnames); #endif /* CallSlotAsVectorcall.proto */ #if CYTHON_VECTORCALL_TPNEW typedef int (*__Pyx_tpinitvectorcallfunc)(PyObject* o, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); static int __Pyx_CallTpinitAsVectorcall(__Pyx_tpinitvectorcallfunc f, PyObject* o, PyObject *a, PyObject *k); #endif /* CallTypeTraverse.proto */ #if !CYTHON_USE_TYPE_SPECS #define __Pyx_call_type_traverse(o, always_call, visit, arg) 0 #else static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg); #endif /* CheckTypeForFreelists.proto */ #if CYTHON_USE_FREELISTS #if CYTHON_USE_TYPE_SPECS #define __PYX_CHECK_FINAL_TYPE_FOR_FREELISTS(t, expected_tp, expected_size) ((int) ((t) == (expected_tp))) #define __PYX_CHECK_TYPE_FOR_FREELIST_FLAGS Py_TPFLAGS_IS_ABSTRACT #else #define __PYX_CHECK_FINAL_TYPE_FOR_FREELISTS(t, expected_tp, expected_size) ((int) ((t)->tp_basicsize == (expected_size))) #define __PYX_CHECK_TYPE_FOR_FREELIST_FLAGS (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE) #endif #define __PYX_CHECK_TYPE_FOR_FREELISTS(t, expected_tp, expected_size)\ (__PYX_CHECK_FINAL_TYPE_FOR_FREELISTS((t), (expected_tp), (expected_size)) &\ (int) (!__Pyx_PyType_HasFeature((t), __PYX_CHECK_TYPE_FOR_FREELIST_FLAGS))) #endif /* GetTypeDictOffset.proto (used by ValidateBasesTuple) */ #if !CYTHON_USE_TYPE_SLOTS CYTHON_UNUSED static Py_ssize_t __Pyx_GetTypeDictOffset(PyObject *tp, int require_cython_valid_result); #endif /* ValidateBasesTuple.proto (used by PyType_Ready) */ #if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS static int __Pyx_validate_bases_tuple(const char *type_name, int has_dictoffset, PyObject *bases); #endif /* PyType_Ready.export */ CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t); /* LimitedApiGetTypeTypeDict.proto (used by DelItemOnTypeDict) */ #if CYTHON_COMPILING_IN_LIMITED_API static PyObject *__Pyx_GetTypeTypeDict(PyTypeObject *tp); #endif /* DelItemOnTypeDict.proto (used by SetupReduce) */ #define __Pyx_DelItemOnTypeDict(tp, k) __Pyx__DelItemOnTypeDict((PyTypeObject*)tp, k) /* DelItemOnTypeDict.export */ static int __Pyx__DelItemOnTypeDict(PyTypeObject *tp, PyObject *k); /* SetItemOnTypeDict.proto (used by SetupReduce) */ #define __Pyx_SetItemOnTypeDict(tp, k, v) __Pyx__SetItemOnTypeDict((PyTypeObject*)tp, k, v) /* SetItemOnTypeDict.export */ static int __Pyx__SetItemOnTypeDict(PyTypeObject *tp, PyObject *k, PyObject *v); /* SetupReduce.export */ static int __Pyx_setup_reduce(PyObject* type_obj); /* TupleOrListFromArrayImpl.proto (used by ListFromArray) */ CYTHON_UNUSED static PyObject * __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); /* ListFromArray.proto (used by ImportImpl) */ /* ImportImpl.export */ static PyObject *__Pyx__Import(PyObject *name, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject *qualname, PyObject *moddict, int level); /* Import.proto */ static CYTHON_INLINE PyObject *__Pyx_Import(PyObject *name, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject *qualname, int level); /* ImportFrom.export */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); /* dict_setdefault.proto (used by FetchCommonType) */ static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value); /* AddModuleRef.proto (used by FetchSharedCythonModule) */ #if ((CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && PY_VERSION_HEX < 0x030F00a3) ||\ __PYX_LIMITED_VERSION_HEX < 0x030d0000) static PyObject *__Pyx_PyImport_AddModuleRef(const char *name); #else #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) #endif /* FetchSharedCythonModule.proto (used by FetchCommonType) */ static PyObject *__Pyx_FetchSharedCythonABIModule(void); /* VerifyCachedType.proto (used by FetchCommonType) */ static int __Pyx_VerifyCachedType(PyObject *cached_type, const char *name, Py_ssize_t expected_basicsize); /* FetchCommonType.proto (used by CommonTypesMetaclass) */ static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases); /* CommonTypesMetaclass.proto (used by CythonFunctionShared) */ static int __pyx_CommonTypesMetaclass_init(PyObject *module); #define __Pyx_CommonTypesMetaclass_USED /* CythonFunctionPerModule.proto (used by CythonFunctionShared) */ #define __Pyx_CyFunction_USED #if CYTHON_OPAQUE_SHARED_TYPES #define __Pyx_as_CyFunctionObject(o) ((__pyx_CyFunctionObject *)PyObject_GetTypeData((o), __pyx_mstate_global->__pyx_CyFunctionType)) #else #define __Pyx_as_CyFunctionObject(o) ((__pyx_CyFunctionObject *)o) #endif #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_as_CyFunctionObject(f))->func_closure) #if CYTHON_COMPILING_IN_LIMITED_API #define __Pyx__CyFunction_GetClassObj(f)\ ((f)->func_classobj) #else #define __Pyx__CyFunction_GetClassObj(f)\ ((PyObject*) ((PyCMethodObject *) (f))->mm_class) #endif #define __Pyx_CyFunction_GetClassObj(f)\ __Pyx__CyFunction_GetClassObj(__Pyx_as_CyFunctionObject(f)) #define __Pyx_CyFunction_SetClassObj(f, classobj)\ __Pyx__CyFunction_SetClassObj(__Pyx_as_CyFunctionObject(f), (classobj)) #define __Pyx_CyFunction_Defaults(type, f)\ ((type *)((__Pyx_as_CyFunctionObject(f))->defaults)) #define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ (__Pyx_as_CyFunctionObject(f))->defaults_getter = (g) typedef struct { #if CYTHON_COMPILING_IN_LIMITED_API #if !CYTHON_OPAQUE_OBJECTS PyObject_HEAD #endif PyMethodDef *func_methoddef; PyObject *func_module; #else PyCMethodObject func; #endif #if (CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY) && CYTHON_VECTORCALL __pyx_vectorcallfunc func_vectorcall; #endif #if CYTHON_COMPILING_IN_LIMITED_API PyObject *func_weakreflist; #endif #if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API PyObject *func_dict; #endif PyObject *func_name; PyObject *func_qualname; PyObject *func_doc; PyObject *func_globals; PyObject *func_code; PyObject *func_closure; #if CYTHON_COMPILING_IN_LIMITED_API PyObject *func_classobj; #endif PyObject *defaults; int flags; PyObject *defaults_tuple; PyObject *defaults_kwdict; PyObject *(*defaults_getter)(PyObject *); PyObject *func_annotations; #if __PYX_LIMITED_VERSION_HEX < 0x030B0000 PyObject *func_is_coroutine; #endif } __pyx_CyFunctionObject; #undef __Pyx_CyOrPyCFunction_Check #define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_mstate_global->__pyx_CyFunctionType) #define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_mstate_global->__pyx_CyFunctionType, &PyCFunction_Type) #define __Pyx_CyFunction_CheckExact(obj) Py_IS_TYPE(obj, __pyx_mstate_global->__pyx_CyFunctionType) static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)); #undef __Pyx_IsSameCFunction #define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCyOrCFunction(func, cfunc) static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); static CYTHON_INLINE PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func, PyTypeObject *defaults_type); static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, PyObject *tuple); static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, PyObject *dict); static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, PyObject *dict); static int __pyx_CyFunction_init(PyObject *module); #if CYTHON_VECTORCALL #if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY #define __Pyx_CyFunction_func_vectorcall(f) ((f)->func_vectorcall) #else #define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall) #endif #endif /* PyMethodNew.proto (used by CythonFunctionShared) */ static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ); /* PyVectorcallFastCallDict.proto (used by CythonFunctionShared) */ #if CYTHON_VECTORCALL static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw); #endif /* CythonFunctionShared.proto (used by CythonFunction) */ static PyObject *__Pyx_CyFunction_Init(PyObject *op_in, PyMethodDef *ml, int flags, PyObject* qualname, PyObject *closure, PyObject *module, PyObject *globals, PyObject* code); #if CYTHON_VECTORCALL 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); #endif /* CythonFunction.export */ static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, PyObject *closure, PyObject *module, PyObject *globals, PyObject* code); static PyTypeObject *__Pyx_Get_CyFunction_Type(void); /* ClassMethod.proto */ #if !CYTHON_COMPILING_IN_LIMITED_API #include "descrobject.h" #endif CYTHON_UNUSED static PyObject* __Pyx_Method_ClassMethod(PyObject *method); /* GetNameInClass.proto */ #define __Pyx_GetNameInClass(var, nmspace, name) (var) = __Pyx__GetNameInClass(nmspace, name) static PyObject *__Pyx__GetNameInClass(PyObject *nmspace, PyObject *name); /* CLineInTraceback.proto (used by AddTraceback) */ #if CYTHON_CLINE_IN_TRACEBACK && CYTHON_CLINE_IN_TRACEBACK_RUNTIME static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #else #define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) #endif /* CodeObjectCache.proto (used by AddTraceback) */ #if CYTHON_COMPILING_IN_LIMITED_API typedef PyObject __Pyx_CachedCodeObjectType; #else typedef PyCodeObject __Pyx_CachedCodeObjectType; #endif typedef struct { __Pyx_CachedCodeObjectType* code_object; int code_line; } __Pyx_CodeObjectCacheEntry; struct __Pyx_CodeObjectCache { int count; int max_count; __Pyx_CodeObjectCacheEntry* entries; #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING __pyx_atomic_int_type accessor_count; #endif }; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static __Pyx_CachedCodeObjectType *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, __Pyx_CachedCodeObjectType* code_object); /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); /* PyObjectCallMethod1.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg); /* CheckUnpickleChecksumError.export */ static void __Pyx_RaiseUnpickleChecksumError(long checksum, long checksum1, long checksum2, long checksum3, const char *members); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_int(int value); /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value); /* UpdateUnpickledDict.export */ static int __Pyx_UpdateUnpickledDict(PyObject *obj, PyObject *state, Py_ssize_t index); /* CheckUnpickleChecksum.proto */ static CYTHON_INLINE int __Pyx_CheckUnpickleChecksum(long checksum, long checksum1, long checksum2, long checksum3, const char *members); /* GetRuntimeVersion.proto */ #if __PYX_LIMITED_VERSION_HEX < 0x030b0000 static unsigned long __Pyx_cached_runtime_version = 0; static void __Pyx_init_runtime_version(void); #else #define __Pyx_init_runtime_version() #endif static unsigned long __Pyx_get_runtime_version(void); /* SwapException.proto (used by CoroutineBase) */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSwap(type, value, tb) __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #else static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); #endif /* IterNextPlain.proto (used by CoroutineBase) */ static CYTHON_INLINE PyObject *__Pyx_PyIter_Next_Plain(PyObject *iterator); #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 static PyObject *__Pyx_GetBuiltinNext_LimitedAPI(void); #endif /* ReturnWithStopIteration.proto (used by CoroutineBase) */ static CYTHON_INLINE void __Pyx_ReturnWithStopIteration(PyObject* value, int async, int iternext); /* CoroutineBase.proto (used by Generator) */ 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 typedef struct { PyObject *exc_type; PyObject *exc_value; PyObject *exc_traceback; } __Pyx_ExcInfoStruct; #endif typedef struct __pyx_CoroutineObject { PyObject_HEAD __pyx_coroutine_body_t body; PyObject *closure; __Pyx_ExcInfoStruct gi_exc_state; #if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API PyObject *gi_weakreflist; #endif PyObject *classobj; PyObject *yieldfrom; __Pyx_pyiter_sendfunc yieldfrom_am_send; PyObject *gi_name; PyObject *gi_qualname; PyObject *gi_modulename; PyObject *gi_code; PyObject *gi_frame; #if CYTHON_USE_SYS_MONITORING && (CYTHON_PROFILE || CYTHON_TRACE) PyMonitoringState __pyx_pymonitoring_state[__Pyx_MonitoringEventTypes_CyGen_count]; uint64_t __pyx_pymonitoring_version; #endif int resume_label; char is_running; } __pyx_CoroutineObject; static __pyx_CoroutineObject *__Pyx__Coroutine_New( PyTypeObject *type, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, PyObject *name, PyObject *qualname, PyObject *module_name); static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit( __pyx_CoroutineObject *gen, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, PyObject *name, PyObject *qualname, PyObject *module_name); static CYTHON_INLINE void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *self); static int __Pyx_Coroutine_clear(PyObject *self); static __Pyx_PySendResult __Pyx_Coroutine_AmSend(PyObject *self, PyObject *value, PyObject **retval); static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value); static __Pyx_PySendResult __Pyx_Coroutine_Close(PyObject *self, PyObject **retval); static PyObject *__Pyx_Coroutine_Throw(PyObject *gen, #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 PyObject *args #else PyObject *const *args, Py_ssize_t nargs #endif ); #if CYTHON_USE_EXC_INFO_STACK #define __Pyx_Coroutine_SwapException(self) #define __Pyx_Coroutine_ResetAndClearException(self) __Pyx_Coroutine_ExceptionClear(&(self)->gi_exc_state) #else #define __Pyx_Coroutine_SwapException(self) {\ __Pyx_ExceptionSwap(&(self)->gi_exc_state.exc_type, &(self)->gi_exc_state.exc_value, &(self)->gi_exc_state.exc_traceback);\ __Pyx_Coroutine_ResetFrameBackpointer(&(self)->gi_exc_state);\ } #define __Pyx_Coroutine_ResetAndClearException(self) {\ __Pyx_ExceptionReset((self)->gi_exc_state.exc_type, (self)->gi_exc_state.exc_value, (self)->gi_exc_state.exc_traceback);\ (self)->gi_exc_state.exc_type = (self)->gi_exc_state.exc_value = (self)->gi_exc_state.exc_traceback = NULL;\ } #endif #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyGen_FetchStopIterationValue(pvalue)\ __Pyx_PyGen__FetchStopIterationValue(__pyx_tstate, pvalue) #else #define __Pyx_PyGen_FetchStopIterationValue(pvalue)\ __Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, pvalue) #endif static int __Pyx_PyGen__FetchStopIterationValue(PyThreadState *tstate, PyObject **pvalue); static CYTHON_INLINE void __Pyx_Coroutine_ResetFrameBackpointer(__Pyx_ExcInfoStruct *exc_state); static char __Pyx_Coroutine_test_and_set_is_running(__pyx_CoroutineObject *gen); static void __Pyx_Coroutine_unset_is_running(__pyx_CoroutineObject *gen); static char __Pyx_Coroutine_get_is_running(__pyx_CoroutineObject *gen); static PyObject *__Pyx_Coroutine_get_is_running_getter(PyObject *gen, void *closure); #if __PYX_HAS_PY_AM_SEND == 2 static void __Pyx_SetBackportTypeAmSend(PyTypeObject *type, __Pyx_PyAsyncMethodsStruct *static_amsend_methods, __Pyx_pyiter_sendfunc am_send); #endif static PyObject *__Pyx_Coroutine_fail_reduce_ex(PyObject *self, PyObject *arg); /* Generator.proto */ #define __Pyx_Generator_USED #define __Pyx_Generator_CheckExact(obj) Py_IS_TYPE(obj, __pyx_mstate_global->__pyx_GeneratorType) #define __Pyx_Generator_New(body, code, closure, name, qualname, module_name)\ __Pyx__Coroutine_New(__pyx_mstate_global->__pyx_GeneratorType, body, code, closure, name, qualname, module_name) static PyObject *__Pyx_Generator_Next(PyObject *self); static int __pyx_Generator_init(PyObject *module); static CYTHON_INLINE PyObject *__Pyx_Generator_GetInlinedResult(PyObject *self); /* CheckBinaryVersion.proto */ static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); /* DecompressString.proto */ static PyObject *__Pyx_DecompressString(const char *s, Py_ssize_t length, int algo); /* DecompressString_LZSS.proto */ static PyObject *__Pyx_DecompressString_LZSS(const char *s, size_t compressed_length, size_t uncompressed_length); /* MultiPhaseInitModuleState.proto */ #if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE #include static PyObject *__Pyx_State_FindModule(void*); static int __Pyx_State_AddModule(PyObject* module, void*); static int __Pyx_State_RemoveModule(void*); #elif CYTHON_USE_MODULE_STATE #define __Pyx_State_FindModule PyState_FindModule #define __Pyx_State_AddModule PyState_AddModule #define __Pyx_State_RemoveModule PyState_RemoveModule #endif /* #### Code section: module_declarations ### */ /* CythonABIVersion.proto */ #if CYTHON_COMPILING_IN_LIMITED_API #if CYTHON_VECTORCALL #define __PYX_VECTORCALL_ABI_SUFFIX "_vectorcall" #else #define __PYX_VECTORCALL_ABI_SUFFIX #endif #define __PYX_LIMITED_ABI_SUFFIX "limited" __PYX_VECTORCALL_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX #else #define __PYX_LIMITED_ABI_SUFFIX #endif #if __PYX_HAS_PY_AM_SEND == 1 #define __PYX_AM_SEND_ABI_SUFFIX #elif __PYX_HAS_PY_AM_SEND == 2 #define __PYX_AM_SEND_ABI_SUFFIX "amsendbackport" #else #define __PYX_AM_SEND_ABI_SUFFIX "noamsend" #endif #ifndef __PYX_MONITORING_ABI_SUFFIX #define __PYX_MONITORING_ABI_SUFFIX #endif #if CYTHON_USE_TP_FINALIZE #define __PYX_TP_FINALIZE_ABI_SUFFIX #else #define __PYX_TP_FINALIZE_ABI_SUFFIX "nofinalize" #endif #if CYTHON_USE_FREELISTS || !defined(__Pyx_AsyncGen_USED) #define __PYX_FREELISTS_ABI_SUFFIX #else #define __PYX_FREELISTS_ABI_SUFFIX "nofreelists" #endif #if CYTHON_OPAQUE_OBJECTS && CYTHON_COMPILING_IN_LIMITED_API #define __PYX_OPAQUE_OBJECTS_ABI_SUFFIX "opaque" #else #define __PYX_OPAQUE_OBJECTS_ABI_SUFFIX #endif #define CYTHON_ABI __PYX_ABI_VERSION __PYX_LIMITED_ABI_SUFFIX __PYX_MONITORING_ABI_SUFFIX __PYX_TP_FINALIZE_ABI_SUFFIX __PYX_FREELISTS_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX __PYX_OPAQUE_OBJECTS_ABI_SUFFIX #define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI #define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." /* Module declarations from "borghash.HashTableNT" */ static PyObject *__pyx_f_8borghash_11HashTableNT___pyx_unpickle_HashTableNT__set_state(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *, PyObject *); /*proto*/ /* #### Code section: typeinfo ### */ /* #### Code section: before_global_var ### */ #define __Pyx_MODULE_NAME "borghash.HashTableNT" extern int __pyx_module_is_main_borghash__HashTableNT; int __pyx_module_is_main_borghash__HashTableNT = 0; /* Implementation of "borghash.HashTableNT" */ /* #### Code section: global_var ### */ static PyObject *__pyx_builtin_object; static PyObject *__pyx_builtin_open; /* #### Code section: string_decls ### */ static const char __pyx_k_HashTableNT_wrapper_around_Hash[] = "\nHashTableNT: wrapper around HashTable, providing namedtuple values and serialization.\n"; static const char __pyx_k_byte_order_inner_key_size_value[] = "byte_order, inner, key_size, value_format, value_size, value_struct, value_type"; /* #### Code section: decls ### */ static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_8__init___genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0); /* proto */ static int __pyx_pf_8borghash_11HashTableNT_11HashTableNT___init__(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_items, PyObject *__pyx_v_key_size, PyObject *__pyx_v_value_type, PyObject *__pyx_v_value_format, PyObject *__pyx_v_capacity, PyObject *__pyx_v_byte_order); /* proto */ static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_2clear(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_4_check_key(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_key); /* proto */ static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_6_to_binary_value(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_8_to_namedtuple_value(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_binary_value); /* proto */ static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_10_set_raw(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value); /* proto */ static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_12_get_raw(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_key); /* proto */ static int __pyx_pf_8borghash_11HashTableNT_11HashTableNT_14__setitem__(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value); /* proto */ static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_16__getitem__(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_key); /* proto */ static int __pyx_pf_8borghash_11HashTableNT_11HashTableNT_18__delitem__(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_key); /* proto */ static int __pyx_pf_8borghash_11HashTableNT_11HashTableNT_20__contains__(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_key); /* proto */ static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_22items(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_prefix_bits, PyObject *__pyx_v_prefix); /* proto */ static Py_ssize_t __pyx_pf_8borghash_11HashTableNT_11HashTableNT_25__len__(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_27get(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_default); /* proto */ static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_29setdefault(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_default); /* proto */ static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_31pop(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_default); /* proto */ static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_33update(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_other, PyObject *__pyx_v_kwds); /* proto */ static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_35k_to_idx(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_key); /* proto */ static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_37idx_to_k(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_idx); /* proto */ static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_39kv_to_idx(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value); /* proto */ static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_41idx_to_kv(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_idx); /* proto */ static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_5stats___get__(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_43write(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_file); /* proto */ static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_45_write_fd(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_fd); /* proto */ static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_47read(PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_file); /* proto */ static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_49_read_fd(PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_fd); /* proto */ static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_51size(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_53__reduce_cython__(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_55__setstate_cython__(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_pf_8borghash_11HashTableNT___pyx_unpickle_HashTableNT(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__initialisation_8borghash_11HashTableNT_HashTableNT(PyObject *o, #if CYTHON_VECTORCALL_TPNEW PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames #else PyObject *a, PyObject *k #endif ); /*proto*/ static PyObject *__pyx_tp_new_vectorcall_8borghash_11HashTableNT_HashTableNT(PyTypeObject *t, #if CYTHON_VECTORCALL_TPNEW PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames #else PyObject *a, PyObject *k #endif ); /*proto*/ #if CYTHON_VECTORCALL_TPNEW static PyObject *__pyx_tp_new_8borghash_11HashTableNT_HashTableNT(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ #endif #if !CYTHON_VECTORCALL_TPNEW #define __pyx_tp_new_8borghash_11HashTableNT_HashTableNT __pyx_tp_new_vectorcall_8borghash_11HashTableNT_HashTableNT #endif #if CYTHON_VECTORCALL_TPNEW static PyObject *__pyx_tp_vectorcall_8borghash_11HashTableNT_HashTableNT(PyObject *t, PyObject *const *args, size_t nargsf, PyObject *kwnames); /*proto*/ #endif #if CYTHON_VECTORCALL_TPNEW static int __pyx_tp_init_8borghash_11HashTableNT_HashTableNT(PyObject *o, PyObject *args, PyObject *kwds); /*proto*/ #endif #if !CYTHON_VECTORCALL_TPNEW #define __pyx_tp_init_8borghash_11HashTableNT_HashTableNT __pyx_pw_8borghash_11HashTableNT_11HashTableNT_1__init__ #endif static PyObject *__pyx_tp_new__initialisation_8borghash_11HashTableNT___pyx_scope_struct__genexpr(PyObject *o, #if CYTHON_VECTORCALL_TPNEW PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames #else PyObject *a, PyObject *k #endif ); /*proto*/ static PyObject *__pyx_tp_new_vectorcall_8borghash_11HashTableNT___pyx_scope_struct__genexpr(PyTypeObject *t, #if CYTHON_VECTORCALL_TPNEW PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames #else PyObject *a, PyObject *k #endif ); /*proto*/ #if CYTHON_VECTORCALL_TPNEW static PyObject *__pyx_tp_new_8borghash_11HashTableNT___pyx_scope_struct__genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ #endif #if !CYTHON_VECTORCALL_TPNEW #define __pyx_tp_new_8borghash_11HashTableNT___pyx_scope_struct__genexpr __pyx_tp_new_vectorcall_8borghash_11HashTableNT___pyx_scope_struct__genexpr #endif #if CYTHON_VECTORCALL_TPNEW static PyObject *__pyx_tp_vectorcall_8borghash_11HashTableNT___pyx_scope_struct__genexpr(PyObject *t, PyObject *const *args, size_t nargsf, PyObject *kwnames); /*proto*/ #endif static PyObject *__pyx_tp_new__initialisation_8borghash_11HashTableNT___pyx_scope_struct_1_items(PyObject *o, #if CYTHON_VECTORCALL_TPNEW PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames #else PyObject *a, PyObject *k #endif ); /*proto*/ static PyObject *__pyx_tp_new_vectorcall_8borghash_11HashTableNT___pyx_scope_struct_1_items(PyTypeObject *t, #if CYTHON_VECTORCALL_TPNEW PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames #else PyObject *a, PyObject *k #endif ); /*proto*/ #if CYTHON_VECTORCALL_TPNEW static PyObject *__pyx_tp_new_8borghash_11HashTableNT___pyx_scope_struct_1_items(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ #endif #if !CYTHON_VECTORCALL_TPNEW #define __pyx_tp_new_8borghash_11HashTableNT___pyx_scope_struct_1_items __pyx_tp_new_vectorcall_8borghash_11HashTableNT___pyx_scope_struct_1_items #endif #if CYTHON_VECTORCALL_TPNEW static PyObject *__pyx_tp_vectorcall_8borghash_11HashTableNT___pyx_scope_struct_1_items(PyObject *t, PyObject *const *args, size_t nargsf, PyObject *kwnames); /*proto*/ #endif /* #### Code section: late_includes ### */ /* #### Code section: module_state ### */ /* SmallCodeConfig */ #ifndef CYTHON_SMALL_CODE #if defined(__clang__) #define CYTHON_SMALL_CODE #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) #define CYTHON_SMALL_CODE __attribute__((cold)) #else #define CYTHON_SMALL_CODE #endif #endif #ifdef __cplusplus namespace { #endif typedef struct { PyObject *__pyx_d; PyObject *__pyx_b; PyObject *__pyx_cython_runtime; PyObject *__pyx_empty_tuple; PyObject *__pyx_empty_bytes; PyObject *__pyx_empty_unicode; PyObject *__pyx_type_8borghash_11HashTableNT_HashTableNT; PyObject *__pyx_type_8borghash_11HashTableNT___pyx_scope_struct__genexpr; PyObject *__pyx_type_8borghash_11HashTableNT___pyx_scope_struct_1_items; PyTypeObject *__pyx_ptype_8borghash_11HashTableNT_HashTableNT; PyTypeObject *__pyx_ptype_8borghash_11HashTableNT___pyx_scope_struct__genexpr; PyTypeObject *__pyx_ptype_8borghash_11HashTableNT___pyx_scope_struct_1_items; __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_items; __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_pop; __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_values; PyObject *__pyx_k_; PyObject *__pyx_k__5; PyObject *__pyx_tuple[6]; PyObject *__pyx_codeobj_tab[24]; PyObject *__pyx_string_tab[228]; PyObject *__pyx_number_tab[5]; /* #### Code section: module_state_contents ### */ /* PyFrozenDict.module_state_decls */ #if CYTHON_COMPILING_IN_LIMITED_API PyObject *__Pyx_PyFrozenDictType; #endif #if CYTHON_USE_FREELISTS struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct__genexpr *__pyx_freelist_8borghash_11HashTableNT___pyx_scope_struct__genexpr[8]; int __pyx_freecount_8borghash_11HashTableNT___pyx_scope_struct__genexpr; #endif #if CYTHON_USE_FREELISTS struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct_1_items *__pyx_freelist_8borghash_11HashTableNT___pyx_scope_struct_1_items[8]; int __pyx_freecount_8borghash_11HashTableNT___pyx_scope_struct_1_items; #endif /* CommonTypesMetaclass.module_state_decls */ PyTypeObject *__pyx_CommonTypesMetaclassType; /* CachedMethodType.module_state_decls */ #if CYTHON_COMPILING_IN_LIMITED_API PyObject *__Pyx_CachedMethodType; #endif /* CythonFunctionPerModule.module_state_decls */ PyTypeObject *__pyx_CyFunctionType; /* CodeObjectCache.module_state_decls */ struct __Pyx_CodeObjectCache __pyx_code_cache; /* IterNextPlain.module_state_decls */ #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 PyObject *__Pyx_GetBuiltinNext_LimitedAPI_cache; #endif /* Generator.module_state_decls */ PyTypeObject *__pyx_GeneratorType; /* #### Code section: module_state_end ### */ } __pyx_mstatetype; #ifdef __cplusplus } /* anonymous namespace */ #endif #if CYTHON_USE_MODULE_STATE #ifdef __cplusplus namespace { extern struct PyModuleDef __pyx_moduledef; } /* anonymous namespace */ #else static struct PyModuleDef __pyx_moduledef; #endif #define __pyx_mstate_global (__Pyx_PyModule_GetState(__Pyx_State_FindModule(&__pyx_moduledef))) #define __pyx_m (__Pyx_State_FindModule(&__pyx_moduledef)) #else static __pyx_mstatetype __pyx_mstate_global_static = #ifdef __cplusplus {}; #else {0}; #endif static __pyx_mstatetype * const __pyx_mstate_global = &__pyx_mstate_global_static; #endif /* #### Code section: constant_name_defines ### */ #define __pyx_kp_u__4 __pyx_string_tab[0] #define __pyx_kp_u_bytes_long __pyx_string_tab[1] #define __pyx_kp_u_not_found __pyx_string_tab[2] #define __pyx_kp_u__9 __pyx_string_tab[3] #define __pyx_kp_u_tree_fragment __pyx_string_tab[4] #define __pyx_kp_u__3 __pyx_string_tab[5] #define __pyx_kp_u_got __pyx_string_tab[6] #define __pyx_kp_u__6 __pyx_string_tab[7] #define __pyx_kp_u__8 __pyx_string_tab[8] #define __pyx_kp_u_8sII __pyx_string_tab[9] #define __pyx_kp_u__10 __pyx_string_tab[10] #define __pyx_kp_u__7 __pyx_string_tab[11] #define __pyx_kp_u__2 __pyx_string_tab[12] #define __pyx_kp_u_BinaryIO_str_bytes __pyx_string_tab[13] #define __pyx_kp_u_Expected_an_instance_of __pyx_string_tab[14] #define __pyx_kp_u_Expected_an_instance_of_bytes_go __pyx_string_tab[15] #define __pyx_kp_u_Invalid_file_file_is_too_short __pyx_string_tab[16] #define __pyx_kp_u_Invalid_file_magic __pyx_string_tab[17] #define __pyx_kp_u_Iterator_tuple_bytes_Any __pyx_string_tab[18] #define __pyx_kp_u_Key_must_be __pyx_string_tab[19] #define __pyx_kp_u_Note_that_Cython_is_deliberately __pyx_string_tab[20] #define __pyx_kp_u_Unsupported_file_version __pyx_string_tab[21] #define __pyx_kp_u_add_note __pyx_string_tab[22] #define __pyx_kp_u_borghash_HashTable __pyx_string_tab[23] #define __pyx_kp_u_byte_order_must_be_one_of __pyx_string_tab[24] #define __pyx_kp_u_disable __pyx_string_tab[25] #define __pyx_kp_u_enable __pyx_string_tab[26] #define __pyx_kp_u_gc __pyx_string_tab[27] #define __pyx_kp_u_isenabled __pyx_string_tab[28] #define __pyx_kp_u_key_size_must_be_an_integer_and __pyx_string_tab[29] #define __pyx_kp_u_src_borghash_HashTableNT_pyx __pyx_string_tab[30] #define __pyx_kp_u_tuple_bytes_Any __pyx_string_tab[31] #define __pyx_kp_u_utf_8 __pyx_string_tab[32] #define __pyx_kp_u_value_format_must_be_a_namedtupl __pyx_string_tab[33] #define __pyx_kp_u_value_format_s_and_value_type_s __pyx_string_tab[34] #define __pyx_kp_u_value_format_s_elements_must_be __pyx_string_tab[35] #define __pyx_kp_u_value_type_must_be_a_namedtuple __pyx_string_tab[36] #define __pyx_n_u_Any __pyx_string_tab[37] #define __pyx_n_u_BYTE_ORDER __pyx_string_tab[38] #define __pyx_n_u_BinaryIO __pyx_string_tab[39] #define __pyx_n_u_HEADER_FMT __pyx_string_tab[40] #define __pyx_n_u_HashTable __pyx_string_tab[41] #define __pyx_n_u_HashTableNT __pyx_string_tab[42] #define __pyx_n_u_HashTableNT___reduce_cython __pyx_string_tab[43] #define __pyx_n_u_HashTableNT___setstate_cython __pyx_string_tab[44] #define __pyx_n_u_HashTableNT__check_key __pyx_string_tab[45] #define __pyx_n_u_HashTableNT__get_raw __pyx_string_tab[46] #define __pyx_n_u_HashTableNT__read_fd __pyx_string_tab[47] #define __pyx_n_u_HashTableNT__set_raw __pyx_string_tab[48] #define __pyx_n_u_HashTableNT__to_binary_value __pyx_string_tab[49] #define __pyx_n_u_HashTableNT__to_namedtuple_value __pyx_string_tab[50] #define __pyx_n_u_HashTableNT__write_fd __pyx_string_tab[51] #define __pyx_n_u_HashTableNT_clear __pyx_string_tab[52] #define __pyx_n_u_HashTableNT_get __pyx_string_tab[53] #define __pyx_n_u_HashTableNT_idx_to_k __pyx_string_tab[54] #define __pyx_n_u_HashTableNT_idx_to_kv __pyx_string_tab[55] #define __pyx_n_u_HashTableNT_items __pyx_string_tab[56] #define __pyx_n_u_HashTableNT_k_to_idx __pyx_string_tab[57] #define __pyx_n_u_HashTableNT_kv_to_idx __pyx_string_tab[58] #define __pyx_n_u_HashTableNT_pop __pyx_string_tab[59] #define __pyx_n_u_HashTableNT_read __pyx_string_tab[60] #define __pyx_n_u_HashTableNT_setdefault __pyx_string_tab[61] #define __pyx_n_u_HashTableNT_size __pyx_string_tab[62] #define __pyx_n_u_HashTableNT_update __pyx_string_tab[63] #define __pyx_n_u_HashTableNT_write __pyx_string_tab[64] #define __pyx_n_u_Iterator __pyx_string_tab[65] #define __pyx_n_u_MAGIC __pyx_string_tab[66] #define __pyx_n_u_MIN_CAPACITY __pyx_string_tab[67] #define __pyx_n_u_Mapping __pyx_string_tab[68] #define __pyx_n_u_N __pyx_string_tab[69] #define __pyx_n_u_None __pyx_string_tab[70] #define __pyx_n_u_Struct __pyx_string_tab[71] #define __pyx_n_u_VERSION __pyx_string_tab[72] #define __pyx_n_u_NoDefault __pyx_string_tab[73] #define __pyx_n_u_Pyx_PyDict_NextRef __pyx_string_tab[74] #define __pyx_n_u_annotate __pyx_string_tab[75] #define __pyx_n_u_class __pyx_string_tab[76] #define __pyx_n_u_class_getitem __pyx_string_tab[77] #define __pyx_n_u_dict __pyx_string_tab[78] #define __pyx_n_u_enter __pyx_string_tab[79] #define __pyx_n_u_exit __pyx_string_tab[80] #define __pyx_n_u_func __pyx_string_tab[81] #define __pyx_n_u_getstate __pyx_string_tab[82] #define __pyx_n_u_init___locals_genexpr __pyx_string_tab[83] #define __pyx_n_u_main __pyx_string_tab[84] #define __pyx_n_u_module __pyx_string_tab[85] #define __pyx_n_u_name __pyx_string_tab[86] #define __pyx_n_u_new __pyx_string_tab[87] #define __pyx_n_u_pyx_checksum __pyx_string_tab[88] #define __pyx_n_u_pyx_result __pyx_string_tab[89] #define __pyx_n_u_pyx_state __pyx_string_tab[90] #define __pyx_n_u_pyx_type __pyx_string_tab[91] #define __pyx_n_u_pyx_unpickle_HashTableNT __pyx_string_tab[92] #define __pyx_n_u_qualname __pyx_string_tab[93] #define __pyx_n_u_reduce __pyx_string_tab[94] #define __pyx_n_u_reduce_cython __pyx_string_tab[95] #define __pyx_n_u_reduce_ex __pyx_string_tab[96] #define __pyx_n_u_set_name __pyx_string_tab[97] #define __pyx_n_u_setstate __pyx_string_tab[98] #define __pyx_n_u_setstate_cython __pyx_string_tab[99] #define __pyx_n_u_test __pyx_string_tab[100] #define __pyx_n_u_check_key __pyx_string_tab[101] #define __pyx_n_u_dict_2 __pyx_string_tab[102] #define __pyx_n_u_fields __pyx_string_tab[103] #define __pyx_n_u_fill __pyx_string_tab[104] #define __pyx_n_u_get_raw __pyx_string_tab[105] #define __pyx_n_u_is_coroutine __pyx_string_tab[106] #define __pyx_n_u_read_fd __pyx_string_tab[107] #define __pyx_n_u_set_raw __pyx_string_tab[108] #define __pyx_n_u_to_binary_value __pyx_string_tab[109] #define __pyx_n_u_to_namedtuple_value __pyx_string_tab[110] #define __pyx_n_u_write_fd __pyx_string_tab[111] #define __pyx_n_u_asyncio_coroutines __pyx_string_tab[112] #define __pyx_n_u_big __pyx_string_tab[113] #define __pyx_n_u_binary_default __pyx_string_tab[114] #define __pyx_n_u_binary_value __pyx_string_tab[115] #define __pyx_n_u_borghash_HashTableNT __pyx_string_tab[116] #define __pyx_n_u_byte_order __pyx_string_tab[117] #define __pyx_n_u_bytes __pyx_string_tab[118] #define __pyx_n_u_calcsize __pyx_string_tab[119] #define __pyx_n_u_capacity __pyx_string_tab[120] #define __pyx_n_u_clear __pyx_string_tab[121] #define __pyx_n_u_cline_in_traceback __pyx_string_tab[122] #define __pyx_n_u_close __pyx_string_tab[123] #define __pyx_n_u_cls __pyx_string_tab[124] #define __pyx_n_u_collections __pyx_string_tab[125] #define __pyx_n_u_collections_abc __pyx_string_tab[126] #define __pyx_n_u_count __pyx_string_tab[127] #define __pyx_n_u_decode __pyx_string_tab[128] #define __pyx_n_u_default __pyx_string_tab[129] #define __pyx_n_u_dumps __pyx_string_tab[130] #define __pyx_n_u_encode __pyx_string_tab[131] #define __pyx_n_u_fd __pyx_string_tab[132] #define __pyx_n_u_file __pyx_string_tab[133] #define __pyx_n_u_fmt __pyx_string_tab[134] #define __pyx_n_u_genexpr __pyx_string_tab[135] #define __pyx_n_u_get __pyx_string_tab[136] #define __pyx_n_u_header_bytes __pyx_string_tab[137] #define __pyx_n_u_header_size __pyx_string_tab[138] #define __pyx_n_u_ht __pyx_string_tab[139] #define __pyx_n_u_i __pyx_string_tab[140] #define __pyx_n_u_idx __pyx_string_tab[141] #define __pyx_n_u_idx_to_k __pyx_string_tab[142] #define __pyx_n_u_idx_to_kv __pyx_string_tab[143] #define __pyx_n_u_int __pyx_string_tab[144] #define __pyx_n_u_items __pyx_string_tab[145] #define __pyx_n_u_json __pyx_string_tab[146] #define __pyx_n_u_k_to_idx __pyx_string_tab[147] #define __pyx_n_u_key __pyx_string_tab[148] #define __pyx_n_u_key_size __pyx_string_tab[149] #define __pyx_n_u_keys __pyx_string_tab[150] #define __pyx_n_u_ksize __pyx_string_tab[151] #define __pyx_n_u_kv_to_idx __pyx_string_tab[152] #define __pyx_n_u_kwds __pyx_string_tab[153] #define __pyx_n_u_little __pyx_string_tab[154] #define __pyx_n_u_loads __pyx_string_tab[155] #define __pyx_n_u_magic __pyx_string_tab[156] #define __pyx_n_u_meta __pyx_string_tab[157] #define __pyx_n_u_meta_bytes __pyx_string_tab[158] #define __pyx_n_u_meta_size __pyx_string_tab[159] #define __pyx_n_u_namedtuple __pyx_string_tab[160] #define __pyx_n_u_native __pyx_string_tab[161] #define __pyx_n_u_network __pyx_string_tab[162] #define __pyx_n_u_next __pyx_string_tab[163] #define __pyx_n_u_object __pyx_string_tab[164] #define __pyx_n_u_one_time_overheads __pyx_string_tab[165] #define __pyx_n_u_open __pyx_string_tab[166] #define __pyx_n_u_other __pyx_string_tab[167] #define __pyx_n_u_pack __pyx_string_tab[168] #define __pyx_n_u_pop __pyx_string_tab[169] #define __pyx_n_u_prefix __pyx_string_tab[170] #define __pyx_n_u_prefix_bits __pyx_string_tab[171] #define __pyx_n_u_rb __pyx_string_tab[172] #define __pyx_n_u_read __pyx_string_tab[173] #define __pyx_n_u_return __pyx_string_tab[174] #define __pyx_n_u_self __pyx_string_tab[175] #define __pyx_n_u_send __pyx_string_tab[176] #define __pyx_n_u_setdefault __pyx_string_tab[177] #define __pyx_n_u_size __pyx_string_tab[178] #define __pyx_n_u_state __pyx_string_tab[179] #define __pyx_n_u_stats __pyx_string_tab[180] #define __pyx_n_u_struct __pyx_string_tab[181] #define __pyx_n_u_throw __pyx_string_tab[182] #define __pyx_n_u_typing __pyx_string_tab[183] #define __pyx_n_u_unpack __pyx_string_tab[184] #define __pyx_n_u_unpacked_data __pyx_string_tab[185] #define __pyx_n_u_update __pyx_string_tab[186] #define __pyx_n_u_use_setstate __pyx_string_tab[187] #define __pyx_n_u_used __pyx_string_tab[188] #define __pyx_n_u_value __pyx_string_tab[189] #define __pyx_n_u_value_format __pyx_string_tab[190] #define __pyx_n_u_value_format_fields __pyx_string_tab[191] #define __pyx_n_u_value_format_name __pyx_string_tab[192] #define __pyx_n_u_value_format_t __pyx_string_tab[193] #define __pyx_n_u_value_size __pyx_string_tab[194] #define __pyx_n_u_value_type __pyx_string_tab[195] #define __pyx_n_u_value_type_fields __pyx_string_tab[196] #define __pyx_n_u_value_type_name __pyx_string_tab[197] #define __pyx_n_u_values __pyx_string_tab[198] #define __pyx_n_u_version __pyx_string_tab[199] #define __pyx_n_u_vsize __pyx_string_tab[200] #define __pyx_n_u_wb __pyx_string_tab[201] #define __pyx_n_u_write __pyx_string_tab[202] #define __pyx_n_b_BORGHASH __pyx_string_tab[203] #define __pyx_kp_b_iso88591__12 __pyx_string_tab[204] #define __pyx_kp_b_iso88591_q_0_kQR_haq_7_QnN_1 __pyx_string_tab[205] #define __pyx_kp_b_iso88591_hd_T_PTTaaeettxxy_q_l_vWE_Q_q_t __pyx_string_tab[206] #define __pyx_kp_b_iso88591_A_QgU_QfIQ_s_1A_3iq __pyx_string_tab[207] #define __pyx_kp_b_iso88591_A_fIQa_r_aq_3a_Rq_AQ_y_F_a_6_A_A __pyx_string_tab[208] #define __pyx_kp_b_iso88591__11 __pyx_string_tab[209] #define __pyx_kp_b_iso88591_a_Q_D_a_s_2S_Jb_M_1 __pyx_string_tab[210] #define __pyx_kp_b_iso88591_q_F __pyx_string_tab[211] #define __pyx_kp_b_iso88591_vYa_Kq_4vQa_1_4_AQ __pyx_string_tab[212] #define __pyx_kp_b_iso88591_v_A_Kq_4vT_xs_1_4_AQ __pyx_string_tab[213] #define __pyx_kp_b_iso88591_QgU_QfIQ_Jaq_1 __pyx_string_tab[214] #define __pyx_kp_b_iso88591_1_QgQ_Ye6_AWA_q_q_q_AWE_AWA_uE __pyx_string_tab[215] #define __pyx_kp_b_iso88591_A_A_a_a_t_a_A_4_A_D_F_D_a_T_q_W __pyx_string_tab[216] #define __pyx_kp_b_iso88591_HA_t6_1 __pyx_string_tab[217] #define __pyx_kp_b_iso88591_Ja_t6 __pyx_string_tab[218] #define __pyx_kp_b_iso88591_Ja_t6_1 __pyx_string_tab[219] #define __pyx_kp_b_iso88591_N_A_F_7 __pyx_string_tab[220] #define __pyx_kp_b_iso88591_XQ__D_j_uD_Qa __pyx_string_tab[221] #define __pyx_kp_b_iso88591_81_t_AQ_t6_1E __pyx_string_tab[222] #define __pyx_kp_b_iso88591_j_4z_q_1_A_aq_3auCt1_A_1D __pyx_string_tab[223] #define __pyx_kp_b_iso88591_ha_Kq_aq_t6_AU_t __pyx_string_tab[224] #define __pyx_kp_b_iso88591_F_V6 __pyx_string_tab[225] #define __pyx_kp_b_iso88591_ha_4z_Q_z_Kr_iq_4_QQRRVVWWX_t_R __pyx_string_tab[226] #define __pyx_kp_b_iso88591_1_1_M_t_b __pyx_string_tab[227] #define __pyx_int_0 __pyx_number_tab[0] #define __pyx_int_1 __pyx_number_tab[1] #define __pyx_int_4 __pyx_number_tab[2] #define __pyx_int_4096 __pyx_number_tab[3] #define __pyx_int_192473518 __pyx_number_tab[4] /* #### Code section: module_state_clear ### */ #if CYTHON_USE_MODULE_STATE static CYTHON_SMALL_CODE int __pyx_m_clear(PyObject *m) { __pyx_mstatetype *clear_module_state = __Pyx_PyModule_GetState(m); if (!clear_module_state) return 0; Py_CLEAR(clear_module_state->__pyx_d); Py_CLEAR(clear_module_state->__pyx_b); Py_CLEAR(clear_module_state->__pyx_cython_runtime); Py_CLEAR(clear_module_state->__pyx_empty_tuple); Py_CLEAR(clear_module_state->__pyx_empty_bytes); Py_CLEAR(clear_module_state->__pyx_empty_unicode); #if CYTHON_PEP489_MULTI_PHASE_INIT __Pyx_State_RemoveModule(NULL); #endif Py_CLEAR(clear_module_state->__pyx_ptype_8borghash_11HashTableNT_HashTableNT); Py_CLEAR(clear_module_state->__pyx_type_8borghash_11HashTableNT_HashTableNT); Py_CLEAR(clear_module_state->__pyx_ptype_8borghash_11HashTableNT___pyx_scope_struct__genexpr); Py_CLEAR(clear_module_state->__pyx_type_8borghash_11HashTableNT___pyx_scope_struct__genexpr); Py_CLEAR(clear_module_state->__pyx_ptype_8borghash_11HashTableNT___pyx_scope_struct_1_items); Py_CLEAR(clear_module_state->__pyx_type_8borghash_11HashTableNT___pyx_scope_struct_1_items); Py_CLEAR(clear_module_state->__pyx_umethod_PyDict_Type_items.method); Py_CLEAR(clear_module_state->__pyx_umethod_PyDict_Type_pop.method); Py_CLEAR(clear_module_state->__pyx_umethod_PyDict_Type_values.method); Py_CLEAR(clear_module_state->__pyx_k_); Py_CLEAR(clear_module_state->__pyx_k__5); for (int i=0; i<6; ++i) { Py_CLEAR(clear_module_state->__pyx_tuple[i]); } for (int i=0; i<24; ++i) { Py_CLEAR(clear_module_state->__pyx_codeobj_tab[i]); } for (int i=0; i<228; ++i) { Py_CLEAR(clear_module_state->__pyx_string_tab[i]); } for (int i=0; i<5; ++i) { Py_CLEAR(clear_module_state->__pyx_number_tab[i]); } /* #### Code section: module_state_clear_contents ### */ /* CommonTypesMetaclass.module_state_clear */ Py_CLEAR(clear_module_state->__pyx_CommonTypesMetaclassType); /* CythonFunctionPerModule.module_state_clear */ Py_CLEAR(clear_module_state->__pyx_CyFunctionType); /* Generator.module_state_clear */ Py_CLEAR(clear_module_state->__pyx_GeneratorType); /* #### Code section: module_state_clear_end ### */ return 0; } #endif /* #### Code section: module_state_traverse ### */ #if CYTHON_USE_MODULE_STATE static CYTHON_SMALL_CODE int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { __pyx_mstatetype *traverse_module_state = __Pyx_PyModule_GetState(m); if (!traverse_module_state) return 0; Py_VISIT(traverse_module_state->__pyx_d); Py_VISIT(traverse_module_state->__pyx_b); Py_VISIT(traverse_module_state->__pyx_cython_runtime); __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_tuple); __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_bytes); __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_unicode); Py_VISIT(traverse_module_state->__pyx_ptype_8borghash_11HashTableNT_HashTableNT); Py_VISIT(traverse_module_state->__pyx_type_8borghash_11HashTableNT_HashTableNT); Py_VISIT(traverse_module_state->__pyx_ptype_8borghash_11HashTableNT___pyx_scope_struct__genexpr); Py_VISIT(traverse_module_state->__pyx_type_8borghash_11HashTableNT___pyx_scope_struct__genexpr); Py_VISIT(traverse_module_state->__pyx_ptype_8borghash_11HashTableNT___pyx_scope_struct_1_items); Py_VISIT(traverse_module_state->__pyx_type_8borghash_11HashTableNT___pyx_scope_struct_1_items); Py_VISIT(traverse_module_state->__pyx_umethod_PyDict_Type_items.method); Py_VISIT(traverse_module_state->__pyx_umethod_PyDict_Type_pop.method); Py_VISIT(traverse_module_state->__pyx_umethod_PyDict_Type_values.method); Py_VISIT(traverse_module_state->__pyx_k_); Py_VISIT(traverse_module_state->__pyx_k__5); for (int i=0; i<6; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_tuple[i]); } for (int i=0; i<24; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_codeobj_tab[i]); } for (int i=0; i<228; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_string_tab[i]); } for (int i=0; i<5; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_number_tab[i]); } /* #### Code section: module_state_traverse_contents ### */ /* CommonTypesMetaclass.module_state_traverse */ Py_VISIT(traverse_module_state->__pyx_CommonTypesMetaclassType); /* CythonFunctionPerModule.module_state_traverse */ Py_VISIT(traverse_module_state->__pyx_CyFunctionType); /* Generator.module_state_traverse */ Py_VISIT(traverse_module_state->__pyx_GeneratorType); /* #### Code section: module_state_traverse_end ### */ return 0; } #endif /* #### Code section: module_code ### */ /* "borghash/HashTableNT.pyx":25 * * cdef class HashTableNT: * def __init__(self, items=None, *, # <<<<<<<<<<<<<< * key_size: int, value_type: Any, value_format: Any, * capacity: int = MIN_CAPACITY, byte_order="little") -> None: */ /* Python wrapper */ static int __pyx_pw_8borghash_11HashTableNT_11HashTableNT_1__init__(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL_TPNEW PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ static int __pyx_pw_8borghash_11HashTableNT_11HashTableNT_1__init__(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL_TPNEW PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_items = 0; PyObject *__pyx_v_key_size = 0; PyObject *__pyx_v_value_type = 0; PyObject *__pyx_v_value_format = 0; PyObject *__pyx_v_capacity = 0; PyObject *__pyx_v_byte_order = 0; #if !CYTHON_VECTORCALL_TPNEW CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[6] = {0,0,0,0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); #if !CYTHON_VECTORCALL_TPNEW #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL_TPNEW(__pyx_args, __pyx_nargs); { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_items,&__pyx_mstate_global->__pyx_n_u_key_size,&__pyx_mstate_global->__pyx_n_u_value_type,&__pyx_mstate_global->__pyx_n_u_value_format,&__pyx_mstate_global->__pyx_n_u_capacity,&__pyx_mstate_global->__pyx_n_u_byte_order,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL_TPNEW(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 25, __pyx_L3_error) if (likely(__pyx_kwds_len > 0)) { switch (__pyx_nargs) { case 1: values[0] = __Pyx_ArgRef_FASTCALL_TPNEW(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 25, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__init__", 0) < (0)) __PYX_ERR(0, 25, __pyx_L3_error) if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)Py_None)); if (!values[4]) values[4] = __Pyx_NewRef(__pyx_mstate_global->__pyx_k_); if (!values[5]) values[5] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_n_u_little)); for (Py_ssize_t i = 1; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseKeywordRequired("__init__", *(__pyx_pyargnames[i - 0])); __PYX_ERR(0, 25, __pyx_L3_error) } } } else if (unlikely(__pyx_nargs > 1)) { goto __pyx_L5_argtuple_error; } else { __Pyx_RaiseKeywordRequired("__init__", __pyx_mstate_global->__pyx_n_u_key_size); __PYX_ERR(0, 25, __pyx_L3_error) } __pyx_v_items = values[0]; if (__Pyx_PyInt_FromNumber(&values[1], "key_size", 0) < (0)) __PYX_ERR(0, 26, __pyx_L3_error) __pyx_v_key_size = ((PyObject*)values[1]); __pyx_v_value_type = values[2]; __pyx_v_value_format = values[3]; if (__Pyx_PyInt_FromNumber(&values[4], "capacity", 0) < (0)) __PYX_ERR(0, 27, __pyx_L3_error) __pyx_v_capacity = ((PyObject*)values[4]); __pyx_v_byte_order = values[5]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__init__", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 25, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_key_size), (&PyLong_Type), 0, "key_size", 2))) __PYX_ERR(0, 26, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_capacity), (&PyLong_Type), 0, "capacity", 2))) __PYX_ERR(0, 27, __pyx_L1_error) __pyx_r = __pyx_pf_8borghash_11HashTableNT_11HashTableNT___init__(((struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)__pyx_v_self), __pyx_v_items, __pyx_v_key_size, __pyx_v_value_type, __pyx_v_value_format, __pyx_v_capacity, __pyx_v_byte_order); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = -1; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } goto __pyx_L7_cleaned_up; __pyx_L0:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_8borghash_11HashTableNT_11HashTableNT_8__init___2generator1(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "borghash/HashTableNT.pyx":36 * if value_format._fields != value_type._fields: * raise TypeError("value_format's and value_type's element names must correspond.") * if not all(isinstance(fmt, str) and len(fmt) > 0 for fmt in value_format): # <<<<<<<<<<<<<< * raise ValueError("value_format's elements must be str and non-empty.") * if byte_order not in BYTE_ORDER: */ static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_8__init___genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0) { struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct__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_8borghash_11HashTableNT___pyx_scope_struct__genexpr *)__pyx_tp_new_8borghash_11HashTableNT___pyx_scope_struct__genexpr(__pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT___pyx_scope_struct__genexpr, __pyx_mstate_global->__pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct__genexpr *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(0, 36, __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_8borghash_11HashTableNT_11HashTableNT_8__init___2generator1, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[0]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_genexpr, __pyx_mstate_global->__pyx_n_u_init___locals_genexpr, __pyx_mstate_global->__pyx_n_u_borghash_HashTableNT); if (unlikely(!gen)) __PYX_ERR(0, 36, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.__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_gb_8borghash_11HashTableNT_11HashTableNT_8__init___2generator1(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct__genexpr *__pyx_cur_scope = ((struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct__genexpr *)__pyx_generator->closure); PyObject *__pyx_r = NULL; PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; PyObject *(*__pyx_t_3)(PyObject *); PyObject *__pyx_t_4 = NULL; int __pyx_t_5; int __pyx_t_6; Py_ssize_t __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("genexpr", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 36, __pyx_L1_error) if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(0, 36, __pyx_L1_error) } if (likely(PyList_CheckExact(__pyx_cur_scope->__pyx_genexpr_arg_0)) || PyTuple_CheckExact(__pyx_cur_scope->__pyx_genexpr_arg_0)) { __pyx_t_1 = __pyx_cur_scope->__pyx_genexpr_arg_0; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; __pyx_t_3 = NULL; } else { __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_cur_scope->__pyx_genexpr_arg_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 36, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 36, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_3)) { if (likely(PyList_CheckExact(__pyx_t_1))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 36, __pyx_L1_error) #endif if (__pyx_t_2 >= __pyx_temp) break; } __pyx_t_4 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_1, __pyx_t_2, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_2; } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 36, __pyx_L1_error) #endif if (__pyx_t_2 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_4 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2)); #else __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); #endif ++__pyx_t_2; } if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 36, __pyx_L1_error) } else { __pyx_t_4 = __pyx_t_3(__pyx_t_1); if (unlikely(!__pyx_t_4)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 36, __pyx_L1_error) PyErr_Clear(); } break; } } __Pyx_GOTREF(__pyx_t_4); __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_fmt); __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_fmt, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = PyUnicode_Check(__pyx_cur_scope->__pyx_v_fmt); if (__pyx_t_6) { } else { __pyx_t_5 = __pyx_t_6; goto __pyx_L7_bool_binop_done; } __pyx_t_7 = PyObject_Length(__pyx_cur_scope->__pyx_v_fmt); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(0, 36, __pyx_L1_error) __pyx_t_6 = (__pyx_t_7 > 0); __pyx_t_5 = __pyx_t_6; __pyx_L7_bool_binop_done:; __pyx_t_6 = (!__pyx_t_5); if (__pyx_t_6) { { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __Pyx_INCREF(Py_False); __pyx_r = Py_False; } __Pyx_XDECREF(__pyx_temp); } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; } } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /*else*/ { { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __Pyx_INCREF(Py_True); __pyx_r = Py_True; } __Pyx_XDECREF(__pyx_temp); } goto __pyx_L0; } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); if (__Pyx_PyErr_Occurred()) { __Pyx_Generator_Replace_StopIteration(0); __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); } __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTableNT.pyx":25 * * cdef class HashTableNT: * def __init__(self, items=None, *, # <<<<<<<<<<<<<< * key_size: int, value_type: Any, value_format: Any, * capacity: int = MIN_CAPACITY, byte_order="little") -> None: */ static int __pyx_pf_8borghash_11HashTableNT_11HashTableNT___init__(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_items, PyObject *__pyx_v_key_size, PyObject *__pyx_v_value_type, PyObject *__pyx_v_value_format, PyObject *__pyx_v_capacity, PyObject *__pyx_v_byte_order) { PyObject *__pyx_gb_8borghash_11HashTableNT_11HashTableNT_8__init___2generator1 = 0; int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; size_t __pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; int __pyx_t_11; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); /* "borghash/HashTableNT.pyx":28 * key_size: int, value_type: Any, value_format: Any, * capacity: int = MIN_CAPACITY, byte_order="little") -> None: * if not isinstance(key_size, int) or not key_size >= 4: # <<<<<<<<<<<<<< * raise ValueError("key_size must be an integer and >= 4.") * if type(value_type) is not type: */ __pyx_t_2 = PyLong_Check(__pyx_v_key_size); __pyx_t_3 = (!__pyx_t_2); if (!__pyx_t_3) { } else { __pyx_t_1 = __pyx_t_3; goto __pyx_L4_bool_binop_done; } __pyx_t_3 = __Pyx_PyObject_CompareBoolGe_int_int(__pyx_v_key_size, __pyx_mstate_global->__pyx_int_4, Py_GE); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 28, __pyx_L1_error) __pyx_t_2 = (!__pyx_t_3); __pyx_t_1 = __pyx_t_2; __pyx_L4_bool_binop_done:; if (unlikely(__pyx_t_1)) { /* "borghash/HashTableNT.pyx":29 * capacity: int = MIN_CAPACITY, byte_order="little") -> None: * if not isinstance(key_size, int) or not key_size >= 4: * raise ValueError("key_size must be an integer and >= 4.") # <<<<<<<<<<<<<< * if type(value_type) is not type: * raise TypeError("value_type must be a namedtuple type.") */ __pyx_t_5 = NULL; __pyx_t_6 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_key_size_must_be_an_integer_and}; __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 29, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); } __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 29, __pyx_L1_error) /* "borghash/HashTableNT.pyx":28 * key_size: int, value_type: Any, value_format: Any, * capacity: int = MIN_CAPACITY, byte_order="little") -> None: * if not isinstance(key_size, int) or not key_size >= 4: # <<<<<<<<<<<<<< * raise ValueError("key_size must be an integer and >= 4.") * if type(value_type) is not type: */ } /* "borghash/HashTableNT.pyx":30 * if not isinstance(key_size, int) or not key_size >= 4: * raise ValueError("key_size must be an integer and >= 4.") * if type(value_type) is not type: # <<<<<<<<<<<<<< * raise TypeError("value_type must be a namedtuple type.") * if not isinstance(value_format, tuple): */ __pyx_t_1 = (((PyObject *)Py_TYPE(__pyx_v_value_type)) != ((PyObject *)(&PyType_Type))); if (unlikely(__pyx_t_1)) { /* "borghash/HashTableNT.pyx":31 * raise ValueError("key_size must be an integer and >= 4.") * if type(value_type) is not type: * raise TypeError("value_type must be a namedtuple type.") # <<<<<<<<<<<<<< * if not isinstance(value_format, tuple): * raise TypeError("value_format must be a namedtuple instance.") */ __pyx_t_5 = NULL; __pyx_t_6 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_value_type_must_be_a_namedtuple}; __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_TypeError)), __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 31, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); } __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 31, __pyx_L1_error) /* "borghash/HashTableNT.pyx":30 * if not isinstance(key_size, int) or not key_size >= 4: * raise ValueError("key_size must be an integer and >= 4.") * if type(value_type) is not type: # <<<<<<<<<<<<<< * raise TypeError("value_type must be a namedtuple type.") * if not isinstance(value_format, tuple): */ } /* "borghash/HashTableNT.pyx":32 * if type(value_type) is not type: * raise TypeError("value_type must be a namedtuple type.") * if not isinstance(value_format, tuple): # <<<<<<<<<<<<<< * raise TypeError("value_format must be a namedtuple instance.") * if value_format._fields != value_type._fields: */ __pyx_t_1 = PyTuple_Check(__pyx_v_value_format); __pyx_t_2 = (!__pyx_t_1); if (unlikely(__pyx_t_2)) { /* "borghash/HashTableNT.pyx":33 * raise TypeError("value_type must be a namedtuple type.") * if not isinstance(value_format, tuple): * raise TypeError("value_format must be a namedtuple instance.") # <<<<<<<<<<<<<< * if value_format._fields != value_type._fields: * raise TypeError("value_format's and value_type's element names must correspond.") */ __pyx_t_5 = NULL; __pyx_t_6 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_value_format_must_be_a_namedtupl}; __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_TypeError)), __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 33, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); } __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 33, __pyx_L1_error) /* "borghash/HashTableNT.pyx":32 * if type(value_type) is not type: * raise TypeError("value_type must be a namedtuple type.") * if not isinstance(value_format, tuple): # <<<<<<<<<<<<<< * raise TypeError("value_format must be a namedtuple instance.") * if value_format._fields != value_type._fields: */ } /* "borghash/HashTableNT.pyx":34 * if not isinstance(value_format, tuple): * raise TypeError("value_format must be a namedtuple instance.") * if value_format._fields != value_type._fields: # <<<<<<<<<<<<<< * raise TypeError("value_format's and value_type's element names must correspond.") * if not all(isinstance(fmt, str) and len(fmt) > 0 for fmt in value_format): */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_value_format, __pyx_mstate_global->__pyx_n_u_fields); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 34, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_value_type, __pyx_mstate_global->__pyx_n_u_fields); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 34, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_2 = __Pyx_PyObject_CompareBoolNe_object_object(__pyx_t_4, __pyx_t_5, Py_NE); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 34, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(__pyx_t_2)) { /* "borghash/HashTableNT.pyx":35 * raise TypeError("value_format must be a namedtuple instance.") * if value_format._fields != value_type._fields: * raise TypeError("value_format's and value_type's element names must correspond.") # <<<<<<<<<<<<<< * if not all(isinstance(fmt, str) and len(fmt) > 0 for fmt in value_format): * raise ValueError("value_format's elements must be str and non-empty.") */ __pyx_t_4 = NULL; __pyx_t_6 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_value_format_s_and_value_type_s}; __pyx_t_5 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_TypeError)), __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 35, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); } __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __PYX_ERR(0, 35, __pyx_L1_error) /* "borghash/HashTableNT.pyx":34 * if not isinstance(value_format, tuple): * raise TypeError("value_format must be a namedtuple instance.") * if value_format._fields != value_type._fields: # <<<<<<<<<<<<<< * raise TypeError("value_format's and value_type's element names must correspond.") * if not all(isinstance(fmt, str) and len(fmt) > 0 for fmt in value_format): */ } /* "borghash/HashTableNT.pyx":36 * if value_format._fields != value_type._fields: * raise TypeError("value_format's and value_type's element names must correspond.") * if not all(isinstance(fmt, str) and len(fmt) > 0 for fmt in value_format): # <<<<<<<<<<<<<< * raise ValueError("value_format's elements must be str and non-empty.") * if byte_order not in BYTE_ORDER: */ __pyx_t_5 = __pyx_pf_8borghash_11HashTableNT_11HashTableNT_8__init___genexpr(NULL, __pyx_v_value_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 36, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = __Pyx_Generator_GetInlinedResult(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 36, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 36, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_1 = (!__pyx_t_2); if (unlikely(__pyx_t_1)) { /* "borghash/HashTableNT.pyx":37 * raise TypeError("value_format's and value_type's element names must correspond.") * if not all(isinstance(fmt, str) and len(fmt) > 0 for fmt in value_format): * raise ValueError("value_format's elements must be str and non-empty.") # <<<<<<<<<<<<<< * if byte_order not in BYTE_ORDER: * raise ValueError(f"byte_order must be one of: {', '.join(BYTE_ORDER.keys())}") */ __pyx_t_5 = NULL; __pyx_t_6 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_value_format_s_elements_must_be}; __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 37, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); } __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 37, __pyx_L1_error) /* "borghash/HashTableNT.pyx":36 * if value_format._fields != value_type._fields: * raise TypeError("value_format's and value_type's element names must correspond.") * if not all(isinstance(fmt, str) and len(fmt) > 0 for fmt in value_format): # <<<<<<<<<<<<<< * raise ValueError("value_format's elements must be str and non-empty.") * if byte_order not in BYTE_ORDER: */ } /* "borghash/HashTableNT.pyx":38 * if not all(isinstance(fmt, str) and len(fmt) > 0 for fmt in value_format): * raise ValueError("value_format's elements must be str and non-empty.") * if byte_order not in BYTE_ORDER: # <<<<<<<<<<<<<< * raise ValueError(f"byte_order must be one of: {', '.join(BYTE_ORDER.keys())}") * self.key_size = key_size */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_BYTE_ORDER); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 38, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_byte_order, __pyx_t_4, Py_NE)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 38, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(__pyx_t_1)) { /* "borghash/HashTableNT.pyx":39 * raise ValueError("value_format's elements must be str and non-empty.") * if byte_order not in BYTE_ORDER: * raise ValueError(f"byte_order must be one of: {', '.join(BYTE_ORDER.keys())}") # <<<<<<<<<<<<<< * self.key_size = key_size * self.value_type = value_type */ __pyx_t_5 = NULL; __pyx_t_8 = NULL; __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_BYTE_ORDER); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 39, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_keys); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 39, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_6 = 1; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_10))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_10); assert(__pyx_t_8); PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_10); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(__pyx__function); __Pyx_DECREF_SET(__pyx_t_10, __pyx__function); __pyx_t_6 = 0; } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_8, NULL}; __pyx_t_7 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_10, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 39, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); } __pyx_t_10 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__3, __pyx_t_7); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 39, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_byte_order_must_be_one_of, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 39, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_t_6 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_7}; __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 39, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); } __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 39, __pyx_L1_error) /* "borghash/HashTableNT.pyx":38 * if not all(isinstance(fmt, str) and len(fmt) > 0 for fmt in value_format): * raise ValueError("value_format's elements must be str and non-empty.") * if byte_order not in BYTE_ORDER: # <<<<<<<<<<<<<< * raise ValueError(f"byte_order must be one of: {', '.join(BYTE_ORDER.keys())}") * self.key_size = key_size */ } /* "borghash/HashTableNT.pyx":40 * if byte_order not in BYTE_ORDER: * raise ValueError(f"byte_order must be one of: {', '.join(BYTE_ORDER.keys())}") * self.key_size = key_size # <<<<<<<<<<<<<< * self.value_type = value_type * self.value_format = value_format */ __pyx_t_11 = __Pyx_PyLong_As_int(__pyx_v_key_size); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 40, __pyx_L1_error) __pyx_v_self->key_size = __pyx_t_11; /* "borghash/HashTableNT.pyx":41 * raise ValueError(f"byte_order must be one of: {', '.join(BYTE_ORDER.keys())}") * self.key_size = key_size * self.value_type = value_type # <<<<<<<<<<<<<< * self.value_format = value_format * self.byte_order = byte_order */ __Pyx_INCREF(__pyx_v_value_type); __Pyx_GIVEREF(__pyx_v_value_type); __Pyx_GOTREF(__pyx_v_self->value_type); __Pyx_DECREF(__pyx_v_self->value_type); __pyx_v_self->value_type = __pyx_v_value_type; /* "borghash/HashTableNT.pyx":42 * self.key_size = key_size * self.value_type = value_type * self.value_format = value_format # <<<<<<<<<<<<<< * self.byte_order = byte_order * self.value_struct = struct.Struct(BYTE_ORDER[byte_order] + "".join(value_format)) */ __Pyx_INCREF(__pyx_v_value_format); __Pyx_GIVEREF(__pyx_v_value_format); __Pyx_GOTREF(__pyx_v_self->value_format); __Pyx_DECREF(__pyx_v_self->value_format); __pyx_v_self->value_format = __pyx_v_value_format; /* "borghash/HashTableNT.pyx":43 * self.value_type = value_type * self.value_format = value_format * self.byte_order = byte_order # <<<<<<<<<<<<<< * self.value_struct = struct.Struct(BYTE_ORDER[byte_order] + "".join(value_format)) * self.value_size = self.value_struct.size */ __Pyx_INCREF(__pyx_v_byte_order); __Pyx_GIVEREF(__pyx_v_byte_order); __Pyx_GOTREF(__pyx_v_self->byte_order); __Pyx_DECREF(__pyx_v_self->byte_order); __pyx_v_self->byte_order = __pyx_v_byte_order; /* "borghash/HashTableNT.pyx":44 * self.value_format = value_format * self.byte_order = byte_order * self.value_struct = struct.Struct(BYTE_ORDER[byte_order] + "".join(value_format)) # <<<<<<<<<<<<<< * self.value_size = self.value_struct.size * self.inner = HashTable(key_size=self.key_size, value_size=self.value_size, capacity=capacity) */ __pyx_t_7 = NULL; __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_struct); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 44, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_Struct); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 44, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_BYTE_ORDER); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 44, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_t_5, __pyx_v_byte_order); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 44, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__4, __pyx_v_value_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 44, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_9 = PyNumber_Add(__pyx_t_8, __pyx_t_5); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 44, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_6 = 1; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_10))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_10); assert(__pyx_t_7); PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_10); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(__pyx__function); __Pyx_DECREF_SET(__pyx_t_10, __pyx__function); __pyx_t_6 = 0; } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_9}; __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_10, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 44, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); } __Pyx_GIVEREF(__pyx_t_4); __Pyx_GOTREF(__pyx_v_self->value_struct); __Pyx_DECREF(__pyx_v_self->value_struct); __pyx_v_self->value_struct = __pyx_t_4; __pyx_t_4 = 0; /* "borghash/HashTableNT.pyx":45 * self.byte_order = byte_order * self.value_struct = struct.Struct(BYTE_ORDER[byte_order] + "".join(value_format)) * self.value_size = self.value_struct.size # <<<<<<<<<<<<<< * self.inner = HashTable(key_size=self.key_size, value_size=self.value_size, capacity=capacity) * _fill(self, items) */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->value_struct, __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 45, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_11 = __Pyx_PyLong_As_int(__pyx_t_4); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 45, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_self->value_size = __pyx_t_11; /* "borghash/HashTableNT.pyx":46 * self.value_struct = struct.Struct(BYTE_ORDER[byte_order] + "".join(value_format)) * self.value_size = self.value_struct.size * self.inner = HashTable(key_size=self.key_size, value_size=self.value_size, capacity=capacity) # <<<<<<<<<<<<<< * _fill(self, items) * */ __pyx_t_10 = NULL; __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_HashTable); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 46, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_self->key_size); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 46, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_self->value_size); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 46, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = 1; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_9))) { __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_9); assert(__pyx_t_10); PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9); __Pyx_INCREF(__pyx_t_10); __Pyx_INCREF(__pyx__function); __Pyx_DECREF_SET(__pyx_t_9, __pyx__function); __pyx_t_6 = 0; } #endif { PyObject *__pyx_callargs[4] = {__pyx_t_10, __pyx_t_7, __pyx_t_5, __pyx_v_capacity}; #if CYTHON_VECTORCALL __pyx_t_8 = __pyx_mstate_global->__pyx_tuple[0]; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 46, __pyx_L1_error) __Pyx_INCREF(__pyx_t_8); #else { PyObject *__pyx_temp[3] = {__pyx_mstate_global->__pyx_n_u_key_size, __pyx_mstate_global->__pyx_n_u_value_size, __pyx_mstate_global->__pyx_n_u_capacity}; __pyx_t_8 = __Pyx_MakeKwargDict(__pyx_temp, __pyx_callargs+1, 3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 46, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); } #endif __pyx_t_4 = __Pyx_Object_VectorcallKwds((PyObject*)__pyx_t_9, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8); __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 46, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); } __Pyx_GIVEREF(__pyx_t_4); __Pyx_GOTREF(__pyx_v_self->inner); __Pyx_DECREF(__pyx_v_self->inner); __pyx_v_self->inner = __pyx_t_4; __pyx_t_4 = 0; /* "borghash/HashTableNT.pyx":47 * self.value_size = self.value_struct.size * self.inner = HashTable(key_size=self.key_size, value_size=self.value_size, capacity=capacity) * _fill(self, items) # <<<<<<<<<<<<<< * * def clear(self) -> None: */ __pyx_t_9 = NULL; __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_fill); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 47, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_6 = 1; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); assert(__pyx_t_9); PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(__pyx__function); __Pyx_DECREF_SET(__pyx_t_8, __pyx__function); __pyx_t_6 = 0; } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_9, ((PyObject *)__pyx_v_self), __pyx_v_items}; __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_8, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __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, 47, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "borghash/HashTableNT.pyx":25 * * cdef class HashTableNT: * def __init__(self, items=None, *, # <<<<<<<<<<<<<< * key_size: int, value_type: Any, value_format: Any, * capacity: int = MIN_CAPACITY, byte_order="little") -> None: */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_XDECREF(__pyx_gb_8borghash_11HashTableNT_11HashTableNT_8__init___2generator1); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTableNT.pyx":49 * _fill(self, items) * * def clear(self) -> None: # <<<<<<<<<<<<<< * self.inner.clear() * */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_3clear(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_8borghash_11HashTableNT_11HashTableNT_3clear = {"clear", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_3clear, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_3clear(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { #if !CYTHON_VECTORCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("clear (wrapper)", 0); #if !CYTHON_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("clear", 1, 0, 0, __pyx_nargs); return NULL; } const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) return NULL; if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("clear", __pyx_kwds); return NULL;} __pyx_r = __pyx_pf_8borghash_11HashTableNT_11HashTableNT_2clear(((struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_2clear(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; size_t __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("clear", 0); /* "borghash/HashTableNT.pyx":50 * * def clear(self) -> None: * self.inner.clear() # <<<<<<<<<<<<<< * * def _check_key(self, key: bytes) -> None: */ __pyx_t_2 = __pyx_v_self->inner; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_clear, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 50, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "borghash/HashTableNT.pyx":49 * _fill(self, items) * * def clear(self) -> None: # <<<<<<<<<<<<<< * self.inner.clear() * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.clear", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTableNT.pyx":52 * self.inner.clear() * * def _check_key(self, key: bytes) -> None: # <<<<<<<<<<<<<< * if not isinstance(key, bytes): * raise TypeError(f"Expected an instance of bytes, got {type(key)}") */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_5_check_key(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_8borghash_11HashTableNT_11HashTableNT_5_check_key = {"_check_key", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_5_check_key, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_5_check_key(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_key = 0; #if !CYTHON_VECTORCALL 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("_check_key (wrapper)", 0); #if !CYTHON_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_key,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 52, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 52, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_check_key", 0) < (0)) __PYX_ERR(0, 52, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_check_key", 1, 1, 1, i); __PYX_ERR(0, 52, __pyx_L3_error) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 52, __pyx_L3_error) } __pyx_v_key = ((PyObject*)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("_check_key", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 52, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT._check_key", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_key), (&PyBytes_Type), 0, "key", 2))) __PYX_ERR(0, 52, __pyx_L1_error) __pyx_r = __pyx_pf_8borghash_11HashTableNT_11HashTableNT_4_check_key(((struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)__pyx_v_self), __pyx_v_key); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } goto __pyx_L7_cleaned_up; __pyx_L0:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_4_check_key(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_key) { PyObject *__pyx_r = NULL; __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; PyObject *__pyx_t_6 = NULL; size_t __pyx_t_7; Py_ssize_t __pyx_t_8; PyObject *__pyx_t_9[3]; int __pyx_t_10; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_check_key", 0); /* "borghash/HashTableNT.pyx":53 * * def _check_key(self, key: bytes) -> None: * if not isinstance(key, bytes): # <<<<<<<<<<<<<< * raise TypeError(f"Expected an instance of bytes, got {type(key)}") * if len(key) != self.key_size: */ __pyx_t_1 = PyBytes_Check(__pyx_v_key); __pyx_t_2 = (!__pyx_t_1); if (unlikely(__pyx_t_2)) { /* "borghash/HashTableNT.pyx":54 * def _check_key(self, key: bytes) -> None: * if not isinstance(key, bytes): * raise TypeError(f"Expected an instance of bytes, got {type(key)}") # <<<<<<<<<<<<<< * if len(key) != self.key_size: * raise ValueError(f"Key must be {self.key_size} bytes long") */ __pyx_t_4 = NULL; __pyx_t_5 = __Pyx_PyObject_FormatSimple(((PyObject *)Py_TYPE(__pyx_v_key)), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 54, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_Expected_an_instance_of_bytes_go, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 54, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_7 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_6}; __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_TypeError)), __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 54, __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, 54, __pyx_L1_error) /* "borghash/HashTableNT.pyx":53 * * def _check_key(self, key: bytes) -> None: * if not isinstance(key, bytes): # <<<<<<<<<<<<<< * raise TypeError(f"Expected an instance of bytes, got {type(key)}") * if len(key) != self.key_size: */ } /* "borghash/HashTableNT.pyx":55 * if not isinstance(key, bytes): * raise TypeError(f"Expected an instance of bytes, got {type(key)}") * if len(key) != self.key_size: # <<<<<<<<<<<<<< * raise ValueError(f"Key must be {self.key_size} bytes long") * */ __pyx_t_8 = __Pyx_PyBytes_GET_SIZE(__pyx_v_key); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(0, 55, __pyx_L1_error) __pyx_t_2 = (__pyx_t_8 != __pyx_v_self->key_size); if (unlikely(__pyx_t_2)) { /* "borghash/HashTableNT.pyx":56 * raise TypeError(f"Expected an instance of bytes, got {type(key)}") * if len(key) != self.key_size: * raise ValueError(f"Key must be {self.key_size} bytes long") # <<<<<<<<<<<<<< * * def _to_binary_value(self, value: Any) -> bytes: */ __pyx_t_6 = NULL; __pyx_t_4 = __Pyx_PyUnicode_From_int(__pyx_v_self->key_size, 0, ' ', 'd'); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 56, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_9[0] = __pyx_mstate_global->__pyx_kp_u_Key_must_be; __pyx_t_9[1] = __pyx_t_4; __pyx_t_9[2] = __pyx_mstate_global->__pyx_kp_u_bytes_long; __pyx_t_8 = 23; #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH __pyx_t_8 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9[1]); #endif __pyx_t_10 = 0; __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_9, 3, __pyx_t_8, __pyx_t_10); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 56, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_7 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 56, __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, 56, __pyx_L1_error) /* "borghash/HashTableNT.pyx":55 * if not isinstance(key, bytes): * raise TypeError(f"Expected an instance of bytes, got {type(key)}") * if len(key) != self.key_size: # <<<<<<<<<<<<<< * raise ValueError(f"Key must be {self.key_size} bytes long") * */ } /* "borghash/HashTableNT.pyx":52 * self.inner.clear() * * def _check_key(self, key: bytes) -> None: # <<<<<<<<<<<<<< * if not isinstance(key, bytes): * raise TypeError(f"Expected an instance of bytes, got {type(key)}") */ /* 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("borghash.HashTableNT.HashTableNT._check_key", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTableNT.pyx":58 * raise ValueError(f"Key must be {self.key_size} bytes long") * * def _to_binary_value(self, value: Any) -> bytes: # <<<<<<<<<<<<<< * if not isinstance(value, self.value_type): * if isinstance(value, tuple): */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_7_to_binary_value(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_8borghash_11HashTableNT_11HashTableNT_7_to_binary_value = {"_to_binary_value", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_7_to_binary_value, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_7_to_binary_value(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_value = 0; #if !CYTHON_VECTORCALL 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("_to_binary_value (wrapper)", 0); #if !CYTHON_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_value,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 58, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 58, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_to_binary_value", 0) < (0)) __PYX_ERR(0, 58, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_to_binary_value", 1, 1, 1, i); __PYX_ERR(0, 58, __pyx_L3_error) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 58, __pyx_L3_error) } __pyx_v_value = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("_to_binary_value", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 58, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT._to_binary_value", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8borghash_11HashTableNT_11HashTableNT_6_to_binary_value(((struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)__pyx_v_self), __pyx_v_value); /* function exit code */ for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_6_to_binary_value(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_value) { PyObject *__pyx_r = NULL; __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[4]; Py_ssize_t __pyx_t_8; int __pyx_t_9; PyObject *__pyx_t_10 = NULL; size_t __pyx_t_11; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_to_binary_value", 0); __Pyx_INCREF(__pyx_v_value); /* "borghash/HashTableNT.pyx":59 * * def _to_binary_value(self, value: Any) -> bytes: * if not isinstance(value, self.value_type): # <<<<<<<<<<<<<< * if isinstance(value, tuple): * value = self.value_type(*value) */ __pyx_t_1 = __pyx_v_self->value_type; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = PyObject_IsInstance(__pyx_v_value, __pyx_t_1); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 59, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (!__pyx_t_2); if (__pyx_t_3) { /* "borghash/HashTableNT.pyx":60 * def _to_binary_value(self, value: Any) -> bytes: * if not isinstance(value, self.value_type): * if isinstance(value, tuple): # <<<<<<<<<<<<<< * value = self.value_type(*value) * else: */ __pyx_t_3 = PyTuple_Check(__pyx_v_value); if (likely(__pyx_t_3)) { /* "borghash/HashTableNT.pyx":61 * if not isinstance(value, self.value_type): * if isinstance(value, tuple): * value = self.value_type(*value) # <<<<<<<<<<<<<< * else: * raise TypeError(f"Expected an instance of {self.value_type}, got {type(value)}") */ __pyx_t_1 = __Pyx_PySequence_Tuple(__pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 61, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __Pyx_PyObject_Call(__pyx_v_self->value_type, __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 61, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_4); __pyx_t_4 = 0; /* "borghash/HashTableNT.pyx":60 * def _to_binary_value(self, value: Any) -> bytes: * if not isinstance(value, self.value_type): * if isinstance(value, tuple): # <<<<<<<<<<<<<< * value = self.value_type(*value) * else: */ goto __pyx_L4; } /* "borghash/HashTableNT.pyx":63 * value = self.value_type(*value) * else: * raise TypeError(f"Expected an instance of {self.value_type}, got {type(value)}") # <<<<<<<<<<<<<< * return self.value_struct.pack(*value) * */ /*else*/ { __pyx_t_1 = NULL; __pyx_t_5 = __Pyx_PyObject_FormatSimple(__pyx_v_self->value_type, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 63, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyObject_FormatSimple(((PyObject *)Py_TYPE(__pyx_v_value)), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 63, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7[0] = __pyx_mstate_global->__pyx_kp_u_Expected_an_instance_of; __pyx_t_7[1] = __pyx_t_5; __pyx_t_7[2] = __pyx_mstate_global->__pyx_kp_u_got; __pyx_t_7[3] = __pyx_t_6; __pyx_t_8 = 30; #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH __pyx_t_8 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7[3]); #endif __pyx_t_9 = 0; #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH __pyx_t_9 |= __Pyx_PyUnicode_KIND_04(__pyx_t_7[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_7[3]); #endif __pyx_t_10 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_8, __pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 63, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_11 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_10}; __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_TypeError)), __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 63, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); } __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 63, __pyx_L1_error) } __pyx_L4:; /* "borghash/HashTableNT.pyx":59 * * def _to_binary_value(self, value: Any) -> bytes: * if not isinstance(value, self.value_type): # <<<<<<<<<<<<<< * if isinstance(value, tuple): * value = self.value_type(*value) */ } /* "borghash/HashTableNT.pyx":64 * else: * raise TypeError(f"Expected an instance of {self.value_type}, got {type(value)}") * return self.value_struct.pack(*value) # <<<<<<<<<<<<<< * * def _to_namedtuple_value(self, binary_value: bytes) -> Any: */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->value_struct, __pyx_mstate_global->__pyx_n_u_pack); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 64, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_10 = __Pyx_PySequence_Tuple(__pyx_v_value); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 64, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 64, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; if (!(likely(PyBytes_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_1))) __PYX_ERR(0, 64, __pyx_L1_error) { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __pyx_r = ((PyObject*)__pyx_t_1); } __Pyx_XDECREF(__pyx_temp); } __pyx_t_1 = 0; goto __pyx_L0; /* "borghash/HashTableNT.pyx":58 * raise ValueError(f"Key must be {self.key_size} bytes long") * * def _to_binary_value(self, value: Any) -> bytes: # <<<<<<<<<<<<<< * if not isinstance(value, self.value_type): * if isinstance(value, tuple): */ /* function exit code */ __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_10); __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT._to_binary_value", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_value); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTableNT.pyx":66 * return self.value_struct.pack(*value) * * def _to_namedtuple_value(self, binary_value: bytes) -> Any: # <<<<<<<<<<<<<< * unpacked_data = self.value_struct.unpack(binary_value) * return self.value_type(*unpacked_data) */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_9_to_namedtuple_value(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_8borghash_11HashTableNT_11HashTableNT_9_to_namedtuple_value = {"_to_namedtuple_value", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_9_to_namedtuple_value, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_9_to_namedtuple_value(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_binary_value = 0; #if !CYTHON_VECTORCALL 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("_to_namedtuple_value (wrapper)", 0); #if !CYTHON_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_binary_value,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 66, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 66, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_to_namedtuple_value", 0) < (0)) __PYX_ERR(0, 66, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_to_namedtuple_value", 1, 1, 1, i); __PYX_ERR(0, 66, __pyx_L3_error) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 66, __pyx_L3_error) } __pyx_v_binary_value = ((PyObject*)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("_to_namedtuple_value", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 66, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT._to_namedtuple_value", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_binary_value), (&PyBytes_Type), 0, "binary_value", 2))) __PYX_ERR(0, 66, __pyx_L1_error) __pyx_r = __pyx_pf_8borghash_11HashTableNT_11HashTableNT_8_to_namedtuple_value(((struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)__pyx_v_self), __pyx_v_binary_value); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } goto __pyx_L7_cleaned_up; __pyx_L0:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_8_to_namedtuple_value(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_binary_value) { PyObject *__pyx_v_unpacked_data = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; size_t __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_to_namedtuple_value", 0); /* "borghash/HashTableNT.pyx":67 * * def _to_namedtuple_value(self, binary_value: bytes) -> Any: * unpacked_data = self.value_struct.unpack(binary_value) # <<<<<<<<<<<<<< * return self.value_type(*unpacked_data) * */ __pyx_t_2 = __pyx_v_self->value_struct; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_binary_value}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_unpack, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 67, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } __pyx_v_unpacked_data = __pyx_t_1; __pyx_t_1 = 0; /* "borghash/HashTableNT.pyx":68 * def _to_namedtuple_value(self, binary_value: bytes) -> Any: * unpacked_data = self.value_struct.unpack(binary_value) * return self.value_type(*unpacked_data) # <<<<<<<<<<<<<< * * def _set_raw(self, key: bytes, value: bytes) -> None: */ __pyx_t_1 = __Pyx_PySequence_Tuple(__pyx_v_unpacked_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_Call(__pyx_v_self->value_type, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __pyx_r = __pyx_t_2; } __Pyx_XDECREF(__pyx_temp); } __pyx_t_2 = 0; goto __pyx_L0; /* "borghash/HashTableNT.pyx":66 * return self.value_struct.pack(*value) * * def _to_namedtuple_value(self, binary_value: bytes) -> Any: # <<<<<<<<<<<<<< * unpacked_data = self.value_struct.unpack(binary_value) * return self.value_type(*unpacked_data) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT._to_namedtuple_value", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_unpacked_data); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTableNT.pyx":70 * return self.value_type(*unpacked_data) * * def _set_raw(self, key: bytes, value: bytes) -> None: # <<<<<<<<<<<<<< * self.inner[key] = value * */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_11_set_raw(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_8borghash_11HashTableNT_11HashTableNT_11_set_raw = {"_set_raw", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_11_set_raw, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_11_set_raw(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_key = 0; PyObject *__pyx_v_value = 0; #if !CYTHON_VECTORCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_set_raw (wrapper)", 0); #if !CYTHON_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_key,&__pyx_mstate_global->__pyx_n_u_value,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 70, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 70, __pyx_L3_error) CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 70, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_set_raw", 0) < (0)) __PYX_ERR(0, 70, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_set_raw", 1, 2, 2, i); __PYX_ERR(0, 70, __pyx_L3_error) } } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 70, __pyx_L3_error) values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 70, __pyx_L3_error) } __pyx_v_key = ((PyObject*)values[0]); __pyx_v_value = ((PyObject*)values[1]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("_set_raw", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 70, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT._set_raw", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_key), (&PyBytes_Type), 0, "key", 2))) __PYX_ERR(0, 70, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_value), (&PyBytes_Type), 0, "value", 2))) __PYX_ERR(0, 70, __pyx_L1_error) __pyx_r = __pyx_pf_8borghash_11HashTableNT_11HashTableNT_10_set_raw(((struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)__pyx_v_self), __pyx_v_key, __pyx_v_value); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } goto __pyx_L7_cleaned_up; __pyx_L0:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_10_set_raw(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_set_raw", 0); /* "borghash/HashTableNT.pyx":71 * * def _set_raw(self, key: bytes, value: bytes) -> None: * self.inner[key] = value # <<<<<<<<<<<<<< * * def _get_raw(self, key: bytes) -> bytes: */ if (unlikely((PyObject_SetItem(__pyx_v_self->inner, __pyx_v_key, __pyx_v_value) < 0))) __PYX_ERR(0, 71, __pyx_L1_error) /* "borghash/HashTableNT.pyx":70 * return self.value_type(*unpacked_data) * * def _set_raw(self, key: bytes, value: bytes) -> None: # <<<<<<<<<<<<<< * self.inner[key] = value * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT._set_raw", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTableNT.pyx":73 * self.inner[key] = value * * def _get_raw(self, key: bytes) -> bytes: # <<<<<<<<<<<<<< * return self.inner[key] * */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_13_get_raw(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_8borghash_11HashTableNT_11HashTableNT_13_get_raw = {"_get_raw", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_13_get_raw, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_13_get_raw(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_key = 0; #if !CYTHON_VECTORCALL 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("_get_raw (wrapper)", 0); #if !CYTHON_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_key,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 73, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 73, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_get_raw", 0) < (0)) __PYX_ERR(0, 73, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_get_raw", 1, 1, 1, i); __PYX_ERR(0, 73, __pyx_L3_error) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 73, __pyx_L3_error) } __pyx_v_key = ((PyObject*)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("_get_raw", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 73, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT._get_raw", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_key), (&PyBytes_Type), 0, "key", 2))) __PYX_ERR(0, 73, __pyx_L1_error) __pyx_r = __pyx_pf_8borghash_11HashTableNT_11HashTableNT_12_get_raw(((struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)__pyx_v_self), __pyx_v_key); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } goto __pyx_L7_cleaned_up; __pyx_L0:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_12_get_raw(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_key) { 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_raw", 0); /* "borghash/HashTableNT.pyx":74 * * def _get_raw(self, key: bytes) -> bytes: * return self.inner[key] # <<<<<<<<<<<<<< * * def __setitem__(self, key: bytes, value: Any) -> None: */ __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_v_self->inner, __pyx_v_key); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 74, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!(likely(PyBytes_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_1))) __PYX_ERR(0, 74, __pyx_L1_error) { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __pyx_r = ((PyObject*)__pyx_t_1); } __Pyx_XDECREF(__pyx_temp); } __pyx_t_1 = 0; goto __pyx_L0; /* "borghash/HashTableNT.pyx":73 * self.inner[key] = value * * def _get_raw(self, key: bytes) -> bytes: # <<<<<<<<<<<<<< * return self.inner[key] * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT._get_raw", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTableNT.pyx":76 * return self.inner[key] * * def __setitem__(self, key: bytes, value: Any) -> None: # <<<<<<<<<<<<<< * self._check_key(key) * self.inner[key] = self._to_binary_value(value) */ /* Python wrapper */ static int __pyx_pw_8borghash_11HashTableNT_11HashTableNT_15__setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_8borghash_11HashTableNT_11HashTableNT_15__setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_key), (&PyBytes_Type), 0, "key", 2))) __PYX_ERR(0, 76, __pyx_L1_error) __pyx_r = __pyx_pf_8borghash_11HashTableNT_11HashTableNT_14__setitem__(((struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)__pyx_v_self), ((PyObject*)__pyx_v_key), ((PyObject *)__pyx_v_value)); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = -1; goto __pyx_L5_cleaned_up; __pyx_L0:; __pyx_L5_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_8borghash_11HashTableNT_11HashTableNT_14__setitem__(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; size_t __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setitem__", 0); /* "borghash/HashTableNT.pyx":77 * * def __setitem__(self, key: bytes, value: Any) -> None: * self._check_key(key) # <<<<<<<<<<<<<< * self.inner[key] = self._to_binary_value(value) * */ __pyx_t_2 = ((PyObject *)__pyx_v_self); __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_key}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_check_key, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "borghash/HashTableNT.pyx":78 * def __setitem__(self, key: bytes, value: Any) -> None: * self._check_key(key) * self.inner[key] = self._to_binary_value(value) # <<<<<<<<<<<<<< * * def __getitem__(self, key: bytes) -> Any: */ __pyx_t_2 = ((PyObject *)__pyx_v_self); __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_value}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_to_binary_value, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 78, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } if (unlikely((PyObject_SetItem(__pyx_v_self->inner, __pyx_v_key, __pyx_t_1) < 0))) __PYX_ERR(0, 78, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "borghash/HashTableNT.pyx":76 * return self.inner[key] * * def __setitem__(self, key: bytes, value: Any) -> None: # <<<<<<<<<<<<<< * self._check_key(key) * self.inner[key] = self._to_binary_value(value) */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTableNT.pyx":80 * self.inner[key] = self._to_binary_value(value) * * def __getitem__(self, key: bytes) -> Any: # <<<<<<<<<<<<<< * self._check_key(key) * binary_value = self.inner[key] */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_17__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/ static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_17__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_key), (&PyBytes_Type), 0, "key", 2))) __PYX_ERR(0, 80, __pyx_L1_error) __pyx_r = __pyx_pf_8borghash_11HashTableNT_11HashTableNT_16__getitem__(((struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)__pyx_v_self), ((PyObject*)__pyx_v_key)); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; goto __pyx_L5_cleaned_up; __pyx_L0:; __pyx_L5_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_16__getitem__(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_key) { PyObject *__pyx_v_binary_value = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; size_t __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__getitem__", 0); /* "borghash/HashTableNT.pyx":81 * * def __getitem__(self, key: bytes) -> Any: * self._check_key(key) # <<<<<<<<<<<<<< * binary_value = self.inner[key] * return self._to_namedtuple_value(binary_value) */ __pyx_t_2 = ((PyObject *)__pyx_v_self); __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_key}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_check_key, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 81, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "borghash/HashTableNT.pyx":82 * def __getitem__(self, key: bytes) -> Any: * self._check_key(key) * binary_value = self.inner[key] # <<<<<<<<<<<<<< * return self._to_namedtuple_value(binary_value) * */ __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_v_self->inner, __pyx_v_key); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 82, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_binary_value = __pyx_t_1; __pyx_t_1 = 0; /* "borghash/HashTableNT.pyx":83 * self._check_key(key) * binary_value = self.inner[key] * return self._to_namedtuple_value(binary_value) # <<<<<<<<<<<<<< * * def __delitem__(self, key: bytes) -> None: */ __pyx_t_2 = ((PyObject *)__pyx_v_self); __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_binary_value}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_to_namedtuple_value, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 83, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __pyx_r = __pyx_t_1; } __Pyx_XDECREF(__pyx_temp); } __pyx_t_1 = 0; goto __pyx_L0; /* "borghash/HashTableNT.pyx":80 * self.inner[key] = self._to_binary_value(value) * * def __getitem__(self, key: bytes) -> Any: # <<<<<<<<<<<<<< * self._check_key(key) * binary_value = self.inner[key] */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_binary_value); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTableNT.pyx":85 * return self._to_namedtuple_value(binary_value) * * def __delitem__(self, key: bytes) -> None: # <<<<<<<<<<<<<< * self._check_key(key) * del self.inner[key] */ /* Python wrapper */ static int __pyx_pw_8borghash_11HashTableNT_11HashTableNT_19__delitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/ static int __pyx_pw_8borghash_11HashTableNT_11HashTableNT_19__delitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__delitem__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_key), (&PyBytes_Type), 0, "key", 2))) __PYX_ERR(0, 85, __pyx_L1_error) __pyx_r = __pyx_pf_8borghash_11HashTableNT_11HashTableNT_18__delitem__(((struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)__pyx_v_self), ((PyObject*)__pyx_v_key)); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = -1; goto __pyx_L5_cleaned_up; __pyx_L0:; __pyx_L5_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_8borghash_11HashTableNT_11HashTableNT_18__delitem__(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_key) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; size_t __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__delitem__", 0); /* "borghash/HashTableNT.pyx":86 * * def __delitem__(self, key: bytes) -> None: * self._check_key(key) # <<<<<<<<<<<<<< * del self.inner[key] * */ __pyx_t_2 = ((PyObject *)__pyx_v_self); __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_key}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_check_key, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 86, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "borghash/HashTableNT.pyx":87 * def __delitem__(self, key: bytes) -> None: * self._check_key(key) * del self.inner[key] # <<<<<<<<<<<<<< * * def __contains__(self, key: bytes) -> bool: */ if (unlikely((PyObject_DelItem(__pyx_v_self->inner, __pyx_v_key) < 0))) __PYX_ERR(0, 87, __pyx_L1_error) /* "borghash/HashTableNT.pyx":85 * return self._to_namedtuple_value(binary_value) * * def __delitem__(self, key: bytes) -> None: # <<<<<<<<<<<<<< * self._check_key(key) * del self.inner[key] */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.__delitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTableNT.pyx":89 * del self.inner[key] * * def __contains__(self, key: bytes) -> bool: # <<<<<<<<<<<<<< * self._check_key(key) * return key in self.inner */ /* Python wrapper */ static int __pyx_pw_8borghash_11HashTableNT_11HashTableNT_21__contains__(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/ static int __pyx_pw_8borghash_11HashTableNT_11HashTableNT_21__contains__(PyObject *__pyx_v_self, PyObject *__pyx_v_key) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__contains__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_key), (&PyBytes_Type), 0, "key", 2))) __PYX_ERR(0, 89, __pyx_L1_error) __pyx_r = __pyx_pf_8borghash_11HashTableNT_11HashTableNT_20__contains__(((struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)__pyx_v_self), ((PyObject*)__pyx_v_key)); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = -1; goto __pyx_L5_cleaned_up; __pyx_L0:; __pyx_L5_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_8borghash_11HashTableNT_11HashTableNT_20__contains__(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_key) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; size_t __pyx_t_3; int __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__contains__", 0); /* "borghash/HashTableNT.pyx":90 * * def __contains__(self, key: bytes) -> bool: * self._check_key(key) # <<<<<<<<<<<<<< * return key in self.inner * */ __pyx_t_2 = ((PyObject *)__pyx_v_self); __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_key}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_check_key, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 90, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "borghash/HashTableNT.pyx":91 * def __contains__(self, key: bytes) -> bool: * self._check_key(key) * return key in self.inner # <<<<<<<<<<<<<< * * def items(self, *, prefix_bits: int = 0, prefix: int = 0) -> Iterator[tuple[bytes, Any]]: */ __pyx_t_4 = (__Pyx_PySequence_ContainsTF(__pyx_v_key, __pyx_v_self->inner, Py_EQ)); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 91, __pyx_L1_error) { __pyx_r = __pyx_t_4; } goto __pyx_L0; /* "borghash/HashTableNT.pyx":89 * del self.inner[key] * * def __contains__(self, key: bytes) -> bool: # <<<<<<<<<<<<<< * self._check_key(key) * return key in self.inner */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.__contains__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_8borghash_11HashTableNT_11HashTableNT_24generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "borghash/HashTableNT.pyx":93 * return key in self.inner * * def items(self, *, prefix_bits: int = 0, prefix: int = 0) -> Iterator[tuple[bytes, Any]]: # <<<<<<<<<<<<<< * """ * Iterate over items, optionally only over items whose key starts with the given bit prefix. */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_23items(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_8borghash_11HashTableNT_11HashTableNT_22items, "\n Iterate over items, optionally only over items whose key starts with the given bit prefix.\n\n See HashTable.items for the prefix_bits / prefix semantics.\n "); static PyMethodDef __pyx_mdef_8borghash_11HashTableNT_11HashTableNT_23items = {"items", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_23items, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8borghash_11HashTableNT_11HashTableNT_22items}; static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_23items(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_prefix_bits = 0; PyObject *__pyx_v_prefix = 0; #if !CYTHON_VECTORCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("items (wrapper)", 0); #if !CYTHON_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_prefix_bits,&__pyx_mstate_global->__pyx_n_u_prefix,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 93, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 0: break; default: goto __pyx_L5_argtuple_error; } if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, 0, __pyx_kwds_len, "items", 0) < (0)) __PYX_ERR(0, 93, __pyx_L3_error) if (!values[0]) values[0] = __Pyx_NewRef(((PyObject*)__pyx_mstate_global->__pyx_int_0)); if (!values[1]) values[1] = __Pyx_NewRef(((PyObject*)__pyx_mstate_global->__pyx_int_0)); } else if (unlikely(__pyx_nargs != 0)) { goto __pyx_L5_argtuple_error; } else { if (!values[0]) values[0] = __Pyx_NewRef(((PyObject*)__pyx_mstate_global->__pyx_int_0)); if (!values[1]) values[1] = __Pyx_NewRef(((PyObject*)__pyx_mstate_global->__pyx_int_0)); } if (__Pyx_PyInt_FromNumber(&values[0], "prefix_bits", 0) < (0)) __PYX_ERR(0, 93, __pyx_L3_error) __pyx_v_prefix_bits = ((PyObject*)values[0]); if (__Pyx_PyInt_FromNumber(&values[1], "prefix", 0) < (0)) __PYX_ERR(0, 93, __pyx_L3_error) __pyx_v_prefix = ((PyObject*)values[1]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("items", 1, 0, 0, __pyx_nargs); __PYX_ERR(0, 93, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.items", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_prefix_bits), (&PyLong_Type), 0, "prefix_bits", 2))) __PYX_ERR(0, 93, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_prefix), (&PyLong_Type), 0, "prefix", 2))) __PYX_ERR(0, 93, __pyx_L1_error) __pyx_r = __pyx_pf_8borghash_11HashTableNT_11HashTableNT_22items(((struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)__pyx_v_self), __pyx_v_prefix_bits, __pyx_v_prefix); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } goto __pyx_L7_cleaned_up; __pyx_L0:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_22items(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_prefix_bits, PyObject *__pyx_v_prefix) { struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct_1_items *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("items", 0); __pyx_cur_scope = (struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct_1_items *)__pyx_tp_new_8borghash_11HashTableNT___pyx_scope_struct_1_items(__pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT___pyx_scope_struct_1_items, __pyx_mstate_global->__pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct_1_items *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(0, 93, __pyx_L1_error) } else { __Pyx_GOTREF((PyObject *)__pyx_cur_scope); } __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_cur_scope->__pyx_v_prefix_bits = __pyx_v_prefix_bits; __Pyx_INCREF(__pyx_cur_scope->__pyx_v_prefix_bits); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_prefix_bits); __pyx_cur_scope->__pyx_v_prefix = __pyx_v_prefix; __Pyx_INCREF(__pyx_cur_scope->__pyx_v_prefix); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_prefix); { __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_8borghash_11HashTableNT_11HashTableNT_24generator, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[1]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_items, __pyx_mstate_global->__pyx_n_u_HashTableNT_items, __pyx_mstate_global->__pyx_n_u_borghash_HashTableNT); if (unlikely(!gen)) __PYX_ERR(0, 93, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.items", __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_8borghash_11HashTableNT_11HashTableNT_24generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct_1_items *__pyx_cur_scope = ((struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct_1_items *)__pyx_generator->closure); PyObject *__pyx_r = NULL; PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; size_t __pyx_t_3; PyObject *__pyx_t_4 = NULL; Py_ssize_t __pyx_t_5; PyObject *(*__pyx_t_6)(PyObject *); PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *(*__pyx_t_9)(PyObject *); int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("items", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L8_resume_from_yield; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(__pyx_sent_value != Py_None)) { if (unlikely(__pyx_sent_value)) PyErr_SetString(PyExc_TypeError, "can't send non-None value to a just-started generator"); __PYX_ERR(0, 93, __pyx_L1_error) } /* "borghash/HashTableNT.pyx":99 * See HashTable.items for the prefix_bits / prefix semantics. * """ * for key, binary_value in self.inner.items(prefix_bits=prefix_bits, prefix=prefix): # <<<<<<<<<<<<<< * yield (key, self._to_namedtuple_value(binary_value)) * */ __pyx_t_2 = __pyx_cur_scope->__pyx_v_self->inner; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; { PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_cur_scope->__pyx_v_prefix_bits, __pyx_cur_scope->__pyx_v_prefix}; #if CYTHON_VECTORCALL __pyx_t_4 = __pyx_mstate_global->__pyx_tuple[1]; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 99, __pyx_L1_error) __Pyx_INCREF(__pyx_t_4); #else { PyObject *__pyx_temp[2] = {__pyx_mstate_global->__pyx_n_u_prefix_bits, __pyx_mstate_global->__pyx_n_u_prefix}; __pyx_t_4 = __Pyx_MakeKwargDict(__pyx_temp, __pyx_callargs+1, 2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 99, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); } #endif __pyx_t_1 = __Pyx_Object_VectorcallMethodKwds((PyObject*)__pyx_mstate_global->__pyx_n_u_items, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 99, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { __pyx_t_4 = __pyx_t_1; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = 0; __pyx_t_6 = NULL; } else { __pyx_t_5 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 99, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 99, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; for (;;) { if (likely(!__pyx_t_6)) { if (likely(PyList_CheckExact(__pyx_t_4))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 99, __pyx_L1_error) #endif if (__pyx_t_5 >= __pyx_temp) break; } __pyx_t_1 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_4, __pyx_t_5, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_5; } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_4); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 99, __pyx_L1_error) #endif if (__pyx_t_5 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_5)); #else __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_5); #endif ++__pyx_t_5; } if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 99, __pyx_L1_error) } else { __pyx_t_1 = __pyx_t_6(__pyx_t_4); if (unlikely(!__pyx_t_1)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 99, __pyx_L1_error) PyErr_Clear(); } break; } } __Pyx_GOTREF(__pyx_t_1); if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) { PyObject* sequence = __pyx_t_1; 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, 99, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); __Pyx_INCREF(__pyx_t_2); __pyx_t_7 = PyTuple_GET_ITEM(sequence, 1); __Pyx_INCREF(__pyx_t_7); } else { __pyx_t_2 = __Pyx_PyList_GET_ITEM_REF(sequence, 0, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 99, __pyx_L1_error) __Pyx_XGOTREF(__pyx_t_2); __pyx_t_7 = __Pyx_PyList_GET_ITEM_REF(sequence, 1, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 99, __pyx_L1_error) __Pyx_XGOTREF(__pyx_t_7); } #else __pyx_t_2 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 99, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_7 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 99, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else { Py_ssize_t index = -1; __pyx_t_8 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 99, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_9 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_8); index = 0; __pyx_t_2 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_2)) goto __pyx_L6_unpacking_failed; __Pyx_GOTREF(__pyx_t_2); index = 1; __pyx_t_7 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_7)) goto __pyx_L6_unpacking_failed; __Pyx_GOTREF(__pyx_t_7); if (__Pyx_IternextUnpackEndCheck(__pyx_t_9(__pyx_t_8), 2) < (0)) __PYX_ERR(0, 99, __pyx_L1_error) __pyx_t_9 = NULL; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L7_unpacking_done; __pyx_L6_unpacking_failed:; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_9 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); __PYX_ERR(0, 99, __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_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_binary_value); __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_binary_value, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; /* "borghash/HashTableNT.pyx":100 * """ * for key, binary_value in self.inner.items(prefix_bits=prefix_bits, prefix=prefix): * yield (key, self._to_namedtuple_value(binary_value)) # <<<<<<<<<<<<<< * * def __len__(self) -> int: */ __pyx_t_7 = ((PyObject *)__pyx_cur_scope->__pyx_v_self); __Pyx_INCREF(__pyx_t_7); __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_cur_scope->__pyx_v_binary_value}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_to_namedtuple_value, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 100, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 100, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_key); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_key); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_cur_scope->__pyx_v_key) != (0)) __PYX_ERR(0, 100, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_1) != (0)) __PYX_ERR(0, 100, __pyx_L1_error); __pyx_t_1 = 0; __pyx_r = __pyx_t_7; __pyx_t_7 = 0; __Pyx_XGIVEREF(__pyx_t_4); __pyx_cur_scope->__pyx_t_0 = __pyx_t_4; __pyx_cur_scope->__pyx_t_1 = __pyx_t_5; __pyx_cur_scope->__pyx_t_2 = __pyx_t_6; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, yielding value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L8_resume_from_yield:; __pyx_t_4 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_4); __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, 100, __pyx_L1_error) /* "borghash/HashTableNT.pyx":99 * See HashTable.items for the prefix_bits / prefix semantics. * """ * for key, binary_value in self.inner.items(prefix_bits=prefix_bits, prefix=prefix): # <<<<<<<<<<<<<< * yield (key, self._to_namedtuple_value(binary_value)) * */ } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "borghash/HashTableNT.pyx":93 * return key in self.inner * * def items(self, *, prefix_bits: int = 0, prefix: int = 0) -> Iterator[tuple[bytes, Any]]: # <<<<<<<<<<<<<< * """ * Iterate over items, optionally only over items whose key starts with the given bit prefix. */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); if (__Pyx_PyErr_Occurred()) { __Pyx_Generator_Replace_StopIteration(0); __Pyx_AddTraceback("items", __pyx_clineno, __pyx_lineno, __pyx_filename); } __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTableNT.pyx":102 * yield (key, self._to_namedtuple_value(binary_value)) * * def __len__(self) -> int: # <<<<<<<<<<<<<< * return len(self.inner) * */ /* Python wrapper */ static Py_ssize_t __pyx_pw_8borghash_11HashTableNT_11HashTableNT_26__len__(PyObject *__pyx_v_self); /*proto*/ static Py_ssize_t __pyx_pw_8borghash_11HashTableNT_11HashTableNT_26__len__(PyObject *__pyx_v_self) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; Py_ssize_t __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_8borghash_11HashTableNT_11HashTableNT_25__len__(((struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static Py_ssize_t __pyx_pf_8borghash_11HashTableNT_11HashTableNT_25__len__(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self) { Py_ssize_t __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__len__", 0); /* "borghash/HashTableNT.pyx":103 * * def __len__(self) -> int: * return len(self.inner) # <<<<<<<<<<<<<< * * def get(self, key: bytes, default: Any = None) -> Any: */ __pyx_t_1 = __pyx_v_self->inner; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 103, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; { __pyx_r = __pyx_t_2; } goto __pyx_L0; /* "borghash/HashTableNT.pyx":102 * yield (key, self._to_namedtuple_value(binary_value)) * * def __len__(self) -> int: # <<<<<<<<<<<<<< * return len(self.inner) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.__len__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTableNT.pyx":105 * return len(self.inner) * * def get(self, key: bytes, default: Any = None) -> Any: # <<<<<<<<<<<<<< * self._check_key(key) * try: */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_28get(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_8borghash_11HashTableNT_11HashTableNT_28get = {"get", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_28get, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_28get(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_key = 0; PyObject *__pyx_v_default = 0; #if !CYTHON_VECTORCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[2] = {0,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); #if !CYTHON_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_key,&__pyx_mstate_global->__pyx_n_u_default,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 105, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 105, __pyx_L3_error) CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 105, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get", 0) < (0)) __PYX_ERR(0, 105, __pyx_L3_error) if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_None)); for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get", 0, 1, 2, i); __PYX_ERR(0, 105, __pyx_L3_error) } } } else { switch (__pyx_nargs) { case 2: values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 105, __pyx_L3_error) CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 105, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_None)); } __pyx_v_key = ((PyObject*)values[0]); __pyx_v_default = values[1]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("get", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 105, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.get", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_key), (&PyBytes_Type), 0, "key", 2))) __PYX_ERR(0, 105, __pyx_L1_error) __pyx_r = __pyx_pf_8borghash_11HashTableNT_11HashTableNT_27get(((struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)__pyx_v_self), __pyx_v_key, __pyx_v_default); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } goto __pyx_L7_cleaned_up; __pyx_L0:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_27get(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_default) { PyObject *__pyx_v_binary_value = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; size_t __pyx_t_3; PyObject *__pyx_t_4 = NULL; 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("get", 0); /* "borghash/HashTableNT.pyx":106 * * def get(self, key: bytes, default: Any = None) -> Any: * self._check_key(key) # <<<<<<<<<<<<<< * try: * binary_value = self.inner[key] */ __pyx_t_2 = ((PyObject *)__pyx_v_self); __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_key}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_check_key, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 106, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "borghash/HashTableNT.pyx":107 * def get(self, key: bytes, default: Any = None) -> Any: * self._check_key(key) * try: # <<<<<<<<<<<<<< * binary_value = self.inner[key] * except KeyError: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6); __Pyx_XGOTREF(__pyx_t_4); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_6); /*try:*/ { /* "borghash/HashTableNT.pyx":108 * self._check_key(key) * try: * binary_value = self.inner[key] # <<<<<<<<<<<<<< * except KeyError: * return default */ __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_v_self->inner, __pyx_v_key); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 108, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_binary_value = __pyx_t_1; __pyx_t_1 = 0; /* "borghash/HashTableNT.pyx":107 * def get(self, key: bytes, default: Any = None) -> Any: * self._check_key(key) * try: # <<<<<<<<<<<<<< * binary_value = self.inner[key] * except KeyError: */ } /* "borghash/HashTableNT.pyx":112 * return default * else: * return self._to_namedtuple_value(binary_value) # <<<<<<<<<<<<<< * * def setdefault(self, key: bytes, default: Any) -> Any: */ /*else:*/ { __pyx_t_2 = ((PyObject *)__pyx_v_self); __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_binary_value}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_to_namedtuple_value, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_1); } { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __pyx_r = __pyx_t_1; } __Pyx_XDECREF(__pyx_temp); } __pyx_t_1 = 0; goto __pyx_L6_except_return; } __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTableNT.pyx":109 * try: * binary_value = self.inner[key] * except KeyError: # <<<<<<<<<<<<<< * return default * else: */ __pyx_t_7 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_KeyError)))); if (__pyx_t_7) { __Pyx_ErrRestore(0,0,0); /* "borghash/HashTableNT.pyx":110 * binary_value = self.inner[key] * except KeyError: * return default # <<<<<<<<<<<<<< * else: * return self._to_namedtuple_value(binary_value) */ { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __Pyx_INCREF(__pyx_v_default); __pyx_r = __pyx_v_default; } __Pyx_XDECREF(__pyx_temp); } goto __pyx_L6_except_return; } goto __pyx_L5_except_error; /* "borghash/HashTableNT.pyx":107 * def get(self, key: bytes, default: Any = None) -> Any: * self._check_key(key) * try: # <<<<<<<<<<<<<< * binary_value = self.inner[key] * except KeyError: */ __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_6); __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6); goto __pyx_L1_error; __pyx_L6_except_return:; __Pyx_XGIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_6); __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6); goto __pyx_L0; } /* "borghash/HashTableNT.pyx":105 * return len(self.inner) * * def get(self, key: bytes, default: Any = None) -> Any: # <<<<<<<<<<<<<< * self._check_key(key) * try: */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.get", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_binary_value); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTableNT.pyx":114 * return self._to_namedtuple_value(binary_value) * * def setdefault(self, key: bytes, default: Any) -> Any: # <<<<<<<<<<<<<< * self._check_key(key) * binary_default = self._to_binary_value(default) */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_30setdefault(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_8borghash_11HashTableNT_11HashTableNT_30setdefault = {"setdefault", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_30setdefault, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_30setdefault(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_key = 0; PyObject *__pyx_v_default = 0; #if !CYTHON_VECTORCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("setdefault (wrapper)", 0); #if !CYTHON_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_key,&__pyx_mstate_global->__pyx_n_u_default,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 114, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 114, __pyx_L3_error) CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 114, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "setdefault", 0) < (0)) __PYX_ERR(0, 114, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("setdefault", 1, 2, 2, i); __PYX_ERR(0, 114, __pyx_L3_error) } } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 114, __pyx_L3_error) values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 114, __pyx_L3_error) } __pyx_v_key = ((PyObject*)values[0]); __pyx_v_default = values[1]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("setdefault", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 114, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.setdefault", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_key), (&PyBytes_Type), 0, "key", 2))) __PYX_ERR(0, 114, __pyx_L1_error) __pyx_r = __pyx_pf_8borghash_11HashTableNT_11HashTableNT_29setdefault(((struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)__pyx_v_self), __pyx_v_key, __pyx_v_default); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } goto __pyx_L7_cleaned_up; __pyx_L0:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_29setdefault(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_default) { PyObject *__pyx_v_binary_default = NULL; PyObject *__pyx_v_binary_value = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; size_t __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("setdefault", 0); /* "borghash/HashTableNT.pyx":115 * * def setdefault(self, key: bytes, default: Any) -> Any: * self._check_key(key) # <<<<<<<<<<<<<< * binary_default = self._to_binary_value(default) * binary_value = self.inner.setdefault(key, binary_default) */ __pyx_t_2 = ((PyObject *)__pyx_v_self); __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_key}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_check_key, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 115, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "borghash/HashTableNT.pyx":116 * def setdefault(self, key: bytes, default: Any) -> Any: * self._check_key(key) * binary_default = self._to_binary_value(default) # <<<<<<<<<<<<<< * binary_value = self.inner.setdefault(key, binary_default) * return self._to_namedtuple_value(binary_value) */ __pyx_t_2 = ((PyObject *)__pyx_v_self); __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_default}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_to_binary_value, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 116, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } __pyx_v_binary_default = __pyx_t_1; __pyx_t_1 = 0; /* "borghash/HashTableNT.pyx":117 * self._check_key(key) * binary_default = self._to_binary_value(default) * binary_value = self.inner.setdefault(key, binary_default) # <<<<<<<<<<<<<< * return self._to_namedtuple_value(binary_value) * */ __pyx_t_2 = __pyx_v_self->inner; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; { PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_v_key, __pyx_v_binary_default}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_setdefault, __pyx_callargs+__pyx_t_3, (3-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 117, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } __pyx_v_binary_value = __pyx_t_1; __pyx_t_1 = 0; /* "borghash/HashTableNT.pyx":118 * binary_default = self._to_binary_value(default) * binary_value = self.inner.setdefault(key, binary_default) * return self._to_namedtuple_value(binary_value) # <<<<<<<<<<<<<< * * def pop(self, key: bytes, default: Any = _NoDefault) -> Any: */ __pyx_t_2 = ((PyObject *)__pyx_v_self); __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_binary_value}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_to_namedtuple_value, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 118, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __pyx_r = __pyx_t_1; } __Pyx_XDECREF(__pyx_temp); } __pyx_t_1 = 0; goto __pyx_L0; /* "borghash/HashTableNT.pyx":114 * return self._to_namedtuple_value(binary_value) * * def setdefault(self, key: bytes, default: Any) -> Any: # <<<<<<<<<<<<<< * self._check_key(key) * binary_default = self._to_binary_value(default) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.setdefault", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_binary_default); __Pyx_XDECREF(__pyx_v_binary_value); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTableNT.pyx":120 * return self._to_namedtuple_value(binary_value) * * def pop(self, key: bytes, default: Any = _NoDefault) -> Any: # <<<<<<<<<<<<<< * self._check_key(key) * try: */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_32pop(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_8borghash_11HashTableNT_11HashTableNT_32pop = {"pop", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_32pop, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_32pop(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_key = 0; PyObject *__pyx_v_default = 0; #if !CYTHON_VECTORCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("pop (wrapper)", 0); #if !CYTHON_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_key,&__pyx_mstate_global->__pyx_n_u_default,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 120, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 120, __pyx_L3_error) CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 120, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "pop", 0) < (0)) __PYX_ERR(0, 120, __pyx_L3_error) if (!values[1]) values[1] = __Pyx_NewRef(__pyx_mstate_global->__pyx_k__5); for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("pop", 0, 1, 2, i); __PYX_ERR(0, 120, __pyx_L3_error) } } } else { switch (__pyx_nargs) { case 2: values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 120, __pyx_L3_error) CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 120, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } if (!values[1]) values[1] = __Pyx_NewRef(__pyx_mstate_global->__pyx_k__5); } __pyx_v_key = ((PyObject*)values[0]); __pyx_v_default = values[1]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("pop", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 120, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.pop", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_key), (&PyBytes_Type), 0, "key", 2))) __PYX_ERR(0, 120, __pyx_L1_error) __pyx_r = __pyx_pf_8borghash_11HashTableNT_11HashTableNT_31pop(((struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)__pyx_v_self), __pyx_v_key, __pyx_v_default); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } goto __pyx_L7_cleaned_up; __pyx_L0:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_31pop(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_default) { PyObject *__pyx_v_binary_value = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; size_t __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_t_7; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; int __pyx_t_10; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("pop", 0); /* "borghash/HashTableNT.pyx":121 * * def pop(self, key: bytes, default: Any = _NoDefault) -> Any: * self._check_key(key) # <<<<<<<<<<<<<< * try: * binary_value = self.inner.pop(key) */ __pyx_t_2 = ((PyObject *)__pyx_v_self); __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_key}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_check_key, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 121, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "borghash/HashTableNT.pyx":122 * def pop(self, key: bytes, default: Any = _NoDefault) -> Any: * self._check_key(key) * try: # <<<<<<<<<<<<<< * binary_value = self.inner.pop(key) * except KeyError: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6); __Pyx_XGOTREF(__pyx_t_4); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_6); /*try:*/ { /* "borghash/HashTableNT.pyx":123 * self._check_key(key) * try: * binary_value = self.inner.pop(key) # <<<<<<<<<<<<<< * except KeyError: * if default is _NoDefault: */ __pyx_t_2 = __pyx_v_self->inner; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_key}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_pop, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 123, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_1); } __pyx_v_binary_value = __pyx_t_1; __pyx_t_1 = 0; /* "borghash/HashTableNT.pyx":122 * def pop(self, key: bytes, default: Any = _NoDefault) -> Any: * self._check_key(key) * try: # <<<<<<<<<<<<<< * binary_value = self.inner.pop(key) * except KeyError: */ } /* "borghash/HashTableNT.pyx":129 * return default * else: * return self._to_namedtuple_value(binary_value) # <<<<<<<<<<<<<< * * def update(self, other=(), /, **kwds): */ /*else:*/ { __pyx_t_2 = ((PyObject *)__pyx_v_self); __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_binary_value}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_to_namedtuple_value, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 129, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_1); } { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __pyx_r = __pyx_t_1; } __Pyx_XDECREF(__pyx_temp); } __pyx_t_1 = 0; goto __pyx_L6_except_return; } __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTableNT.pyx":124 * try: * binary_value = self.inner.pop(key) * except KeyError: # <<<<<<<<<<<<<< * if default is _NoDefault: * raise */ __pyx_t_7 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_KeyError)))); if (__pyx_t_7) { __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.pop", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_2, &__pyx_t_8) < 0) __PYX_ERR(0, 124, __pyx_L5_except_error) __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_8); /* "borghash/HashTableNT.pyx":125 * binary_value = self.inner.pop(key) * except KeyError: * if default is _NoDefault: # <<<<<<<<<<<<<< * raise * return default */ __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_NoDefault); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 125, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_10 = (__pyx_v_default == __pyx_t_9); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if (unlikely(__pyx_t_10)) { /* "borghash/HashTableNT.pyx":126 * except KeyError: * if default is _NoDefault: * raise # <<<<<<<<<<<<<< * return default * else: */ __Pyx_GIVEREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_8); __Pyx_ErrRestoreWithState(__pyx_t_1, __pyx_t_2, __pyx_t_8); __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_8 = 0; __PYX_ERR(0, 126, __pyx_L5_except_error) /* "borghash/HashTableNT.pyx":125 * binary_value = self.inner.pop(key) * except KeyError: * if default is _NoDefault: # <<<<<<<<<<<<<< * raise * return default */ } /* "borghash/HashTableNT.pyx":127 * if default is _NoDefault: * raise * return default # <<<<<<<<<<<<<< * else: * return self._to_namedtuple_value(binary_value) */ { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __Pyx_INCREF(__pyx_v_default); __pyx_r = __pyx_v_default; } __Pyx_XDECREF(__pyx_temp); } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L6_except_return; } goto __pyx_L5_except_error; /* "borghash/HashTableNT.pyx":122 * def pop(self, key: bytes, default: Any = _NoDefault) -> Any: * self._check_key(key) * try: # <<<<<<<<<<<<<< * binary_value = self.inner.pop(key) * except KeyError: */ __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_6); __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6); goto __pyx_L1_error; __pyx_L6_except_return:; __Pyx_XGIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_6); __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6); goto __pyx_L0; } /* "borghash/HashTableNT.pyx":120 * return self._to_namedtuple_value(binary_value) * * def pop(self, key: bytes, default: Any = _NoDefault) -> Any: # <<<<<<<<<<<<<< * self._check_key(key) * try: */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.pop", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_binary_value); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTableNT.pyx":131 * return self._to_namedtuple_value(binary_value) * * def update(self, other=(), /, **kwds): # <<<<<<<<<<<<<< * """Like dict.update(), but 'other' can also be a HashTableNT instance.""" * if isinstance(other, HashTableNT): */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_34update(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_8borghash_11HashTableNT_11HashTableNT_33update, "Like dict.update(), but \047other\047 can also be a HashTableNT instance."); static PyMethodDef __pyx_mdef_8borghash_11HashTableNT_11HashTableNT_34update = {"update", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_34update, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8borghash_11HashTableNT_11HashTableNT_33update}; static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_34update(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_other = 0; PyObject *__pyx_v_kwds = 0; #if !CYTHON_VECTORCALL 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("update (wrapper)", 0); #if !CYTHON_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); __pyx_v_kwds = PyDict_New(); if (unlikely(!__pyx_v_kwds)) return NULL; __Pyx_GOTREF(__pyx_v_kwds); { PyObject ** const __pyx_pyargnames[] = {0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 131, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 131, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = (unlikely(__pyx_nargs < 1)) ? 0 : __pyx_nargs - 1; if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwds, values, kwd_pos_args, __pyx_kwds_len, "update", 1) < (0)) __PYX_ERR(0, 131, __pyx_L3_error) if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_empty_tuple)); } else { switch (__pyx_nargs) { case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 131, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_empty_tuple)); } __pyx_v_other = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("update", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 131, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_DECREF(__pyx_v_kwds); __pyx_v_kwds = 0; __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.update", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8borghash_11HashTableNT_11HashTableNT_33update(((struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)__pyx_v_self), __pyx_v_other, __pyx_v_kwds); /* function exit code */ for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_DECREF(__pyx_v_kwds); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_33update(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_other, PyObject *__pyx_v_kwds) { PyObject *__pyx_v_key = NULL; PyObject *__pyx_v_value = NULL; PyObject *__pyx_r = NULL; __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; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; PyObject *(*__pyx_t_9)(PyObject *); PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *(*__pyx_t_12)(PyObject *); int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("update", 0); /* "borghash/HashTableNT.pyx":133 * def update(self, other=(), /, **kwds): * """Like dict.update(), but 'other' can also be a HashTableNT instance.""" * if isinstance(other, HashTableNT): # <<<<<<<<<<<<<< * for key, value in other.items(): * self[key] = value */ __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_other, __pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT_HashTableNT); if (__pyx_t_1) { /* "borghash/HashTableNT.pyx":134 * """Like dict.update(), but 'other' can also be a HashTableNT instance.""" * if isinstance(other, HashTableNT): * for key, value in other.items(): # <<<<<<<<<<<<<< * self[key] = value * elif isinstance(other, Mapping): */ __pyx_t_3 = 0; if (unlikely(__pyx_v_other == Py_None)) { PyErr_Format(PyExc_AttributeError, "\047NoneType\047 object has no attribute \047%.30s\047", "items"); __PYX_ERR(0, 134, __pyx_L1_error) } __pyx_t_6 = __Pyx_dict_iterator(__pyx_v_other, 0, __pyx_mstate_global->__pyx_n_u_items, (&__pyx_t_4), (&__pyx_t_5)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 134, __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_8 = __Pyx_dict_iter_next(__pyx_t_2, __pyx_t_4, &__pyx_t_3, &__pyx_t_6, &__pyx_t_7, NULL, __pyx_t_5); if (unlikely(__pyx_t_8 == 0)) break; if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 134, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_7); __pyx_t_7 = 0; /* "borghash/HashTableNT.pyx":135 * if isinstance(other, HashTableNT): * for key, value in other.items(): * self[key] = value # <<<<<<<<<<<<<< * elif isinstance(other, Mapping): * for key in other: */ if (unlikely((PyObject_SetItem(((PyObject *)__pyx_v_self), __pyx_v_key, __pyx_v_value) < 0))) __PYX_ERR(0, 135, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTableNT.pyx":133 * def update(self, other=(), /, **kwds): * """Like dict.update(), but 'other' can also be a HashTableNT instance.""" * if isinstance(other, HashTableNT): # <<<<<<<<<<<<<< * for key, value in other.items(): * self[key] = value */ goto __pyx_L3; } /* "borghash/HashTableNT.pyx":136 * for key, value in other.items(): * self[key] = value * elif isinstance(other, Mapping): # <<<<<<<<<<<<<< * for key in other: * self[key] = other[key] */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_Mapping); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = PyObject_IsInstance(__pyx_v_other, __pyx_t_2); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 136, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__pyx_t_1) { /* "borghash/HashTableNT.pyx":137 * self[key] = value * elif isinstance(other, Mapping): * for key in other: # <<<<<<<<<<<<<< * self[key] = other[key] * elif hasattr(other, "keys"): */ if (likely(PyList_CheckExact(__pyx_v_other)) || PyTuple_CheckExact(__pyx_v_other)) { __pyx_t_2 = __pyx_v_other; __Pyx_INCREF(__pyx_t_2); __pyx_t_4 = 0; __pyx_t_9 = NULL; } else { __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_other); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 137, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_9 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 137, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_9)) { if (likely(PyList_CheckExact(__pyx_t_2))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 137, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } __pyx_t_7 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_2, __pyx_t_4, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_4; } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 137, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_7 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4)); #else __pyx_t_7 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_4); #endif ++__pyx_t_4; } if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 137, __pyx_L1_error) } else { __pyx_t_7 = __pyx_t_9(__pyx_t_2); if (unlikely(!__pyx_t_7)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 137, __pyx_L1_error) PyErr_Clear(); } break; } } __Pyx_GOTREF(__pyx_t_7); __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_7); __pyx_t_7 = 0; /* "borghash/HashTableNT.pyx":138 * elif isinstance(other, Mapping): * for key in other: * self[key] = other[key] # <<<<<<<<<<<<<< * elif hasattr(other, "keys"): * for key in other.keys(): */ __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_v_other, __pyx_v_key); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 138, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (unlikely((PyObject_SetItem(((PyObject *)__pyx_v_self), __pyx_v_key, __pyx_t_7) < 0))) __PYX_ERR(0, 138, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "borghash/HashTableNT.pyx":137 * self[key] = value * elif isinstance(other, Mapping): * for key in other: # <<<<<<<<<<<<<< * self[key] = other[key] * elif hasattr(other, "keys"): */ } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTableNT.pyx":136 * for key, value in other.items(): * self[key] = value * elif isinstance(other, Mapping): # <<<<<<<<<<<<<< * for key in other: * self[key] = other[key] */ goto __pyx_L3; } /* "borghash/HashTableNT.pyx":139 * for key in other: * self[key] = other[key] * elif hasattr(other, "keys"): # <<<<<<<<<<<<<< * for key in other.keys(): * self[key] = other[key] */ __pyx_t_1 = __Pyx_HasAttr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_keys); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 139, __pyx_L1_error) if (__pyx_t_1) { /* "borghash/HashTableNT.pyx":140 * self[key] = other[key] * elif hasattr(other, "keys"): * for key in other.keys(): # <<<<<<<<<<<<<< * self[key] = other[key] * else: */ __pyx_t_4 = 0; if (unlikely(__pyx_v_other == Py_None)) { PyErr_Format(PyExc_AttributeError, "\047NoneType\047 object has no attribute \047%.30s\047", "keys"); __PYX_ERR(0, 140, __pyx_L1_error) } __pyx_t_7 = __Pyx_dict_iterator(__pyx_v_other, 0, __pyx_mstate_global->__pyx_n_u_keys, (&__pyx_t_3), (&__pyx_t_5)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 140, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = __pyx_t_7; __pyx_t_7 = 0; while (1) { __pyx_t_8 = __Pyx_dict_iter_next(__pyx_t_2, __pyx_t_3, &__pyx_t_4, &__pyx_t_7, NULL, NULL, __pyx_t_5); if (unlikely(__pyx_t_8 == 0)) break; if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 140, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_7); __pyx_t_7 = 0; /* "borghash/HashTableNT.pyx":141 * elif hasattr(other, "keys"): * for key in other.keys(): * self[key] = other[key] # <<<<<<<<<<<<<< * else: * for key, value in other: */ __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_v_other, __pyx_v_key); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 141, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (unlikely((PyObject_SetItem(((PyObject *)__pyx_v_self), __pyx_v_key, __pyx_t_7) < 0))) __PYX_ERR(0, 141, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTableNT.pyx":139 * for key in other: * self[key] = other[key] * elif hasattr(other, "keys"): # <<<<<<<<<<<<<< * for key in other.keys(): * self[key] = other[key] */ goto __pyx_L3; } /* "borghash/HashTableNT.pyx":143 * self[key] = other[key] * else: * for key, value in other: # <<<<<<<<<<<<<< * self[key] = value * for key, value in kwds.items(): */ /*else*/ { if (likely(PyList_CheckExact(__pyx_v_other)) || PyTuple_CheckExact(__pyx_v_other)) { __pyx_t_2 = __pyx_v_other; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; __pyx_t_9 = NULL; } else { __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_other); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 143, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_9 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 143, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_9)) { if (likely(PyList_CheckExact(__pyx_t_2))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 143, __pyx_L1_error) #endif if (__pyx_t_3 >= __pyx_temp) break; } __pyx_t_7 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_2, __pyx_t_3, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_3; } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 143, __pyx_L1_error) #endif if (__pyx_t_3 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_7 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3)); #else __pyx_t_7 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_3); #endif ++__pyx_t_3; } if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 143, __pyx_L1_error) } else { __pyx_t_7 = __pyx_t_9(__pyx_t_2); if (unlikely(!__pyx_t_7)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 143, __pyx_L1_error) PyErr_Clear(); } break; } } __Pyx_GOTREF(__pyx_t_7); if ((likely(PyTuple_CheckExact(__pyx_t_7))) || (PyList_CheckExact(__pyx_t_7))) { PyObject* sequence = __pyx_t_7; 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, 143, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0); __Pyx_INCREF(__pyx_t_6); __pyx_t_10 = PyTuple_GET_ITEM(sequence, 1); __Pyx_INCREF(__pyx_t_10); } else { __pyx_t_6 = __Pyx_PyList_GET_ITEM_REF(sequence, 0, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 143, __pyx_L1_error) __Pyx_XGOTREF(__pyx_t_6); __pyx_t_10 = __Pyx_PyList_GET_ITEM_REF(sequence, 1, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 143, __pyx_L1_error) __Pyx_XGOTREF(__pyx_t_10); } #else __pyx_t_6 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 143, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_10 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 143, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); #endif __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else { Py_ssize_t index = -1; __pyx_t_11 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 143, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_12 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_11); index = 0; __pyx_t_6 = __pyx_t_12(__pyx_t_11); if (unlikely(!__pyx_t_6)) goto __pyx_L13_unpacking_failed; __Pyx_GOTREF(__pyx_t_6); index = 1; __pyx_t_10 = __pyx_t_12(__pyx_t_11); if (unlikely(!__pyx_t_10)) goto __pyx_L13_unpacking_failed; __Pyx_GOTREF(__pyx_t_10); if (__Pyx_IternextUnpackEndCheck(__pyx_t_12(__pyx_t_11), 2) < (0)) __PYX_ERR(0, 143, __pyx_L1_error) __pyx_t_12 = NULL; __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L14_unpacking_done; __pyx_L13_unpacking_failed:; __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __pyx_t_12 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); __PYX_ERR(0, 143, __pyx_L1_error) __pyx_L14_unpacking_done:; } __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_10); __pyx_t_10 = 0; /* "borghash/HashTableNT.pyx":144 * else: * for key, value in other: * self[key] = value # <<<<<<<<<<<<<< * for key, value in kwds.items(): * self[key] = value */ if (unlikely((PyObject_SetItem(((PyObject *)__pyx_v_self), __pyx_v_key, __pyx_v_value) < 0))) __PYX_ERR(0, 144, __pyx_L1_error) /* "borghash/HashTableNT.pyx":143 * self[key] = other[key] * else: * for key, value in other: # <<<<<<<<<<<<<< * self[key] = value * for key, value in kwds.items(): */ } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_L3:; /* "borghash/HashTableNT.pyx":145 * for key, value in other: * self[key] = value * for key, value in kwds.items(): # <<<<<<<<<<<<<< * self[key] = value * */ __pyx_t_3 = 0; __pyx_t_7 = __Pyx_dict_iterator(__pyx_v_kwds, 1, __pyx_mstate_global->__pyx_n_u_items, (&__pyx_t_4), (&__pyx_t_5)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 145, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = __pyx_t_7; __pyx_t_7 = 0; while (1) { __pyx_t_8 = __Pyx_dict_iter_next(__pyx_t_2, __pyx_t_4, &__pyx_t_3, &__pyx_t_7, &__pyx_t_10, NULL, __pyx_t_5); if (unlikely(__pyx_t_8 == 0)) break; if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 145, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_10); __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_10); __pyx_t_10 = 0; /* "borghash/HashTableNT.pyx":146 * self[key] = value * for key, value in kwds.items(): * self[key] = value # <<<<<<<<<<<<<< * * def k_to_idx(self, key: bytes) -> int: */ if (unlikely((PyObject_SetItem(((PyObject *)__pyx_v_self), __pyx_v_key, __pyx_v_value) < 0))) __PYX_ERR(0, 146, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTableNT.pyx":131 * return self._to_namedtuple_value(binary_value) * * def update(self, other=(), /, **kwds): # <<<<<<<<<<<<<< * """Like dict.update(), but 'other' can also be a HashTableNT instance.""" * if isinstance(other, HashTableNT): */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_10); __Pyx_XDECREF(__pyx_t_11); __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.update", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_key); __Pyx_XDECREF(__pyx_v_value); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTableNT.pyx":148 * self[key] = value * * def k_to_idx(self, key: bytes) -> int: # <<<<<<<<<<<<<< * return self.inner.k_to_idx(key) * */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_36k_to_idx(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_8borghash_11HashTableNT_11HashTableNT_36k_to_idx = {"k_to_idx", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_36k_to_idx, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_36k_to_idx(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_key = 0; #if !CYTHON_VECTORCALL 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("k_to_idx (wrapper)", 0); #if !CYTHON_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_key,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 148, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 148, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "k_to_idx", 0) < (0)) __PYX_ERR(0, 148, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("k_to_idx", 1, 1, 1, i); __PYX_ERR(0, 148, __pyx_L3_error) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 148, __pyx_L3_error) } __pyx_v_key = ((PyObject*)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("k_to_idx", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 148, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.k_to_idx", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_key), (&PyBytes_Type), 0, "key", 2))) __PYX_ERR(0, 148, __pyx_L1_error) __pyx_r = __pyx_pf_8borghash_11HashTableNT_11HashTableNT_35k_to_idx(((struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)__pyx_v_self), __pyx_v_key); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } goto __pyx_L7_cleaned_up; __pyx_L0:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_35k_to_idx(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_key) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; size_t __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("k_to_idx", 0); /* "borghash/HashTableNT.pyx":149 * * def k_to_idx(self, key: bytes) -> int: * return self.inner.k_to_idx(key) # <<<<<<<<<<<<<< * * def idx_to_k(self, idx: int) -> bytes: */ __pyx_t_2 = __pyx_v_self->inner; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_key}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_k_to_idx, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 149, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } if (__Pyx_PyInt_FromNumber(&__pyx_t_1, NULL, 1) < (0)) __PYX_ERR(0, 149, __pyx_L1_error) { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __pyx_r = ((PyObject*)__pyx_t_1); } __Pyx_XDECREF(__pyx_temp); } __pyx_t_1 = 0; goto __pyx_L0; /* "borghash/HashTableNT.pyx":148 * self[key] = value * * def k_to_idx(self, key: bytes) -> int: # <<<<<<<<<<<<<< * return self.inner.k_to_idx(key) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.k_to_idx", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTableNT.pyx":151 * return self.inner.k_to_idx(key) * * def idx_to_k(self, idx: int) -> bytes: # <<<<<<<<<<<<<< * return self.inner.idx_to_k(idx) * */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_38idx_to_k(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_8borghash_11HashTableNT_11HashTableNT_38idx_to_k = {"idx_to_k", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_38idx_to_k, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_38idx_to_k(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_idx = 0; #if !CYTHON_VECTORCALL 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("idx_to_k (wrapper)", 0); #if !CYTHON_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_idx,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 151, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 151, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "idx_to_k", 0) < (0)) __PYX_ERR(0, 151, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("idx_to_k", 1, 1, 1, i); __PYX_ERR(0, 151, __pyx_L3_error) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 151, __pyx_L3_error) } if (__Pyx_PyInt_FromNumber(&values[0], "idx", 0) < (0)) __PYX_ERR(0, 151, __pyx_L3_error) __pyx_v_idx = ((PyObject*)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("idx_to_k", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 151, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.idx_to_k", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_idx), (&PyLong_Type), 0, "idx", 2))) __PYX_ERR(0, 151, __pyx_L1_error) __pyx_r = __pyx_pf_8borghash_11HashTableNT_11HashTableNT_37idx_to_k(((struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)__pyx_v_self), __pyx_v_idx); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } goto __pyx_L7_cleaned_up; __pyx_L0:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_37idx_to_k(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_idx) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; size_t __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("idx_to_k", 0); /* "borghash/HashTableNT.pyx":152 * * def idx_to_k(self, idx: int) -> bytes: * return self.inner.idx_to_k(idx) # <<<<<<<<<<<<<< * * def kv_to_idx(self, key: bytes, value: Any) -> int: */ __pyx_t_2 = __pyx_v_self->inner; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_idx}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_idx_to_k, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 152, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } if (!(likely(PyBytes_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_1))) __PYX_ERR(0, 152, __pyx_L1_error) { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __pyx_r = ((PyObject*)__pyx_t_1); } __Pyx_XDECREF(__pyx_temp); } __pyx_t_1 = 0; goto __pyx_L0; /* "borghash/HashTableNT.pyx":151 * return self.inner.k_to_idx(key) * * def idx_to_k(self, idx: int) -> bytes: # <<<<<<<<<<<<<< * return self.inner.idx_to_k(idx) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.idx_to_k", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTableNT.pyx":154 * return self.inner.idx_to_k(idx) * * def kv_to_idx(self, key: bytes, value: Any) -> int: # <<<<<<<<<<<<<< * binary_value = self._to_binary_value(value) * return self.inner.kv_to_idx(key, binary_value) */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_40kv_to_idx(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_8borghash_11HashTableNT_11HashTableNT_40kv_to_idx = {"kv_to_idx", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_40kv_to_idx, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_40kv_to_idx(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_key = 0; PyObject *__pyx_v_value = 0; #if !CYTHON_VECTORCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("kv_to_idx (wrapper)", 0); #if !CYTHON_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_key,&__pyx_mstate_global->__pyx_n_u_value,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 154, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 154, __pyx_L3_error) CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 154, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "kv_to_idx", 0) < (0)) __PYX_ERR(0, 154, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("kv_to_idx", 1, 2, 2, i); __PYX_ERR(0, 154, __pyx_L3_error) } } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 154, __pyx_L3_error) values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 154, __pyx_L3_error) } __pyx_v_key = ((PyObject*)values[0]); __pyx_v_value = values[1]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("kv_to_idx", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 154, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.kv_to_idx", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_key), (&PyBytes_Type), 0, "key", 2))) __PYX_ERR(0, 154, __pyx_L1_error) __pyx_r = __pyx_pf_8borghash_11HashTableNT_11HashTableNT_39kv_to_idx(((struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)__pyx_v_self), __pyx_v_key, __pyx_v_value); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } goto __pyx_L7_cleaned_up; __pyx_L0:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_39kv_to_idx(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value) { PyObject *__pyx_v_binary_value = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; size_t __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("kv_to_idx", 0); /* "borghash/HashTableNT.pyx":155 * * def kv_to_idx(self, key: bytes, value: Any) -> int: * binary_value = self._to_binary_value(value) # <<<<<<<<<<<<<< * return self.inner.kv_to_idx(key, binary_value) * */ __pyx_t_2 = ((PyObject *)__pyx_v_self); __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_value}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_to_binary_value, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 155, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } __pyx_v_binary_value = __pyx_t_1; __pyx_t_1 = 0; /* "borghash/HashTableNT.pyx":156 * def kv_to_idx(self, key: bytes, value: Any) -> int: * binary_value = self._to_binary_value(value) * return self.inner.kv_to_idx(key, binary_value) # <<<<<<<<<<<<<< * * def idx_to_kv(self, idx: int) -> tuple[bytes, Any]: */ __pyx_t_2 = __pyx_v_self->inner; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; { PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_v_key, __pyx_v_binary_value}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_kv_to_idx, __pyx_callargs+__pyx_t_3, (3-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 156, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } if (__Pyx_PyInt_FromNumber(&__pyx_t_1, NULL, 1) < (0)) __PYX_ERR(0, 156, __pyx_L1_error) { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __pyx_r = ((PyObject*)__pyx_t_1); } __Pyx_XDECREF(__pyx_temp); } __pyx_t_1 = 0; goto __pyx_L0; /* "borghash/HashTableNT.pyx":154 * return self.inner.idx_to_k(idx) * * def kv_to_idx(self, key: bytes, value: Any) -> int: # <<<<<<<<<<<<<< * binary_value = self._to_binary_value(value) * return self.inner.kv_to_idx(key, binary_value) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.kv_to_idx", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_binary_value); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTableNT.pyx":158 * return self.inner.kv_to_idx(key, binary_value) * * def idx_to_kv(self, idx: int) -> tuple[bytes, Any]: # <<<<<<<<<<<<<< * key, binary_value = self.inner.idx_to_kv(idx) * return key, self._to_namedtuple_value(binary_value) */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_42idx_to_kv(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_8borghash_11HashTableNT_11HashTableNT_42idx_to_kv = {"idx_to_kv", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_42idx_to_kv, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_42idx_to_kv(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_idx = 0; #if !CYTHON_VECTORCALL 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("idx_to_kv (wrapper)", 0); #if !CYTHON_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_idx,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 158, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 158, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "idx_to_kv", 0) < (0)) __PYX_ERR(0, 158, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("idx_to_kv", 1, 1, 1, i); __PYX_ERR(0, 158, __pyx_L3_error) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 158, __pyx_L3_error) } if (__Pyx_PyInt_FromNumber(&values[0], "idx", 0) < (0)) __PYX_ERR(0, 158, __pyx_L3_error) __pyx_v_idx = ((PyObject*)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("idx_to_kv", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 158, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.idx_to_kv", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_idx), (&PyLong_Type), 0, "idx", 2))) __PYX_ERR(0, 158, __pyx_L1_error) __pyx_r = __pyx_pf_8borghash_11HashTableNT_11HashTableNT_41idx_to_kv(((struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)__pyx_v_self), __pyx_v_idx); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } goto __pyx_L7_cleaned_up; __pyx_L0:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_41idx_to_kv(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_idx) { PyObject *__pyx_v_key = NULL; PyObject *__pyx_v_binary_value = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; size_t __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *(*__pyx_t_6)(PyObject *); int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("idx_to_kv", 0); /* "borghash/HashTableNT.pyx":159 * * def idx_to_kv(self, idx: int) -> tuple[bytes, Any]: * key, binary_value = self.inner.idx_to_kv(idx) # <<<<<<<<<<<<<< * return key, self._to_namedtuple_value(binary_value) * */ __pyx_t_2 = __pyx_v_self->inner; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_idx}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_idx_to_kv, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 159, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) { PyObject* sequence = __pyx_t_1; 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, 159, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); __Pyx_INCREF(__pyx_t_2); __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); __Pyx_INCREF(__pyx_t_4); } else { __pyx_t_2 = __Pyx_PyList_GET_ITEM_REF(sequence, 0, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 159, __pyx_L1_error) __Pyx_XGOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyList_GET_ITEM_REF(sequence, 1, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 159, __pyx_L1_error) __Pyx_XGOTREF(__pyx_t_4); } #else __pyx_t_2 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 159, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 159, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else { Py_ssize_t index = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 159, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_6 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_5); index = 0; __pyx_t_2 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed; __Pyx_GOTREF(__pyx_t_2); index = 1; __pyx_t_4 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_4)) goto __pyx_L3_unpacking_failed; __Pyx_GOTREF(__pyx_t_4); if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 2) < (0)) __PYX_ERR(0, 159, __pyx_L1_error) __pyx_t_6 = NULL; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L4_unpacking_done; __pyx_L3_unpacking_failed:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_6 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); __PYX_ERR(0, 159, __pyx_L1_error) __pyx_L4_unpacking_done:; } __pyx_v_key = __pyx_t_2; __pyx_t_2 = 0; __pyx_v_binary_value = __pyx_t_4; __pyx_t_4 = 0; /* "borghash/HashTableNT.pyx":160 * def idx_to_kv(self, idx: int) -> tuple[bytes, Any]: * key, binary_value = self.inner.idx_to_kv(idx) * return key, self._to_namedtuple_value(binary_value) # <<<<<<<<<<<<<< * * @property */ __pyx_t_4 = ((PyObject *)__pyx_v_self); __Pyx_INCREF(__pyx_t_4); __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_binary_value}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_to_namedtuple_value, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 160, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_v_key); __Pyx_GIVEREF(__pyx_v_key); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_key) != (0)) __PYX_ERR(0, 160, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1) != (0)) __PYX_ERR(0, 160, __pyx_L1_error); __pyx_t_1 = 0; { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __pyx_r = ((PyObject*)__pyx_t_4); } __Pyx_XDECREF(__pyx_temp); } __pyx_t_4 = 0; goto __pyx_L0; /* "borghash/HashTableNT.pyx":158 * return self.inner.kv_to_idx(key, binary_value) * * def idx_to_kv(self, idx: int) -> tuple[bytes, Any]: # <<<<<<<<<<<<<< * key, binary_value = self.inner.idx_to_kv(idx) * return key, self._to_namedtuple_value(binary_value) */ /* 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("borghash.HashTableNT.HashTableNT.idx_to_kv", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_key); __Pyx_XDECREF(__pyx_v_binary_value); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTableNT.pyx":162 * return key, self._to_namedtuple_value(binary_value) * * @property # <<<<<<<<<<<<<< * def stats(self) -> dict[str, int]: * return self.inner.stats */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_5stats_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_5stats_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_8borghash_11HashTableNT_11HashTableNT_5stats___get__(((struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_5stats___get__(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__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__", 0); /* "borghash/HashTableNT.pyx":164 * @property * def stats(self) -> dict[str, int]: * return self.inner.stats # <<<<<<<<<<<<<< * * def write(self, file: BinaryIO|str|bytes): */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->inner, __pyx_mstate_global->__pyx_n_u_stats); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 164, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __pyx_r = __pyx_t_1; } __Pyx_XDECREF(__pyx_temp); } __pyx_t_1 = 0; goto __pyx_L0; /* "borghash/HashTableNT.pyx":162 * return key, self._to_namedtuple_value(binary_value) * * @property # <<<<<<<<<<<<<< * def stats(self) -> dict[str, int]: * return self.inner.stats */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.stats.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTableNT.pyx":166 * return self.inner.stats * * def write(self, file: BinaryIO|str|bytes): # <<<<<<<<<<<<<< * if isinstance(file, (str, bytes)): * with open(file, 'wb') as fd: */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_44write(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_8borghash_11HashTableNT_11HashTableNT_44write = {"write", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_44write, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_44write(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_file = 0; #if !CYTHON_VECTORCALL 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("write (wrapper)", 0); #if !CYTHON_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_file,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 166, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 166, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "write", 0) < (0)) __PYX_ERR(0, 166, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("write", 1, 1, 1, i); __PYX_ERR(0, 166, __pyx_L3_error) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 166, __pyx_L3_error) } __pyx_v_file = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("write", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 166, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.write", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8borghash_11HashTableNT_11HashTableNT_43write(((struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)__pyx_v_self), __pyx_v_file); /* function exit code */ for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_43write(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_file) { PyObject *__pyx_v_fd = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; size_t __pyx_t_5; 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("write", 0); /* "borghash/HashTableNT.pyx":167 * * def write(self, file: BinaryIO|str|bytes): * if isinstance(file, (str, bytes)): # <<<<<<<<<<<<<< * with open(file, 'wb') as fd: * self._write_fd(fd) */ __pyx_t_2 = PyUnicode_Check(__pyx_v_file); if (!__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L4_bool_binop_done; } __pyx_t_2 = PyBytes_Check(__pyx_v_file); __pyx_t_1 = __pyx_t_2; __pyx_L4_bool_binop_done:; if (__pyx_t_1) { /* "borghash/HashTableNT.pyx":168 * def write(self, file: BinaryIO|str|bytes): * if isinstance(file, (str, bytes)): * with open(file, 'wb') as fd: # <<<<<<<<<<<<<< * self._write_fd(fd) * else: */ /*with:*/ { __pyx_t_4 = NULL; __pyx_t_5 = 1; { PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_v_file, __pyx_mstate_global->__pyx_n_u_wb}; __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_open, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 168, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); } __pyx_t_6 = __Pyx_PyObject_LookupSpecial(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_exit); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 168, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = __Pyx_PyObject_LookupSpecial(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_enter); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 168, __pyx_L6_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_5 = 1; #if CYTHON_UNPACK_METHODS if (likely(PyMethod_Check(__pyx_t_8))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); assert(__pyx_t_7); PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(__pyx__function); __Pyx_DECREF_SET(__pyx_t_8, __pyx__function); __pyx_t_5 = 0; } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL}; __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_8, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 168, __pyx_L6_error) __Pyx_GOTREF(__pyx_t_4); } __pyx_t_8 = __pyx_t_4; __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /*try:*/ { { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { __pyx_v_fd = __pyx_t_8; __pyx_t_8 = 0; /* "borghash/HashTableNT.pyx":169 * if isinstance(file, (str, bytes)): * with open(file, 'wb') as fd: * self._write_fd(fd) # <<<<<<<<<<<<<< * else: * self._write_fd(file) */ __pyx_t_3 = ((PyObject *)__pyx_v_self); __Pyx_INCREF(__pyx_t_3); __pyx_t_5 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_fd}; __pyx_t_8 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_write_fd, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 169, __pyx_L10_error) __Pyx_GOTREF(__pyx_t_8); } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; /* "borghash/HashTableNT.pyx":168 * def write(self, file: BinaryIO|str|bytes): * if isinstance(file, (str, bytes)): * with open(file, 'wb') as fd: # <<<<<<<<<<<<<< * self._write_fd(fd) * else: */ } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L15_try_end; __pyx_L10_error:; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; /*except:*/ { __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.write", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_3, &__pyx_t_4) < 0) __PYX_ERR(0, 168, __pyx_L12_except_error) __Pyx_XGOTREF(__pyx_t_8); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); { PyObject* __pyx_temp[3] = {__pyx_t_8, __pyx_t_3, __pyx_t_4}; __pyx_t_7 = __Pyx_PyTuple_FromArray(__pyx_temp, 3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 168, __pyx_L12_except_error) __Pyx_GOTREF(__pyx_t_7); } __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_7, NULL); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 168, __pyx_L12_except_error) __Pyx_GOTREF(__pyx_t_12); __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__pyx_t_1 < (0)) __PYX_ERR(0, 168, __pyx_L12_except_error) __pyx_t_2 = (!__pyx_t_1); if (unlikely(__pyx_t_2)) { __Pyx_GIVEREF(__pyx_t_8); __Pyx_GIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ErrRestoreWithState(__pyx_t_8, __pyx_t_3, __pyx_t_4); __pyx_t_8 = 0; __pyx_t_3 = 0; __pyx_t_4 = 0; __PYX_ERR(0, 168, __pyx_L12_except_error) } __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L11_exception_handled; } __pyx_L12_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L1_error; __pyx_L11_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L15_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_6) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_mstate_global->__pyx_tuple[2], NULL); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 168, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L9; } __pyx_L9:; } goto __pyx_L19; __pyx_L6_error:; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L1_error; __pyx_L19:; } /* "borghash/HashTableNT.pyx":167 * * def write(self, file: BinaryIO|str|bytes): * if isinstance(file, (str, bytes)): # <<<<<<<<<<<<<< * with open(file, 'wb') as fd: * self._write_fd(fd) */ goto __pyx_L3; } /* "borghash/HashTableNT.pyx":171 * self._write_fd(fd) * else: * self._write_fd(file) # <<<<<<<<<<<<<< * * def _write_fd(self, fd: BinaryIO): */ /*else*/ { __pyx_t_3 = ((PyObject *)__pyx_v_self); __Pyx_INCREF(__pyx_t_3); __pyx_t_5 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_file}; __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_write_fd, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 171, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __pyx_L3:; /* "borghash/HashTableNT.pyx":166 * return self.inner.stats * * def write(self, file: BinaryIO|str|bytes): # <<<<<<<<<<<<<< * if isinstance(file, (str, bytes)): * with open(file, 'wb') as fd: */ /* 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_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.write", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_fd); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTableNT.pyx":173 * self._write_fd(file) * * def _write_fd(self, fd: BinaryIO): # <<<<<<<<<<<<<< * meta = { * 'key_size': self.key_size, */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_46_write_fd(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_8borghash_11HashTableNT_11HashTableNT_46_write_fd = {"_write_fd", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_46_write_fd, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_46_write_fd(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_fd = 0; #if !CYTHON_VECTORCALL 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("_write_fd (wrapper)", 0); #if !CYTHON_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_fd,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 173, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 173, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_write_fd", 0) < (0)) __PYX_ERR(0, 173, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_write_fd", 1, 1, 1, i); __PYX_ERR(0, 173, __pyx_L3_error) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 173, __pyx_L3_error) } __pyx_v_fd = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("_write_fd", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 173, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT._write_fd", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8borghash_11HashTableNT_11HashTableNT_45_write_fd(((struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)__pyx_v_self), __pyx_v_fd); /* function exit code */ for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_45_write_fd(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v_fd) { PyObject *__pyx_v_meta = NULL; PyObject *__pyx_v_meta_bytes = NULL; Py_ssize_t __pyx_v_meta_size; PyObject *__pyx_v_header_bytes = NULL; PyObject *__pyx_v_count = NULL; PyObject *__pyx_v_key = NULL; PyObject *__pyx_v_value = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; size_t __pyx_t_7; Py_ssize_t __pyx_t_8; PyObject *__pyx_t_9 = NULL; Py_ssize_t __pyx_t_10; int __pyx_t_11; int __pyx_t_12; int __pyx_t_13; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_write_fd", 0); /* "borghash/HashTableNT.pyx":175 * def _write_fd(self, fd: BinaryIO): * meta = { * 'key_size': self.key_size, # <<<<<<<<<<<<<< * 'value_size': self.value_size, * 'byte_order': self.byte_order, */ __pyx_t_1 = __Pyx_PyDict_NewPresized(10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 175, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_self->key_size); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 175, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_key_size, __pyx_t_2) < (0)) __PYX_ERR(0, 175, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTableNT.pyx":176 * meta = { * 'key_size': self.key_size, * 'value_size': self.value_size, # <<<<<<<<<<<<<< * 'byte_order': self.byte_order, * 'value_type_name': self.value_type.__name__, */ __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_self->value_size); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 176, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_value_size, __pyx_t_2) < (0)) __PYX_ERR(0, 175, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTableNT.pyx":177 * 'key_size': self.key_size, * 'value_size': self.value_size, * 'byte_order': self.byte_order, # <<<<<<<<<<<<<< * 'value_type_name': self.value_type.__name__, * 'value_type_fields': self.value_type._fields, */ if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_byte_order, __pyx_v_self->byte_order) < (0)) __PYX_ERR(0, 175, __pyx_L1_error) /* "borghash/HashTableNT.pyx":178 * 'value_size': self.value_size, * 'byte_order': self.byte_order, * 'value_type_name': self.value_type.__name__, # <<<<<<<<<<<<<< * 'value_type_fields': self.value_type._fields, * 'value_format_name': self.value_format.__class__.__name__, */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->value_type, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 178, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_value_type_name, __pyx_t_2) < (0)) __PYX_ERR(0, 175, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTableNT.pyx":179 * 'byte_order': self.byte_order, * 'value_type_name': self.value_type.__name__, * 'value_type_fields': self.value_type._fields, # <<<<<<<<<<<<<< * 'value_format_name': self.value_format.__class__.__name__, * 'value_format_fields': self.value_format._fields, */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->value_type, __pyx_mstate_global->__pyx_n_u_fields); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 179, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_value_type_fields, __pyx_t_2) < (0)) __PYX_ERR(0, 175, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTableNT.pyx":180 * 'value_type_name': self.value_type.__name__, * 'value_type_fields': self.value_type._fields, * 'value_format_name': self.value_format.__class__.__name__, # <<<<<<<<<<<<<< * 'value_format_fields': self.value_format._fields, * 'value_format': self.value_format, */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->value_format, __pyx_mstate_global->__pyx_n_u_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 180, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 180, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_value_format_name, __pyx_t_3) < (0)) __PYX_ERR(0, 175, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "borghash/HashTableNT.pyx":181 * 'value_type_fields': self.value_type._fields, * 'value_format_name': self.value_format.__class__.__name__, * 'value_format_fields': self.value_format._fields, # <<<<<<<<<<<<<< * 'value_format': self.value_format, * 'capacity': self.inner.capacity, */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->value_format, __pyx_mstate_global->__pyx_n_u_fields); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 181, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_value_format_fields, __pyx_t_3) < (0)) __PYX_ERR(0, 175, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "borghash/HashTableNT.pyx":182 * 'value_format_name': self.value_format.__class__.__name__, * 'value_format_fields': self.value_format._fields, * 'value_format': self.value_format, # <<<<<<<<<<<<<< * 'capacity': self.inner.capacity, * 'used': self.inner.used, # count of keys / values */ if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_value_format, __pyx_v_self->value_format) < (0)) __PYX_ERR(0, 175, __pyx_L1_error) /* "borghash/HashTableNT.pyx":183 * 'value_format_fields': self.value_format._fields, * 'value_format': self.value_format, * 'capacity': self.inner.capacity, # <<<<<<<<<<<<<< * 'used': self.inner.used, # count of keys / values * } */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->inner, __pyx_mstate_global->__pyx_n_u_capacity); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 183, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_capacity, __pyx_t_3) < (0)) __PYX_ERR(0, 175, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "borghash/HashTableNT.pyx":184 * 'value_format': self.value_format, * 'capacity': self.inner.capacity, * 'used': self.inner.used, # count of keys / values # <<<<<<<<<<<<<< * } * meta_bytes = json.dumps(meta).encode("utf-8") */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->inner, __pyx_mstate_global->__pyx_n_u_used); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 184, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_used, __pyx_t_3) < (0)) __PYX_ERR(0, 175, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_meta = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "borghash/HashTableNT.pyx":186 * 'used': self.inner.used, # count of keys / values * } * meta_bytes = json.dumps(meta).encode("utf-8") # <<<<<<<<<<<<<< * meta_size = len(meta_bytes) * header_bytes = struct.pack(HEADER_FMT, MAGIC, VERSION, meta_size) */ __pyx_t_4 = NULL; __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_json); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 186, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_dumps); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 186, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_7 = 1; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_6))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6); assert(__pyx_t_4); PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(__pyx__function); __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); __pyx_t_7 = 0; } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_meta}; __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 186, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); } __pyx_t_3 = __pyx_t_2; __Pyx_INCREF(__pyx_t_3); __pyx_t_7 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_utf_8}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_encode, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 186, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } __pyx_v_meta_bytes = __pyx_t_1; __pyx_t_1 = 0; /* "borghash/HashTableNT.pyx":187 * } * meta_bytes = json.dumps(meta).encode("utf-8") * meta_size = len(meta_bytes) # <<<<<<<<<<<<<< * header_bytes = struct.pack(HEADER_FMT, MAGIC, VERSION, meta_size) * fd.write(header_bytes) */ __pyx_t_8 = PyObject_Length(__pyx_v_meta_bytes); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(0, 187, __pyx_L1_error) __pyx_v_meta_size = __pyx_t_8; /* "borghash/HashTableNT.pyx":188 * meta_bytes = json.dumps(meta).encode("utf-8") * meta_size = len(meta_bytes) * header_bytes = struct.pack(HEADER_FMT, MAGIC, VERSION, meta_size) # <<<<<<<<<<<<<< * fd.write(header_bytes) * fd.write(meta_bytes) */ __pyx_t_2 = NULL; __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_struct); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 188, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_pack); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 188, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_HEADER_FMT); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 188, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_MAGIC); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 188, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_VERSION); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 188, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_9 = PyLong_FromSsize_t(__pyx_v_meta_size); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 188, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_7 = 1; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_6))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_6); assert(__pyx_t_2); PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(__pyx__function); __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); __pyx_t_7 = 0; } #endif { PyObject *__pyx_callargs[5] = {__pyx_t_2, __pyx_t_3, __pyx_t_4, __pyx_t_5, __pyx_t_9}; __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_7, (5-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 188, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } __pyx_v_header_bytes = __pyx_t_1; __pyx_t_1 = 0; /* "borghash/HashTableNT.pyx":189 * meta_size = len(meta_bytes) * header_bytes = struct.pack(HEADER_FMT, MAGIC, VERSION, meta_size) * fd.write(header_bytes) # <<<<<<<<<<<<<< * fd.write(meta_bytes) * count = 0 */ __pyx_t_6 = __pyx_v_fd; __Pyx_INCREF(__pyx_t_6); __pyx_t_7 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_v_header_bytes}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_write, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 189, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "borghash/HashTableNT.pyx":190 * header_bytes = struct.pack(HEADER_FMT, MAGIC, VERSION, meta_size) * fd.write(header_bytes) * fd.write(meta_bytes) # <<<<<<<<<<<<<< * count = 0 * for key, value in self.inner.items(): */ __pyx_t_6 = __pyx_v_fd; __Pyx_INCREF(__pyx_t_6); __pyx_t_7 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_v_meta_bytes}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_write, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 190, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "borghash/HashTableNT.pyx":191 * fd.write(header_bytes) * fd.write(meta_bytes) * count = 0 # <<<<<<<<<<<<<< * for key, value in self.inner.items(): * fd.write(key) */ __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); __pyx_v_count = __pyx_mstate_global->__pyx_int_0; /* "borghash/HashTableNT.pyx":192 * fd.write(meta_bytes) * count = 0 * for key, value in self.inner.items(): # <<<<<<<<<<<<<< * fd.write(key) * fd.write(value) */ __pyx_t_8 = 0; if (unlikely(__pyx_v_self->inner == Py_None)) { PyErr_Format(PyExc_AttributeError, "\047NoneType\047 object has no attribute \047%.30s\047", "items"); __PYX_ERR(0, 192, __pyx_L1_error) } __pyx_t_6 = __Pyx_dict_iterator(__pyx_v_self->inner, 0, __pyx_mstate_global->__pyx_n_u_items, (&__pyx_t_10), (&__pyx_t_11)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 192, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = __pyx_t_6; __pyx_t_6 = 0; while (1) { __pyx_t_12 = __Pyx_dict_iter_next(__pyx_t_1, __pyx_t_10, &__pyx_t_8, &__pyx_t_6, &__pyx_t_9, NULL, __pyx_t_11); if (unlikely(__pyx_t_12 == 0)) break; if (unlikely(__pyx_t_12 == -1)) __PYX_ERR(0, 192, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_9); __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_9); __pyx_t_9 = 0; /* "borghash/HashTableNT.pyx":193 * count = 0 * for key, value in self.inner.items(): * fd.write(key) # <<<<<<<<<<<<<< * fd.write(value) * count += 1 */ __pyx_t_6 = __pyx_v_fd; __Pyx_INCREF(__pyx_t_6); __pyx_t_7 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_v_key}; __pyx_t_9 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_write, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 193, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); } __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; /* "borghash/HashTableNT.pyx":194 * for key, value in self.inner.items(): * fd.write(key) * fd.write(value) # <<<<<<<<<<<<<< * count += 1 * assert count == self.inner.used */ __pyx_t_6 = __pyx_v_fd; __Pyx_INCREF(__pyx_t_6); __pyx_t_7 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_v_value}; __pyx_t_9 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_write, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 194, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); } __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; /* "borghash/HashTableNT.pyx":195 * fd.write(key) * fd.write(value) * count += 1 # <<<<<<<<<<<<<< * assert count == self.inner.used * */ __pyx_t_9 = __Pyx_PyLong_AddObjC(__pyx_v_count, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 195, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF_SET(__pyx_v_count, ((PyObject*)__pyx_t_9)); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "borghash/HashTableNT.pyx":196 * fd.write(value) * count += 1 * assert count == self.inner.used # <<<<<<<<<<<<<< * * @classmethod */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(__pyx_assertions_enabled())) { __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->inner, __pyx_mstate_global->__pyx_n_u_used); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 196, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_13 = __Pyx_PyObject_CompareBoolEq_int_object(__pyx_v_count, __pyx_t_1, Py_EQ); if (unlikely((__pyx_t_13 < 0))) __PYX_ERR(0, 196, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_13)) { __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_AssertionError))), 0, 0, 0); __PYX_ERR(0, 196, __pyx_L1_error) } } #else if ((1)); else __PYX_ERR(0, 196, __pyx_L1_error) #endif /* "borghash/HashTableNT.pyx":173 * self._write_fd(file) * * def _write_fd(self, fd: BinaryIO): # <<<<<<<<<<<<<< * meta = { * 'key_size': self.key_size, */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT._write_fd", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_meta); __Pyx_XDECREF(__pyx_v_meta_bytes); __Pyx_XDECREF(__pyx_v_header_bytes); __Pyx_XDECREF(__pyx_v_count); __Pyx_XDECREF(__pyx_v_key); __Pyx_XDECREF(__pyx_v_value); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTableNT.pyx":198 * assert count == self.inner.used * * @classmethod # <<<<<<<<<<<<<< * def read(cls, file: BinaryIO|str|bytes): * if isinstance(file, (str, bytes)): */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_48read(PyObject *__pyx_v_cls, #if CYTHON_VECTORCALL 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_8borghash_11HashTableNT_11HashTableNT_48read = {"read", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_48read, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_48read(PyObject *__pyx_v_cls, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_file = 0; #if !CYTHON_VECTORCALL 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("read (wrapper)", 0); #if !CYTHON_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_file,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 198, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 198, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "read", 0) < (0)) __PYX_ERR(0, 198, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("read", 1, 1, 1, i); __PYX_ERR(0, 198, __pyx_L3_error) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 198, __pyx_L3_error) } __pyx_v_file = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("read", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 198, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.read", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8borghash_11HashTableNT_11HashTableNT_47read(((PyTypeObject*)__pyx_v_cls), __pyx_v_file); /* function exit code */ for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_47read(PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_file) { PyObject *__pyx_v_fd = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; size_t __pyx_t_5; 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("read", 0); /* "borghash/HashTableNT.pyx":200 * @classmethod * def read(cls, file: BinaryIO|str|bytes): * if isinstance(file, (str, bytes)): # <<<<<<<<<<<<<< * with open(file, 'rb') as fd: * return cls._read_fd(fd) */ __pyx_t_2 = PyUnicode_Check(__pyx_v_file); if (!__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L4_bool_binop_done; } __pyx_t_2 = PyBytes_Check(__pyx_v_file); __pyx_t_1 = __pyx_t_2; __pyx_L4_bool_binop_done:; if (__pyx_t_1) { /* "borghash/HashTableNT.pyx":201 * def read(cls, file: BinaryIO|str|bytes): * if isinstance(file, (str, bytes)): * with open(file, 'rb') as fd: # <<<<<<<<<<<<<< * return cls._read_fd(fd) * else: */ /*with:*/ { __pyx_t_4 = NULL; __pyx_t_5 = 1; { PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_v_file, __pyx_mstate_global->__pyx_n_u_rb}; __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_open, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 201, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); } __pyx_t_6 = __Pyx_PyObject_LookupSpecial(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_exit); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 201, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = __Pyx_PyObject_LookupSpecial(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_enter); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 201, __pyx_L6_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_5 = 1; #if CYTHON_UNPACK_METHODS if (likely(PyMethod_Check(__pyx_t_8))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); assert(__pyx_t_7); PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(__pyx__function); __Pyx_DECREF_SET(__pyx_t_8, __pyx__function); __pyx_t_5 = 0; } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL}; __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_8, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 201, __pyx_L6_error) __Pyx_GOTREF(__pyx_t_4); } __pyx_t_8 = __pyx_t_4; __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /*try:*/ { { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { __pyx_v_fd = __pyx_t_8; __pyx_t_8 = 0; /* "borghash/HashTableNT.pyx":202 * if isinstance(file, (str, bytes)): * with open(file, 'rb') as fd: * return cls._read_fd(fd) # <<<<<<<<<<<<<< * else: * return cls._read_fd(file) */ __pyx_t_3 = ((PyObject *)__pyx_v_cls); __Pyx_INCREF(__pyx_t_3); __pyx_t_5 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_fd}; __pyx_t_8 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_read_fd, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 202, __pyx_L10_error) __Pyx_GOTREF(__pyx_t_8); } { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __pyx_r = __pyx_t_8; } __Pyx_XDECREF(__pyx_temp); } __pyx_t_8 = 0; goto __pyx_L14_try_return; /* "borghash/HashTableNT.pyx":201 * def read(cls, file: BinaryIO|str|bytes): * if isinstance(file, (str, bytes)): * with open(file, 'rb') as fd: # <<<<<<<<<<<<<< * return cls._read_fd(fd) * else: */ } __pyx_L10_error:; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; /*except:*/ { __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.read", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_3, &__pyx_t_4) < 0) __PYX_ERR(0, 201, __pyx_L12_except_error) __Pyx_XGOTREF(__pyx_t_8); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); { PyObject* __pyx_temp[3] = {__pyx_t_8, __pyx_t_3, __pyx_t_4}; __pyx_t_7 = __Pyx_PyTuple_FromArray(__pyx_temp, 3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 201, __pyx_L12_except_error) __Pyx_GOTREF(__pyx_t_7); } __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_7, NULL); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 201, __pyx_L12_except_error) __Pyx_GOTREF(__pyx_t_12); __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__pyx_t_1 < (0)) __PYX_ERR(0, 201, __pyx_L12_except_error) __pyx_t_2 = (!__pyx_t_1); if (unlikely(__pyx_t_2)) { __Pyx_GIVEREF(__pyx_t_8); __Pyx_GIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ErrRestoreWithState(__pyx_t_8, __pyx_t_3, __pyx_t_4); __pyx_t_8 = 0; __pyx_t_3 = 0; __pyx_t_4 = 0; __PYX_ERR(0, 201, __pyx_L12_except_error) } __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L11_exception_handled; } __pyx_L12_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L1_error; __pyx_L14_try_return:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L7_return; __pyx_L11_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_6) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_mstate_global->__pyx_tuple[2], NULL); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 201, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L9; } __pyx_L7_return: { __pyx_t_11 = __pyx_r; __pyx_r = 0; if (__pyx_t_6) { __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_mstate_global->__pyx_tuple[2], NULL); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 201, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __pyx_r = __pyx_t_11; __pyx_t_11 = 0; goto __pyx_L0; } __pyx_L9:; } goto __pyx_L19; __pyx_L6_error:; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L1_error; __pyx_L19:; } /* "borghash/HashTableNT.pyx":200 * @classmethod * def read(cls, file: BinaryIO|str|bytes): * if isinstance(file, (str, bytes)): # <<<<<<<<<<<<<< * with open(file, 'rb') as fd: * return cls._read_fd(fd) */ goto __pyx_L3; } /* "borghash/HashTableNT.pyx":204 * return cls._read_fd(fd) * else: * return cls._read_fd(file) # <<<<<<<<<<<<<< * * @classmethod */ /*else*/ { __pyx_t_3 = ((PyObject *)__pyx_v_cls); __Pyx_INCREF(__pyx_t_3); __pyx_t_5 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_file}; __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_read_fd, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 204, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); } { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __pyx_r = __pyx_t_4; } __Pyx_XDECREF(__pyx_temp); } __pyx_t_4 = 0; goto __pyx_L0; } __pyx_L3:; /* "borghash/HashTableNT.pyx":198 * assert count == self.inner.used * * @classmethod # <<<<<<<<<<<<<< * def read(cls, file: BinaryIO|str|bytes): * if isinstance(file, (str, bytes)): */ /* 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_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.read", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_fd); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTableNT.pyx":206 * return cls._read_fd(file) * * @classmethod # <<<<<<<<<<<<<< * def _read_fd(cls, fd: BinaryIO): * header_size = struct.calcsize(HEADER_FMT) */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_50_read_fd(PyObject *__pyx_v_cls, #if CYTHON_VECTORCALL 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_8borghash_11HashTableNT_11HashTableNT_50_read_fd = {"_read_fd", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_50_read_fd, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_50_read_fd(PyObject *__pyx_v_cls, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_fd = 0; #if !CYTHON_VECTORCALL 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("_read_fd (wrapper)", 0); #if !CYTHON_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_fd,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 206, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 206, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_read_fd", 0) < (0)) __PYX_ERR(0, 206, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_read_fd", 1, 1, 1, i); __PYX_ERR(0, 206, __pyx_L3_error) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 206, __pyx_L3_error) } __pyx_v_fd = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("_read_fd", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 206, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT._read_fd", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8borghash_11HashTableNT_11HashTableNT_49_read_fd(((PyTypeObject*)__pyx_v_cls), __pyx_v_fd); /* function exit code */ for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_49_read_fd(PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_fd) { PyObject *__pyx_v_header_size = NULL; PyObject *__pyx_v_header_bytes = NULL; PyObject *__pyx_v_magic = NULL; PyObject *__pyx_v_version = NULL; PyObject *__pyx_v_meta_size = NULL; PyObject *__pyx_v_meta_bytes = NULL; PyObject *__pyx_v_meta = NULL; PyObject *__pyx_v_value_type = NULL; PyObject *__pyx_v_value_format_t = NULL; PyObject *__pyx_v_value_format = NULL; PyObject *__pyx_v_ht = NULL; CYTHON_UNUSED long __pyx_v_count; PyObject *__pyx_v_ksize = NULL; PyObject *__pyx_v_vsize = NULL; CYTHON_UNUSED PyObject *__pyx_v_i = NULL; PyObject *__pyx_v_key = NULL; PyObject *__pyx_v_value = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; size_t __pyx_t_5; Py_ssize_t __pyx_t_6; int __pyx_t_7; PyObject *__pyx_t_8 = NULL; PyObject *(*__pyx_t_9)(PyObject *); PyObject *__pyx_t_10[3]; int __pyx_t_11; PyObject *__pyx_t_12 = NULL; PyObject *(*__pyx_t_13)(PyObject *); int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_read_fd", 0); /* "borghash/HashTableNT.pyx":208 * @classmethod * def _read_fd(cls, fd: BinaryIO): * header_size = struct.calcsize(HEADER_FMT) # <<<<<<<<<<<<<< * header_bytes = fd.read(header_size) * if len(header_bytes) < header_size: */ __pyx_t_2 = NULL; __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_struct); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 208, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_calcsize); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 208, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_HEADER_FMT); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 208, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = 1; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); assert(__pyx_t_2); PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(__pyx__function); __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); __pyx_t_5 = 0; } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_3}; __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 208, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } __pyx_v_header_size = __pyx_t_1; __pyx_t_1 = 0; /* "borghash/HashTableNT.pyx":209 * def _read_fd(cls, fd: BinaryIO): * header_size = struct.calcsize(HEADER_FMT) * header_bytes = fd.read(header_size) # <<<<<<<<<<<<<< * if len(header_bytes) < header_size: * raise ValueError(f"Invalid file, file is too short.") */ __pyx_t_4 = __pyx_v_fd; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_header_size}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_read, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 209, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } __pyx_v_header_bytes = __pyx_t_1; __pyx_t_1 = 0; /* "borghash/HashTableNT.pyx":210 * header_size = struct.calcsize(HEADER_FMT) * header_bytes = fd.read(header_size) * if len(header_bytes) < header_size: # <<<<<<<<<<<<<< * raise ValueError(f"Invalid file, file is too short.") * magic, version, meta_size = struct.unpack(HEADER_FMT, header_bytes) */ __pyx_t_6 = PyObject_Length(__pyx_v_header_bytes); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 210, __pyx_L1_error) __pyx_t_1 = PyLong_FromSsize_t(__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 210, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = __Pyx_PyObject_CompareBoolLt_int_object(__pyx_t_1, __pyx_v_header_size, Py_LT); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 210, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(__pyx_t_7)) { /* "borghash/HashTableNT.pyx":211 * header_bytes = fd.read(header_size) * if len(header_bytes) < header_size: * raise ValueError(f"Invalid file, file is too short.") # <<<<<<<<<<<<<< * magic, version, meta_size = struct.unpack(HEADER_FMT, header_bytes) * if magic != MAGIC: */ __pyx_t_4 = NULL; __pyx_t_5 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_Invalid_file_file_is_too_short}; __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 211, __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_ERR(0, 211, __pyx_L1_error) /* "borghash/HashTableNT.pyx":210 * header_size = struct.calcsize(HEADER_FMT) * header_bytes = fd.read(header_size) * if len(header_bytes) < header_size: # <<<<<<<<<<<<<< * raise ValueError(f"Invalid file, file is too short.") * magic, version, meta_size = struct.unpack(HEADER_FMT, header_bytes) */ } /* "borghash/HashTableNT.pyx":212 * if len(header_bytes) < header_size: * raise ValueError(f"Invalid file, file is too short.") * magic, version, meta_size = struct.unpack(HEADER_FMT, header_bytes) # <<<<<<<<<<<<<< * if magic != MAGIC: * raise ValueError(f"Invalid file, magic {MAGIC.decode()} not found.") */ __pyx_t_4 = NULL; __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_struct); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 212, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_unpack); 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_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_HEADER_FMT); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 212, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = 1; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); assert(__pyx_t_4); PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(__pyx__function); __Pyx_DECREF_SET(__pyx_t_2, __pyx__function); __pyx_t_5 = 0; } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_3, __pyx_v_header_bytes}; __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_2, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 212, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) { PyObject* sequence = __pyx_t_1; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 3)) { if (size > 3) __Pyx_RaiseTooManyValuesError(3); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); __PYX_ERR(0, 212, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); __Pyx_INCREF(__pyx_t_3); __pyx_t_4 = PyTuple_GET_ITEM(sequence, 2); __Pyx_INCREF(__pyx_t_4); } else { __pyx_t_2 = __Pyx_PyList_GET_ITEM_REF(sequence, 0, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 212, __pyx_L1_error) __Pyx_XGOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyList_GET_ITEM_REF(sequence, 1, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 212, __pyx_L1_error) __Pyx_XGOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyList_GET_ITEM_REF(sequence, 2, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 212, __pyx_L1_error) __Pyx_XGOTREF(__pyx_t_4); } #else __pyx_t_2 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 212, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 212, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 212, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else { Py_ssize_t index = -1; __pyx_t_8 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 212, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_9 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_8); index = 0; __pyx_t_2 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_2)) goto __pyx_L4_unpacking_failed; __Pyx_GOTREF(__pyx_t_2); index = 1; __pyx_t_3 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_3)) goto __pyx_L4_unpacking_failed; __Pyx_GOTREF(__pyx_t_3); index = 2; __pyx_t_4 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_4)) goto __pyx_L4_unpacking_failed; __Pyx_GOTREF(__pyx_t_4); if (__Pyx_IternextUnpackEndCheck(__pyx_t_9(__pyx_t_8), 3) < (0)) __PYX_ERR(0, 212, __pyx_L1_error) __pyx_t_9 = NULL; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L5_unpacking_done; __pyx_L4_unpacking_failed:; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_9 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); __PYX_ERR(0, 212, __pyx_L1_error) __pyx_L5_unpacking_done:; } __pyx_v_magic = __pyx_t_2; __pyx_t_2 = 0; __pyx_v_version = __pyx_t_3; __pyx_t_3 = 0; __pyx_v_meta_size = __pyx_t_4; __pyx_t_4 = 0; /* "borghash/HashTableNT.pyx":213 * raise ValueError(f"Invalid file, file is too short.") * magic, version, meta_size = struct.unpack(HEADER_FMT, header_bytes) * if magic != MAGIC: # <<<<<<<<<<<<<< * raise ValueError(f"Invalid file, magic {MAGIC.decode()} not found.") * if version != VERSION: */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_MAGIC); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 213, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = __Pyx_PyObject_CompareBoolNe_object_object(__pyx_v_magic, __pyx_t_1, Py_NE); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 213, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(__pyx_t_7)) { /* "borghash/HashTableNT.pyx":214 * magic, version, meta_size = struct.unpack(HEADER_FMT, header_bytes) * if magic != MAGIC: * raise ValueError(f"Invalid file, magic {MAGIC.decode()} not found.") # <<<<<<<<<<<<<< * if version != VERSION: * raise ValueError(f"Unsupported file version {version}.") */ __pyx_t_4 = NULL; __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_MAGIC); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 214, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_decode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 214, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 214, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 214, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_10[0] = __pyx_mstate_global->__pyx_kp_u_Invalid_file_magic; __pyx_t_10[1] = __pyx_t_2; __pyx_t_10[2] = __pyx_mstate_global->__pyx_kp_u_not_found; __pyx_t_6 = 31; #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH __pyx_t_6 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10[1]); #endif __pyx_t_11 = 0; #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH __pyx_t_11 |= __Pyx_PyUnicode_KIND_04(__pyx_t_10[1]); #endif __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_10, 3, __pyx_t_6, __pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 214, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_5 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 214, __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_ERR(0, 214, __pyx_L1_error) /* "borghash/HashTableNT.pyx":213 * raise ValueError(f"Invalid file, file is too short.") * magic, version, meta_size = struct.unpack(HEADER_FMT, header_bytes) * if magic != MAGIC: # <<<<<<<<<<<<<< * raise ValueError(f"Invalid file, magic {MAGIC.decode()} not found.") * if version != VERSION: */ } /* "borghash/HashTableNT.pyx":215 * if magic != MAGIC: * raise ValueError(f"Invalid file, magic {MAGIC.decode()} not found.") * if version != VERSION: # <<<<<<<<<<<<<< * raise ValueError(f"Unsupported file version {version}.") * meta_bytes = fd.read(meta_size) */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_VERSION); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 215, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = __Pyx_PyObject_CompareBoolNe_object_object(__pyx_v_version, __pyx_t_1, Py_NE); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 215, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(__pyx_t_7)) { /* "borghash/HashTableNT.pyx":216 * raise ValueError(f"Invalid file, magic {MAGIC.decode()} not found.") * if version != VERSION: * raise ValueError(f"Unsupported file version {version}.") # <<<<<<<<<<<<<< * meta_bytes = fd.read(meta_size) * if len(meta_bytes) < meta_size: */ __pyx_t_3 = NULL; __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_v_version, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 216, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_10[0] = __pyx_mstate_global->__pyx_kp_u_Unsupported_file_version; __pyx_t_10[1] = __pyx_t_4; __pyx_t_10[2] = __pyx_mstate_global->__pyx_kp_u__6; __pyx_t_6 = 26; #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH __pyx_t_6 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10[1]); #endif __pyx_t_11 = 0; #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH __pyx_t_11 |= __Pyx_PyUnicode_KIND_04(__pyx_t_10[1]); #endif __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_10, 3, __pyx_t_6, __pyx_t_11); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 216, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_5 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_2}; __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 216, __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_ERR(0, 216, __pyx_L1_error) /* "borghash/HashTableNT.pyx":215 * if magic != MAGIC: * raise ValueError(f"Invalid file, magic {MAGIC.decode()} not found.") * if version != VERSION: # <<<<<<<<<<<<<< * raise ValueError(f"Unsupported file version {version}.") * meta_bytes = fd.read(meta_size) */ } /* "borghash/HashTableNT.pyx":217 * if version != VERSION: * raise ValueError(f"Unsupported file version {version}.") * meta_bytes = fd.read(meta_size) # <<<<<<<<<<<<<< * if len(meta_bytes) < meta_size: * raise ValueError(f"Invalid file, file is too short.") */ __pyx_t_2 = __pyx_v_fd; __Pyx_INCREF(__pyx_t_2); __pyx_t_5 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_meta_size}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_read, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 217, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } __pyx_v_meta_bytes = __pyx_t_1; __pyx_t_1 = 0; /* "borghash/HashTableNT.pyx":218 * raise ValueError(f"Unsupported file version {version}.") * meta_bytes = fd.read(meta_size) * if len(meta_bytes) < meta_size: # <<<<<<<<<<<<<< * raise ValueError(f"Invalid file, file is too short.") * meta = json.loads(meta_bytes.decode("utf-8")) */ __pyx_t_6 = PyObject_Length(__pyx_v_meta_bytes); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 218, __pyx_L1_error) __pyx_t_1 = PyLong_FromSsize_t(__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 218, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = __Pyx_PyObject_CompareBoolLt_int_object(__pyx_t_1, __pyx_v_meta_size, Py_LT); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 218, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(__pyx_t_7)) { /* "borghash/HashTableNT.pyx":219 * meta_bytes = fd.read(meta_size) * if len(meta_bytes) < meta_size: * raise ValueError(f"Invalid file, file is too short.") # <<<<<<<<<<<<<< * meta = json.loads(meta_bytes.decode("utf-8")) * value_type = namedtuple(meta['value_type_name'], meta['value_type_fields']) */ __pyx_t_2 = NULL; __pyx_t_5 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_mstate_global->__pyx_kp_u_Invalid_file_file_is_too_short}; __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 219, __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_ERR(0, 219, __pyx_L1_error) /* "borghash/HashTableNT.pyx":218 * raise ValueError(f"Unsupported file version {version}.") * meta_bytes = fd.read(meta_size) * if len(meta_bytes) < meta_size: # <<<<<<<<<<<<<< * raise ValueError(f"Invalid file, file is too short.") * meta = json.loads(meta_bytes.decode("utf-8")) */ } /* "borghash/HashTableNT.pyx":220 * if len(meta_bytes) < meta_size: * raise ValueError(f"Invalid file, file is too short.") * meta = json.loads(meta_bytes.decode("utf-8")) # <<<<<<<<<<<<<< * value_type = namedtuple(meta['value_type_name'], meta['value_type_fields']) * value_format_t = namedtuple(meta['value_format_name'], meta['value_format_fields']) */ __pyx_t_2 = NULL; __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_json); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_loads); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_8 = __pyx_v_meta_bytes; __Pyx_INCREF(__pyx_t_8); __pyx_t_5 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_mstate_global->__pyx_kp_u_utf_8}; __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_decode, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); } __pyx_t_5 = 1; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); assert(__pyx_t_2); PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(__pyx__function); __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); __pyx_t_5 = 0; } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_3}; __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } __pyx_v_meta = __pyx_t_1; __pyx_t_1 = 0; /* "borghash/HashTableNT.pyx":221 * raise ValueError(f"Invalid file, file is too short.") * meta = json.loads(meta_bytes.decode("utf-8")) * value_type = namedtuple(meta['value_type_name'], meta['value_type_fields']) # <<<<<<<<<<<<<< * value_format_t = namedtuple(meta['value_format_name'], meta['value_format_fields']) * value_format = value_format_t(*meta['value_format']) */ __pyx_t_4 = NULL; __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_namedtuple); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 221, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_v_meta, __pyx_mstate_global->__pyx_n_u_value_type_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 221, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_meta, __pyx_mstate_global->__pyx_n_u_value_type_fields); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 221, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_5 = 1; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); assert(__pyx_t_4); PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(__pyx__function); __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); __pyx_t_5 = 0; } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_2, __pyx_t_8}; __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 221, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } __pyx_v_value_type = __pyx_t_1; __pyx_t_1 = 0; /* "borghash/HashTableNT.pyx":222 * meta = json.loads(meta_bytes.decode("utf-8")) * value_type = namedtuple(meta['value_type_name'], meta['value_type_fields']) * value_format_t = namedtuple(meta['value_format_name'], meta['value_format_fields']) # <<<<<<<<<<<<<< * value_format = value_format_t(*meta['value_format']) * ht = cls(key_size=meta['key_size'], value_format=value_format, value_type=value_type, */ __pyx_t_3 = NULL; __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_namedtuple); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 222, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_v_meta, __pyx_mstate_global->__pyx_n_u_value_format_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 222, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyObject_Dict_GetItem(__pyx_v_meta, __pyx_mstate_global->__pyx_n_u_value_format_fields); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 222, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = 1; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_8); assert(__pyx_t_3); PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(__pyx__function); __Pyx_DECREF_SET(__pyx_t_8, __pyx__function); __pyx_t_5 = 0; } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_2, __pyx_t_4}; __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_8, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 222, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } __pyx_v_value_format_t = __pyx_t_1; __pyx_t_1 = 0; /* "borghash/HashTableNT.pyx":223 * value_type = namedtuple(meta['value_type_name'], meta['value_type_fields']) * value_format_t = namedtuple(meta['value_format_name'], meta['value_format_fields']) * value_format = value_format_t(*meta['value_format']) # <<<<<<<<<<<<<< * ht = cls(key_size=meta['key_size'], value_format=value_format, value_type=value_type, * capacity=meta['capacity'], byte_order=meta['byte_order']) */ __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_v_meta, __pyx_mstate_global->__pyx_n_u_value_format); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 223, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_8 = __Pyx_PySequence_Tuple(__pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 223, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_v_value_format_t, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 223, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_value_format = __pyx_t_1; __pyx_t_1 = 0; /* "borghash/HashTableNT.pyx":224 * value_format_t = namedtuple(meta['value_format_name'], meta['value_format_fields']) * value_format = value_format_t(*meta['value_format']) * ht = cls(key_size=meta['key_size'], value_format=value_format, value_type=value_type, # <<<<<<<<<<<<<< * capacity=meta['capacity'], byte_order=meta['byte_order']) * count = 0 */ __pyx_t_8 = NULL; __pyx_t_4 = __Pyx_PyObject_Dict_GetItem(__pyx_v_meta, __pyx_mstate_global->__pyx_n_u_key_size); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 224, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); /* "borghash/HashTableNT.pyx":225 * value_format = value_format_t(*meta['value_format']) * ht = cls(key_size=meta['key_size'], value_format=value_format, value_type=value_type, * capacity=meta['capacity'], byte_order=meta['byte_order']) # <<<<<<<<<<<<<< * count = 0 * ksize, vsize = meta['key_size'], meta['value_size'] */ __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_v_meta, __pyx_mstate_global->__pyx_n_u_capacity); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 225, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_meta, __pyx_mstate_global->__pyx_n_u_byte_order); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 225, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = 1; { PyObject *__pyx_callargs[6] = {__pyx_t_8, __pyx_t_4, __pyx_v_value_format, __pyx_v_value_type, __pyx_t_2, __pyx_t_3}; #if CYTHON_VECTORCALL __pyx_t_12 = __pyx_mstate_global->__pyx_tuple[3]; if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 224, __pyx_L1_error) __Pyx_INCREF(__pyx_t_12); #else { PyObject *__pyx_temp[5] = {__pyx_mstate_global->__pyx_n_u_key_size, __pyx_mstate_global->__pyx_n_u_value_format, __pyx_mstate_global->__pyx_n_u_value_type, __pyx_mstate_global->__pyx_n_u_capacity, __pyx_mstate_global->__pyx_n_u_byte_order}; __pyx_t_12 = __Pyx_MakeKwargDict(__pyx_temp, __pyx_callargs+1, 5); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 224, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_12); } #endif __pyx_t_1 = __Pyx_Object_VectorcallKwds((PyObject*)__pyx_v_cls, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_12); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 224, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } __pyx_v_ht = __pyx_t_1; __pyx_t_1 = 0; /* "borghash/HashTableNT.pyx":226 * ht = cls(key_size=meta['key_size'], value_format=value_format, value_type=value_type, * capacity=meta['capacity'], byte_order=meta['byte_order']) * count = 0 # <<<<<<<<<<<<<< * ksize, vsize = meta['key_size'], meta['value_size'] * for i in range(meta['used']): */ __pyx_v_count = 0; /* "borghash/HashTableNT.pyx":227 * capacity=meta['capacity'], byte_order=meta['byte_order']) * count = 0 * ksize, vsize = meta['key_size'], meta['value_size'] # <<<<<<<<<<<<<< * for i in range(meta['used']): * key = fd.read(ksize) */ __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_v_meta, __pyx_mstate_global->__pyx_n_u_key_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 227, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_12 = __Pyx_PyObject_Dict_GetItem(__pyx_v_meta, __pyx_mstate_global->__pyx_n_u_value_size); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 227, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_12); __pyx_v_ksize = __pyx_t_1; __pyx_t_1 = 0; __pyx_v_vsize = __pyx_t_12; __pyx_t_12 = 0; /* "borghash/HashTableNT.pyx":228 * count = 0 * ksize, vsize = meta['key_size'], meta['value_size'] * for i in range(meta['used']): # <<<<<<<<<<<<<< * key = fd.read(ksize) * value = fd.read(vsize) */ __pyx_t_1 = NULL; __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_meta, __pyx_mstate_global->__pyx_n_u_used); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 228, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_3}; __pyx_t_12 = __Pyx_PyObject_FastCall((PyObject*)(&PyRange_Type), __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 228, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_12); } __pyx_t_3 = PyObject_GetIter(__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 228, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_13 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 228, __pyx_L1_error) __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; for (;;) { { __pyx_t_12 = __pyx_t_13(__pyx_t_3); if (unlikely(!__pyx_t_12)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 228, __pyx_L1_error) PyErr_Clear(); } break; } } __Pyx_GOTREF(__pyx_t_12); __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_12); __pyx_t_12 = 0; /* "borghash/HashTableNT.pyx":229 * ksize, vsize = meta['key_size'], meta['value_size'] * for i in range(meta['used']): * key = fd.read(ksize) # <<<<<<<<<<<<<< * value = fd.read(vsize) * ht._set_raw(key, value) */ __pyx_t_1 = __pyx_v_fd; __Pyx_INCREF(__pyx_t_1); __pyx_t_5 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_v_ksize}; __pyx_t_12 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_read, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 229, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_12); } __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_12); __pyx_t_12 = 0; /* "borghash/HashTableNT.pyx":230 * for i in range(meta['used']): * key = fd.read(ksize) * value = fd.read(vsize) # <<<<<<<<<<<<<< * ht._set_raw(key, value) * return ht */ __pyx_t_1 = __pyx_v_fd; __Pyx_INCREF(__pyx_t_1); __pyx_t_5 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_v_vsize}; __pyx_t_12 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_read, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 230, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_12); } __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_12); __pyx_t_12 = 0; /* "borghash/HashTableNT.pyx":231 * key = fd.read(ksize) * value = fd.read(vsize) * ht._set_raw(key, value) # <<<<<<<<<<<<<< * return ht * */ __pyx_t_1 = __pyx_v_ht; __Pyx_INCREF(__pyx_t_1); __pyx_t_5 = 0; { PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_v_key, __pyx_v_value}; __pyx_t_12 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_set_raw, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 231, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_12); } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; /* "borghash/HashTableNT.pyx":228 * count = 0 * ksize, vsize = meta['key_size'], meta['value_size'] * for i in range(meta['used']): # <<<<<<<<<<<<<< * key = fd.read(ksize) * value = fd.read(vsize) */ } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "borghash/HashTableNT.pyx":232 * value = fd.read(vsize) * ht._set_raw(key, value) * return ht # <<<<<<<<<<<<<< * * def size(self) -> int: */ { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __Pyx_INCREF(__pyx_v_ht); __pyx_r = __pyx_v_ht; } __Pyx_XDECREF(__pyx_temp); } goto __pyx_L0; /* "borghash/HashTableNT.pyx":206 * return cls._read_fd(file) * * @classmethod # <<<<<<<<<<<<<< * def _read_fd(cls, fd: BinaryIO): * header_size = struct.calcsize(HEADER_FMT) */ /* 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_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT._read_fd", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_header_size); __Pyx_XDECREF(__pyx_v_header_bytes); __Pyx_XDECREF(__pyx_v_magic); __Pyx_XDECREF(__pyx_v_version); __Pyx_XDECREF(__pyx_v_meta_size); __Pyx_XDECREF(__pyx_v_meta_bytes); __Pyx_XDECREF(__pyx_v_meta); __Pyx_XDECREF(__pyx_v_value_type); __Pyx_XDECREF(__pyx_v_value_format_t); __Pyx_XDECREF(__pyx_v_value_format); __Pyx_XDECREF(__pyx_v_ht); __Pyx_XDECREF(__pyx_v_ksize); __Pyx_XDECREF(__pyx_v_vsize); __Pyx_XDECREF(__pyx_v_i); __Pyx_XDECREF(__pyx_v_key); __Pyx_XDECREF(__pyx_v_value); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "borghash/HashTableNT.pyx":234 * return ht * * def size(self) -> int: # <<<<<<<<<<<<<< * """ * Do a rough worst-case estimate of the on-disk size when using .write(). */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_52size(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_8borghash_11HashTableNT_11HashTableNT_51size, "\n Do a rough worst-case estimate of the on-disk size when using .write().\n\n The serialized size of the metadata is a bit hard to predict, but we cover that with one_time_overheads.\n "); static PyMethodDef __pyx_mdef_8borghash_11HashTableNT_11HashTableNT_52size = {"size", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_52size, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8borghash_11HashTableNT_11HashTableNT_51size}; static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_52size(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { #if !CYTHON_VECTORCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("size (wrapper)", 0); #if !CYTHON_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("size", 1, 0, 0, __pyx_nargs); return NULL; } const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) return NULL; if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("size", __pyx_kwds); return NULL;} __pyx_r = __pyx_pf_8borghash_11HashTableNT_11HashTableNT_51size(((struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_51size(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self) { PyObject *__pyx_v_one_time_overheads = NULL; PyObject *__pyx_v_N = NULL; PyObject *__pyx_r = NULL; __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("size", 0); /* "borghash/HashTableNT.pyx":240 * The serialized size of the metadata is a bit hard to predict, but we cover that with one_time_overheads. * """ * one_time_overheads = 4096 # very rough # <<<<<<<<<<<<<< * N = self.inner.used * return int(N * (self.key_size + self.value_size) + one_time_overheads) */ __Pyx_INCREF(__pyx_mstate_global->__pyx_int_4096); __pyx_v_one_time_overheads = __pyx_mstate_global->__pyx_int_4096; /* "borghash/HashTableNT.pyx":241 * """ * one_time_overheads = 4096 # very rough * N = self.inner.used # <<<<<<<<<<<<<< * return int(N * (self.key_size + self.value_size) + one_time_overheads) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->inner, __pyx_mstate_global->__pyx_n_u_used); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 241, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_N = __pyx_t_1; __pyx_t_1 = 0; /* "borghash/HashTableNT.pyx":242 * one_time_overheads = 4096 # very rough * N = self.inner.used * return int(N * (self.key_size + self.value_size) + one_time_overheads) # <<<<<<<<<<<<<< */ __pyx_t_1 = __Pyx_PyLong_From_int((__pyx_v_self->key_size + __pyx_v_self->value_size)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyNumber_Multiply_object_int(__pyx_v_N, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 242, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyNumber_Add_object_int(__pyx_t_2, __pyx_v_one_time_overheads); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyNumber_Int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 242, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __pyx_r = ((PyObject*)__pyx_t_2); } __Pyx_XDECREF(__pyx_temp); } __pyx_t_2 = 0; goto __pyx_L0; /* "borghash/HashTableNT.pyx":234 * return ht * * def size(self) -> int: # <<<<<<<<<<<<<< * """ * Do a rough worst-case estimate of the on-disk size when using .write(). */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.size", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_one_time_overheads); __Pyx_XDECREF(__pyx_v_N); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * cdef tuple state * cdef object _dict */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_54__reduce_cython__(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_8borghash_11HashTableNT_11HashTableNT_54__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_54__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_54__reduce_cython__(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { #if !CYTHON_VECTORCALL 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_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; } const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) return NULL; if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;} __pyx_r = __pyx_pf_8borghash_11HashTableNT_11HashTableNT_53__reduce_cython__(((struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_53__reduce_cython__(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self) { PyObject *__pyx_v_state = 0; PyObject *__pyx_v__dict = 0; int __pyx_v_use_setstate; PyObject *__pyx_r = NULL; __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_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":5 * cdef object _dict * cdef bint use_setstate * with CRITICAL_SECTION(self): # <<<<<<<<<<<<<< * state = (self.byte_order, self.inner, self.key_size, self.value_format, self.value_size, self.value_struct, self.value_type) * _dict = getattr(self, '__dict__', None) */ { __Pyx_PyCriticalSection __pyx_cs; __pyx_t_1 = ((PyObject *)__pyx_v_self); __Pyx_INCREF(__pyx_t_1); __Pyx_PyCriticalSection_Begin(&__pyx_cs, (PyObject*)__pyx_t_1); /*try:*/ { /* "(tree fragment)":6 * cdef bint use_setstate * with CRITICAL_SECTION(self): * state = (self.byte_order, self.inner, self.key_size, self.value_format, self.value_size, self.value_struct, self.value_type) # <<<<<<<<<<<<<< * _dict = getattr(self, '__dict__', None) * if _dict is not None and _dict: */ __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_self->key_size); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 6, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_self->value_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyTuple_New(7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 6, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_v_self->byte_order); __Pyx_GIVEREF(__pyx_v_self->byte_order); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_self->byte_order) != (0)) __PYX_ERR(1, 6, __pyx_L4_error); __Pyx_INCREF(__pyx_v_self->inner); __Pyx_GIVEREF(__pyx_v_self->inner); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_self->inner) != (0)) __PYX_ERR(1, 6, __pyx_L4_error); __Pyx_GIVEREF(__pyx_t_2); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_2) != (0)) __PYX_ERR(1, 6, __pyx_L4_error); __Pyx_INCREF(__pyx_v_self->value_format); __Pyx_GIVEREF(__pyx_v_self->value_format); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_v_self->value_format) != (0)) __PYX_ERR(1, 6, __pyx_L4_error); __Pyx_GIVEREF(__pyx_t_3); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 4, __pyx_t_3) != (0)) __PYX_ERR(1, 6, __pyx_L4_error); __Pyx_INCREF(__pyx_v_self->value_struct); __Pyx_GIVEREF(__pyx_v_self->value_struct); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 5, __pyx_v_self->value_struct) != (0)) __PYX_ERR(1, 6, __pyx_L4_error); __Pyx_INCREF(__pyx_v_self->value_type); __Pyx_GIVEREF(__pyx_v_self->value_type); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 6, __pyx_v_self->value_type) != (0)) __PYX_ERR(1, 6, __pyx_L4_error); __pyx_t_2 = 0; __pyx_t_3 = 0; __pyx_v_state = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; /* "(tree fragment)":7 * with CRITICAL_SECTION(self): * state = (self.byte_order, self.inner, self.key_size, self.value_format, self.value_size, self.value_struct, self.value_type) * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< * if _dict is not None and _dict: * state += (_dict,) */ __pyx_t_4 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_dict, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 7, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v__dict = __pyx_t_4; __pyx_t_4 = 0; } /* "(tree fragment)":5 * cdef object _dict * cdef bint use_setstate * with CRITICAL_SECTION(self): # <<<<<<<<<<<<<< * state = (self.byte_order, self.inner, self.key_size, self.value_format, self.value_size, self.value_struct, self.value_type) * _dict = getattr(self, '__dict__', None) */ /*finally:*/ { /*normal exit:*/{ __Pyx_PyCriticalSection_End(&__pyx_cs); goto __pyx_L5; } __pyx_L4_error: { __Pyx_PyCriticalSection_End(&__pyx_cs); goto __pyx_L1_error; } __pyx_L5:; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } /* "(tree fragment)":8 * state = (self.byte_order, self.inner, self.key_size, self.value_format, self.value_size, self.value_struct, self.value_type) * _dict = getattr(self, '__dict__', None) * if _dict is not None and _dict: # <<<<<<<<<<<<<< * state += (_dict,) * use_setstate = True */ __pyx_t_6 = (__pyx_v__dict != Py_None); if (__pyx_t_6) { } else { __pyx_t_5 = __pyx_t_6; goto __pyx_L7_bool_binop_done; } __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_v__dict); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(1, 8, __pyx_L1_error) __pyx_t_5 = __pyx_t_6; __pyx_L7_bool_binop_done:; if (__pyx_t_5) { /* "(tree fragment)":9 * _dict = getattr(self, '__dict__', None) * if _dict is not None and _dict: * state += (_dict,) # <<<<<<<<<<<<<< * use_setstate = True * else: */ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_v__dict); __Pyx_GIVEREF(__pyx_v__dict); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict) != (0)) __PYX_ERR(1, 9, __pyx_L1_error); __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4)); __pyx_t_4 = 0; /* "(tree fragment)":10 * if _dict is not None and _dict: * state += (_dict,) * use_setstate = True # <<<<<<<<<<<<<< * else: * use_setstate = self.byte_order is not None or self.inner is not None or self.value_format is not None or self.value_struct is not None or self.value_type is not None */ __pyx_v_use_setstate = 1; /* "(tree fragment)":8 * state = (self.byte_order, self.inner, self.key_size, self.value_format, self.value_size, self.value_struct, self.value_type) * _dict = getattr(self, '__dict__', None) * if _dict is not None and _dict: # <<<<<<<<<<<<<< * state += (_dict,) * use_setstate = True */ goto __pyx_L6; } /* "(tree fragment)":12 * use_setstate = True * else: * use_setstate = self.byte_order is not None or self.inner is not None or self.value_format is not None or self.value_struct is not None or self.value_type is not None # <<<<<<<<<<<<<< * if use_setstate: * return __pyx_unpickle_HashTableNT, (type(self), 0xb78e9ae, None), state */ /*else*/ { __pyx_t_6 = (__pyx_v_self->byte_order != Py_None); if (!__pyx_t_6) { } else { __pyx_t_5 = __pyx_t_6; goto __pyx_L9_bool_binop_done; } __pyx_t_6 = (__pyx_v_self->inner != Py_None); if (!__pyx_t_6) { } else { __pyx_t_5 = __pyx_t_6; goto __pyx_L9_bool_binop_done; } __pyx_t_6 = (__pyx_v_self->value_format != Py_None); if (!__pyx_t_6) { } else { __pyx_t_5 = __pyx_t_6; goto __pyx_L9_bool_binop_done; } __pyx_t_6 = (__pyx_v_self->value_struct != Py_None); if (!__pyx_t_6) { } else { __pyx_t_5 = __pyx_t_6; goto __pyx_L9_bool_binop_done; } __pyx_t_6 = (__pyx_v_self->value_type != Py_None); __pyx_t_5 = __pyx_t_6; __pyx_L9_bool_binop_done:; __pyx_v_use_setstate = __pyx_t_5; } __pyx_L6:; /* "(tree fragment)":13 * else: * use_setstate = self.byte_order is not None or self.inner is not None or self.value_format is not None or self.value_struct is not None or self.value_type is not None * if use_setstate: # <<<<<<<<<<<<<< * return __pyx_unpickle_HashTableNT, (type(self), 0xb78e9ae, None), state * else: */ if (__pyx_v_use_setstate) { /* "(tree fragment)":14 * use_setstate = self.byte_order is not None or self.inner is not None or self.value_format is not None or self.value_struct is not None or self.value_type is not None * if use_setstate: * return __pyx_unpickle_HashTableNT, (type(self), 0xb78e9ae, None), state # <<<<<<<<<<<<<< * else: * return __pyx_unpickle_HashTableNT, (type(self), 0xb78e9ae, state) */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_HashTableNT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 14, __pyx_L1_error); __Pyx_INCREF(__pyx_mstate_global->__pyx_int_192473518); __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_192473518); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_mstate_global->__pyx_int_192473518) != (0)) __PYX_ERR(1, 14, __pyx_L1_error); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None) != (0)) __PYX_ERR(1, 14, __pyx_L1_error); __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4) != (0)) __PYX_ERR(1, 14, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1) != (0)) __PYX_ERR(1, 14, __pyx_L1_error); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 14, __pyx_L1_error); __pyx_t_4 = 0; __pyx_t_1 = 0; { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __pyx_r = __pyx_t_3; } __Pyx_XDECREF(__pyx_temp); } __pyx_t_3 = 0; goto __pyx_L0; /* "(tree fragment)":13 * else: * use_setstate = self.byte_order is not None or self.inner is not None or self.value_format is not None or self.value_struct is not None or self.value_type is not None * if use_setstate: # <<<<<<<<<<<<<< * return __pyx_unpickle_HashTableNT, (type(self), 0xb78e9ae, None), state * else: */ } /* "(tree fragment)":16 * return __pyx_unpickle_HashTableNT, (type(self), 0xb78e9ae, None), state * else: * return __pyx_unpickle_HashTableNT, (type(self), 0xb78e9ae, state) # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle_HashTableNT__set_state(self, __pyx_state) */ /*else*/ { __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_HashTableNT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 16, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 16, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 16, __pyx_L1_error); __Pyx_INCREF(__pyx_mstate_global->__pyx_int_192473518); __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_192473518); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_mstate_global->__pyx_int_192473518) != (0)) __PYX_ERR(1, 16, __pyx_L1_error); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 16, __pyx_L1_error); __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 16, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_3); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3) != (0)) __PYX_ERR(1, 16, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1) != (0)) __PYX_ERR(1, 16, __pyx_L1_error); __pyx_t_3 = 0; __pyx_t_1 = 0; { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __pyx_r = __pyx_t_4; } __Pyx_XDECREF(__pyx_temp); } __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_AddTraceback("borghash.HashTableNT.HashTableNT.__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_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":17 * else: * return __pyx_unpickle_HashTableNT, (type(self), 0xb78e9ae, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_HashTableNT__set_state(self, __pyx_state) */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_56__setstate_cython__(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_8borghash_11HashTableNT_11HashTableNT_56__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_56__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_8borghash_11HashTableNT_11HashTableNT_56__setstate_cython__(PyObject *__pyx_v_self, #if CYTHON_VECTORCALL 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_VECTORCALL 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_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 17, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 17, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__setstate_cython__", 0) < (0)) __PYX_ERR(1, 17, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 17, __pyx_L3_error) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 17, __pyx_L3_error) } __pyx_v___pyx_state = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 17, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8borghash_11HashTableNT_11HashTableNT_55__setstate_cython__(((struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_11HashTableNT_11HashTableNT_55__setstate_cython__(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __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("__setstate_cython__", 0); /* "(tree fragment)":18 * return __pyx_unpickle_HashTableNT, (type(self), 0xb78e9ae, state) * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle_HashTableNT__set_state(self, __pyx_state) # <<<<<<<<<<<<<< */ __pyx_t_1 = __pyx_v___pyx_state; __Pyx_INCREF(__pyx_t_1); if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_t_1))) __PYX_ERR(1, 18, __pyx_L1_error) if (unlikely(__pyx_t_1 == Py_None)) { PyErr_SetString(PyExc_TypeError, "cannot pass None into a C function argument that is declared \047not None\047"); __PYX_ERR(1, 18, __pyx_L1_error) } __pyx_t_2 = __pyx_f_8borghash_11HashTableNT___pyx_unpickle_HashTableNT__set_state(__pyx_v_self, ((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 18, __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; /* "(tree fragment)":17 * else: * return __pyx_unpickle_HashTableNT, (type(self), 0xb78e9ae, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_HashTableNT__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_XDECREF(__pyx_t_2); __Pyx_AddTraceback("borghash.HashTableNT.HashTableNT.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":4 * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 * def __pyx_unpickle_HashTableNT(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_result * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0xb78e9ae, 0x9612968, 0xfd3bc11, b'byte_order, inner, key_size, value_format, value_size, value_struct, value_type') */ /* Python wrapper */ static PyObject *__pyx_pw_8borghash_11HashTableNT_1__pyx_unpickle_HashTableNT(PyObject *__pyx_self, #if CYTHON_VECTORCALL 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_8borghash_11HashTableNT_1__pyx_unpickle_HashTableNT = {"__pyx_unpickle_HashTableNT", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_1__pyx_unpickle_HashTableNT, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_8borghash_11HashTableNT_1__pyx_unpickle_HashTableNT(PyObject *__pyx_self, #if CYTHON_VECTORCALL 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_VECTORCALL 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_HashTableNT (wrapper)", 0); #if !CYTHON_VECTORCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_type,&__pyx_mstate_global->__pyx_n_u_pyx_checksum,&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 4, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 4, __pyx_L3_error) CYTHON_FALLTHROUGH; case 2: values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 4, __pyx_L3_error) CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 4, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__pyx_unpickle_HashTableNT", 0) < (0)) __PYX_ERR(1, 4, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_HashTableNT", 1, 3, 3, i); __PYX_ERR(1, 4, __pyx_L3_error) } } } else if (unlikely(__pyx_nargs != 3)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 4, __pyx_L3_error) values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 4, __pyx_L3_error) values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 4, __pyx_L3_error) } __pyx_v___pyx_type = values[0]; __pyx_v___pyx_checksum = __Pyx_PyLong_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 4, __pyx_L3_error) __pyx_v___pyx_state = ((PyObject*)values[2]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_HashTableNT", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 4, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("borghash.HashTableNT.__pyx_unpickle_HashTableNT", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v___pyx_state), (&PyTuple_Type), 1, "__pyx_state", 1))) __PYX_ERR(1, 4, __pyx_L1_error) __pyx_r = __pyx_pf_8borghash_11HashTableNT___pyx_unpickle_HashTableNT(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } goto __pyx_L7_cleaned_up; __pyx_L0:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8borghash_11HashTableNT___pyx_unpickle_HashTableNT(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_v___pyx_result = 0; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; size_t __pyx_t_4; int __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_unpickle_HashTableNT", 0); /* "(tree fragment)":6 * def __pyx_unpickle_HashTableNT(__pyx_type, long __pyx_checksum, tuple __pyx_state): * cdef object __pyx_result * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0xb78e9ae, 0x9612968, 0xfd3bc11, b'byte_order, inner, key_size, value_format, value_size, value_struct, value_type') # <<<<<<<<<<<<<< * __pyx_result = HashTableNT.__new__(__pyx_type) * if __pyx_state is not None: */ __pyx_t_1 = __Pyx_CheckUnpickleChecksum(__pyx_v___pyx_checksum, 0xb78e9ae, 0x9612968, 0xfd3bc11, __pyx_k_byte_order_inner_key_size_value); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(1, 6, __pyx_L1_error) /* "(tree fragment)":7 * cdef object __pyx_result * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0xb78e9ae, 0x9612968, 0xfd3bc11, b'byte_order, inner, key_size, value_format, value_size, value_struct, value_type') * __pyx_result = HashTableNT.__new__(__pyx_type) # <<<<<<<<<<<<<< * if __pyx_state is not None: * __pyx_unpickle_HashTableNT__set_state( __pyx_result, __pyx_state) */ __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT_HashTableNT); __Pyx_INCREF(__pyx_t_3); __pyx_t_4 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v___pyx_type}; __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_new, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); } __pyx_v___pyx_result = __pyx_t_2; __pyx_t_2 = 0; /* "(tree fragment)":8 * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0xb78e9ae, 0x9612968, 0xfd3bc11, b'byte_order, inner, key_size, value_format, value_size, value_struct, value_type') * __pyx_result = HashTableNT.__new__(__pyx_type) * if __pyx_state is not None: # <<<<<<<<<<<<<< * __pyx_unpickle_HashTableNT__set_state( __pyx_result, __pyx_state) * return __pyx_result */ __pyx_t_5 = (__pyx_v___pyx_state != ((PyObject*)Py_None)); if (__pyx_t_5) { /* "(tree fragment)":9 * __pyx_result = HashTableNT.__new__(__pyx_type) * if __pyx_state is not None: * __pyx_unpickle_HashTableNT__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< * return __pyx_result * cdef __pyx_unpickle_HashTableNT__set_state(HashTableNT __pyx_result, __pyx_state: tuple): */ if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "cannot pass None into a C function argument that is declared \047not None\047"); __PYX_ERR(1, 9, __pyx_L1_error) } __pyx_t_2 = __pyx_f_8borghash_11HashTableNT___pyx_unpickle_HashTableNT__set_state(((struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)__pyx_v___pyx_result), __pyx_v___pyx_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "(tree fragment)":8 * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0xb78e9ae, 0x9612968, 0xfd3bc11, b'byte_order, inner, key_size, value_format, value_size, value_struct, value_type') * __pyx_result = HashTableNT.__new__(__pyx_type) * if __pyx_state is not None: # <<<<<<<<<<<<<< * __pyx_unpickle_HashTableNT__set_state( __pyx_result, __pyx_state) * return __pyx_result */ } /* "(tree fragment)":10 * if __pyx_state is not None: * __pyx_unpickle_HashTableNT__set_state( __pyx_result, __pyx_state) * return __pyx_result # <<<<<<<<<<<<<< * cdef __pyx_unpickle_HashTableNT__set_state(HashTableNT __pyx_result, __pyx_state: tuple): * __pyx_result.byte_order = __pyx_state[0]; __pyx_result.inner = __pyx_state[1]; __pyx_result.key_size = __pyx_state[2]; __pyx_result.value_format = __pyx_state[3]; __pyx_result.value_size = __pyx_state[4]; __pyx_result.value_struct = __pyx_state[5]; __pyx_result.value_type = __pyx_state[6] */ { PyObject *__pyx_temp; { __pyx_temp = __pyx_r; __Pyx_INCREF(__pyx_v___pyx_result); __pyx_r = __pyx_v___pyx_result; } __Pyx_XDECREF(__pyx_temp); } goto __pyx_L0; /* "(tree fragment)":4 * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 * def __pyx_unpickle_HashTableNT(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_result * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0xb78e9ae, 0x9612968, 0xfd3bc11, b'byte_order, inner, key_size, value_format, value_size, value_struct, value_type') */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("borghash.HashTableNT.__pyx_unpickle_HashTableNT", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v___pyx_result); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":11 * __pyx_unpickle_HashTableNT__set_state( __pyx_result, __pyx_state) * return __pyx_result * cdef __pyx_unpickle_HashTableNT__set_state(HashTableNT __pyx_result, __pyx_state: tuple): # <<<<<<<<<<<<<< * __pyx_result.byte_order = __pyx_state[0]; __pyx_result.inner = __pyx_state[1]; __pyx_result.key_size = __pyx_state[2]; __pyx_result.value_format = __pyx_state[3]; __pyx_result.value_size = __pyx_state[4]; __pyx_result.value_struct = __pyx_state[5]; __pyx_result.value_type = __pyx_state[6] * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 7) */ static PyObject *__pyx_f_8borghash_11HashTableNT___pyx_unpickle_HashTableNT__set_state(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __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("__pyx_unpickle_HashTableNT__set_state", 0); /* "(tree fragment)":12 * return __pyx_result * cdef __pyx_unpickle_HashTableNT__set_state(HashTableNT __pyx_result, __pyx_state: tuple): * __pyx_result.byte_order = __pyx_state[0]; __pyx_result.inner = __pyx_state[1]; __pyx_result.key_size = __pyx_state[2]; __pyx_result.value_format = __pyx_state[3]; __pyx_result.value_size = __pyx_state[4]; __pyx_result.value_struct = __pyx_state[5]; __pyx_result.value_type = __pyx_state[6] # <<<<<<<<<<<<<< * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 7) */ __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v___pyx_result->byte_order); __Pyx_DECREF(__pyx_v___pyx_result->byte_order); __pyx_v___pyx_result->byte_order = __pyx_t_1; __pyx_t_1 = 0; __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v___pyx_result->inner); __Pyx_DECREF(__pyx_v___pyx_result->inner); __pyx_v___pyx_result->inner = __pyx_t_1; __pyx_t_1 = 0; __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result->key_size = __pyx_t_2; __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v___pyx_result->value_format); __Pyx_DECREF(__pyx_v___pyx_result->value_format); __pyx_v___pyx_result->value_format = __pyx_t_1; __pyx_t_1 = 0; __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 4, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result->value_size = __pyx_t_2; __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 5, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v___pyx_result->value_struct); __Pyx_DECREF(__pyx_v___pyx_result->value_struct); __pyx_v___pyx_result->value_struct = __pyx_t_1; __pyx_t_1 = 0; __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 6, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v___pyx_result->value_type); __Pyx_DECREF(__pyx_v___pyx_result->value_type); __pyx_v___pyx_result->value_type = __pyx_t_1; __pyx_t_1 = 0; /* "(tree fragment)":13 * cdef __pyx_unpickle_HashTableNT__set_state(HashTableNT __pyx_result, __pyx_state: tuple): * __pyx_result.byte_order = __pyx_state[0]; __pyx_result.inner = __pyx_state[1]; __pyx_result.key_size = __pyx_state[2]; __pyx_result.value_format = __pyx_state[3]; __pyx_result.value_size = __pyx_state[4]; __pyx_result.value_struct = __pyx_state[5]; __pyx_result.value_type = __pyx_state[6] * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 7) # <<<<<<<<<<<<<< */ __pyx_t_2 = __Pyx_UpdateUnpickledDict(((PyObject *)__pyx_v___pyx_result), __pyx_v___pyx_state, 7); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) /* "(tree fragment)":11 * __pyx_unpickle_HashTableNT__set_state( __pyx_result, __pyx_state) * return __pyx_result * cdef __pyx_unpickle_HashTableNT__set_state(HashTableNT __pyx_result, __pyx_state: tuple): # <<<<<<<<<<<<<< * __pyx_result.byte_order = __pyx_state[0]; __pyx_result.inner = __pyx_state[1]; __pyx_result.key_size = __pyx_state[2]; __pyx_result.value_format = __pyx_state[3]; __pyx_result.value_size = __pyx_state[4]; __pyx_result.value_struct = __pyx_state[5]; __pyx_result.value_type = __pyx_state[6] * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 7) */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("borghash.HashTableNT.__pyx_unpickle_HashTableNT__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* #### Code section: module_exttypes ### */ static PyObject *__pyx_tp_new__initialisation_8borghash_11HashTableNT_HashTableNT(PyObject *o, #if CYTHON_VECTORCALL_TPNEW CYTHON_UNUSED PyObject *const *args, CYTHON_UNUSED Py_ssize_t nargs, CYTHON_UNUSED PyObject *kwnames #else CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k #endif ) { struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *p = ((struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)o); p->byte_order = Py_None; Py_INCREF(Py_None); p->value_type = Py_None; Py_INCREF(Py_None); p->value_format = Py_None; Py_INCREF(Py_None); p->value_struct = Py_None; Py_INCREF(Py_None); p->inner = Py_None; Py_INCREF(Py_None); return o; } static PyObject *__pyx_tp_new_vectorcall_8borghash_11HashTableNT_HashTableNT(PyTypeObject *t, #if CYTHON_VECTORCALL_TPNEW PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames #else PyObject *a, PyObject *k #endif ) { PyObject *o; o = __Pyx_AllocateExtensionType(t, 0); if (unlikely(!o)) return 0; return __pyx_tp_new__initialisation_8borghash_11HashTableNT_HashTableNT(o, #if CYTHON_VECTORCALL_TPNEW args, nargs, kwnames #else a, k #endif ); } #if CYTHON_VECTORCALL_TPNEW static PyObject *__pyx_tp_new_8borghash_11HashTableNT_HashTableNT(PyTypeObject *t, PyObject *a, PyObject *k) { return __Pyx_CallTpnewAsVectorcall(__pyx_tp_new_vectorcall_8borghash_11HashTableNT_HashTableNT, t, a, k); } #endif #if CYTHON_VECTORCALL_TPNEW static PyObject *__pyx_tp_vectorcall_8borghash_11HashTableNT_HashTableNT(PyObject *t, PyObject *const *args, size_t nargsf, PyObject *kwnames) { if (unlikely((PyTypeObject*)t != __pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT_HashTableNT || __Pyx_PyType_HasFeature((PyTypeObject*)t, Py_TPFLAGS_IS_ABSTRACT))) { return __Pyx_CallNewInitFromVectorcall((PyTypeObject*)t, args, nargsf, kwnames); } Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); PyObject *o = __pyx_tp_new_vectorcall_8borghash_11HashTableNT_HashTableNT((PyTypeObject*)t, args, nargs, kwnames); if (likely(o)) { assert(Py_TYPE(o) == (PyTypeObject*)t); if (unlikely(__pyx_pw_8borghash_11HashTableNT_11HashTableNT_1__init__(o, args, nargs, kwnames) < 0)) { Py_CLEAR(o); } } return o; } #endif #if CYTHON_VECTORCALL_TPNEW static int __pyx_tp_init_8borghash_11HashTableNT_HashTableNT(PyObject *o, PyObject *args, PyObject *kwds) { return __Pyx_CallTpinitAsVectorcall(__pyx_pw_8borghash_11HashTableNT_11HashTableNT_1__init__, o, args, kwds); } #endif static void __pyx_tp_dealloc_8borghash_11HashTableNT_HashTableNT(PyObject *o) { struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *p = (struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_8borghash_11HashTableNT_HashTableNT) { if (PyObject_CallFinalizerFromDealloc(o)) return; } } #endif PyObject_GC_UnTrack(o); Py_CLEAR(p->byte_order); Py_CLEAR(p->value_type); Py_CLEAR(p->value_format); Py_CLEAR(p->value_struct); Py_CLEAR(p->inner); PyTypeObject *tp = Py_TYPE(o); #if CYTHON_USE_TYPE_SLOTS (*tp->tp_free)(o); #else { freefunc tp_free = (freefunc)PyType_GetSlot(tp, Py_tp_free); if (tp_free) tp_free(o); } #endif #if CYTHON_USE_TYPE_SPECS Py_DECREF(tp); #endif } static int __pyx_tp_traverse_8borghash_11HashTableNT_HashTableNT(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *p = (struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)o; { e = __Pyx_call_type_traverse(o, 1, v, a); if (e) return e; } if (p->byte_order) { e = (*v)(p->byte_order, a); if (e) return e; } if (p->value_type) { e = (*v)(p->value_type, a); if (e) return e; } if (p->value_format) { e = (*v)(p->value_format, a); if (e) return e; } if (p->value_struct) { e = (*v)(p->value_struct, a); if (e) return e; } if (p->inner) { e = (*v)(p->inner, a); if (e) return e; } return 0; } static int __pyx_tp_clear_8borghash_11HashTableNT_HashTableNT(PyObject *o) { PyObject* tmp; struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *p = (struct __pyx_obj_8borghash_11HashTableNT_HashTableNT *)o; tmp = ((PyObject*)p->byte_order); p->byte_order = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->value_type); p->value_type = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->value_format); p->value_format = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->value_struct); p->value_struct = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->inner); p->inner = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); return 0; } static PyObject *__pyx_sq_item_8borghash_11HashTableNT_HashTableNT(PyObject *o, Py_ssize_t i) { PyObject *r; PyObject *x = PyLong_FromSsize_t(i); if (unlikely(!x)) return NULL; #if CYTHON_USE_TYPE_SLOTS || (!CYTHON_USE_TYPE_SPECS && __PYX_LIMITED_VERSION_HEX < 0x030A0000) binaryfunc f = Py_TYPE(o)->tp_as_mapping->mp_subscript; #else binaryfunc f = ((binaryfunc)PyType_GetSlot(Py_TYPE(o), Py_mp_subscript)); #endif r = f(o, x); Py_DECREF(x); return r; } static PyObject *__pyx_mp_subscript_8borghash_11HashTableNT_HashTableNT(PyObject *o, PyObject *i) { return __pyx_pw_8borghash_11HashTableNT_11HashTableNT_17__getitem__(o, i); } static int __pyx_sq_ass_item_8borghash_11HashTableNT_HashTableNT(PyObject *o, Py_ssize_t i, PyObject *v) { if (v) { PyObject *x = PyLong_FromSsize_t(i); if (unlikely(!x)) return -1; int r = __pyx_pw_8borghash_11HashTableNT_11HashTableNT_15__setitem__(o, x, v); Py_DECREF(x); return r; } else { PyObject *x = PyLong_FromSsize_t(i); if (unlikely(!x)) return -1; int r = __pyx_pw_8borghash_11HashTableNT_11HashTableNT_19__delitem__(o, x); Py_DECREF(x); return r; } } static int __pyx_mp_ass_subscript_8borghash_11HashTableNT_HashTableNT(PyObject *o, PyObject *i, PyObject *v) { if (v) { return __pyx_pw_8borghash_11HashTableNT_11HashTableNT_15__setitem__(o, i, v); } else { return __pyx_pw_8borghash_11HashTableNT_11HashTableNT_19__delitem__(o, i); } } static PyObject *__pyx_getprop_8borghash_11HashTableNT_11HashTableNT_stats(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_8borghash_11HashTableNT_11HashTableNT_5stats_1__get__(o); } static PyMethodDef __pyx_methods_8borghash_11HashTableNT_HashTableNT[] = { {"clear", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_3clear, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {"_check_key", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_5_check_key, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {"_to_binary_value", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_7_to_binary_value, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {"_to_namedtuple_value", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_9_to_namedtuple_value, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {"_set_raw", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_11_set_raw, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {"_get_raw", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_13_get_raw, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {"items", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_23items, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8borghash_11HashTableNT_11HashTableNT_22items}, {"get", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_28get, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {"setdefault", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_30setdefault, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {"pop", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_32pop, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {"update", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_34update, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8borghash_11HashTableNT_11HashTableNT_33update}, {"k_to_idx", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_36k_to_idx, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {"idx_to_k", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_38idx_to_k, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {"kv_to_idx", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_40kv_to_idx, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {"idx_to_kv", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_42idx_to_kv, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {"write", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_44write, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {"_write_fd", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_46_write_fd, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {"read", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_48read, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {"_read_fd", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_50_read_fd, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {"size", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_52size, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8borghash_11HashTableNT_11HashTableNT_51size}, {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_54__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_56__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_8borghash_11HashTableNT_HashTableNT[] = { {"stats", __pyx_getprop_8borghash_11HashTableNT_11HashTableNT_stats, 0, 0, 0}, {0, 0, 0, 0, 0} }; #if CYTHON_USE_TYPE_SPECS static PyType_Slot __pyx_type_8borghash_11HashTableNT_HashTableNT_slots[] = { {Py_tp_dealloc, (void *)__pyx_tp_dealloc_8borghash_11HashTableNT_HashTableNT}, {Py_sq_length, (void *)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_26__len__}, {Py_sq_item, (void *)__pyx_sq_item_8borghash_11HashTableNT_HashTableNT}, {Py_sq_ass_item, (void *)__pyx_sq_ass_item_8borghash_11HashTableNT_HashTableNT}, {Py_sq_contains, (void *)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_21__contains__}, {Py_mp_length, (void *)__pyx_pw_8borghash_11HashTableNT_11HashTableNT_26__len__}, {Py_mp_subscript, (void *)__pyx_mp_subscript_8borghash_11HashTableNT_HashTableNT}, {Py_mp_ass_subscript, (void *)__pyx_mp_ass_subscript_8borghash_11HashTableNT_HashTableNT}, {Py_tp_traverse, (void *)__pyx_tp_traverse_8borghash_11HashTableNT_HashTableNT}, {Py_tp_clear, (void *)__pyx_tp_clear_8borghash_11HashTableNT_HashTableNT}, {Py_tp_methods, (void *)__pyx_methods_8borghash_11HashTableNT_HashTableNT}, {Py_tp_getset, (void *)__pyx_getsets_8borghash_11HashTableNT_HashTableNT}, {Py_tp_init, (void *)__pyx_tp_init_8borghash_11HashTableNT_HashTableNT}, {Py_tp_new, (void *)__pyx_tp_new_8borghash_11HashTableNT_HashTableNT}, #if (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) && (!CYTHON_COMPILING_IN_LIMITED_API || __PYX_LIMITED_VERSION_HEX >= 0x030E0000) #if CYTHON_VECTORCALL_TPNEW {Py_tp_vectorcall, (void *)__pyx_tp_vectorcall_8borghash_11HashTableNT_HashTableNT}, #endif #endif {0, 0}, }; static PyType_Spec __pyx_type_8borghash_11HashTableNT_HashTableNT_spec = { "borghash.HashTableNT.HashTableNT", sizeof(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT), 0, Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, __pyx_type_8borghash_11HashTableNT_HashTableNT_slots, }; #else static PySequenceMethods __pyx_tp_as_sequence_HashTableNT = { __pyx_pw_8borghash_11HashTableNT_11HashTableNT_26__len__, /*sq_length*/ 0, /*sq_concat*/ 0, /*sq_repeat*/ __pyx_sq_item_8borghash_11HashTableNT_HashTableNT, /*sq_item*/ 0, /*sq_slice*/ __pyx_sq_ass_item_8borghash_11HashTableNT_HashTableNT, /*sq_ass_item*/ 0, /*sq_ass_slice*/ __pyx_pw_8borghash_11HashTableNT_11HashTableNT_21__contains__, /*sq_contains*/ 0, /*sq_inplace_concat*/ 0, /*sq_inplace_repeat*/ }; static PyMappingMethods __pyx_tp_as_mapping_HashTableNT = { __pyx_pw_8borghash_11HashTableNT_11HashTableNT_26__len__, /*mp_length*/ __pyx_mp_subscript_8borghash_11HashTableNT_HashTableNT, /*mp_subscript*/ __pyx_mp_ass_subscript_8borghash_11HashTableNT_HashTableNT, /*mp_ass_subscript*/ }; static PyTypeObject __pyx_type_8borghash_11HashTableNT_HashTableNT = { PyVarObject_HEAD_INIT(0, 0) "borghash.HashTableNT.""HashTableNT", /*tp_name*/ sizeof(struct __pyx_obj_8borghash_11HashTableNT_HashTableNT), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_8borghash_11HashTableNT_HashTableNT, /*tp_dealloc*/ 0, /*tp_vectorcall_offset*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ 0, /*tp_as_async*/ 0, /*tp_repr*/ 0, /*tp_as_number*/ &__pyx_tp_as_sequence_HashTableNT, /*tp_as_sequence*/ &__pyx_tp_as_mapping_HashTableNT, /*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_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_8borghash_11HashTableNT_HashTableNT, /*tp_traverse*/ __pyx_tp_clear_8borghash_11HashTableNT_HashTableNT, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_8borghash_11HashTableNT_HashTableNT, /*tp_methods*/ 0, /*tp_members*/ __pyx_getsets_8borghash_11HashTableNT_HashTableNT, /*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_tp_init_8borghash_11HashTableNT_HashTableNT, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_8borghash_11HashTableNT_HashTableNT, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ #else NULL, /*tp_finalize*/ #endif #if (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) && (!CYTHON_COMPILING_IN_LIMITED_API || __PYX_LIMITED_VERSION_HEX >= 0x030E0000) #if CYTHON_VECTORCALL_TPNEW __pyx_tp_vectorcall_8borghash_11HashTableNT_HashTableNT, /*tp_vectorcall*/ #else NULL, /*tp_vectorcall*/ #endif #endif #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030C0000 0, /*tp_watched*/ #endif #if PY_VERSION_HEX >= 0x030d00A4 0, /*tp_versions_used*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; #endif static PyObject *__pyx_tp_new__initialisation_8borghash_11HashTableNT___pyx_scope_struct__genexpr(PyObject *o, #if CYTHON_VECTORCALL_TPNEW CYTHON_UNUSED PyObject *const *args, CYTHON_UNUSED Py_ssize_t nargs, CYTHON_UNUSED PyObject *kwnames #else CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k #endif ) { return o; } static PyObject *__pyx_tp_new_vectorcall_8borghash_11HashTableNT___pyx_scope_struct__genexpr(PyTypeObject *t, #if CYTHON_VECTORCALL_TPNEW PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames #else PyObject *a, PyObject *k #endif ) { PyObject *o; #if CYTHON_USE_FREELISTS if (likely((int)(__pyx_mstate_global->__pyx_freecount_8borghash_11HashTableNT___pyx_scope_struct__genexpr > 0) & __PYX_CHECK_FINAL_TYPE_FOR_FREELISTS(t, __pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT___pyx_scope_struct__genexpr, sizeof(struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct__genexpr)))) { o = (PyObject*)__pyx_mstate_global->__pyx_freelist_8borghash_11HashTableNT___pyx_scope_struct__genexpr[--__pyx_mstate_global->__pyx_freecount_8borghash_11HashTableNT___pyx_scope_struct__genexpr]; #if CYTHON_USE_TYPE_SPECS Py_DECREF(Py_TYPE(o)); #endif memset(o, 0, sizeof(struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct__genexpr)); #if CYTHON_COMPILING_IN_LIMITED_API (void) PyObject_Init(o, t); #else (void) PyObject_INIT(o, t); #endif PyObject_GC_Track(o); } else #endif { o = __Pyx_AllocateExtensionType(t, 1); } if (unlikely(!o)) return 0; return __pyx_tp_new__initialisation_8borghash_11HashTableNT___pyx_scope_struct__genexpr(o, #if CYTHON_VECTORCALL_TPNEW args, nargs, kwnames #else a, k #endif ); } #if CYTHON_VECTORCALL_TPNEW static PyObject *__pyx_tp_new_8borghash_11HashTableNT___pyx_scope_struct__genexpr(PyTypeObject *t, PyObject *a, PyObject *k) { return __Pyx_CallTpnewAsVectorcall(__pyx_tp_new_vectorcall_8borghash_11HashTableNT___pyx_scope_struct__genexpr, t, a, k); } #endif #if CYTHON_VECTORCALL_TPNEW static PyObject *__pyx_tp_vectorcall_8borghash_11HashTableNT___pyx_scope_struct__genexpr(PyObject *t, PyObject *const *args, size_t nargsf, PyObject *kwnames) { if (unlikely((PyTypeObject*)t != __pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT___pyx_scope_struct__genexpr || __Pyx_PyType_HasFeature((PyTypeObject*)t, Py_TPFLAGS_IS_ABSTRACT))) { return __Pyx_CallNewInitFromVectorcall((PyTypeObject*)t, args, nargsf, kwnames); } Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); PyObject *o = __pyx_tp_new_vectorcall_8borghash_11HashTableNT___pyx_scope_struct__genexpr((PyTypeObject*)t, args, nargs, kwnames); return o; } #endif static void __pyx_tp_dealloc_8borghash_11HashTableNT___pyx_scope_struct__genexpr(PyObject *o) { struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct__genexpr *p = (struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct__genexpr *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_8borghash_11HashTableNT___pyx_scope_struct__genexpr) { if (PyObject_CallFinalizerFromDealloc(o)) return; } } #endif PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_genexpr_arg_0); Py_CLEAR(p->__pyx_v_fmt); #if CYTHON_USE_FREELISTS if (likely((int)(__pyx_mstate_global->__pyx_freecount_8borghash_11HashTableNT___pyx_scope_struct__genexpr < 8) & __PYX_CHECK_FINAL_TYPE_FOR_FREELISTS(Py_TYPE(o), __pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT___pyx_scope_struct__genexpr, sizeof(struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct__genexpr)))) { __pyx_mstate_global->__pyx_freelist_8borghash_11HashTableNT___pyx_scope_struct__genexpr[__pyx_mstate_global->__pyx_freecount_8borghash_11HashTableNT___pyx_scope_struct__genexpr++] = ((struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct__genexpr *)o); } else #endif { PyTypeObject *tp = Py_TYPE(o); #if CYTHON_USE_TYPE_SLOTS (*tp->tp_free)(o); #else { freefunc tp_free = (freefunc)PyType_GetSlot(tp, Py_tp_free); if (tp_free) tp_free(o); } #endif #if CYTHON_USE_TYPE_SPECS Py_DECREF(tp); #endif } } static int __pyx_tp_traverse_8borghash_11HashTableNT___pyx_scope_struct__genexpr(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct__genexpr *p = (struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct__genexpr *)o; { e = __Pyx_call_type_traverse(o, 1, v, a); if (e) return e; } if (p->__pyx_genexpr_arg_0) { e = (*v)(p->__pyx_genexpr_arg_0, a); if (e) return e; } if (p->__pyx_v_fmt) { e = (*v)(p->__pyx_v_fmt, a); if (e) return e; } return 0; } #if CYTHON_USE_TYPE_SPECS static PyType_Slot __pyx_type_8borghash_11HashTableNT___pyx_scope_struct__genexpr_slots[] = { {Py_tp_dealloc, (void *)__pyx_tp_dealloc_8borghash_11HashTableNT___pyx_scope_struct__genexpr}, {Py_tp_traverse, (void *)__pyx_tp_traverse_8borghash_11HashTableNT___pyx_scope_struct__genexpr}, {Py_tp_new, (void *)__pyx_tp_new_8borghash_11HashTableNT___pyx_scope_struct__genexpr}, #if (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) && (!CYTHON_COMPILING_IN_LIMITED_API || __PYX_LIMITED_VERSION_HEX >= 0x030E0000) #if CYTHON_VECTORCALL_TPNEW {Py_tp_vectorcall, (void *)__pyx_tp_vectorcall_8borghash_11HashTableNT___pyx_scope_struct__genexpr}, #endif #endif {0, 0}, }; static PyType_Spec __pyx_type_8borghash_11HashTableNT___pyx_scope_struct__genexpr_spec = { "borghash.HashTableNT.__pyx_scope_struct__genexpr", sizeof(struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct__genexpr), 0, Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_HAVE_GC, __pyx_type_8borghash_11HashTableNT___pyx_scope_struct__genexpr_slots, }; #else static PyTypeObject __pyx_type_8borghash_11HashTableNT___pyx_scope_struct__genexpr = { PyVarObject_HEAD_INIT(0, 0) "borghash.HashTableNT.""__pyx_scope_struct__genexpr", /*tp_name*/ sizeof(struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct__genexpr), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_8borghash_11HashTableNT___pyx_scope_struct__genexpr, /*tp_dealloc*/ 0, /*tp_vectorcall_offset*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ 0, /*tp_as_async*/ 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_8borghash_11HashTableNT___pyx_scope_struct__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_8borghash_11HashTableNT___pyx_scope_struct__genexpr, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ #else NULL, /*tp_finalize*/ #endif #if (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) && (!CYTHON_COMPILING_IN_LIMITED_API || __PYX_LIMITED_VERSION_HEX >= 0x030E0000) #if CYTHON_VECTORCALL_TPNEW __pyx_tp_vectorcall_8borghash_11HashTableNT___pyx_scope_struct__genexpr, /*tp_vectorcall*/ #else NULL, /*tp_vectorcall*/ #endif #endif #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030C0000 0, /*tp_watched*/ #endif #if PY_VERSION_HEX >= 0x030d00A4 0, /*tp_versions_used*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; #endif static PyObject *__pyx_tp_new__initialisation_8borghash_11HashTableNT___pyx_scope_struct_1_items(PyObject *o, #if CYTHON_VECTORCALL_TPNEW CYTHON_UNUSED PyObject *const *args, CYTHON_UNUSED Py_ssize_t nargs, CYTHON_UNUSED PyObject *kwnames #else CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k #endif ) { return o; } static PyObject *__pyx_tp_new_vectorcall_8borghash_11HashTableNT___pyx_scope_struct_1_items(PyTypeObject *t, #if CYTHON_VECTORCALL_TPNEW PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames #else PyObject *a, PyObject *k #endif ) { PyObject *o; #if CYTHON_USE_FREELISTS if (likely((int)(__pyx_mstate_global->__pyx_freecount_8borghash_11HashTableNT___pyx_scope_struct_1_items > 0) & __PYX_CHECK_FINAL_TYPE_FOR_FREELISTS(t, __pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT___pyx_scope_struct_1_items, sizeof(struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct_1_items)))) { o = (PyObject*)__pyx_mstate_global->__pyx_freelist_8borghash_11HashTableNT___pyx_scope_struct_1_items[--__pyx_mstate_global->__pyx_freecount_8borghash_11HashTableNT___pyx_scope_struct_1_items]; #if CYTHON_USE_TYPE_SPECS Py_DECREF(Py_TYPE(o)); #endif memset(o, 0, sizeof(struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct_1_items)); #if CYTHON_COMPILING_IN_LIMITED_API (void) PyObject_Init(o, t); #else (void) PyObject_INIT(o, t); #endif PyObject_GC_Track(o); } else #endif { o = __Pyx_AllocateExtensionType(t, 1); } if (unlikely(!o)) return 0; return __pyx_tp_new__initialisation_8borghash_11HashTableNT___pyx_scope_struct_1_items(o, #if CYTHON_VECTORCALL_TPNEW args, nargs, kwnames #else a, k #endif ); } #if CYTHON_VECTORCALL_TPNEW static PyObject *__pyx_tp_new_8borghash_11HashTableNT___pyx_scope_struct_1_items(PyTypeObject *t, PyObject *a, PyObject *k) { return __Pyx_CallTpnewAsVectorcall(__pyx_tp_new_vectorcall_8borghash_11HashTableNT___pyx_scope_struct_1_items, t, a, k); } #endif #if CYTHON_VECTORCALL_TPNEW static PyObject *__pyx_tp_vectorcall_8borghash_11HashTableNT___pyx_scope_struct_1_items(PyObject *t, PyObject *const *args, size_t nargsf, PyObject *kwnames) { if (unlikely((PyTypeObject*)t != __pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT___pyx_scope_struct_1_items || __Pyx_PyType_HasFeature((PyTypeObject*)t, Py_TPFLAGS_IS_ABSTRACT))) { return __Pyx_CallNewInitFromVectorcall((PyTypeObject*)t, args, nargsf, kwnames); } Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); PyObject *o = __pyx_tp_new_vectorcall_8borghash_11HashTableNT___pyx_scope_struct_1_items((PyTypeObject*)t, args, nargs, kwnames); return o; } #endif static void __pyx_tp_dealloc_8borghash_11HashTableNT___pyx_scope_struct_1_items(PyObject *o) { struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct_1_items *p = (struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct_1_items *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_8borghash_11HashTableNT___pyx_scope_struct_1_items) { if (PyObject_CallFinalizerFromDealloc(o)) return; } } #endif PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_binary_value); Py_CLEAR(p->__pyx_v_key); Py_CLEAR(p->__pyx_v_prefix); Py_CLEAR(p->__pyx_v_prefix_bits); Py_CLEAR(p->__pyx_v_self); Py_CLEAR(p->__pyx_t_0); #if CYTHON_USE_FREELISTS if (likely((int)(__pyx_mstate_global->__pyx_freecount_8borghash_11HashTableNT___pyx_scope_struct_1_items < 8) & __PYX_CHECK_FINAL_TYPE_FOR_FREELISTS(Py_TYPE(o), __pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT___pyx_scope_struct_1_items, sizeof(struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct_1_items)))) { __pyx_mstate_global->__pyx_freelist_8borghash_11HashTableNT___pyx_scope_struct_1_items[__pyx_mstate_global->__pyx_freecount_8borghash_11HashTableNT___pyx_scope_struct_1_items++] = ((struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct_1_items *)o); } else #endif { PyTypeObject *tp = Py_TYPE(o); #if CYTHON_USE_TYPE_SLOTS (*tp->tp_free)(o); #else { freefunc tp_free = (freefunc)PyType_GetSlot(tp, Py_tp_free); if (tp_free) tp_free(o); } #endif #if CYTHON_USE_TYPE_SPECS Py_DECREF(tp); #endif } } static int __pyx_tp_traverse_8borghash_11HashTableNT___pyx_scope_struct_1_items(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct_1_items *p = (struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct_1_items *)o; { e = __Pyx_call_type_traverse(o, 1, v, a); if (e) return e; } if (p->__pyx_v_binary_value) { e = (*v)(p->__pyx_v_binary_value, 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_self) { e = (*v)(((PyObject *)p->__pyx_v_self), 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_8borghash_11HashTableNT___pyx_scope_struct_1_items_slots[] = { {Py_tp_dealloc, (void *)__pyx_tp_dealloc_8borghash_11HashTableNT___pyx_scope_struct_1_items}, {Py_tp_traverse, (void *)__pyx_tp_traverse_8borghash_11HashTableNT___pyx_scope_struct_1_items}, {Py_tp_new, (void *)__pyx_tp_new_8borghash_11HashTableNT___pyx_scope_struct_1_items}, #if (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) && (!CYTHON_COMPILING_IN_LIMITED_API || __PYX_LIMITED_VERSION_HEX >= 0x030E0000) #if CYTHON_VECTORCALL_TPNEW {Py_tp_vectorcall, (void *)__pyx_tp_vectorcall_8borghash_11HashTableNT___pyx_scope_struct_1_items}, #endif #endif {0, 0}, }; static PyType_Spec __pyx_type_8borghash_11HashTableNT___pyx_scope_struct_1_items_spec = { "borghash.HashTableNT.__pyx_scope_struct_1_items", sizeof(struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct_1_items), 0, Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_HAVE_GC, __pyx_type_8borghash_11HashTableNT___pyx_scope_struct_1_items_slots, }; #else static PyTypeObject __pyx_type_8borghash_11HashTableNT___pyx_scope_struct_1_items = { PyVarObject_HEAD_INIT(0, 0) "borghash.HashTableNT.""__pyx_scope_struct_1_items", /*tp_name*/ sizeof(struct __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct_1_items), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_8borghash_11HashTableNT___pyx_scope_struct_1_items, /*tp_dealloc*/ 0, /*tp_vectorcall_offset*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ 0, /*tp_as_async*/ 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_8borghash_11HashTableNT___pyx_scope_struct_1_items, /*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_8borghash_11HashTableNT___pyx_scope_struct_1_items, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ #else NULL, /*tp_finalize*/ #endif #if (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) && (!CYTHON_COMPILING_IN_LIMITED_API || __PYX_LIMITED_VERSION_HEX >= 0x030E0000) #if CYTHON_VECTORCALL_TPNEW __pyx_tp_vectorcall_8borghash_11HashTableNT___pyx_scope_struct_1_items, /*tp_vectorcall*/ #else NULL, /*tp_vectorcall*/ #endif #endif #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030C0000 0, /*tp_watched*/ #endif #if PY_VERSION_HEX >= 0x030d00A4 0, /*tp_versions_used*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; #endif static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; /* #### Code section: initfunc_declarations ### */ static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(__pyx_mstatetype *__pyx_mstate); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_InitAfterSharedUtility(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_Global_init_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_Variable_export_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_Function_export_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_Exttype___pyx_obj_8borghash_11HashTableNT_HashTableNT(__pyx_mstatetype *__pyx_mstate); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_Exttype___pyx_obj_8borghash_11HashTableNT___pyx_scope_struct__genexpr(__pyx_mstatetype *__pyx_mstate); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_Exttype___pyx_obj_8borghash_11HashTableNT___pyx_scope_struct_1_items(__pyx_mstatetype *__pyx_mstate); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_Type_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_Variable_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_Function_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate); /*proto*/ /* #### Code section: init_module ### */ static int __Pyx_modinit_Global_init_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_modinit_Global_init_code", 0); /*--- Global init code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_Variable_export_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_modinit_Variable_export_code", 0); /*--- Variable export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_Function_export_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_modinit_Function_export_code", 0); /*--- Function export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_Exttype___pyx_obj_8borghash_11HashTableNT_HashTableNT(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_modinit_Exttype___pyx_obj_8borghash_11HashTableNT_HashTableNT", 0); /*--- Exttype __pyx_obj_8borghash_11HashTableNT_HashTableNT ---*/ #if CYTHON_USE_TYPE_SPECS __pyx_mstate->__pyx_ptype_8borghash_11HashTableNT_HashTableNT = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_8borghash_11HashTableNT_HashTableNT_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_8borghash_11HashTableNT_HashTableNT)) __PYX_ERR(0, 24, __pyx_L1_error) #else __pyx_mstate->__pyx_ptype_8borghash_11HashTableNT_HashTableNT = &__pyx_type_8borghash_11HashTableNT_HashTableNT; #endif #if !CYTHON_COMPILING_IN_LIMITED_API #endif #if !CYTHON_USE_TYPE_SPECS if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_8borghash_11HashTableNT_HashTableNT) < (0)) __PYX_ERR(0, 24, __pyx_L1_error) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_ptype_8borghash_11HashTableNT_HashTableNT); #endif #if !CYTHON_COMPILING_IN_LIMITED_API if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_8borghash_11HashTableNT_HashTableNT->tp_dictoffset && __pyx_mstate->__pyx_ptype_8borghash_11HashTableNT_HashTableNT->tp_getattro == PyObject_GenericGetAttr)) { __pyx_mstate->__pyx_ptype_8borghash_11HashTableNT_HashTableNT->tp_getattro = PyObject_GenericGetAttr; } #endif if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_HashTableNT, (PyObject *) __pyx_mstate->__pyx_ptype_8borghash_11HashTableNT_HashTableNT) < (0)) __PYX_ERR(0, 24, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_8borghash_11HashTableNT_HashTableNT) < (0)) __PYX_ERR(0, 24, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_modinit_Exttype___pyx_obj_8borghash_11HashTableNT___pyx_scope_struct__genexpr(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_modinit_Exttype___pyx_obj_8borghash_11HashTableNT___pyx_scope_struct__genexpr", 0); /*--- Exttype __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct__genexpr ---*/ #if CYTHON_USE_TYPE_SPECS __pyx_mstate->__pyx_ptype_8borghash_11HashTableNT___pyx_scope_struct__genexpr = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_8borghash_11HashTableNT___pyx_scope_struct__genexpr_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_8borghash_11HashTableNT___pyx_scope_struct__genexpr)) __PYX_ERR(0, 36, __pyx_L1_error) #else __pyx_mstate->__pyx_ptype_8borghash_11HashTableNT___pyx_scope_struct__genexpr = &__pyx_type_8borghash_11HashTableNT___pyx_scope_struct__genexpr; #endif #if !CYTHON_COMPILING_IN_LIMITED_API #endif #if !CYTHON_USE_TYPE_SPECS if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_8borghash_11HashTableNT___pyx_scope_struct__genexpr) < (0)) __PYX_ERR(0, 36, __pyx_L1_error) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_ptype_8borghash_11HashTableNT___pyx_scope_struct__genexpr); #endif #if !CYTHON_COMPILING_IN_LIMITED_API if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_8borghash_11HashTableNT___pyx_scope_struct__genexpr->tp_dictoffset && __pyx_mstate->__pyx_ptype_8borghash_11HashTableNT___pyx_scope_struct__genexpr->tp_getattro == PyObject_GenericGetAttr)) { __pyx_mstate->__pyx_ptype_8borghash_11HashTableNT___pyx_scope_struct__genexpr->tp_getattro = PyObject_GenericGetAttr; } #endif __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_modinit_Exttype___pyx_obj_8borghash_11HashTableNT___pyx_scope_struct_1_items(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_modinit_Exttype___pyx_obj_8borghash_11HashTableNT___pyx_scope_struct_1_items", 0); /*--- Exttype __pyx_obj_8borghash_11HashTableNT___pyx_scope_struct_1_items ---*/ #if CYTHON_USE_TYPE_SPECS __pyx_mstate->__pyx_ptype_8borghash_11HashTableNT___pyx_scope_struct_1_items = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_8borghash_11HashTableNT___pyx_scope_struct_1_items_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_8borghash_11HashTableNT___pyx_scope_struct_1_items)) __PYX_ERR(0, 93, __pyx_L1_error) #else __pyx_mstate->__pyx_ptype_8borghash_11HashTableNT___pyx_scope_struct_1_items = &__pyx_type_8borghash_11HashTableNT___pyx_scope_struct_1_items; #endif #if !CYTHON_COMPILING_IN_LIMITED_API #endif #if !CYTHON_USE_TYPE_SPECS if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_8borghash_11HashTableNT___pyx_scope_struct_1_items) < (0)) __PYX_ERR(0, 93, __pyx_L1_error) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_ptype_8borghash_11HashTableNT___pyx_scope_struct_1_items); #endif #if !CYTHON_COMPILING_IN_LIMITED_API if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_8borghash_11HashTableNT___pyx_scope_struct_1_items->tp_dictoffset && __pyx_mstate->__pyx_ptype_8borghash_11HashTableNT___pyx_scope_struct_1_items->tp_getattro == PyObject_GenericGetAttr)) { __pyx_mstate->__pyx_ptype_8borghash_11HashTableNT___pyx_scope_struct_1_items->tp_getattro = PyObject_GenericGetAttr; } #endif __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_modinit_Type_import_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_modinit_Type_import_code", 0); /*--- Type import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_Variable_import_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_modinit_Variable_import_code", 0); /*--- Variable import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_Function_import_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_modinit_Function_import_code", 0); /*--- Function import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } #if CYTHON_PEP489_MULTI_PHASE_INIT static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ static int __pyx_pymod_exec_HashTableNT(PyObject* module); /*proto*/ static PyModuleDef_Slot __pyx_moduledef_slots[] = { {Py_mod_create, (void*)__pyx_pymod_create}, {Py_mod_exec, (void*)__pyx_pymod_exec_HashTableNT}, #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING {Py_mod_gil, __Pyx_FREETHREADING_COMPATIBLE}, #endif #if PY_VERSION_HEX >= 0x030C0000 && CYTHON_USE_MODULE_STATE {Py_mod_multiple_interpreters, Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED}, #endif {0, NULL} }; #endif #ifdef __cplusplus namespace { struct PyModuleDef __pyx_moduledef = #else static struct PyModuleDef __pyx_moduledef = #endif { PyModuleDef_HEAD_INIT, "HashTableNT", __pyx_k_HashTableNT_wrapper_around_Hash, /* m_doc */ #if CYTHON_USE_MODULE_STATE sizeof(__pyx_mstatetype), /* m_size */ #else (CYTHON_PEP489_MULTI_PHASE_INIT) ? 0 : -1, /* m_size */ #endif __pyx_methods /* m_methods */, #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_moduledef_slots, /* m_slots */ #else NULL, /* m_reload */ #endif #if CYTHON_USE_MODULE_STATE __pyx_m_traverse, /* m_traverse */ __pyx_m_clear, /* m_clear */ NULL /* m_free */ #else NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ #endif }; #ifdef __cplusplus } /* anonymous namespace */ #endif /* PyModInitFuncType */ #ifndef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #else #ifdef __cplusplus #define __Pyx_PyMODINIT_FUNC extern "C" PyObject * #else #define __Pyx_PyMODINIT_FUNC PyObject * #endif #endif __Pyx_PyMODINIT_FUNC PyInit_HashTableNT(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC PyInit_HashTableNT(void) #if CYTHON_PEP489_MULTI_PHASE_INIT { return PyModuleDef_Init(&__pyx_moduledef); } /* ModuleCreationPEP489 */ #if CYTHON_COMPILING_IN_LIMITED_API && (__PYX_LIMITED_VERSION_HEX < 0x030A0000 &&\ (defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS))) static PY_INT64_T __Pyx_GetCurrentInterpreterId(void) { { PyObject *module = PyImport_ImportModule("_interpreters"); // 3.13+ I think if (!module) { if (!PyErr_ExceptionMatches(PyExc_Exception)) { goto bad; // BaseException } PyErr_Clear(); // just try the 3.8-3.12 version module = PyImport_ImportModule("_xxsubinterpreters"); if (!module) goto bad; } PyObject *current = PyObject_CallMethod(module, "get_current", NULL); Py_DECREF(module); if (!current) goto bad; if (PyTuple_Check(current)) { PyObject *new_current = PySequence_GetItem(current, 0); Py_DECREF(current); current = new_current; if (!new_current) goto bad; } long long as_c_int = PyLong_AsLongLong(current); Py_DECREF(current); return as_c_int; } bad: PySys_WriteStderr("__Pyx_GetCurrentInterpreterId failed. Try setting the C define CYTHON_PEP489_MULTI_PHASE_INIT=0\n"); return -1; } #endif #if !CYTHON_USE_MODULE_STATE static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { static PY_INT64_T main_interpreter_id = -1; #if CYTHON_COMPILING_IN_GRAAL && defined(GRAALPY_VERSION_NUM) && GRAALPY_VERSION_NUM > 0x19000000 PY_INT64_T current_id = GraalPyInterpreterState_GetIDFromThreadState(PyThreadState_Get()); #elif CYTHON_COMPILING_IN_GRAAL PY_INT64_T current_id = PyInterpreterState_GetIDFromThreadState(PyThreadState_Get()); #elif CYTHON_COMPILING_IN_LIMITED_API && (__PYX_LIMITED_VERSION_HEX < 0x030A0000 &&\ (defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS))) PY_INT64_T current_id = __Pyx_GetCurrentInterpreterId(); #elif CYTHON_COMPILING_IN_LIMITED_API PY_INT64_T current_id = PyInterpreterState_GetID(PyInterpreterState_Get()); #else PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); #endif if (unlikely(current_id == -1)) { return -1; } if (main_interpreter_id == -1) { main_interpreter_id = current_id; return 0; } else if (unlikely(main_interpreter_id != current_id)) { PyErr_SetString( PyExc_ImportError, "Interpreter change detected - this module can only be loaded into one interpreter per process."); return -1; } return 0; } #endif static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { if (allow_none || value != Py_None) { result = PyDict_SetItemString(moddict, to_name, value); } Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Clear(); } else { result = -1; } return result; } static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; CYTHON_UNUSED_VAR(def); #if !CYTHON_USE_MODULE_STATE if (__Pyx_check_single_interpreter()) return NULL; #endif if (__pyx_m) return __Pyx_NewRef(__pyx_m); modname = PyObject_GetAttrString(spec, "name"); if (unlikely(!modname)) goto bad; module = PyModule_NewObject(modname); Py_DECREF(modname); if (unlikely(!module)) goto bad; moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; return module; bad: Py_XDECREF(module); return NULL; } static CYTHON_SMALL_CODE int __pyx_pymod_exec_HashTableNT(PyObject *__pyx_pyinit_module) #endif { int stringtab_initialized = 0; #if CYTHON_USE_MODULE_STATE int pystate_addmodule_run = 0; #endif __pyx_mstatetype *__pyx_mstate = NULL; PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; Py_ssize_t __pyx_t_3; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; size_t __pyx_t_6; PyObject *__pyx_t_7 = 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 'HashTableNT' has already been imported. Re-initialisation is not supported."); return -1; } #else if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif /*--- Module creation code ---*/ #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_t_1 = __pyx_pyinit_module; Py_INCREF(__pyx_t_1); #else __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) #endif #if CYTHON_USE_MODULE_STATE { int add_module_result = __Pyx_State_AddModule(__pyx_t_1, &__pyx_moduledef); __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "HashTableNT" pseudovariable */ if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error) pystate_addmodule_run = 1; } #else __pyx_m = __pyx_t_1; #endif #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING PyUnstable_Module_SetGIL(__pyx_m, Py_MOD_GIL_USED); #endif __pyx_mstate = __pyx_mstate_global; CYTHON_UNUSED_VAR(__pyx_t_1); __pyx_mstate->__pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_mstate->__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_mstate->__pyx_d); __pyx_mstate->__pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_mstate->__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_mstate->__pyx_cython_runtime = __Pyx_PyImport_AddModuleRef("cython_runtime"); if (unlikely(!__pyx_mstate->__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_mstate->__pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) /* ImportRefnannyAPI */ #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { if (PyErr_ExceptionMatches(PyExc_Exception)) { PyErr_Clear(); __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); } if (!__Pyx_RefNanny) Py_FatalError("failed to import 'refnanny' module"); } #endif __Pyx_RefNannySetupContext("PyInit_HashTableNT", 0); __Pyx_init_runtime_version(); 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) __pyx_mstate->__pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_mstate->__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_mstate->__pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_mstate->__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_mstate->__pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_mstate->__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Library function declarations ---*/ /*--- Initialize various global constants etc. ---*/ if (__Pyx_InitConstants(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) stringtab_initialized = 1; if (__Pyx_InitGlobals() < (0)) __PYX_ERR(0, 1, __pyx_L1_error) if (__pyx_module_is_main_borghash__HashTableNT) { if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_name, __pyx_mstate_global->__pyx_n_u_main) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) } { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) if (!PyDict_GetItemString(modules, "borghash.HashTableNT")) { if (unlikely((PyDict_SetItemString(modules, "borghash.HashTableNT", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) } } /*--- Builtin init code ---*/ if (__Pyx_InitCachedBuiltins(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Constants init code ---*/ if (__Pyx_InitCachedConstants(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) if (__Pyx_CreateCodeObjects(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Global type/function init code ---*/ (void)__Pyx_modinit_Global_init_code(__pyx_mstate); (void)__Pyx_modinit_Variable_export_code(__pyx_mstate); (void)__Pyx_modinit_Function_export_code(__pyx_mstate); /*--- Type init code ---*/ if (unlikely((__Pyx_modinit_Exttype___pyx_obj_8borghash_11HashTableNT_HashTableNT(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) if (unlikely((__Pyx_modinit_Exttype___pyx_obj_8borghash_11HashTableNT___pyx_scope_struct__genexpr(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) if (unlikely((__Pyx_modinit_Exttype___pyx_obj_8borghash_11HashTableNT___pyx_scope_struct_1_items(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) (void)__Pyx_modinit_Type_import_code(__pyx_mstate); (void)__Pyx_modinit_Variable_import_code(__pyx_mstate); (void)__Pyx_modinit_Function_import_code(__pyx_mstate); if (__Pyx_InitAfterSharedUtility() < (0)) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Execution code ---*/ /* "borghash/HashTableNT.pyx":6 * from __future__ import annotations * * from collections.abc import Mapping # <<<<<<<<<<<<<< * from typing import BinaryIO, Iterator, Any * */ { PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_Mapping}; __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_collections_abc, __pyx_imported_names, 1, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) } __pyx_t_2 = __pyx_t_1; __Pyx_GOTREF(__pyx_t_2); { PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_Mapping}; __pyx_t_3 = 0; { __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_3], __pyx_t_4) < (0)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTableNT.pyx":7 * * from collections.abc import Mapping * from typing import BinaryIO, Iterator, Any # <<<<<<<<<<<<<< * * from collections import namedtuple */ { PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_BinaryIO,__pyx_mstate_global->__pyx_n_u_Iterator,__pyx_mstate_global->__pyx_n_u_Any}; __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_typing, __pyx_imported_names, 3, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) } __pyx_t_2 = __pyx_t_1; __Pyx_GOTREF(__pyx_t_2); { PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_BinaryIO,__pyx_mstate_global->__pyx_n_u_Iterator,__pyx_mstate_global->__pyx_n_u_Any}; for (__pyx_t_3=0; __pyx_t_3 < 3; __pyx_t_3++) { __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_3], __pyx_t_4) < (0)) __PYX_ERR(0, 7, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTableNT.pyx":9 * from typing import BinaryIO, Iterator, Any * * from collections import namedtuple # <<<<<<<<<<<<<< * import json * import struct */ { PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_namedtuple}; __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_collections, __pyx_imported_names, 1, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error) } __pyx_t_2 = __pyx_t_1; __Pyx_GOTREF(__pyx_t_2); { PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_namedtuple}; __pyx_t_3 = 0; { __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_3], __pyx_t_4) < (0)) __PYX_ERR(0, 9, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTableNT.pyx":10 * * from collections import namedtuple * import json # <<<<<<<<<<<<<< * import struct * */ __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_json, 0, 0, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 10, __pyx_L1_error) __pyx_t_2 = __pyx_t_1; __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_json, __pyx_t_2) < (0)) __PYX_ERR(0, 10, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTableNT.pyx":11 * from collections import namedtuple * import json * import struct # <<<<<<<<<<<<<< * * from .HashTable import HashTable, MIN_CAPACITY, _fill */ __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_struct, 0, 0, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 11, __pyx_L1_error) __pyx_t_2 = __pyx_t_1; __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_struct, __pyx_t_2) < (0)) __PYX_ERR(0, 11, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTableNT.pyx":13 * import struct * * from .HashTable import HashTable, MIN_CAPACITY, _fill # <<<<<<<<<<<<<< * * MAGIC = b"BORGHASH" */ { PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_HashTable,__pyx_mstate_global->__pyx_n_u_MIN_CAPACITY,__pyx_mstate_global->__pyx_n_u_fill}; __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_HashTable, __pyx_imported_names, 3, __pyx_mstate_global->__pyx_kp_u_borghash_HashTable, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error) } __pyx_t_2 = __pyx_t_1; __Pyx_GOTREF(__pyx_t_2); { PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_HashTable,__pyx_mstate_global->__pyx_n_u_MIN_CAPACITY,__pyx_mstate_global->__pyx_n_u_fill}; for (__pyx_t_3=0; __pyx_t_3 < 3; __pyx_t_3++) { __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_3], __pyx_t_4) < (0)) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTableNT.pyx":15 * from .HashTable import HashTable, MIN_CAPACITY, _fill * * MAGIC = b"BORGHASH" # <<<<<<<<<<<<<< * assert len(MAGIC) == 8 * VERSION = 1 # version of the on-disk (serialized) format produced by .write(). */ if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MAGIC, __pyx_mstate_global->__pyx_n_b_BORGHASH) < (0)) __PYX_ERR(0, 15, __pyx_L1_error) /* "borghash/HashTableNT.pyx":16 * * MAGIC = b"BORGHASH" * assert len(MAGIC) == 8 # <<<<<<<<<<<<<< * VERSION = 1 # version of the on-disk (serialized) format produced by .write(). * HEADER_FMT = "<8sII" # magic, version, meta length */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(__pyx_assertions_enabled())) { __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_MAGIC); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 16, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyObject_Length(__pyx_t_2); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 16, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_5 = (__pyx_t_3 == 8); if (unlikely(!__pyx_t_5)) { __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_AssertionError))), 0, 0, 0); __PYX_ERR(0, 16, __pyx_L1_error) } } #else if ((1)); else __PYX_ERR(0, 16, __pyx_L1_error) #endif /* "borghash/HashTableNT.pyx":17 * MAGIC = b"BORGHASH" * assert len(MAGIC) == 8 * VERSION = 1 # version of the on-disk (serialized) format produced by .write(). # <<<<<<<<<<<<<< * HEADER_FMT = "<8sII" # magic, version, meta length * */ if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_VERSION, __pyx_mstate_global->__pyx_int_1) < (0)) __PYX_ERR(0, 17, __pyx_L1_error) /* "borghash/HashTableNT.pyx":18 * assert len(MAGIC) == 8 * VERSION = 1 # version of the on-disk (serialized) format produced by .write(). * HEADER_FMT = "<8sII" # magic, version, meta length # <<<<<<<<<<<<<< * * BYTE_ORDER = dict(big=">", little="<", network="!", native="=") # struct format chars */ if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_HEADER_FMT, __pyx_mstate_global->__pyx_kp_u_8sII) < (0)) __PYX_ERR(0, 18, __pyx_L1_error) /* "borghash/HashTableNT.pyx":20 * HEADER_FMT = "<8sII" # magic, version, meta length * * BYTE_ORDER = dict(big=">", little="<", network="!", native="=") # struct format chars # <<<<<<<<<<<<<< * * _NoDefault = object() */ __pyx_t_2 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 20, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_big, __pyx_mstate_global->__pyx_kp_u__7) < (0)) __PYX_ERR(0, 20, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_little, __pyx_mstate_global->__pyx_kp_u__8) < (0)) __PYX_ERR(0, 20, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_network, __pyx_mstate_global->__pyx_kp_u__9) < (0)) __PYX_ERR(0, 20, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_native, __pyx_mstate_global->__pyx_kp_u__10) < (0)) __PYX_ERR(0, 20, __pyx_L1_error) if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_BYTE_ORDER, __pyx_t_2) < (0)) __PYX_ERR(0, 20, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTableNT.pyx":22 * BYTE_ORDER = dict(big=">", little="<", network="!", native="=") # struct format chars * * _NoDefault = object() # <<<<<<<<<<<<<< * * cdef class HashTableNT: */ __pyx_t_4 = NULL; __pyx_t_6 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_object, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); } if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_NoDefault, __pyx_t_2) < (0)) __PYX_ERR(0, 22, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTableNT.pyx":27 * def __init__(self, items=None, *, * key_size: int, value_type: Any, value_format: Any, * capacity: int = MIN_CAPACITY, byte_order="little") -> None: # <<<<<<<<<<<<<< * if not isinstance(key_size, int) or not key_size >= 4: * raise ValueError("key_size must be an integer and >= 4.") */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_MIN_CAPACITY); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 27, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (__Pyx_PyInt_FromNumber(&__pyx_t_2, NULL, 1) < (0)) __PYX_ERR(0, 27, __pyx_L1_error) __pyx_mstate_global->__pyx_k_ = ((PyObject*)__pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTableNT.pyx":49 * _fill(self, items) * * def clear(self) -> None: # <<<<<<<<<<<<<< * self.inner.clear() * */ __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 49, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < (0)) __PYX_ERR(0, 49, __pyx_L1_error) __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_11HashTableNT_11HashTableNT_3clear, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTableNT_clear, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTableNT, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[2])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 49, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT_HashTableNT, __pyx_mstate_global->__pyx_n_u_clear, __pyx_t_4) < (0)) __PYX_ERR(0, 49, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "borghash/HashTableNT.pyx":52 * self.inner.clear() * * def _check_key(self, key: bytes) -> None: # <<<<<<<<<<<<<< * if not isinstance(key, bytes): * raise TypeError(f"Expected an instance of bytes, got {type(key)}") */ __pyx_t_4 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 52, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_key, __pyx_mstate_global->__pyx_n_u_bytes) < (0)) __PYX_ERR(0, 52, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < (0)) __PYX_ERR(0, 52, __pyx_L1_error) __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_11HashTableNT_11HashTableNT_5_check_key, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTableNT__check_key, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTableNT, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[3])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 52, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); #endif __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT_HashTableNT, __pyx_mstate_global->__pyx_n_u_check_key, __pyx_t_2) < (0)) __PYX_ERR(0, 52, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTableNT.pyx":58 * raise ValueError(f"Key must be {self.key_size} bytes long") * * def _to_binary_value(self, value: Any) -> bytes: # <<<<<<<<<<<<<< * if not isinstance(value, self.value_type): * if isinstance(value, tuple): */ __pyx_t_2 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 58, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_value, __pyx_mstate_global->__pyx_n_u_Any) < (0)) __PYX_ERR(0, 58, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bytes) < (0)) __PYX_ERR(0, 58, __pyx_L1_error) __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_11HashTableNT_11HashTableNT_7_to_binary_value, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTableNT__to_binary_value, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTableNT, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[4])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 58, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT_HashTableNT, __pyx_mstate_global->__pyx_n_u_to_binary_value, __pyx_t_4) < (0)) __PYX_ERR(0, 58, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "borghash/HashTableNT.pyx":66 * return self.value_struct.pack(*value) * * def _to_namedtuple_value(self, binary_value: bytes) -> Any: # <<<<<<<<<<<<<< * unpacked_data = self.value_struct.unpack(binary_value) * return self.value_type(*unpacked_data) */ __pyx_t_4 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 66, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_binary_value, __pyx_mstate_global->__pyx_n_u_bytes) < (0)) __PYX_ERR(0, 66, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_Any) < (0)) __PYX_ERR(0, 66, __pyx_L1_error) __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_11HashTableNT_11HashTableNT_9_to_namedtuple_value, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTableNT__to_namedtuple_value, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTableNT, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[5])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 66, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); #endif __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT_HashTableNT, __pyx_mstate_global->__pyx_n_u_to_namedtuple_value, __pyx_t_2) < (0)) __PYX_ERR(0, 66, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTableNT.pyx":70 * return self.value_type(*unpacked_data) * * def _set_raw(self, key: bytes, value: bytes) -> None: # <<<<<<<<<<<<<< * self.inner[key] = value * */ __pyx_t_2 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 70, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_key, __pyx_mstate_global->__pyx_n_u_bytes) < (0)) __PYX_ERR(0, 70, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_value, __pyx_mstate_global->__pyx_n_u_bytes) < (0)) __PYX_ERR(0, 70, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < (0)) __PYX_ERR(0, 70, __pyx_L1_error) __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_11HashTableNT_11HashTableNT_11_set_raw, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTableNT__set_raw, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTableNT, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[6])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 70, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT_HashTableNT, __pyx_mstate_global->__pyx_n_u_set_raw, __pyx_t_4) < (0)) __PYX_ERR(0, 70, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "borghash/HashTableNT.pyx":73 * self.inner[key] = value * * def _get_raw(self, key: bytes) -> bytes: # <<<<<<<<<<<<<< * return self.inner[key] * */ __pyx_t_4 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 73, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_key, __pyx_mstate_global->__pyx_n_u_bytes) < (0)) __PYX_ERR(0, 73, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bytes) < (0)) __PYX_ERR(0, 73, __pyx_L1_error) __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_11HashTableNT_11HashTableNT_13_get_raw, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTableNT__get_raw, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTableNT, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[7])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 73, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); #endif __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT_HashTableNT, __pyx_mstate_global->__pyx_n_u_get_raw, __pyx_t_2) < (0)) __PYX_ERR(0, 73, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTableNT.pyx":93 * return key in self.inner * * def items(self, *, prefix_bits: int = 0, prefix: int = 0) -> Iterator[tuple[bytes, Any]]: # <<<<<<<<<<<<<< * """ * Iterate over items, optionally only over items whose key starts with the given bit prefix. */ __pyx_t_2 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 93, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_prefix_bits, __pyx_mstate_global->__pyx_int_0) < (0)) __PYX_ERR(0, 93, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_prefix, __pyx_mstate_global->__pyx_int_0) < (0)) __PYX_ERR(0, 93, __pyx_L1_error) __pyx_t_4 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 93, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_prefix_bits, __pyx_mstate_global->__pyx_n_u_int) < (0)) __PYX_ERR(0, 93, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_prefix, __pyx_mstate_global->__pyx_n_u_int) < (0)) __PYX_ERR(0, 93, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_Iterator_tuple_bytes_Any) < (0)) __PYX_ERR(0, 93, __pyx_L1_error) __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_11HashTableNT_11HashTableNT_23items, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTableNT_items, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTableNT, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[1])); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 93, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_7); #endif __Pyx_CyFunction_SetDefaultsKwDict(__pyx_t_7, __pyx_t_2); __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_7, __pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT_HashTableNT, __pyx_mstate_global->__pyx_n_u_items, __pyx_t_7) < (0)) __PYX_ERR(0, 93, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "borghash/HashTableNT.pyx":105 * return len(self.inner) * * def get(self, key: bytes, default: Any = None) -> Any: # <<<<<<<<<<<<<< * self._check_key(key) * try: */ __pyx_t_7 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 105, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (PyDict_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_key, __pyx_mstate_global->__pyx_n_u_bytes) < (0)) __PYX_ERR(0, 105, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_default, __pyx_mstate_global->__pyx_n_u_Any) < (0)) __PYX_ERR(0, 105, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_Any) < (0)) __PYX_ERR(0, 105, __pyx_L1_error) __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_11HashTableNT_11HashTableNT_28get, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTableNT_get, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTableNT, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[8])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 105, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_mstate_global->__pyx_tuple[4]); __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_7); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT_HashTableNT, __pyx_mstate_global->__pyx_n_u_get, __pyx_t_4) < (0)) __PYX_ERR(0, 105, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "borghash/HashTableNT.pyx":114 * return self._to_namedtuple_value(binary_value) * * def setdefault(self, key: bytes, default: Any) -> Any: # <<<<<<<<<<<<<< * self._check_key(key) * binary_default = self._to_binary_value(default) */ __pyx_t_4 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 114, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_key, __pyx_mstate_global->__pyx_n_u_bytes) < (0)) __PYX_ERR(0, 114, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_default, __pyx_mstate_global->__pyx_n_u_Any) < (0)) __PYX_ERR(0, 114, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_Any) < (0)) __PYX_ERR(0, 114, __pyx_L1_error) __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_11HashTableNT_11HashTableNT_30setdefault, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTableNT_setdefault, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTableNT, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[9])); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 114, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_7); #endif __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_7, __pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT_HashTableNT, __pyx_mstate_global->__pyx_n_u_setdefault, __pyx_t_7) < (0)) __PYX_ERR(0, 114, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "borghash/HashTableNT.pyx":120 * return self._to_namedtuple_value(binary_value) * * def pop(self, key: bytes, default: Any = _NoDefault) -> Any: # <<<<<<<<<<<<<< * self._check_key(key) * try: */ __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_NoDefault); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_mstate_global->__pyx_k__5 = __pyx_t_7; __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_NoDefault); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); { PyObject* __pyx_temp[1] = {__pyx_t_7}; __pyx_t_4 = __Pyx_PyTuple_FromArray(__pyx_temp, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (PyDict_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_key, __pyx_mstate_global->__pyx_n_u_bytes) < (0)) __PYX_ERR(0, 120, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_default, __pyx_mstate_global->__pyx_n_u_Any) < (0)) __PYX_ERR(0, 120, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_Any) < (0)) __PYX_ERR(0, 120, __pyx_L1_error) __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_11HashTableNT_11HashTableNT_32pop, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTableNT_pop, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTableNT, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[10])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_4); __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_7); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT_HashTableNT, __pyx_mstate_global->__pyx_n_u_pop, __pyx_t_2) < (0)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTableNT.pyx":131 * return self._to_namedtuple_value(binary_value) * * def update(self, other=(), /, **kwds): # <<<<<<<<<<<<<< * """Like dict.update(), but 'other' can also be a HashTableNT instance.""" * if isinstance(other, HashTableNT): */ __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_11HashTableNT_11HashTableNT_34update, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTableNT_update, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTableNT, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[11])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 131, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_mstate_global->__pyx_tuple[5]); if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT_HashTableNT, __pyx_mstate_global->__pyx_n_u_update, __pyx_t_2) < (0)) __PYX_ERR(0, 131, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTableNT.pyx":148 * self[key] = value * * def k_to_idx(self, key: bytes) -> int: # <<<<<<<<<<<<<< * return self.inner.k_to_idx(key) * */ __pyx_t_2 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 148, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_key, __pyx_mstate_global->__pyx_n_u_bytes) < (0)) __PYX_ERR(0, 148, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_int) < (0)) __PYX_ERR(0, 148, __pyx_L1_error) __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_11HashTableNT_11HashTableNT_36k_to_idx, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTableNT_k_to_idx, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTableNT, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[12])); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 148, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_7); #endif __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_7, __pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT_HashTableNT, __pyx_mstate_global->__pyx_n_u_k_to_idx, __pyx_t_7) < (0)) __PYX_ERR(0, 148, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "borghash/HashTableNT.pyx":151 * return self.inner.k_to_idx(key) * * def idx_to_k(self, idx: int) -> bytes: # <<<<<<<<<<<<<< * return self.inner.idx_to_k(idx) * */ __pyx_t_7 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 151, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (PyDict_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_idx, __pyx_mstate_global->__pyx_n_u_int) < (0)) __PYX_ERR(0, 151, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bytes) < (0)) __PYX_ERR(0, 151, __pyx_L1_error) __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_11HashTableNT_11HashTableNT_38idx_to_k, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTableNT_idx_to_k, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTableNT, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[13])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 151, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); #endif __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_7); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT_HashTableNT, __pyx_mstate_global->__pyx_n_u_idx_to_k, __pyx_t_2) < (0)) __PYX_ERR(0, 151, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTableNT.pyx":154 * return self.inner.idx_to_k(idx) * * def kv_to_idx(self, key: bytes, value: Any) -> int: # <<<<<<<<<<<<<< * binary_value = self._to_binary_value(value) * return self.inner.kv_to_idx(key, binary_value) */ __pyx_t_2 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 154, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_key, __pyx_mstate_global->__pyx_n_u_bytes) < (0)) __PYX_ERR(0, 154, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_value, __pyx_mstate_global->__pyx_n_u_Any) < (0)) __PYX_ERR(0, 154, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_int) < (0)) __PYX_ERR(0, 154, __pyx_L1_error) __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_11HashTableNT_11HashTableNT_40kv_to_idx, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTableNT_kv_to_idx, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTableNT, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[14])); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 154, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_7); #endif __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_7, __pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT_HashTableNT, __pyx_mstate_global->__pyx_n_u_kv_to_idx, __pyx_t_7) < (0)) __PYX_ERR(0, 154, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "borghash/HashTableNT.pyx":158 * return self.inner.kv_to_idx(key, binary_value) * * def idx_to_kv(self, idx: int) -> tuple[bytes, Any]: # <<<<<<<<<<<<<< * key, binary_value = self.inner.idx_to_kv(idx) * return key, self._to_namedtuple_value(binary_value) */ __pyx_t_7 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 158, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (PyDict_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_idx, __pyx_mstate_global->__pyx_n_u_int) < (0)) __PYX_ERR(0, 158, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_tuple_bytes_Any) < (0)) __PYX_ERR(0, 158, __pyx_L1_error) __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_11HashTableNT_11HashTableNT_42idx_to_kv, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTableNT_idx_to_kv, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTableNT, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[15])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 158, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); #endif __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_7); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT_HashTableNT, __pyx_mstate_global->__pyx_n_u_idx_to_kv, __pyx_t_2) < (0)) __PYX_ERR(0, 158, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTableNT.pyx":166 * return self.inner.stats * * def write(self, file: BinaryIO|str|bytes): # <<<<<<<<<<<<<< * if isinstance(file, (str, bytes)): * with open(file, 'wb') as fd: */ __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 166, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_file, __pyx_mstate_global->__pyx_kp_u_BinaryIO_str_bytes) < (0)) __PYX_ERR(0, 166, __pyx_L1_error) __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_11HashTableNT_11HashTableNT_44write, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTableNT_write, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTableNT, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[16])); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 166, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_7); #endif __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_7, __pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT_HashTableNT, __pyx_mstate_global->__pyx_n_u_write, __pyx_t_7) < (0)) __PYX_ERR(0, 166, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "borghash/HashTableNT.pyx":173 * self._write_fd(file) * * def _write_fd(self, fd: BinaryIO): # <<<<<<<<<<<<<< * meta = { * 'key_size': self.key_size, */ __pyx_t_7 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 173, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (PyDict_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_fd, __pyx_mstate_global->__pyx_n_u_BinaryIO) < (0)) __PYX_ERR(0, 173, __pyx_L1_error) __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_11HashTableNT_11HashTableNT_46_write_fd, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTableNT__write_fd, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTableNT, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[17])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 173, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); #endif __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_7); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT_HashTableNT, __pyx_mstate_global->__pyx_n_u_write_fd, __pyx_t_2) < (0)) __PYX_ERR(0, 173, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTableNT.pyx":198 * assert count == self.inner.used * * @classmethod # <<<<<<<<<<<<<< * def read(cls, file: BinaryIO|str|bytes): * if isinstance(file, (str, bytes)): */ __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 198, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_file, __pyx_mstate_global->__pyx_kp_u_BinaryIO_str_bytes) < (0)) __PYX_ERR(0, 198, __pyx_L1_error) __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_11HashTableNT_11HashTableNT_48read, __Pyx_CYFUNCTION_CLASSMETHOD | __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTableNT_read, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTableNT, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[18])); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 198, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_7); #endif __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_7, __pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT_HashTableNT, __pyx_mstate_global->__pyx_n_u_read, __pyx_t_7) < (0)) __PYX_ERR(0, 198, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GetNameInClass(__pyx_t_7, (PyObject*)__pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT_HashTableNT, __pyx_mstate_global->__pyx_n_u_read); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 198, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_2 = __Pyx_Method_ClassMethod(__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 198, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT_HashTableNT, __pyx_mstate_global->__pyx_n_u_read, __pyx_t_2) < (0)) __PYX_ERR(0, 198, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTableNT.pyx":206 * return cls._read_fd(file) * * @classmethod # <<<<<<<<<<<<<< * def _read_fd(cls, fd: BinaryIO): * header_size = struct.calcsize(HEADER_FMT) */ __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 206, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_fd, __pyx_mstate_global->__pyx_n_u_BinaryIO) < (0)) __PYX_ERR(0, 206, __pyx_L1_error) __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_11HashTableNT_11HashTableNT_50_read_fd, __Pyx_CYFUNCTION_CLASSMETHOD | __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTableNT__read_fd, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTableNT, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[19])); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 206, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_7); #endif __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_7, __pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT_HashTableNT, __pyx_mstate_global->__pyx_n_u_read_fd, __pyx_t_7) < (0)) __PYX_ERR(0, 206, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GetNameInClass(__pyx_t_7, (PyObject*)__pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT_HashTableNT, __pyx_mstate_global->__pyx_n_u_read_fd); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 206, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_2 = __Pyx_Method_ClassMethod(__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 206, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT_HashTableNT, __pyx_mstate_global->__pyx_n_u_read_fd, __pyx_t_2) < (0)) __PYX_ERR(0, 206, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "borghash/HashTableNT.pyx":234 * return ht * * def size(self) -> int: # <<<<<<<<<<<<<< * """ * Do a rough worst-case estimate of the on-disk size when using .write(). */ __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_int) < (0)) __PYX_ERR(0, 234, __pyx_L1_error) __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_11HashTableNT_11HashTableNT_52size, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTableNT_size, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTableNT, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[20])); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_7); #endif __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_7, __pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT_HashTableNT, __pyx_mstate_global->__pyx_n_u_size, __pyx_t_7) < (0)) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * cdef tuple state * cdef object _dict */ __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_11HashTableNT_11HashTableNT_54__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTableNT___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTableNT, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[21])); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_7); #endif if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT_HashTableNT, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_7) < (0)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "(tree fragment)":17 * else: * return __pyx_unpickle_HashTableNT, (type(self), 0xb78e9ae, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_HashTableNT__set_state(self, __pyx_state) */ __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_11HashTableNT_11HashTableNT_56__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HashTableNT___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTableNT, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[22])); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 17, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_7); #endif if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_8borghash_11HashTableNT_HashTableNT, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_7) < (0)) __PYX_ERR(1, 17, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "(tree fragment)":4 * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 * def __pyx_unpickle_HashTableNT(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_result * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0xb78e9ae, 0x9612968, 0xfd3bc11, b'byte_order, inner, key_size, value_format, value_size, value_struct, value_type') */ __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_8borghash_11HashTableNT_1__pyx_unpickle_HashTableNT, 0, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_HashTableNT, NULL, __pyx_mstate_global->__pyx_n_u_borghash_HashTableNT, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[23])); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_7); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_HashTableNT, __pyx_t_7) < (0)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "borghash/HashTableNT.pyx":1 * """ # <<<<<<<<<<<<<< * HashTableNT: wrapper around HashTable, providing namedtuple values and serialization. * """ */ __pyx_t_7 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_test, __pyx_t_7) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_7); if (__pyx_m) { if (__pyx_mstate->__pyx_d && stringtab_initialized) { __Pyx_AddTraceback("init borghash.HashTableNT", __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; __Pyx_PyErr_FetchException(&tp, &value, &tb); __Pyx_State_RemoveModule(&__pyx_moduledef); __Pyx_PyErr_RestoreException(tp, value, tb); } #endif } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init borghash.HashTableNT"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); #if CYTHON_PEP489_MULTI_PHASE_INIT return (__pyx_m != NULL) ? 0 : -1; #else return __pyx_m; #endif } /* #### Code section: pystring_table ### */ /* #### Code section: cached_builtins ### */ static int __Pyx_InitCachedBuiltins(__pyx_mstatetype *__pyx_mstate) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; CYTHON_UNUSED_VAR(__pyx_mstate); __pyx_builtin_object = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_object); if (!__pyx_builtin_object) __PYX_ERR(0, 22, __pyx_L1_error) __pyx_builtin_open = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_open); if (!__pyx_builtin_open) __PYX_ERR(0, 168, __pyx_L1_error) /* Cached unbound methods */ __pyx_mstate->__pyx_umethod_PyDict_Type_items.type = (PyObject*)&PyDict_Type; __pyx_mstate->__pyx_umethod_PyDict_Type_items.method_name = &__pyx_mstate->__pyx_n_u_items; __pyx_mstate->__pyx_umethod_PyDict_Type_pop.type = (PyObject*)&PyDict_Type; __pyx_mstate->__pyx_umethod_PyDict_Type_pop.method_name = &__pyx_mstate->__pyx_n_u_pop; __pyx_mstate->__pyx_umethod_PyDict_Type_values.type = (PyObject*)&PyDict_Type; __pyx_mstate->__pyx_umethod_PyDict_Type_values.method_name = &__pyx_mstate->__pyx_n_u_values; return 0; __pyx_L1_error:; return -1; } /* #### Code section: cached_constants ### */ static int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); /* "borghash/HashTableNT.pyx":46 * self.value_struct = struct.Struct(BYTE_ORDER[byte_order] + "".join(value_format)) * self.value_size = self.value_struct.size * self.inner = HashTable(key_size=self.key_size, value_size=self.value_size, capacity=capacity) # <<<<<<<<<<<<<< * _fill(self, items) * */ { PyObject* __pyx_temp[3] = {__pyx_mstate_global->__pyx_n_u_key_size, __pyx_mstate_global->__pyx_n_u_value_size, __pyx_mstate_global->__pyx_n_u_capacity}; __pyx_mstate_global->__pyx_tuple[0] = __Pyx_PyTuple_FromArray(__pyx_temp, 3); if (unlikely(!__pyx_mstate_global->__pyx_tuple[0])) __PYX_ERR(0, 46, __pyx_L1_error) __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[0]); } __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[0]); /* "borghash/HashTableNT.pyx":99 * See HashTable.items for the prefix_bits / prefix semantics. * """ * for key, binary_value in self.inner.items(prefix_bits=prefix_bits, prefix=prefix): # <<<<<<<<<<<<<< * yield (key, self._to_namedtuple_value(binary_value)) * */ { PyObject* __pyx_temp[2] = {__pyx_mstate_global->__pyx_n_u_prefix_bits, __pyx_mstate_global->__pyx_n_u_prefix}; __pyx_mstate_global->__pyx_tuple[1] = __Pyx_PyTuple_FromArray(__pyx_temp, 2); if (unlikely(!__pyx_mstate_global->__pyx_tuple[1])) __PYX_ERR(0, 99, __pyx_L1_error) __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[1]); } __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[1]); /* "borghash/HashTableNT.pyx":168 * def write(self, file: BinaryIO|str|bytes): * if isinstance(file, (str, bytes)): * with open(file, 'wb') as fd: # <<<<<<<<<<<<<< * self._write_fd(fd) * else: */ { PyObject* __pyx_temp[3] = {Py_None, Py_None, Py_None}; __pyx_mstate_global->__pyx_tuple[2] = __Pyx_PyTuple_FromArray(__pyx_temp, 3); if (unlikely(!__pyx_mstate_global->__pyx_tuple[2])) __PYX_ERR(0, 168, __pyx_L1_error) __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[2]); } __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[2]); /* "borghash/HashTableNT.pyx":224 * value_format_t = namedtuple(meta['value_format_name'], meta['value_format_fields']) * value_format = value_format_t(*meta['value_format']) * ht = cls(key_size=meta['key_size'], value_format=value_format, value_type=value_type, # <<<<<<<<<<<<<< * capacity=meta['capacity'], byte_order=meta['byte_order']) * count = 0 */ { PyObject* __pyx_temp[5] = {__pyx_mstate_global->__pyx_n_u_key_size, __pyx_mstate_global->__pyx_n_u_value_format, __pyx_mstate_global->__pyx_n_u_value_type, __pyx_mstate_global->__pyx_n_u_capacity, __pyx_mstate_global->__pyx_n_u_byte_order}; __pyx_mstate_global->__pyx_tuple[3] = __Pyx_PyTuple_FromArray(__pyx_temp, 5); if (unlikely(!__pyx_mstate_global->__pyx_tuple[3])) __PYX_ERR(0, 224, __pyx_L1_error) __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[3]); } __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[3]); /* "borghash/HashTableNT.pyx":105 * return len(self.inner) * * def get(self, key: bytes, default: Any = None) -> Any: # <<<<<<<<<<<<<< * self._check_key(key) * try: */ { PyObject* __pyx_temp[1] = {Py_None}; __pyx_mstate_global->__pyx_tuple[4] = __Pyx_PyTuple_FromArray(__pyx_temp, 1); if (unlikely(!__pyx_mstate_global->__pyx_tuple[4])) __PYX_ERR(0, 105, __pyx_L1_error) __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[4]); } __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[4]); /* "borghash/HashTableNT.pyx":131 * return self._to_namedtuple_value(binary_value) * * def update(self, other=(), /, **kwds): # <<<<<<<<<<<<<< * """Like dict.update(), but 'other' can also be a HashTableNT instance.""" * if isinstance(other, HashTableNT): */ { PyObject* __pyx_temp[1] = {__pyx_mstate_global->__pyx_empty_tuple}; __pyx_mstate_global->__pyx_tuple[5] = __Pyx_PyTuple_FromArray(__pyx_temp, 1); if (unlikely(!__pyx_mstate_global->__pyx_tuple[5])) __PYX_ERR(0, 131, __pyx_L1_error) __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[5]); } __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[5]); #if CYTHON_IMMORTAL_CONSTANTS { PyObject **table = __pyx_mstate->__pyx_tuple; for (Py_ssize_t i=0; i<6; ++i) { #if PY_VERSION_HEX >= 0x030F0000 PyUnstable_SetImmortal(table[i]); #elif CYTHON_COMPILING_IN_CPYTHON_FREETHREADING if ((PY_SSIZE_T_MAX <= _Py_IMMORTAL_REFCNT_LOCAL)) break; #if PY_VERSION_HEX < 0x030E0000 if (_Py_IsOwnedByCurrentThread(table[i]) && Py_REFCNT(table[i]) == 1) #else if (PyUnstable_Object_IsUniquelyReferenced(table[i])) #endif { Py_SET_REFCNT(table[i], ((Py_ssize_t)_Py_IMMORTAL_REFCNT_LOCAL + 1)); } #else if ((PY_SSIZE_T_MAX < _Py_IMMORTAL_INITIAL_REFCNT)) break; Py_SET_REFCNT(table[i], _Py_IMMORTAL_INITIAL_REFCNT); #endif } } #endif __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } /* #### Code section: init_constants ### */ static int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; CYTHON_UNUSED_VAR(__pyx_mstate); { const struct { const unsigned int length: 8; } str_length_index[] = {{0},{11},{11},{1},{15},{2},{6},{1},{1},{5},{1},{1},{1},{22},{24},{35},{32},{20},{27},{12},{179},{25},{8},{18},{27},{7},{6},{2},{9},{37},{28},{17},{5},{43},{62},{50},{37},{3},{10},{8},{10},{9},{11},{29},{31},{22},{20},{20},{20},{28},{32},{21},{17},{15},{20},{21},{17},{20},{21},{15},{16},{22},{16},{18},{17},{8},{5},{12},{7},{1},{4},{6},{7},{10},{20},{12},{9},{17},{8},{9},{8},{8},{12},{25},{8},{10},{8},{7},{14},{12},{11},{10},{26},{12},{10},{17},{13},{12},{12},{19},{8},{10},{5},{7},{5},{8},{13},{8},{8},{16},{20},{9},{18},{3},{14},{12},{20},{10},{5},{8},{8},{5},{18},{5},{3},{11},{15},{5},{6},{7},{5},{6},{2},{4},{3},{7},{3},{12},{11},{2},{1},{3},{8},{9},{3},{5},{4},{8},{3},{8},{4},{5},{9},{4},{6},{5},{5},{4},{10},{9},{10},{6},{7},{4},{6},{18},{4},{5},{4},{3},{6},{11},{2},{4},{6},{4},{4},{10},{4},{5},{5},{6},{5},{6},{6},{13},{6},{12},{4},{5},{12},{19},{17},{14},{10},{10},{17},{15},{6},{7},{5},{2},{5}}; const struct { const unsigned int length: 9; } bytes_length_index[] = {{8},{11},{55},{218},{51},{335},{2},{46},{14},{55},{69},{47},{140},{209},{20},{18},{20},{20},{36},{36},{68},{58},{13},{86},{31}}; #ifndef CYTHON_COMPRESS_STRINGS #define CYTHON_COMPRESS_STRINGS 90 #endif #if (CYTHON_COMPRESS_STRINGS) == 1 /* compression: zlib (2228 bytes) */ static const char cstring[] = "x\332uU\315s\323H\026\307)\003\031\010K\014\201\000\341C\336e\310\300\004\317zH1Y>\313\340\004L*!q\002\031\226bTm\251m+\226%[\335r\354Yf\212\243\217:\352\250\243\216:\372\350#G\035}\314\237\300\237\260\357\265\374\t\301UVw\277~\337\357\367^K\205\026\247L\322M\243$\031&\227\212\246m\250\251\344O\334\242T*Z\244T\245\006\277\275$-I%\270M=z\264\302r\271\307O\236>\323\014b\265r\257\245\217\022\343\026|\205\236\325f\215*\234\252\0221$\315`\234\030\n\225\314\242\364=\272\020\212T\347\214\006\3215U*j:]\022_Ic\0227M\211\225M\213\247&\357\253\244\244)R\216S\213p\323z\317\355\232N\337\367\265e\214\326\207\017\353\264%Um\306\245\002\2256MN%^&\\z\336\342e\323@\305*\325\265\002JS\275\205\021h\340\236\205L\206\264\265\272uwye\031|U%\213\356\203\343LbvA\321\tc\220*t\333\326t\256\031\022o\325(KI\271\242\3242m\311\240\020 7\245\032\360\215\013\36025$F9n\244Eb@\232\t\327LC\006q\315(-J\252f\201\021\255AQz\215\350\214\246\336\030\314\256\325 n\032E,5\250\305@F\"\252*\203\002Z0\255R\231\260r\352%|vIA\247\030\275lZ*\2041\010\33440\313\017\300\000C\016j\340\267\244h,\332\251\025\332\222\231\366\047\035\n\210\362pZ\002\035\030\375\223\307\322r\212Y\312/\003k\277\014\255m\356\246j\255\3467y\267y\361\356\n\024\312\246r\321\264\252\220\362\241j\311 U\252\n\211!\006R\343\254\213L\030\215H\230Z P\235\"\000\205,\213t)\246eQV3\001\246_I\367\231\331\320&\"\023U\032\246q\227Vk\274\225\032)?\3321\274IA \317\336\355\256\312\257\363\331\325\374\000\350/W3p\222\3276v\2079\030K\306x^d\331\242\252\255PY\021h\223\345\311K@\002\004\317\277s\255\224\251R\221\2410\023\324\022\345\262E\016&h\026%\252\\T\047h\354\010>n\312\005\021\203,\202\377\372n\024\374\021\367\007\226\006\216N\032QtJ\254q\00287~\324\324&\352\255\034EkL\0209\255\262qB\005y\200u\202\3268\202X3k\343G\314\304\370\031\262\240\322\"\261\365\t\277\020\350\343g\273\246B\025\306)\"\332\301L\331\310\274\310=\337\310m\312\3173[\231\347\271\335w\033\244\206\355\272\271\t]\265\303-[\341oW\363;\271\327\233\362\246\231\215\314\311\362V\253\t\377,L\023y""\2236y\236\026e\271\337\361T\206\237\230\t\243\r\244\016\263\200\004\025e\340\007\000\246\226\33045A(\332\206\202ki\200\033\370i\006\336\245\036\351\246\002\343\342\t\224\300\240\315\032\210U\211f C\325Tm]\260b}\305J\017p\201\246\2150\306\354jt\202f\022\256\343\276o\000\267\330\t\321\3166j\232R\001mc\271\222\345\272M\364\201\356>\336\345o\220?$\320&\036\020\236\003\0316\026\3167-!\3130Q0\372a;D\371)jTW\031,\272>\350\tYc2\214\004\323\206\201L\007M1h\204\257\301\177\024\340\207 \047\254e(\232\231\032jc\005\255\324\227\356\343i\\\327\267\023xsw4\203\305L\204\342(\010;\205\324\210\242\361\226h\035EGG\241L\334\"\n-\020\245\242\350&\243\212\316\024S\327\361!0\215\361m\212\024\024\005^e\300\264b\252\264\357\211jWk0\306\221RT\361\205(Vy\037\005\220\2302\244\001P$\234\350\357\321\2172\327\240\223\006\3158lJ\030\371\242\027\367\231i\014z\020R>x\035`e\025\261\031\364b\345@e\272\306\271Nu\223\250L<\306U\312\t\376#\243b\2072\243l\033\004\2378\203\362\003\323\252\200\243\334,\340\333\n\335$s\r0a\302\023\207\2762\263F\241a\312\324\202\244U\240\325k\026-j\315\350\013\325\344\314*`\231-\312m\313`T/B\036\324Q\317\243U\201&\3740&:\225\227-\363 zn\001\315\2406\372RU\206\031@\242I`3:\004\"\354UQ\344\361\027f|\337G\342\004\tC\235 \364%\320\241\321\2733\332M\350\020\204\241\006\326\177\356\033({P\020\010}\366:\377\342ef\347\345\247X/~\333O\370\267\202\330\247\330a\374\206[\017\245\177\007\247;\017\273\225p;\337\213\237w\036\272e\217x\365^\374\344\247\217\316on\2627}\327\337\366\215\316\346\347d/~\272\235\376\024\3732}\354\324\002^$\2349\347\203w\323+\373j\360sg\267{#\334\332\rwIHhHy\310\233a\263\325\233\236uN:u\367\204\253\373I\324\331h\3579\253\356\234\273\335\233>\347\200\216y\247~\010\037\356>\362\016|\032\334\013\324\316bw\376\363\361\317;BY!,h\241f\204F=\254\333_\216\035k\304\262S\260d\247\326qY\237\332\302ekj\007\227\235\251=\\\366\246\024\\\224\251}\\\366\247*Sh\267\336\233>\033\236]\362\263A,\230\357\234\356\376\3669y8II\177\312\364.]\356M\237n?p\266\235\222\373\306K\366\022\027`[""ts\336vov\336a\356m/\355e\016g\316;\367\034\315\255{1\020\271\262\320\233\276\030\361x\004\343\261\334\013.q\353\250\350^\233\264\377v\363p\2309\347\334q3\030\365\331v\313\235\361\326\374\305 \021,u\010\262\335w\316;\231>Kx\355^\220\016V;\363\335\030^\255\200%2\274Z\351\304:\211\336\364\005\047\357\330\221\266\310\306G\367W8\214\333\340\316}7\341\336\361^\370i?\203\022\377\005w\343^&\374\361?\235\271\3166\332\275\354^\201h\262~,\274\375\264\303\273\351n\006\275\377\333\313{<\022:\323\336qb\316e\367&\204\363\227\277\321\271\336\375_\230\337\351%\256\364)\353\001\357\244;\031,q\014m6\241\212iw\303\237\003\274\200\376\231\366\252s\301!\202(\242\373\047\024>\001\270\231\231s\23694\242\376\243\255\001:\216GN\327\301\227\370E\207|\2319\366\303u$\315\264\263\316\t\210\037\356\230\223t~uv\334\270\373\312+\370qp\347\\\047\035\306\001>\310\266\346\334rAv>\234_\364\032\376\273@\230_\007\315\340\330\017\275\231\005w\331m\210\372\234\235\355A\365\322X\302\345p~\311\317\370\333C1\031c\371Vl\027\332%)\0041D\006\001\314&\216Pr\005;\342{\330\231s^!&\016gf\235Sn\322\005\307\027\334\364\341\220\035j7\353\034w\336\271\324\273\357\047\220=\343\354Az\316@x\356I\204\217\350\242\301\305\252\227\000\375g\006\\\342\322F\352\004\303a_\047\031\351\0235\301\202\026=!\026s\3461mW\361\n\342\275\004\331\005\272\250\357p\271\341r\357!\324s&\351\315y\357\203X\264\371\020\334\201l\315\374\313[\366\376\n`s\325\315z\261H\303\232\047J\234\205\236\047\207\200\274]\367\"`\357\270\267\207y\352M\3179\317\243\004\317;\r\314\223\367\310?\010\264\016\224\361T\373\026x\224\030\333\010`\215|^\203:\000b\212\020\315\366\330\006\362\214\010i\010t\200u\014\350%\004\330o\203\313`#\215\264W\036\031\265F\362+\312\220k\323\277\023d\"L%q\376\205\361k\356\357PCh\007\031\202<\341\355\303\274H\240\230\355d\303K8\034\t\362\374\341\257\004i\214\212\207\013KQ\250\221f\354\262U?\021\306\257\273\373\276h\352\345\366\237\340\301\217\321X\270\rh\270\232\351&\2727\273\244;\234\0326d\t\032g\320\323\177@G\302\234\002\035\341\365\224_""\236\300\367ew.\274\226\362\211_\027\326\335\373\336\002\230\177\023$\205\003\341\371\237\374\030Z\277\t\351\3739x\333\271\337\205\303-\230\331d\344\312\"Tt\033\361\035\035\000GX\310u\317\362\023\207\263\027q\324\205\322\203N\262\263\034>\335\206g\"\314\277\r\337\356\205{\277G!>\206\342\346\275z\030O\007W:\220\002\224\335\360\347\007i\342\360\244\024\274\330\377\001yANa"; PyObject *data = __Pyx_DecompressString(cstring, 2228, 1); #define __Pyx_DecompressString_LZSS_UNUSED if (unlikely(!data)) __PYX_ERR(0, 1, __pyx_L1_error) const char* const bytes = __Pyx_PyBytes_AsString(data); #if !CYTHON_ASSUME_SAFE_MACROS if (likely(bytes)); else { Py_DECREF(data); __PYX_ERR(0, 1, __pyx_L1_error) } #endif #elif (CYTHON_COMPRESS_STRINGS) > 0 && (CYTHON_COMPRESS_STRINGS) <= 90 /* compression: lzss (2939 bytes) */ static const char cstring[] = "\377 bytes l\377ong not \377found.!(\377tree fra\377gment), \367, g\033\000.<<8\377sII=>?Bi\377naryIO |\317 str\003\000C\002Ex\377pected a\377n instan?ce of \000\025x\002\376U\003Invalid\277 file,\001\002 \377is too s\337hort.\022\013ma\377gic Iter\377ator[tup\367le[G\004Any]\377]Key mus\377t be Not\377e that C\357ytho\230\000s d\357elib:\001ely\352\276\001i\264\000r!\001n P\277EP-484\301\000d\357 rej\316\000s s\177ubclass\250 \376\314\000builtin\377 types. \377If you n=e\366\000to p%\000%\t\377then set\276\200\000e \047an\344 a\337tion_<\000in\277g\047 dir\263 i\375v\242\000o Fals\377e.Unsupp\372\365\000e\214# vers\2761\000 add_\245@e\377borghash\373.H\002\000Table~\305A_order\360\006\253on\372!:^\000s\036\001e\275n$\001gcis\004\003d\377key_size\334\241&\262BtegA\000an\377d >= 4.s\327rc/f\005/e\006NT\357.pyx\347.utf\373-8\306@ue_fo\363rm\360 \375%a na\247med\245B\223f.\037\t\047\341s\356\"8\003\327!\016\000ele\364\375a7\002s\313Ccorr?espond.\r&\004\361s\360F\226\204\001\304\001non-\277empty.S\007 \364\204\022\316A.\276`BYTE\277_ORDER\341\204\005H{EA\013\000_FMT\351&\374\202(\214)__reduoce_c\351b__\017\013\336\207`stat\010\024ch\317eck_\226@E\nge\337t_rawY\nre_ad_fdm\ns\025\020/to_b\250\206\002_\223B\235\n8\031\000\214G\r\020wri\246\000W\013\037clear\374I\232\000\213i\257idx_q\000k\000\021v^\034\ntems\305ik4\001t<\000\007\nv\002\020pop\375i\374\206!\215\204\tsetdef\357ault\t\nize\016\263\204\tupd\203@\305\204\t\351\002\314\207\005\377MAGICMIN\377_CAPACIT\377YMapping\377NNoneStr\377uctVERSI\277ON_NoDi\003_\357_Pyx\001\000Dic\377t_NextRe\367f__\353\206\004e___I_\300\207\002\000\006_\325@\336 m\026\001\371d0\001 \000enter\336\047\001exit/\001fu\303nc7\001\201`\262cE\000in\376\030\001..genex\275p4\000maind\001m\217odulm\002\362\205\001v\001n\313ew}\001p\236\000\337bsu\334t\000\n\001res\247 __\340\026\001Z\004!\001\330\210\001\017\003unp\347ickK\000\362\206\010__q\047ualT\005\351\204\004_\351\204\016\202\205\006\003ex\372\001\233\204\001\210\005\376\204\006""\224 \202\205\016\237__tes\372\001\206\205\006_\376\233\"fields_\337fill_\215\205\004_i\377s_corout\257ine_\216\205\004_\202\205\004_\352\356\204\014_\336\204\020_\335\204\005asy\337ncio.E\006sb\303ig\264\205\004\311d\275\205\t\360\211\017NT\350\372\211\007\322\215\002\232@c\334\211\001cap\337acity\266\205\002cl\374\245\001\244@traceb\377ackclose\177clscoll\205\213\001\373on\000\010s.abc\377countdec\367ode\323\204\004dump\267sen\016\001fd\260\215\001f\373mt\377Dgethe\303ad\303`\327\216\002\005\004\344\212\001ht\317iidx\231\206\005\241\206\005vi\373nt\202\204\001sjson\356\374\205\005key\226\213\005key\353sk\243\213\001k\204\206\005kwd\377slittlel\357oads\210\216\002met\205a\000\001_\314\217\002\005\002\327\213\001\353\212\007n\377ativenet\377worknext\353ob\330\215\001o\263@tim\277e_over\264\001s\377openothe\375r\262 kpoppr\357efix\000\003_bi\357tsrb\370\210\001ret\377urnselfs\207end\352\206\007\315\214\001\334\211\002\342\211\001s}s\245\206\002throw\351\215\003\363unS\001\000\003ed_d\367ata\204\207\003use_D\224\212\005\t\000d\301\214\002\277\214\t\313\214\t_\204\204\003\010\006\n\334\214\001\027\nt\203\215\003\336\215\001\313\214\007\325\214\007\2507\n\352\205\0029\006s\350\216\004v\232\216\001w\375b\202\212\002BORGHA\377SH\200\001\330\004)\250\377\021\250&\260\001\200\001\340\377\004\037\230q\320 0\260\377\013\270;\300k\320QR\377\330\004\023\220;\230h\240\377a\240q\330\004\007\200|\377\2207\230!\330\010-\250\377Q\250n\270N\310!\330\377\004\013\2101\200\001\360\010\367\000\n\033\025\001\021\220\024\220\377]\240$\240h\250d\260\377+\270T\300\037\320PT\377\320Ta\320ae\320e\377t\320tx\320xy\330\377\010\020\220\007\220q\230\006\367\230l\250=\000\007\200v\210\377W\220E\230\024\230Q\330\367\010\022\220Z\000\027\220q\340\377\010\027\220t\230<\240w\377\250e\2603\260d\270\047\277\300\027\310\005\310SH\002b\377\320bi\320in\320n\377q\320qu\360\000\000vw\001D\002\004\000D\002K\003\001wK\002P\n\001P\002S\021\001wS\002W\030\001W\002c\037\001\367c\002j&\001j\002k\002\376\310\001q""\330\010\017\320\017,\377\250D\260\001\260\027\270\013\337\3007\310!\340\004\0131\200\377A\330\030\031\330\010\013\210\377:\220Q\220g\230U\240\357!\330\021\025\010\000f\230I\377\240Q\330\020\027\220s\230\377)\2401\240A\340\014\023\377\2203\220i\230q\240\001~0\000\032\033\330\010\026\220\037\002\367\240a\330\310\000r\230\025\230\373a\230m\000\013\2103\210a\357\210~\230R\n\000\014\022\220\367*\230A\362\001\017\210y\230\377\014\240F\250\047\260\021\260\373,\270/\000\013\2106\220\023\367\220A\330\035\003\320\0353\260\1771\260E\270\027\300\001\207\001\3658g\000a\022\0068\270\001\270\377\021\330\010\025\220R\220u\234H\003^\003|\2302\316 X\tt\377\2206\230\021\230*\240G\257\2501\250A.\001Z\254\000\004\377\240A\320%9\270\024\270\335Qt\001\031\230\032\313\000D\250\377\001\320)?\270t\3001\375\300%\000\027\220~\240R\240\375t/\003\r\210S\220\001\220\367\031\230$\314\000}\250M\270\377\036\300{\320RS\330\021\375\032\013\004K\260t\2701\270v[\000\020\220\251\000\017\210x\303@\2371\230M\250\024\255`\207 \014?\210E\220\025\220a\020\002\331\002\365\"\366@\021\316`\014\024\220B\337\220e\2301\230\361\000\016\210\325i\233`\005\223#q\211\000\004\026\177\220a\360\014\000\t\036\236a\277\014\210D\220\006\220\323 \017\377\210s\220!\2202\220S\377\230\004\230J\240b\250\004\276\214\000\022\2701\320\004\274`\330\377\010\014\210F\220&\230\001\376\013\000\320\027\047\240v\250Y\345\260z\002K\365`\302 \t\330\014\177\033\2304\230v\240Q\235@\327\017\020\330\273@1\277A4\320\277\027,\250A\250Q.\006_\366\310\001\014\210\047\rT\250\021\250\363!\3305\001\337\001s\230!\330\313\020\0212\020\032\247\205\001\244u\024\220\375J\220a\340\014\020\220\n\230{!\230\266\000\033\2301\340\342f\373Q\330\026\000\005\220Y\230e\377\2406\250\021\330\020\024\220\367A\220W\234 \r\027\220q\343\230\007\273a\301\205\002\021\005E\240\021O\240!\330\r\036\005R\000\007\215`\224\023\000\024\n\340M\004aF\007\247 Ef\314Bf\240\355`\264@\220\027\263!\325\034\207@\010\244 \030\333 A\330\371\014\333B\000\004\330\014\037\230t\377\240;\250a""\330\014!\240\337\024\240[\260\001\003\003]\260\375*\367@\014#\2404\240}\377\260A\330\014\034\230D\240\274\030\000>\001F\240!\330\340@D\377\230\006\230a\340\010\025\220\377T\230\026\230q\240\005\240}W\351!\330\010\024\220C\222C\367\027\220v\340\205\001\240<\250w\377\260i\270q\330\010\n\210e&\355`\021\000\006\270\207\001\001\330\251\010;F\250W\000\016\210f\233 \257 \376\000\006\025\220Q\330\010\017\210\371v\231b{\000\320\004\034\230Hx\336\000\021\000\203\205\001\031\240!\240\247`\321\034\266`\305b\225\205\003!\"\001J\240\234\t\006\035\006N\250*\316\000\317b!\376\374\210\001\320\004\035\230X\240Q\337\330\010\r\210_\342\000\006\240\337j\260\001\260\021m\001u\220\327D\320\030\231\211\001a \001^\250w8\2601\374\206\001t\320\033\323b\371\330y\004\342\205\001E\250\021\320\004\357\036\230j\250\320\206\0024\210z\257\230\021\230%\221\207\003)\213`\034\377A\300\021\300$\300a\300\272\255\207\006u\243 t\2301\216\207\004\230\347^\2501\266\210\001A\000\320\036.\373\250h\323\204\n\031\230\024\320\035\337.\250a\250qy\002\2306\377\240\033\250A\250U\260!\276|\002\320\023(\250\001z\001$\377\240F\250+\260V\2706=\300\210\000&\240h\250\366\207\002\205\003\275\047\330@Q\330\014\017\223\002\047\371\240\377`\207aK\240r\250\021\367\340\020\026\347\210\001\320 :\270\377!\2704\320?Q\320Q\377R\320RV\320VW\320\353WX\335\003=\332@R\240q?\320\0041\260\032\270\200 \303a\367M\250\027\237%t\220;\230\007b\240\001"; PyObject *data = __Pyx_DecompressString_LZSS(cstring, 2939, 4140); #define __Pyx_DecompressString_UNUSED if (unlikely(!data)) __PYX_ERR(0, 1, __pyx_L1_error) const char* const bytes = __Pyx_PyBytes_AsString(data); #if !CYTHON_ASSUME_SAFE_MACROS if (likely(bytes)); else { Py_DECREF(data); __PYX_ERR(0, 1, __pyx_L1_error) } #endif #else /* compression: none (4140 bytes) */ static const char bytes[] = " bytes long not found.!(tree fragment), , got .<<8sII=>?BinaryIO | str | bytesExpected an instance of Expected an instance of bytes, got Invalid file, file is too short.Invalid file, magic Iterator[tuple[bytes, Any]]Key must be Note that Cython is deliberately stricter than PEP-484 and rejects subclasses of builtin types. If you need to pass subclasses then set the \047annotation_typing\047 directive to False.Unsupported file version add_noteborghash.HashTablebyte_order must be one of: disableenablegcisenabledkey_size must be an integer and >= 4.src/borghash/HashTableNT.pyxtuple[bytes, Any]utf-8value_format must be a namedtuple instance.value_format\047s and value_type\047s element names must correspond.value_format\047s elements must be str and non-empty.value_type must be a namedtuple type.AnyBYTE_ORDERBinaryIOHEADER_FMTHashTableHashTableNTHashTableNT.__reduce_cython__HashTableNT.__setstate_cython__HashTableNT._check_keyHashTableNT._get_rawHashTableNT._read_fdHashTableNT._set_rawHashTableNT._to_binary_valueHashTableNT._to_namedtuple_valueHashTableNT._write_fdHashTableNT.clearHashTableNT.getHashTableNT.idx_to_kHashTableNT.idx_to_kvHashTableNT.itemsHashTableNT.k_to_idxHashTableNT.kv_to_idxHashTableNT.popHashTableNT.readHashTableNT.setdefaultHashTableNT.sizeHashTableNT.updateHashTableNT.writeIteratorMAGICMIN_CAPACITYMappingNNoneStructVERSION_NoDefault__Pyx_PyDict_NextRef__annotate____class____class_getitem____dict____enter____exit____func____getstate____init__..genexpr__main____module____name____new____pyx_checksum__pyx_result__pyx_state__pyx_type__pyx_unpickle_HashTableNT__qualname____reduce____reduce_cython____reduce_ex____set_name____setstate____setstate_cython____test___check_key_dict_fields_fill_get_raw_is_coroutine_read_fd_set_raw_to_binary_value_to_namedtuple_value_write_fdasyncio.coroutinesbigbinary_defaultbinary_valueborghash.HashTableNTbyte_orderbytescalcsizecapacityclearcline_in_tracebackcloseclscollectionscollections.abccountdecodedefaultdumpsenco""defdfilefmtgenexprgetheader_bytesheader_sizehtiidxidx_to_kidx_to_kvintitemsjsonk_to_idxkeykey_sizekeysksizekv_to_idxkwdslittleloadsmagicmetameta_bytesmeta_sizenamedtuplenativenetworknextobjectone_time_overheadsopenotherpackpopprefixprefix_bitsrbreadreturnselfsendsetdefaultsizestatestatsstructthrowtypingunpackunpacked_dataupdateuse_setstateusedvaluevalue_formatvalue_format_fieldsvalue_format_namevalue_format_tvalue_sizevalue_typevalue_type_fieldsvalue_type_namevaluesversionvsizewbwriteBORGHASH\200\001\330\004)\250\021\250&\260\001\200\001\340\004\037\230q\320 0\260\013\270;\300k\320QR\330\004\023\220;\230h\240a\240q\330\004\007\200|\2207\230!\330\010-\250Q\250n\270N\310!\330\004\013\2101\200\001\360\010\000\n\033\230!\330\010\021\220\024\220]\240$\240h\250d\260+\270T\300\037\320PT\320Ta\320ae\320et\320tx\320xy\330\010\020\220\007\220q\230\006\230l\250!\330\004\007\200v\210W\220E\230\024\230Q\330\010\022\220!\330\010\027\220q\340\010\027\220t\230<\240w\250e\2603\260d\270\047\300\027\310\005\310S\320PT\320Tb\320bi\320in\320nq\320qu\360\000\000v\001D\002\360\000\000D\002K\002\360\000\000K\002P\002\360\000\000P\002S\002\360\000\000S\002W\002\360\000\000W\002c\002\360\000\000c\002j\002\360\000\000j\002k\002\330\004\007\200q\330\010\017\320\017,\250D\260\001\260\027\270\013\3007\310!\340\010\017\320\017,\250D\260\001\260\027\270\013\3001\200A\330\030\031\330\010\013\210:\220Q\220g\230U\240!\330\021\025\220Q\220f\230I\240Q\330\020\027\220s\230)\2401\240A\340\014\023\2203\220i\230q\240\001\200A\330\032\033\330\010\026\220f\230I\240Q\240a\330\010\027\220r\230\025\230a\230q\330\010\013\2103\210a\210~\230R\230q\330\014\022\220*\230A\230Q\330\010\017\210y\230\014\240F\250\047\260\021\260,\270a\330\010\013\2106\220\023\220A\330\014\022\220*\230A\320\0353\2601\260E\270\027\300\001\330\010\013\2108\2203\220a\330\014\022\220*\230A\320\0358\270\001\270\021\330\010\025\220R\220u\230A\230Q\330\010\013\2103\210a\210|\2302\230Q\330\014\022\220*\230A\230Q\330\010\017\210t\2206\230\021""\230*\240G\2501\250A\330\010\025\220Z\230q\240\004\240A\320%9\270\024\270Q\270a\330\010\031\230\032\2401\240D\250\001\320)?\270t\3001\300A\330\010\027\220~\240R\240t\2501\250A\330\010\r\210S\220\001\220\031\230$\230a\230}\250M\270\036\300{\320RS\330\021\032\230$\230a\230}\250K\260t\2701\270A\330\010\020\220\001\330\010\017\210x\220t\2301\230M\250\024\250Q\250a\330\010\014\210E\220\025\220a\220t\2301\230A\330\014\022\220\"\220E\230\021\230!\330\014\024\220B\220e\2301\230A\330\014\016\210i\220q\230\005\230Q\330\010\017\210q\250\001\320\004\026\220a\360\014\000\t\036\230Q\330\010\014\210D\220\006\220a\330\010\017\210s\220!\2202\220S\230\004\230J\240b\250\004\250M\270\022\2701\320\004\027\220q\330\010\014\210F\220&\230\001\320\004\027\320\027\047\240v\250Y\260a\330\010\014\210K\220q\230\001\330\010\t\330\014\033\2304\230v\240Q\240a\330\017\020\330\014\023\2201\340\014\023\2204\320\027,\250A\250Q\320\004\027\320\027\047\240v\250_\270A\330\010\014\210K\220q\230\001\330\010\t\330\014\033\2304\230v\240T\250\021\250!\330\017\020\330\014\017\210x\220s\230!\330\020\021\330\014\023\2201\340\014\023\2204\320\027,\250A\250Q\320\004\032\230!\330\010\013\210:\220Q\220g\230U\240!\330\021\025\220Q\220f\230I\240Q\330\020\024\220J\230a\230q\340\014\020\220\n\230!\2301\320\004\033\2301\340\010\013\210:\220Q\220g\230Q\330\014\020\220\005\220Y\230e\2406\250\021\330\020\024\220A\220W\230A\330\r\027\220q\230\007\230q\330\014\020\220\007\220q\330\020\024\220A\220W\230E\240\021\240!\330\r\024\220A\220W\230A\330\014\020\220\007\220u\230E\240\021\330\020\024\220A\220W\230E\240\021\240!\340\014\020\220\005\220Y\230a\330\020\024\220A\220W\230A\330\010\014\210E\220\031\230$\230f\240A\330\014\020\220\001\220\027\230\001\320\004\034\230A\330\010\t\330\014\030\230\004\230A\330\014\032\230$\230a\330\014\032\230$\230a\330\014\037\230t\240;\250a\330\014!\240\024\240[\260\001\330\014!\240\024\240]\260*\270A\330\014#\2404\240}\260A\330\014\034\230D\240\001\330\014\030\230\004\230F\240!\330\014\024\220D""\230\006\230a\340\010\025\220T\230\026\230q\240\005\240W\250A\250Q\330\010\024\220C\220q\230\001\330\010\027\220v\230U\240!\240<\250w\260i\270q\330\010\n\210&\220\001\220\021\330\010\n\210&\220\001\220\021\330\010\020\220\001\330\010\014\210E\220\031\230$\230f\240F\250!\330\014\016\210f\220A\220Q\330\014\016\210f\220A\220Q\330\014\025\220Q\330\010\017\210v\220S\230\004\230F\240!\320\004\034\230H\240A\330\010\017\210t\2206\230\031\240!\2401\320\004\034\230J\240a\330\010\017\210t\2206\230\021\230!\320\004\034\230J\240a\330\010\017\210t\2206\230\031\240!\2401\320\004\034\230N\250*\260A\330\010\014\210F\220!\2207\230!\320\004\035\230X\240Q\330\010\r\210_\230D\240\006\240j\260\001\260\021\330\010\017\210u\220D\320\030-\250Q\250a\320\004\035\230^\2508\2601\330\010\027\220t\320\033,\250A\250Q\330\010\017\210t\2206\230\032\2401\240E\250\021\320\004\036\230j\250\001\330\010\013\2104\210z\230\021\230%\230q\330\014\022\220)\2301\320\034A\300\021\300$\300a\300q\330\010\013\2103\210a\210u\220C\220t\2301\330\014\022\220*\230A\230^\2501\250D\260\001\320\004\036\320\036.\250h\260a\330\010\014\210K\220q\230\001\330\010\031\230\024\320\035.\250a\250q\330\010\027\220t\2306\240\033\250A\250U\260!\330\010\017\210t\320\023(\250\001\250\021\320\004$\240F\250+\260V\2706\300\021\320\004&\240h\250a\330\010\013\2104\210z\230\021\230\047\240\024\240Q\330\014\017\210z\230\021\230\047\240\021\330\020\030\230\004\230K\240r\250\021\340\020\026\220i\230q\320 :\270!\2704\320?Q\320QR\320RV\320VW\320WX\330\010\017\210t\220=\240\005\240R\240q\320\0041\260\032\2701\330\010\030\230\004\230M\250\027\260\001\260\021\330\010\017\210t\220;\230b\240\001"; PyObject *data = NULL; #define __Pyx_DecompressString_UNUSED #define __Pyx_DecompressString_LZSS_UNUSED #endif PyObject **stringtab = __pyx_mstate->__pyx_string_tab; Py_ssize_t pos = 0; for (int i = 0; i < 203; i++) { Py_ssize_t bytes_length = str_length_index[i].length; PyObject *string = PyUnicode_DecodeUTF8(bytes + pos, bytes_length, NULL); if (likely(string) && i >= 37) PyUnicode_InternInPlace(&string); if (unlikely(!string)) { Py_XDECREF(data); __PYX_ERR(0, 1, __pyx_L1_error) } stringtab[i] = string; pos += bytes_length; } for (int i = 203; i < 228; i++) { Py_ssize_t bytes_length = bytes_length_index[i-203].length; PyObject *string = PyBytes_FromStringAndSize(bytes + pos, bytes_length); stringtab[i] = string; pos += bytes_length; if (unlikely(!string)) { Py_XDECREF(data); __PYX_ERR(0, 1, __pyx_L1_error) } } Py_XDECREF(data); for (Py_ssize_t i = 0; i < 228; i++) { if (unlikely(PyObject_Hash(stringtab[i]) == -1)) { __PYX_ERR(0, 1, __pyx_L1_error) } } #if CYTHON_IMMORTAL_CONSTANTS { PyObject **table = stringtab + 203; for (Py_ssize_t i=0; i<25; ++i) { #if PY_VERSION_HEX >= 0x030F0000 PyUnstable_SetImmortal(table[i]); #elif CYTHON_COMPILING_IN_CPYTHON_FREETHREADING if ((PY_SSIZE_T_MAX <= _Py_IMMORTAL_REFCNT_LOCAL)) break; #if PY_VERSION_HEX < 0x030E0000 if (_Py_IsOwnedByCurrentThread(table[i]) && Py_REFCNT(table[i]) == 1) #else if (PyUnstable_Object_IsUniquelyReferenced(table[i])) #endif { Py_SET_REFCNT(table[i], ((Py_ssize_t)_Py_IMMORTAL_REFCNT_LOCAL + 1)); } #else if ((PY_SSIZE_T_MAX < _Py_IMMORTAL_INITIAL_REFCNT)) break; Py_SET_REFCNT(table[i], _Py_IMMORTAL_INITIAL_REFCNT); #endif } } #endif } { PyObject **numbertab = __pyx_mstate->__pyx_number_tab + 0; int8_t const cint_constants_1[] = {0,1,4}; int16_t const cint_constants_2[] = {4096}; int32_t const cint_constants_4[] = {192473518L}; for (int i = 0; i < 5; i++) { numbertab[i] = PyLong_FromLong((i < 3 ? cint_constants_1[i - 0] : (i < 4 ? cint_constants_2[i - 3] : cint_constants_4[i - 4]))); if (unlikely(!numbertab[i])) __PYX_ERR(0, 1, __pyx_L1_error) } } #if CYTHON_IMMORTAL_CONSTANTS { PyObject **table = __pyx_mstate->__pyx_number_tab; for (Py_ssize_t i=0; i<5; ++i) { #if PY_VERSION_HEX >= 0x030F0000 PyUnstable_SetImmortal(table[i]); #elif CYTHON_COMPILING_IN_CPYTHON_FREETHREADING if ((PY_SSIZE_T_MAX <= _Py_IMMORTAL_REFCNT_LOCAL)) break; #if PY_VERSION_HEX < 0x030E0000 if (_Py_IsOwnedByCurrentThread(table[i]) && Py_REFCNT(table[i]) == 1) #else if (PyUnstable_Object_IsUniquelyReferenced(table[i])) #endif { Py_SET_REFCNT(table[i], ((Py_ssize_t)_Py_IMMORTAL_REFCNT_LOCAL + 1)); } #else if ((PY_SSIZE_T_MAX < _Py_IMMORTAL_INITIAL_REFCNT)) break; Py_SET_REFCNT(table[i], _Py_IMMORTAL_INITIAL_REFCNT); #endif } } #endif return 0; __pyx_L1_error:; return -1; } /* #### Code section: init_codeobjects ### */ #ifdef __cplusplus namespace { #endif typedef struct { unsigned int argcount : 2; unsigned int num_posonly_args : 2; unsigned int num_kwonly_args : 2; unsigned int nlocals : 5; unsigned int flags : 10; unsigned int first_line : 8; } __Pyx_PyCode_New_function_description; #ifdef __cplusplus } /* anonymous namespace */ #endif /* NewCodeObj.proto */ static PyObject* __Pyx_PyCode_New( const __Pyx_PyCode_New_function_description descr, PyObject * const *varnames, PyObject *filename, PyObject *funcname, PyObject *line_table, PyObject *tuple_dedup_map ); static int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate) { PyObject* tuple_dedup_map = PyDict_New(); if (unlikely(!tuple_dedup_map)) return -1; { const __Pyx_PyCode_New_function_description descr = {0, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_GENERATOR), 36}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_fmt}; __pyx_mstate_global->__pyx_codeobj_tab[0] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_borghash_HashTableNT_pyx, __pyx_mstate->__pyx_n_u_genexpr, __pyx_mstate->__pyx_kp_b_iso88591__11, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[0])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {1, 0, 2, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_GENERATOR), 93}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_prefix_bits, __pyx_mstate->__pyx_n_u_prefix, __pyx_mstate->__pyx_n_u_key, __pyx_mstate->__pyx_n_u_binary_value}; __pyx_mstate_global->__pyx_codeobj_tab[1] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_borghash_HashTableNT_pyx, __pyx_mstate->__pyx_n_u_items, __pyx_mstate->__pyx_kp_b_iso88591_F_V6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[1])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 49}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; __pyx_mstate_global->__pyx_codeobj_tab[2] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_borghash_HashTableNT_pyx, __pyx_mstate->__pyx_n_u_clear, __pyx_mstate->__pyx_kp_b_iso88591_q_F, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[2])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 52}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_key}; __pyx_mstate_global->__pyx_codeobj_tab[3] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_borghash_HashTableNT_pyx, __pyx_mstate->__pyx_n_u_check_key, __pyx_mstate->__pyx_kp_b_iso88591_j_4z_q_1_A_aq_3auCt1_A_1D, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[3])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 58}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_value}; __pyx_mstate_global->__pyx_codeobj_tab[4] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_borghash_HashTableNT_pyx, __pyx_mstate->__pyx_n_u_to_binary_value, __pyx_mstate->__pyx_kp_b_iso88591_ha_4z_Q_z_Kr_iq_4_QQRRVVWWX_t_R, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[4])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 66}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_binary_value, __pyx_mstate->__pyx_n_u_unpacked_data}; __pyx_mstate_global->__pyx_codeobj_tab[5] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_borghash_HashTableNT_pyx, __pyx_mstate->__pyx_n_u_to_namedtuple_value, __pyx_mstate->__pyx_kp_b_iso88591_1_1_M_t_b, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[5])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 70}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_key, __pyx_mstate->__pyx_n_u_value}; __pyx_mstate_global->__pyx_codeobj_tab[6] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_borghash_HashTableNT_pyx, __pyx_mstate->__pyx_n_u_set_raw, __pyx_mstate->__pyx_kp_b_iso88591_N_A_F_7, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[6])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 73}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_key}; __pyx_mstate_global->__pyx_codeobj_tab[7] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_borghash_HashTableNT_pyx, __pyx_mstate->__pyx_n_u_get_raw, __pyx_mstate->__pyx_kp_b_iso88591_Ja_t6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[7])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 105}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_key, __pyx_mstate->__pyx_n_u_default, __pyx_mstate->__pyx_n_u_binary_value}; __pyx_mstate_global->__pyx_codeobj_tab[8] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_borghash_HashTableNT_pyx, __pyx_mstate->__pyx_n_u_get, __pyx_mstate->__pyx_kp_b_iso88591_vYa_Kq_4vQa_1_4_AQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[8])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 114}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_key, __pyx_mstate->__pyx_n_u_default, __pyx_mstate->__pyx_n_u_binary_default, __pyx_mstate->__pyx_n_u_binary_value}; __pyx_mstate_global->__pyx_codeobj_tab[9] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_borghash_HashTableNT_pyx, __pyx_mstate->__pyx_n_u_setdefault, __pyx_mstate->__pyx_kp_b_iso88591_ha_Kq_aq_t6_AU_t, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[9])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 120}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_key, __pyx_mstate->__pyx_n_u_default, __pyx_mstate->__pyx_n_u_binary_value}; __pyx_mstate_global->__pyx_codeobj_tab[10] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_borghash_HashTableNT_pyx, __pyx_mstate->__pyx_n_u_pop, __pyx_mstate->__pyx_kp_b_iso88591_v_A_Kq_4vT_xs_1_4_AQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[10])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {2, 2, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 131}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_other, __pyx_mstate->__pyx_n_u_kwds, __pyx_mstate->__pyx_n_u_key, __pyx_mstate->__pyx_n_u_value}; __pyx_mstate_global->__pyx_codeobj_tab[11] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_borghash_HashTableNT_pyx, __pyx_mstate->__pyx_n_u_update, __pyx_mstate->__pyx_kp_b_iso88591_1_QgQ_Ye6_AWA_q_q_q_AWE_AWA_uE, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[11])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 148}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_key}; __pyx_mstate_global->__pyx_codeobj_tab[12] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_borghash_HashTableNT_pyx, __pyx_mstate->__pyx_n_u_k_to_idx, __pyx_mstate->__pyx_kp_b_iso88591_Ja_t6_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[12])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 151}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_idx}; __pyx_mstate_global->__pyx_codeobj_tab[13] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_borghash_HashTableNT_pyx, __pyx_mstate->__pyx_n_u_idx_to_k, __pyx_mstate->__pyx_kp_b_iso88591_HA_t6_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[13])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 154}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_key, __pyx_mstate->__pyx_n_u_value, __pyx_mstate->__pyx_n_u_binary_value}; __pyx_mstate_global->__pyx_codeobj_tab[14] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_borghash_HashTableNT_pyx, __pyx_mstate->__pyx_n_u_kv_to_idx, __pyx_mstate->__pyx_kp_b_iso88591_81_t_AQ_t6_1E, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[14])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 158}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_idx, __pyx_mstate->__pyx_n_u_key, __pyx_mstate->__pyx_n_u_binary_value}; __pyx_mstate_global->__pyx_codeobj_tab[15] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_borghash_HashTableNT_pyx, __pyx_mstate->__pyx_n_u_idx_to_kv, __pyx_mstate->__pyx_kp_b_iso88591_XQ__D_j_uD_Qa, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[15])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 166}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_file, __pyx_mstate->__pyx_n_u_fd}; __pyx_mstate_global->__pyx_codeobj_tab[16] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_borghash_HashTableNT_pyx, __pyx_mstate->__pyx_n_u_write, __pyx_mstate->__pyx_kp_b_iso88591_QgU_QfIQ_Jaq_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[16])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 173}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_fd, __pyx_mstate->__pyx_n_u_meta, __pyx_mstate->__pyx_n_u_meta_bytes, __pyx_mstate->__pyx_n_u_meta_size, __pyx_mstate->__pyx_n_u_header_bytes, __pyx_mstate->__pyx_n_u_count, __pyx_mstate->__pyx_n_u_key, __pyx_mstate->__pyx_n_u_value}; __pyx_mstate_global->__pyx_codeobj_tab[17] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_borghash_HashTableNT_pyx, __pyx_mstate->__pyx_n_u_write_fd, __pyx_mstate->__pyx_kp_b_iso88591_A_A_a_a_t_a_A_4_A_D_F_D_a_T_q_W, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[17])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 198}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_cls, __pyx_mstate->__pyx_n_u_file, __pyx_mstate->__pyx_n_u_fd}; __pyx_mstate_global->__pyx_codeobj_tab[18] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_borghash_HashTableNT_pyx, __pyx_mstate->__pyx_n_u_read, __pyx_mstate->__pyx_kp_b_iso88591_A_QgU_QfIQ_s_1A_3iq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[18])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 19, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 206}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_cls, __pyx_mstate->__pyx_n_u_fd, __pyx_mstate->__pyx_n_u_header_size, __pyx_mstate->__pyx_n_u_header_bytes, __pyx_mstate->__pyx_n_u_magic, __pyx_mstate->__pyx_n_u_version, __pyx_mstate->__pyx_n_u_meta_size, __pyx_mstate->__pyx_n_u_meta_bytes, __pyx_mstate->__pyx_n_u_meta, __pyx_mstate->__pyx_n_u_value_type, __pyx_mstate->__pyx_n_u_value_format_t, __pyx_mstate->__pyx_n_u_value_format, __pyx_mstate->__pyx_n_u_ht, __pyx_mstate->__pyx_n_u_count, __pyx_mstate->__pyx_n_u_ksize, __pyx_mstate->__pyx_n_u_vsize, __pyx_mstate->__pyx_n_u_i, __pyx_mstate->__pyx_n_u_key, __pyx_mstate->__pyx_n_u_value}; __pyx_mstate_global->__pyx_codeobj_tab[19] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_borghash_HashTableNT_pyx, __pyx_mstate->__pyx_n_u_read_fd, __pyx_mstate->__pyx_kp_b_iso88591_A_fIQa_r_aq_3a_Rq_AQ_y_F_a_6_A_A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[19])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 234}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_one_time_overheads, __pyx_mstate->__pyx_n_u_N}; __pyx_mstate_global->__pyx_codeobj_tab[20] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_borghash_HashTableNT_pyx, __pyx_mstate->__pyx_n_u_size, __pyx_mstate->__pyx_kp_b_iso88591_a_Q_D_a_s_2S_Jb_M_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[20])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_state, __pyx_mstate->__pyx_n_u_dict_2, __pyx_mstate->__pyx_n_u_use_setstate}; __pyx_mstate_global->__pyx_codeobj_tab[21] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_tree_fragment, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_mstate->__pyx_kp_b_iso88591_hd_T_PTTaaeettxxy_q_l_vWE_Q_q_t, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[21])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 17}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state}; __pyx_mstate_global->__pyx_codeobj_tab[22] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_tree_fragment, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_mstate->__pyx_kp_b_iso88591__12, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[22])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_pyx_type, __pyx_mstate->__pyx_n_u_pyx_checksum, __pyx_mstate->__pyx_n_u_pyx_state, __pyx_mstate->__pyx_n_u_pyx_result}; __pyx_mstate_global->__pyx_codeobj_tab[23] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_tree_fragment, __pyx_mstate->__pyx_n_u_pyx_unpickle_HashTableNT, __pyx_mstate->__pyx_kp_b_iso88591_q_0_kQR_haq_7_QnN_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[23])) goto bad; } Py_DECREF(tuple_dedup_map); return 0; bad: Py_DECREF(tuple_dedup_map); return -1; } /* #### Code section: init_globals ### */ static int __Pyx_InitGlobals(void) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; /* PythonCompatibility.init */ if (likely(__Pyx_init_co_variables() == 0 && __Pyx_init_tpflags_variables() == 0)); else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) /* PyFrozenDict.init */ #if CYTHON_COMPILING_IN_LIMITED_API { PyObject *builtins = PyEval_GetBuiltins(); // borrowed if (likely(builtins)) { PyObject *type_name = PyUnicode_FromStringAndSize("frozendict", sizeof("frozendict")-1); if (likely(type_name)) { PyObject *frozendict_type = PyObject_GetItem(builtins, type_name); Py_DECREF(type_name); if (!frozendict_type && PyErr_ExceptionMatches(PyExc_KeyError)) { PyErr_Clear(); frozendict_type = (PyObject*) &PyDict_Type; Py_INCREF(frozendict_type); } __pyx_mstate_global->__Pyx_PyFrozenDictType = frozendict_type; } } } // error handling follows #endif if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) /* AssertionsEnabled.init */ if (likely(__Pyx_init_assertions_enabled() == 0)); else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) /* CommonTypesMetaclass.init */ if (likely(__pyx_CommonTypesMetaclass_init(__pyx_m) == 0)); else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) /* CachedMethodType.init */ #if CYTHON_COMPILING_IN_LIMITED_API { PyObject *typesModule=NULL; typesModule = PyImport_ImportModule("types"); if (typesModule) { __pyx_mstate_global->__Pyx_CachedMethodType = PyObject_GetAttrString(typesModule, "MethodType"); Py_DECREF(typesModule); } } // error handling follows #endif if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) /* Generator.init */ if (likely(__pyx_Generator_init(__pyx_m) == 0)); else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } /* #### Code section: init_after_shared_utility ### */ static int __Pyx_InitAfterSharedUtility(void) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; /* CythonFunctionPerModule.init */ if (likely(__pyx_CyFunction_init(__pyx_m) == 0)); else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } /* #### Code section: cleanup_globals ### */ /* #### Code section: cleanup_module ### */ /* #### Code section: main_method ### */ /* #### Code section: utility_code_pragmas ### */ #ifdef _MSC_VER #pragma warning( push ) /* Warning 4127: conditional expression is constant * Cython uses constant conditional expressions to allow in inline functions to be optimized at * compile-time, so this warning is not useful */ #pragma warning( disable : 4127 ) #endif /* #### Code section: utility_code_def ### */ /* --- Runtime support code --- */ /* Refnanny */ #if CYTHON_REFNANNY static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { PyObject *m = NULL, *p = NULL; void *r = NULL; m = PyImport_ImportModule(modname); if (!m) goto end; p = PyObject_GetAttrString(m, "RefNannyAPI"); if (!p) goto end; r = PyLong_AsVoidPtr(p); end: Py_XDECREF(p); Py_XDECREF(m); return (__Pyx_RefNannyAPIStruct *)r; } #endif /* FastTypeChecks (used by GivenExceptionMatches) */ #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); } #endif /* PyErrFetchRestore (used by GivenExceptionMatches) */ #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 /* GivenExceptionMatches (used by PyErrExceptionMatches) */ #if CYTHON_COMPILING_IN_CPYTHON 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); } } static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; assert(PyExceptionClass_Check(exc_type)); n = PyTuple_GET_SIZE(tuple); for (i=0; i= 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 /* PyObjectGetAttrStr (used by PyObjectGetAttrStrNoError) */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro)) return tp->tp_getattro(obj, attr_name); return PyObject_GetAttr(obj, attr_name); } #endif /* PyObjectGetAttrStrNoError (used by GetBuiltinName) */ #if __PYX_LIMITED_VERSION_HEX < 0x030d0000 static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) __Pyx_PyErr_Clear(); } #endif static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { PyObject *result; #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 (void) PyObject_GetOptionalAttr(obj, attr_name, &result); return result; #else #if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); } #endif result = __Pyx_PyObject_GetAttrStr(obj, attr_name); if (unlikely(!result)) { __Pyx_PyObject_GetAttrStr_ClearAttributeError(); } return result; #endif } /* GetBuiltinName */ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_mstate_global->__pyx_b, name); if (unlikely(!result) && !PyErr_Occurred()) { PyErr_Format(PyExc_NameError, "name '%U' is not defined", name); } return result; } /* CopyObjectArray (used by TupleOrListFromArrayImpl) */ #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); } } #endif /* TupleOrListFromArrayImpl (used by TupleFromArray) */ #if !(PY_VERSION_HEX >= 0x030F0000 && !CYTHON_COMPILING_IN_LIMITED_API) CYTHON_UNUSED static PyObject * __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) { if (n <= 0) { return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_tuple); } PyObject *res = PyTuple_New(n); if (unlikely(res == NULL)) return NULL; #if CYTHON_COMPILING_IN_CPYTHON __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n); #else Py_ssize_t i; for (i = 0; i < n; i++) { Py_INCREF(src[i]); if (unlikely(__Pyx_PyTuple_SET_ITEM(res, i, src[i]) < (0))) { Py_DECREF(res); return NULL; } } #endif return res; } #endif /* PyObjectCompare (used by UnicodeEquals) */ #ifndef __Pyx_DEFINED_PyObject_CompareStrStrBoolEq #define __Pyx_DEFINED_PyObject_CompareStrStrBoolEq static CYTHON_INLINE int __Pyx_PyObject_CompareStrStrBoolEq(PyObject* s1, PyObject* s2) { #if __PYX_LIMITED_VERSION_HEX >= 0x030e0000 int result = PyUnicode_Equal(s1, s2); #if !CYTHON_COMPILING_IN_CPYTHON if (unlikely(result == -1)) return -1; #endif if (result == 0) goto __pyx_return_false; else goto __pyx_return_true; #else int result = PyUnicode_Compare(s1, s2); if (unlikely((result == -1) && PyErr_Occurred())) return -1; if (result == 0) goto __pyx_return_true; else goto __pyx_return_false; #endif __pyx_return_true: return 1; __pyx_return_false: return 0; } #endif static CYTHON_INLINE int __Pyx_PyObject_CompareBoolEq_str_str(PyObject *op1, PyObject *op2, int pyop) { CYTHON_UNUSED_VAR(pyop); if (unlikely(op1 == Py_None)) { if (op2 == Py_None) goto __pyx_return_true; else goto __pyx_return_false; } if (unlikely(op2 == Py_None)) { if (op1 == Py_None) goto __pyx_return_true; else goto __pyx_return_false; } if (likely(op1 != Py_None)) { if (op1 == op2) goto __pyx_return_true; if (likely(op2 != Py_None)) { return __Pyx_PyObject_CompareStrStrBoolEq(op1, op2); } goto __pyx_richcmp; } if ((0)) goto __pyx_richcmp; if ((0)) goto __pyx_return_true; if ((0)) goto __pyx_return_false; __pyx_richcmp: return __Pyx_PyObject_RichCompareBool(op1, op2, Py_EQ); __pyx_return_true: return 1; __pyx_return_false: return 0; } /* fastcall */ #if CYTHON_VECTORCALL static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) { Py_ssize_t i, n = __Pyx_PyTuple_GET_SIZE(kwnames); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely(n == -1)) return NULL; #endif for (i = 0; i < n; i++) { PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely(!namei)) return NULL; #endif if (s == namei) return kwvalues[i]; } for (i = 0; i < n; i++) { PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely(!namei)) return NULL; #endif int eq = __Pyx_PyUnicode_Equals(s, namei); if (unlikely(eq != 0)) { if (unlikely(eq < 0)) return NULL; return kwvalues[i]; } } return NULL; } #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_GRAAL CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { Py_ssize_t i, nkwargs; PyObject *dict; #if !CYTHON_ASSUME_SAFE_SIZE nkwargs = PyTuple_Size(kwnames); if (unlikely(nkwargs < 0)) return NULL; #else nkwargs = PyTuple_GET_SIZE(kwnames); #endif dict = PyDict_New(); if (unlikely(!dict)) return NULL; for (i=0; itp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) return NULL; result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* PyObjectCallMethO (used by PyObjectFastCall) */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { PyObject *self, *result; PyCFunction cfunc; cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); self = __Pyx_CyOrPyCFunction_GET_SELF(func); if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) return NULL; result = cfunc(self, arg); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* PyObjectFastCall (used by PyObjectCallOneArg) */ #if CYTHON_COMPILING_IN_LIMITED_API static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject * const*args, size_t nargs, PyObject *kwargs) { PyObject *argstuple; PyObject *result = 0; size_t i; argstuple = PyTuple_New((Py_ssize_t)nargs); if (unlikely(!argstuple)) return NULL; for (i = 0; i < nargs; i++) { Py_INCREF(args[i]); if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) != (0)) goto bad; } result = __Pyx_PyObject_Call(func, argstuple, kwargs); bad: Py_DECREF(argstuple); return result; } #endif #if CYTHON_VECTORCALL && !(CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY) #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE vectorcallfunc __Pyx_PyVectorcall_Function(PyObject *callable) { PyTypeObject *tp = Py_TYPE(callable); #if defined(__Pyx_CyFunction_USED) if (__Pyx_CyFunction_CheckExact(callable)) { return __Pyx_CyFunction_func_vectorcall(callable); } #endif if (!PyType_HasFeature(tp, Py_TPFLAGS_HAVE_VECTORCALL)) { return NULL; } assert(PyCallable_Check(callable)); Py_ssize_t offset = tp->tp_vectorcall_offset; assert(offset > 0); vectorcallfunc ptr; memcpy(&ptr, (char *) callable + offset, sizeof(ptr)); return ptr; } #else #define __Pyx_PyVectorcall_Function(callable) PyVectorcall_Function(callable) #endif #endif static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwargs) { Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(nargsf); #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 (kwargs == NULL) { #if CYTHON_VECTORCALL #if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY return PyObject_Vectorcall(func, args, nargsf, NULL); #else vectorcallfunc f = __Pyx_PyVectorcall_Function(func); if (f) { return f(func, args, nargsf, NULL); } #endif #endif } if (nargs == 0) { return __Pyx_PyObject_Call(func, __pyx_mstate_global->__pyx_empty_tuple, kwargs); } #if CYTHON_COMPILING_IN_LIMITED_API return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs); #elif CYTHON_COMPILING_IN_PYPY return PyObject_VectorcallDict(func, args, (size_t) nargs, kwargs); #else return PyObject_VectorcallDict(func, args, nargsf, kwargs); #endif } /* PyObjectCallOneArg (used by CallUnboundCMethod0) */ 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); } /* IgnoreException (used by UnpackUnboundCMethod_impl) */ static CYTHON_INLINE int __Pyx_IgnoreGivenException(PyObject *given_exception, PyObject *ignorable_exception) { if (PyErr_GivenExceptionMatches(given_exception ? given_exception : PyErr_Occurred(), ignorable_exception)) { PyErr_Clear(); return 1; } return 0; } /* UnpackUnboundCMethod_impl (used by UnpackUnboundCMethod) */ #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030C0000 static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *args, PyObject *kwargs) { PyObject *result; PyObject *selfless_args = PyTuple_GetSlice(args, 1, PyTuple_Size(args)); if (unlikely(!selfless_args)) return NULL; result = PyObject_Call(method, selfless_args, kwargs); Py_DECREF(selfless_args); return result; } #else static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) { return PyObject_Vectorcall(method, args ? args+1 : NULL, nargs ? (size_t) nargs-1 : 0, kwnames); } #endif static PyMethodDef __Pyx_UnboundCMethod_Def = { "CythonUnboundCMethod", __PYX_REINTERPRET_FUNCION(PyCFunction, __Pyx_SelflessCall), #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030C0000 METH_VARARGS | METH_KEYWORDS, #else METH_FASTCALL | METH_KEYWORDS, #endif NULL }; static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) { PyObject *method, *result=NULL; method = __Pyx_PyObject_GetAttrStr(target->type, *target->method_name); if (unlikely(!method)) return -1; result = method; #if CYTHON_COMPILING_IN_CPYTHON if (likely(__Pyx_TypeCheck(method, &PyMethodDescr_Type))) { PyMethodDescrObject *descr = (PyMethodDescrObject*) method; target->func = descr->d_method->ml_meth; target->flag = descr->d_method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST); } 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 && !__Pyx_IgnoreException(PyExc_AttributeError)) { return -1; } #else self = PyCFunction_GET_SELF(method); #endif self_found = (self && self != Py_None); #if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY Py_XDECREF(self); #endif if (self_found) { PyObject *unbound_method = PyCFunction_New(&__Pyx_UnboundCMethod_Def, method); if (unlikely(!unbound_method)) return -1; Py_DECREF(method); result = unbound_method; } } #if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING if (unlikely(target->method)) { Py_DECREF(result); } else #endif target->method = result; return 0; } /* CallUnboundCMethod0 */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) { int was_initialized = __Pyx_CachedCFunction_GetAndSetInitializing(cfunc); if (likely(was_initialized == 2 && cfunc->func)) { if (likely(cfunc->flag == METH_NOARGS)) return __Pyx_CallCFunction(cfunc, self, NULL); if (likely(cfunc->flag == METH_FASTCALL)) return __Pyx_CallCFunctionFast(cfunc, self, NULL, 0); if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS)) return __Pyx_CallCFunctionFastWithKeywords(cfunc, self, NULL, 0, NULL); if (likely(cfunc->flag == (METH_VARARGS | METH_KEYWORDS))) return __Pyx_CallCFunctionWithKeywords(cfunc, self, __pyx_mstate_global->__pyx_empty_tuple, NULL); if (cfunc->flag == METH_VARARGS) return __Pyx_CallCFunction(cfunc, self, __pyx_mstate_global->__pyx_empty_tuple); return __Pyx__CallUnboundCMethod0(cfunc, self); } #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING else if (unlikely(was_initialized == 1)) { __Pyx_CachedCFunction tmp_cfunc = { #ifndef __cplusplus 0 #endif }; tmp_cfunc.type = cfunc->type; tmp_cfunc.method_name = cfunc->method_name; return __Pyx__CallUnboundCMethod0(&tmp_cfunc, self); } #endif PyObject *result = __Pyx__CallUnboundCMethod0(cfunc, self); __Pyx_CachedCFunction_SetFinishedInitializing(cfunc); return result; } #endif static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) { PyObject *result; if (unlikely(!cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; result = __Pyx_PyObject_CallOneArg(cfunc->method, self); return result; } /* py_dict_items (used by OwnedDictNext) */ static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d) { return __Pyx_CallUnboundCMethod0(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_items, d); } /* py_dict_values (used by OwnedDictNext) */ static CYTHON_INLINE PyObject* __Pyx_PyDict_Values(PyObject* d) { return __Pyx_CallUnboundCMethod0(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_values, d); } /* OwnedDictNext (used by ParseKeywordsImpl) */ #if CYTHON_AVOID_BORROWED_REFS static int __Pyx_PyDict_NextRef(PyObject *p, PyObject **ppos, PyObject **pkey, PyObject **pvalue) { PyObject *next = NULL; if (!*ppos) { if (pvalue) { PyObject *dictview = pkey ? __Pyx_PyDict_Items(p) : __Pyx_PyDict_Values(p); if (unlikely(!dictview)) goto bad; *ppos = PyObject_GetIter(dictview); Py_DECREF(dictview); } else { *ppos = PyObject_GetIter(p); } if (unlikely(!*ppos)) goto bad; } next = PyIter_Next(*ppos); if (!next) { if (PyErr_Occurred()) goto bad; return 0; } if (pkey && pvalue) { *pkey = __Pyx_PySequence_ITEM(next, 0); if (unlikely(*pkey)) goto bad; *pvalue = __Pyx_PySequence_ITEM(next, 1); if (unlikely(*pvalue)) goto bad; Py_DECREF(next); } else if (pkey) { *pkey = next; } else { assert(pvalue); *pvalue = next; } return 1; bad: Py_XDECREF(next); #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d0000 PyErr_FormatUnraisable("Exception ignored in __Pyx_PyDict_NextRef"); #else PyErr_WriteUnraisable(__pyx_mstate_global->__pyx_n_u_Pyx_PyDict_NextRef); #endif if (pkey) *pkey = NULL; if (pvalue) *pvalue = NULL; return 0; } #else // !CYTHON_AVOID_BORROWED_REFS static int __Pyx_PyDict_NextRef(PyObject *p, Py_ssize_t *ppos, PyObject **pkey, PyObject **pvalue) { int result = PyDict_Next(p, ppos, pkey, pvalue); if (likely(result == 1)) { if (pkey) Py_INCREF(*pkey); if (pvalue) Py_INCREF(*pvalue); } return result; } #endif /* RaiseDoubleKeywords (used by ParseKeywordsImpl) */ static void __Pyx_RaiseDoubleKeywordsError( const char* func_name, PyObject* kw_name) { PyErr_Format(PyExc_TypeError, "%s() got multiple values for keyword argument '%U'", func_name, kw_name); } /* CallUnboundCMethod2 */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2) { int was_initialized = __Pyx_CachedCFunction_GetAndSetInitializing(cfunc); if (likely(was_initialized == 2 && cfunc->func)) { PyObject *args[2] = {arg1, arg2}; if (cfunc->flag == METH_FASTCALL) { return __Pyx_CallCFunctionFast(cfunc, self, args, 2); } if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS)) return __Pyx_CallCFunctionFastWithKeywords(cfunc, self, args, 2, NULL); } #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING else if (unlikely(was_initialized == 1)) { __Pyx_CachedCFunction tmp_cfunc = { #ifndef __cplusplus 0 #endif }; tmp_cfunc.type = cfunc->type; tmp_cfunc.method_name = cfunc->method_name; return __Pyx__CallUnboundCMethod2(&tmp_cfunc, self, arg1, arg2); } #endif PyObject *result = __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2); __Pyx_CachedCFunction_SetFinishedInitializing(cfunc); return result; } #endif static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2){ if (unlikely(!cfunc->func && !cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; #if CYTHON_COMPILING_IN_CPYTHON if (cfunc->func && (cfunc->flag & METH_VARARGS)) { PyObject *result = NULL; PyObject *args = PyTuple_New(2); if (unlikely(!args)) return NULL; Py_INCREF(arg1); PyTuple_SET_ITEM(args, 0, arg1); Py_INCREF(arg2); PyTuple_SET_ITEM(args, 1, arg2); if (cfunc->flag & METH_KEYWORDS) result = __Pyx_CallCFunctionWithKeywords(cfunc, self, args, NULL); else result = __Pyx_CallCFunction(cfunc, self, args); Py_DECREF(args); return result; } #endif { PyObject *args[4] = {NULL, self, arg1, arg2}; return __Pyx_PyObject_FastCall(cfunc->method, args+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); } } /* ParseKeywordsImpl (used by ParseKeywords) */ static int __Pyx_ValidateDuplicatePosArgs( PyObject *kwds, PyObject ** const argnames[], PyObject ** const *first_kw_arg, const char* function_name) { PyObject ** const *name = argnames; while (name != first_kw_arg) { PyObject *key = **name; int found = PyDict_Contains(kwds, key); if (unlikely(found)) { if (found == 1) __Pyx_RaiseDoubleKeywordsError(function_name, key); goto bad; } name++; } return 0; bad: return -1; } #if CYTHON_USE_UNICODE_INTERNALS static CYTHON_INLINE int __Pyx_UnicodeKeywordsEqual(PyObject *s1, PyObject *s2) { int kind; Py_ssize_t len = PyUnicode_GET_LENGTH(s1); if (len != PyUnicode_GET_LENGTH(s2)) return 0; kind = PyUnicode_KIND(s1); if (kind != PyUnicode_KIND(s2)) return 0; const void *data1 = PyUnicode_DATA(s1); const void *data2 = PyUnicode_DATA(s2); return (memcmp(data1, data2, (size_t) len * (size_t) kind) == 0); } #endif static int __Pyx_MatchKeywordArg_str( PyObject *key, PyObject ** const argnames[], PyObject ** const *first_kw_arg, size_t *index_found, const char *function_name) { PyObject ** const *name; #if CYTHON_USE_UNICODE_INTERNALS Py_hash_t key_hash = ((PyASCIIObject*)key)->hash; if (unlikely(key_hash == -1)) { key_hash = PyObject_Hash(key); if (unlikely(key_hash == -1)) goto bad; } #endif name = first_kw_arg; while (*name) { PyObject *name_str = **name; #if CYTHON_USE_UNICODE_INTERNALS if (key_hash == ((PyASCIIObject*)name_str)->hash && __Pyx_UnicodeKeywordsEqual(name_str, key)) { *index_found = (size_t) (name - argnames); return 1; } #else #if CYTHON_ASSUME_SAFE_SIZE if (PyUnicode_GET_LENGTH(name_str) == PyUnicode_GET_LENGTH(key)) #endif { int cmp = PyUnicode_Compare(name_str, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) { *index_found = (size_t) (name - argnames); return 1; } } #endif name++; } name = argnames; while (name != first_kw_arg) { PyObject *name_str = **name; #if CYTHON_USE_UNICODE_INTERNALS if (unlikely(key_hash == ((PyASCIIObject*)name_str)->hash)) { if (__Pyx_UnicodeKeywordsEqual(name_str, key)) goto arg_passed_twice; } #else #if CYTHON_ASSUME_SAFE_SIZE if (PyUnicode_GET_LENGTH(name_str) == PyUnicode_GET_LENGTH(key)) #endif { if (unlikely(name_str == key)) goto arg_passed_twice; int cmp = PyUnicode_Compare(name_str, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) goto arg_passed_twice; } #endif name++; } return 0; arg_passed_twice: __Pyx_RaiseDoubleKeywordsError(function_name, key); goto bad; bad: return -1; } static int __Pyx_MatchKeywordArg_nostr( PyObject *key, PyObject ** const argnames[], PyObject ** const *first_kw_arg, size_t *index_found, const char *function_name) { PyObject ** const *name; if (unlikely(!PyUnicode_Check(key))) goto invalid_keyword_type; name = first_kw_arg; while (*name) { int cmp = PyObject_RichCompareBool(**name, key, Py_EQ); if (cmp == 1) { *index_found = (size_t) (name - argnames); return 1; } if (unlikely(cmp == -1)) goto bad; name++; } name = argnames; while (name != first_kw_arg) { int cmp = PyObject_RichCompareBool(**name, key, Py_EQ); if (unlikely(cmp != 0)) { if (cmp == 1) goto arg_passed_twice; else goto bad; } name++; } return 0; arg_passed_twice: __Pyx_RaiseDoubleKeywordsError(function_name, key); goto bad; invalid_keyword_type: PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); goto bad; bad: return -1; } static CYTHON_INLINE int __Pyx_MatchKeywordArg( PyObject *key, PyObject ** const argnames[], PyObject ** const *first_kw_arg, size_t *index_found, const char *function_name) { return likely(PyUnicode_CheckExact(key)) ? __Pyx_MatchKeywordArg_str(key, argnames, first_kw_arg, index_found, function_name) : __Pyx_MatchKeywordArg_nostr(key, argnames, first_kw_arg, index_found, function_name); } static void __Pyx_RejectUnknownKeyword( PyObject *kwds, PyObject ** const argnames[], PyObject ** const *first_kw_arg, const char *function_name) { #if CYTHON_AVOID_BORROWED_REFS PyObject *pos = NULL; #else Py_ssize_t pos = 0; #endif PyObject *key = NULL; __Pyx_BEGIN_CRITICAL_SECTION(kwds); #if CYTHON_AVOID_BORROWED_REFS while (__Pyx_PyDict_NextRef(kwds, &pos, &key, NULL)) #else (void) __Pyx_PyDict_NextRef; while (PyDict_Next(kwds, &pos, &key, NULL)) #endif { PyObject** const *name = first_kw_arg; while (*name && (**name != key)) name++; if (!*name) { size_t index_found = 0; int cmp = __Pyx_MatchKeywordArg(key, argnames, first_kw_arg, &index_found, function_name); if (cmp != 1) { if (cmp == 0) { PyErr_Format(PyExc_TypeError, "%s() got an unexpected keyword argument '%U'", function_name, key); } #if CYTHON_AVOID_BORROWED_REFS Py_DECREF(key); #endif break; } } #if CYTHON_AVOID_BORROWED_REFS Py_DECREF(key); #endif } __Pyx_END_CRITICAL_SECTION(); #if CYTHON_AVOID_BORROWED_REFS Py_XDECREF(pos); #endif assert(PyErr_Occurred()); } static int __Pyx_ParseKeywordDict( PyObject *kwds, PyObject ** const argnames[], PyObject *values[], Py_ssize_t num_pos_args, Py_ssize_t num_kwargs, const char* function_name, int ignore_unknown_kwargs) { PyObject** const *name; PyObject** const *first_kw_arg = argnames + num_pos_args; Py_ssize_t extracted = 0; #if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return -1; #endif name = first_kw_arg; while (*name && num_kwargs > extracted) { PyObject * key = **name; PyObject *value; int found = 0; #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 found = PyDict_GetItemRef(kwds, key, &value); #else value = PyDict_GetItemWithError(kwds, key); if (value) { Py_INCREF(value); found = 1; } else { if (unlikely(PyErr_Occurred())) goto bad; } #endif if (found) { if (unlikely(found < 0)) goto bad; values[name-argnames] = value; extracted++; } name++; } if (num_kwargs > extracted) { if (ignore_unknown_kwargs) { if (unlikely(__Pyx_ValidateDuplicatePosArgs(kwds, argnames, first_kw_arg, function_name) == -1)) goto bad; } else { __Pyx_RejectUnknownKeyword(kwds, argnames, first_kw_arg, function_name); goto bad; } } return 0; bad: return -1; } static int __Pyx_ParseKeywordDictToDict( PyObject *kwds, PyObject ** const argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name) { PyObject** const *name; PyObject** const *first_kw_arg = argnames + num_pos_args; Py_ssize_t len; #if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return -1; #endif if (PyDict_Update(kwds2, kwds) < 0) goto bad; name = first_kw_arg; while (*name) { PyObject *key = **name; PyObject *value; #if !CYTHON_COMPILING_IN_LIMITED_API && (PY_VERSION_HEX >= 0x030d00A2 || defined(PyDict_Pop)) int found = PyDict_Pop(kwds2, key, &value); if (found) { if (unlikely(found < 0)) goto bad; values[name-argnames] = value; } #elif __PYX_LIMITED_VERSION_HEX >= 0x030d0000 int found = PyDict_GetItemRef(kwds2, key, &value); if (found) { if (unlikely(found < 0)) goto bad; values[name-argnames] = value; if (unlikely(PyDict_DelItem(kwds2, key) < 0)) goto bad; } #else #if CYTHON_COMPILING_IN_CPYTHON value = _PyDict_Pop(kwds2, key, kwds2); #else value = __Pyx_CallUnboundCMethod2(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_pop, kwds2, key, kwds2); #endif if (value == kwds2) { Py_DECREF(value); } else { if (unlikely(!value)) goto bad; values[name-argnames] = value; } #endif name++; } len = PyDict_Size(kwds2); if (len > 0) { return __Pyx_ValidateDuplicatePosArgs(kwds, argnames, first_kw_arg, function_name); } else if (unlikely(len == -1)) { goto bad; } return 0; bad: return -1; } static int __Pyx_ParseKeywordsTuple( PyObject *kwds, PyObject * const *kwvalues, PyObject ** const argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, Py_ssize_t num_kwargs, const char* function_name, int ignore_unknown_kwargs) { PyObject *key = NULL; PyObject** const * name; PyObject** const *first_kw_arg = argnames + num_pos_args; for (Py_ssize_t pos = 0; pos < num_kwargs; pos++) { #if CYTHON_AVOID_BORROWED_REFS key = __Pyx_PySequence_ITEM(kwds, pos); #else key = __Pyx_PyTuple_GET_ITEM(kwds, pos); #endif #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely(!key)) goto bad; #endif name = first_kw_arg; while (*name && (**name != key)) name++; if (*name) { PyObject *value = kwvalues[pos]; values[name-argnames] = __Pyx_NewRef(value); } else { size_t index_found = 0; int cmp = __Pyx_MatchKeywordArg(key, argnames, first_kw_arg, &index_found, function_name); if (cmp == 1) { PyObject *value = kwvalues[pos]; values[index_found] = __Pyx_NewRef(value); } else { if (unlikely(cmp == -1)) goto bad; if (kwds2) { PyObject *value = kwvalues[pos]; if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; } else if (!ignore_unknown_kwargs) { goto invalid_keyword; } } } #if CYTHON_AVOID_BORROWED_REFS Py_DECREF(key); key = NULL; #endif } return 0; invalid_keyword: PyErr_Format(PyExc_TypeError, "%s() got an unexpected keyword argument '%U'", function_name, key); goto bad; bad: #if CYTHON_AVOID_BORROWED_REFS Py_XDECREF(key); #endif return -1; } /* ParseKeywords */ static int __Pyx_ParseKeywords( PyObject *kwds, PyObject * const *kwvalues, PyObject ** const argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, Py_ssize_t num_kwargs, const char* function_name, int ignore_unknown_kwargs) { if (CYTHON_VECTORCALL && likely(PyTuple_Check(kwds))) return __Pyx_ParseKeywordsTuple(kwds, kwvalues, argnames, kwds2, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs); else if (kwds2) return __Pyx_ParseKeywordDictToDict(kwds, argnames, kwds2, values, num_pos_args, function_name); else return __Pyx_ParseKeywordDict(kwds, argnames, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs); } /* RaiseKeywordRequired */ static void __Pyx_RaiseKeywordRequired(const char* func_name, PyObject* kw_name) { PyErr_Format(PyExc_TypeError, "%s() needs keyword-only argument %U", func_name, kw_name); } /* FormatTypeName (used by pybuiltin_invalid) */ #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 static __Pyx_TypeName __Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp) { PyObject *module = NULL, *name = NULL, *result = NULL; #if __PYX_LIMITED_VERSION_HEX < 0x030b0000 name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, __pyx_mstate_global->__pyx_n_u_qualname); #else name = PyType_GetQualName(tp); #endif if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) goto bad; module = __Pyx_PyObject_GetAttrStr((PyObject *)tp, __pyx_mstate_global->__pyx_n_u_module); if (unlikely(module == NULL) || unlikely(!PyUnicode_Check(module))) goto bad; if (PyUnicode_CompareWithASCIIString(module, "builtins") == 0) { result = name; name = NULL; goto done; } result = PyUnicode_FromFormat("%U.%U", module, name); if (unlikely(result == NULL)) goto bad; done: Py_XDECREF(name); Py_XDECREF(module); return result; bad: PyErr_Clear(); if (name) { result = name; name = NULL; } else { result = __Pyx_NewRef(__pyx_mstate_global->__pyx_kp_u__2); } goto done; } #endif /* pybuiltin_invalid (used by pyint_simplify) */ static void __Pyx_PyBuiltin_Invalid(PyObject *obj, const char *builtin_type_name, const char *argname) { __Pyx_TypeName obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 if (unlikely(!obj_type_name)) return; #endif if (argname) { PyErr_Format(PyExc_TypeError, "Argument '%.200s' has incorrect type (expected %.5s, got " __Pyx_FMT_TYPENAME ")", argname, builtin_type_name, obj_type_name ); } else { PyErr_Format(PyExc_TypeError, "Expected %.5s, got " __Pyx_FMT_TYPENAME, builtin_type_name, obj_type_name ); } __Pyx_DECREF_TypeName(obj_type_name); } /* pyint_simplify */ static int __Pyx__PyInt_FromNumber(PyObject **number_var, const char *argname); static CYTHON_INLINE int __Pyx_PyInt_FromNumber(PyObject **number_var, const char *argname, int accept_none) { PyObject *number = *number_var; if (likely((accept_none && number == Py_None) || PyLong_CheckExact(number))) { return 0; } return __Pyx__PyInt_FromNumber(number_var, argname); } static int __Pyx__PyInt_FromNumber(PyObject **number_var, const char *argname) { PyObject *number = *number_var; PyObject *int_object; if (likely(PyNumber_Check(number))) { int_object = PyNumber_Long(number); if (unlikely(!int_object)) goto bad; } else { __Pyx_PyBuiltin_Invalid(number, "int", argname); goto bad; } *number_var = int_object; Py_DECREF(number); return 0; bad: *number_var = NULL; Py_DECREF(number); 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); } /* ArgTypeTestError (used by ArgTypeTest) */ static void __Pyx_ArgTypeError(PyObject *obj, PyTypeObject *type, const char *name, int exact) { __Pyx_TypeName type_name; __Pyx_TypeName obj_type_name; PyObject *extra_info = __pyx_mstate_global->__pyx_empty_unicode; int from_annotation_subclass = 0; if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return; } else if (exact == 2) { if (__Pyx_TypeCheck(obj, type)) { from_annotation_subclass = 1; extra_info = __pyx_mstate_global->__pyx_kp_u_Note_that_Cython_is_deliberately; } } type_name = __Pyx_PyType_GetFullyQualifiedName(type); #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 if (unlikely(!type_name)) return; #endif obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 if (unlikely(!obj_type_name)) goto obj_type_name_failed; #endif PyErr_Format(PyExc_TypeError, "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME ", got " __Pyx_FMT_TYPENAME ")" #if __PYX_LIMITED_VERSION_HEX < 0x030C0000 "%s%U" #endif , name, type_name, obj_type_name #if __PYX_LIMITED_VERSION_HEX < 0x030C0000 , (from_annotation_subclass ? ". " : ""), extra_info #endif ); #if __PYX_LIMITED_VERSION_HEX >= 0x030C0000 if (exact == 2 && from_annotation_subclass) { PyObject *res; PyObject *vargs[2]; vargs[0] = PyErr_GetRaisedException(); vargs[1] = extra_info; res = PyObject_VectorcallMethod(__pyx_mstate_global->__pyx_kp_u_add_note, vargs, 2, NULL); Py_XDECREF(res); PyErr_SetRaisedException(vargs[0]); } #endif __Pyx_DECREF_TypeName(obj_type_name); #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 obj_type_name_failed: #endif __Pyx_DECREF_TypeName(type_name); return; } /* ArgTypeTest */ static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, const char *name, int exact) { if (likely(Py_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) return 1; if (!exact && likely(type) && likely(__Pyx_TypeCheck(obj, type))) return 1; __Pyx_ArgTypeError(obj, type, name, exact); return 0; } /* RaiseUnboundLocalError */ static void __Pyx_RaiseUnboundLocalError(const char *varname) { PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); } /* GetException (used by pep479) */ #if CYTHON_FAST_THREAD_STATE static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) #endif { PyObject *local_type = NULL, *local_value, *local_tb = NULL; #if CYTHON_FAST_THREAD_STATE PyObject *tmp_type, *tmp_value, *tmp_tb; #if PY_VERSION_HEX >= 0x030C0000 local_value = tstate->current_exception; tstate->current_exception = 0; #else local_type = tstate->curexc_type; local_value = tstate->curexc_value; local_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; #endif #elif __PYX_LIMITED_VERSION_HEX >= 0x030C0000 local_value = PyErr_GetRaisedException(); #else PyErr_Fetch(&local_type, &local_value, &local_tb); #endif #if __PYX_LIMITED_VERSION_HEX >= 0x030C0000 if (likely(local_value)) { local_type = (PyObject*) Py_TYPE(local_value); Py_INCREF(local_type); local_tb = PyException_GetTraceback(local_value); } #else PyErr_NormalizeException(&local_type, &local_value, &local_tb); #if CYTHON_FAST_THREAD_STATE if (unlikely(tstate->curexc_type)) #else if (unlikely(PyErr_Occurred())) #endif goto bad; if (local_tb) { if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) goto bad; } #endif // __PYX_LIMITED_VERSION_HEX >= 0x030C0000 Py_XINCREF(local_tb); Py_XINCREF(local_type); Py_XINCREF(local_value); *type = local_type; *value = local_value; *tb = local_tb; #if CYTHON_FAST_THREAD_STATE #if CYTHON_USE_EXC_INFO_STACK { _PyErr_StackItem *exc_info = tstate->exc_info; #if PY_VERSION_HEX >= 0x030B00a4 tmp_value = exc_info->exc_value; exc_info->exc_value = local_value; tmp_type = NULL; tmp_tb = NULL; Py_XDECREF(local_type); Py_XDECREF(local_tb); #else tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = local_type; exc_info->exc_value = local_value; exc_info->exc_traceback = local_tb; #endif } #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = local_type; tstate->exc_value = local_value; tstate->exc_traceback = local_tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #elif __PYX_LIMITED_VERSION_HEX >= 0x030b0000 PyErr_SetHandledException(local_value); Py_XDECREF(local_value); Py_XDECREF(local_type); Py_XDECREF(local_tb); #else PyErr_SetExcInfo(local_type, local_value, local_tb); #endif return 0; #if __PYX_LIMITED_VERSION_HEX < 0x030C0000 bad: *type = 0; *value = 0; *tb = 0; Py_XDECREF(local_type); Py_XDECREF(local_value); Py_XDECREF(local_tb); return -1; #endif } /* pep479 */ static void __Pyx_Generator_Replace_StopIteration(int in_async_gen) { PyObject *exc, *val, *tb, *cur_exc, *new_exc; __Pyx_PyThreadState_declare int is_async_stopiteration = 0; CYTHON_MAYBE_UNUSED_VAR(in_async_gen); __Pyx_PyThreadState_assign cur_exc = __Pyx_PyErr_CurrentExceptionType(); if (likely(!__Pyx_PyErr_GivenExceptionMatches(cur_exc, PyExc_StopIteration))) { if (in_async_gen && unlikely(__Pyx_PyErr_GivenExceptionMatches(cur_exc, PyExc_StopAsyncIteration))) { is_async_stopiteration = 1; } else { return; } } __Pyx_GetException(&exc, &val, &tb); Py_XDECREF(exc); Py_XDECREF(tb); new_exc = PyObject_CallFunction(PyExc_RuntimeError, "s", is_async_stopiteration ? "async generator raised StopAsyncIteration" : in_async_gen ? "async generator raised StopIteration" : "generator raised StopIteration"); if (!new_exc) { Py_XDECREF(val); return; } PyException_SetCause(new_exc, val); // steals ref to val PyErr_SetObject(PyExc_RuntimeError, new_exc); Py_DECREF(new_exc); } /* PyObjectCompare */ #ifndef __Pyx_DEFINED_PyObject_CompareIntIntBoolGe #define __Pyx_DEFINED_PyObject_CompareIntIntBoolGe static int __Pyx_PyObject_CompareIntIntBoolGe(PyObject *op1, PyObject *op2) { #if CYTHON_USE_PYLONG_INTERNALS Py_ssize_t cmp = __Pyx_PyLong_CompareSignAndSize(op1, op2); if (cmp == 0) { Py_ssize_t size = __Pyx_PyLong_DigitCount(op1); if (size > 0) { const digit* digits1 = __Pyx_PyLong_Digits(op1); const digit* digits2 = __Pyx_PyLong_Digits(op2); if (size == 1) { cmp = (Py_ssize_t) digits1[0] - (Py_ssize_t) digits2[0]; } else if ((size == 2) && (8 * sizeof(Py_ssize_t) >= 2 * PyLong_SHIFT)) { cmp = (Py_ssize_t) (((((size_t)digits1[1]) << PyLong_SHIFT) | (size_t)digits1[0])) - (Py_ssize_t) (((((size_t)digits2[1]) << PyLong_SHIFT) | (size_t)digits2[0])); } else { for (Py_ssize_t i=size-1; i >= 0 && !cmp; --i) { cmp = (Py_ssize_t) digits1[i] - (Py_ssize_t) digits2[i]; } } } if (cmp == 0) goto __pyx_return_true; if (__Pyx_PyLong_IsNeg(op1)) cmp = -cmp; } if (cmp < 0) goto __pyx_return_false; else goto __pyx_return_true; #else int overflow1, overflow2; long long iop1 = PyLong_AsLongLongAndOverflow(op1, &overflow1); long long iop2 = PyLong_AsLongLongAndOverflow(op2, &overflow2); if (likely(!(overflow1 | overflow2))) { if (iop1 >= iop2) goto __pyx_return_true; else goto __pyx_return_false; } else if (overflow1 != overflow2) { if (overflow1 >= overflow2) goto __pyx_return_true; else goto __pyx_return_false; } else { return __Pyx_PyObject_RichCompareBool(op1, op2, Py_GE); } #endif __pyx_return_true: return 1; __pyx_return_false: return 0; } #endif static CYTHON_INLINE int __Pyx_PyObject_CompareBoolGe_int_int(PyObject *op1, PyObject *op2, int pyop) { CYTHON_UNUSED_VAR(pyop); if (unlikely(op1 == Py_None)) { goto __pyx_richcmp; } if (unlikely(op2 == Py_None)) { goto __pyx_richcmp; } if (op1 == op2) goto __pyx_return_true; if (likely(op1 != Py_None)) { if (op1 == op2) goto __pyx_return_true; if (likely(op2 != Py_None)) { return __Pyx_PyObject_CompareIntIntBoolGe(op1, op2); } goto __pyx_richcmp; } if ((0)) goto __pyx_richcmp; if ((0)) goto __pyx_return_true; if ((0)) goto __pyx_return_false; __pyx_richcmp: return __Pyx_PyObject_RichCompareBool(op1, op2, Py_GE); __pyx_return_true: return 1; __pyx_return_false: return 0; } /* RaiseException */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { PyObject* owned_instance = NULL; if (tb == Py_None) { tb = 0; } else if (tb && !PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto bad; } if (value == Py_None) value = 0; if (PyExceptionInstance_Check(type)) { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto bad; } value = type; type = (PyObject*) Py_TYPE(value); } else if (PyExceptionClass_Check(type)) { PyObject *instance_class = NULL; if (value && PyExceptionInstance_Check(value)) { instance_class = (PyObject*) Py_TYPE(value); if (instance_class != type) { int is_subclass = PyObject_IsSubclass(instance_class, type); if (!is_subclass) { instance_class = NULL; } else if (unlikely(is_subclass == -1)) { goto bad; } else { type = instance_class; } } } if (!instance_class) { PyObject *args; if (!value) args = PyTuple_New(0); else if (PyTuple_Check(value)) { Py_INCREF(value); args = value; } else args = PyTuple_Pack(1, value); if (!args) goto bad; owned_instance = PyObject_Call(type, args, NULL); Py_DECREF(args); if (!owned_instance) goto bad; value = owned_instance; if (!PyExceptionInstance_Check(value)) { PyErr_Format(PyExc_TypeError, "calling %R should have returned an instance of " "BaseException, not %R", type, Py_TYPE(value)); goto bad; } } } else { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto bad; } if (cause) { PyObject *fixed_cause; if (cause == Py_None) { fixed_cause = NULL; } else if (PyExceptionClass_Check(cause)) { fixed_cause = PyObject_CallObject(cause, NULL); if (fixed_cause == NULL) goto bad; } else if (PyExceptionInstance_Check(cause)) { fixed_cause = cause; Py_INCREF(fixed_cause); } else { PyErr_SetString(PyExc_TypeError, "exception causes must derive from " "BaseException"); goto bad; } PyException_SetCause(value, fixed_cause); } PyErr_SetObject(type, value); if (tb) { #if PY_VERSION_HEX >= 0x030C00A6 PyException_SetTraceback(value, tb); #elif CYTHON_FAST_THREAD_STATE PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* tmp_tb = tstate->curexc_traceback; if (tb != tmp_tb) { Py_INCREF(tb); tstate->curexc_traceback = tb; Py_XDECREF(tmp_tb); } #else PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); Py_INCREF(tb); PyErr_Restore(tmp_type, tmp_value, tb); Py_XDECREF(tmp_tb); #endif } bad: Py_XDECREF(owned_instance); return; } /* PyObjectCompare */ #ifndef __Pyx_DEFINED_PyObject_CompareStrStrBoolNe #define __Pyx_DEFINED_PyObject_CompareStrStrBoolNe static CYTHON_INLINE int __Pyx_PyObject_CompareStrStrBoolNe(PyObject* s1, PyObject* s2) { #if __PYX_LIMITED_VERSION_HEX >= 0x030e0000 int result = PyUnicode_Equal(s1, s2); #if !CYTHON_COMPILING_IN_CPYTHON if (unlikely(result == -1)) return -1; #endif if (result != 0) goto __pyx_return_false; else goto __pyx_return_true; #else int result = PyUnicode_Compare(s1, s2); if (unlikely((result == -1) && PyErr_Occurred())) return -1; if (result != 0) goto __pyx_return_true; else goto __pyx_return_false; #endif __pyx_return_true: return 1; __pyx_return_false: return 0; } #endif #if !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_GRAAL) #ifndef __Pyx_DEFINED_PyObject_ComparePyBytesPyBytesBoolNe #define __Pyx_DEFINED_PyObject_ComparePyBytesPyBytesBoolNe static CYTHON_INLINE int __Pyx_PyObject_ComparePyBytesPyBytesBoolNe(PyObject* s1, PyObject* s2) { #if CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS const char *ps1, *ps2; Py_ssize_t length = PyBytes_GET_SIZE(s1); if (length != PyBytes_GET_SIZE(s2)) goto __pyx_return_true; ps1 = PyBytes_AS_STRING(s1); ps2 = PyBytes_AS_STRING(s2); #else char *ps1, *ps2; Py_ssize_t length, length2; if (unlikely(PyBytes_AsStringAndSize(s1, &ps1, &length) == -1)) return -1; if (unlikely(PyBytes_AsStringAndSize(s2, &ps2, &length2) == -1)) return -1; if (length != length2) goto __pyx_return_true; #endif if (ps1[0] != ps2[0]) goto __pyx_return_true; if (length == 1) goto __pyx_return_false; { int cmp; #if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000) Py_hash_t hash1 = ((PyBytesObject*)s1)->ob_shash; Py_hash_t hash2 = ((PyBytesObject*)s2)->ob_shash; if (hash1 != hash2 && hash1 != -1 && hash2 != -1) goto __pyx_return_true; #endif cmp = memcmp(ps1, ps2, (size_t)length); if (cmp != 0) goto __pyx_return_true; else goto __pyx_return_false; } __pyx_return_true: return 1; __pyx_return_false: return 0; } #endif #endif #if !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_GRAAL) #ifndef __Pyx_DEFINED_PyObject_ComparePyBytesPyByteArrayBoolNe #define __Pyx_DEFINED_PyObject_ComparePyBytesPyByteArrayBoolNe static CYTHON_INLINE int __Pyx_PyObject_ComparePyBytesPyByteArrayBoolNe(PyObject* s1, PyObject* s2) { #if CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS const char *ps1, *ps2; Py_ssize_t length = PyBytes_GET_SIZE(s1); if (length != PyByteArray_GET_SIZE(s2)) goto __pyx_return_true; ps1 = PyBytes_AS_STRING(s1); ps2 = PyByteArray_AS_STRING(s2); #else char *ps1, *ps2; Py_ssize_t length, length2; if (unlikely(PyBytes_AsStringAndSize(s1, &ps1, &length) == -1)) return -1; ps2 = __Pyx_PyByteArray_AsString(s2); if (unlikely(!ps2)) return -1; length2 = __Pyx_PyByteArray_GET_SIZE(s2); if (unlikely(length2 == -1)) return -1; if (length != length2) goto __pyx_return_true; #endif if (ps1[0] != ps2[0]) goto __pyx_return_true; if (length == 1) goto __pyx_return_false; { int cmp; cmp = memcmp(ps1, ps2, (size_t)length); if (cmp != 0) goto __pyx_return_true; else goto __pyx_return_false; } __pyx_return_true: return 1; __pyx_return_false: return 0; } #endif #endif #if !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_GRAAL) #ifndef __Pyx_DEFINED_PyObject_ComparePyByteArrayPyBytesBoolNe #define __Pyx_DEFINED_PyObject_ComparePyByteArrayPyBytesBoolNe static CYTHON_INLINE int __Pyx_PyObject_ComparePyByteArrayPyBytesBoolNe(PyObject* s1, PyObject* s2) { #if CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS const char *ps1, *ps2; Py_ssize_t length = PyByteArray_GET_SIZE(s1); if (length != PyBytes_GET_SIZE(s2)) goto __pyx_return_true; ps1 = PyByteArray_AS_STRING(s1); ps2 = PyBytes_AS_STRING(s2); #else char *ps1, *ps2; Py_ssize_t length, length2; ps1 = __Pyx_PyByteArray_AsString(s1); if (unlikely(!ps1)) return -1; length = __Pyx_PyByteArray_GET_SIZE(s1); if (unlikely(length == -1)) return -1; if (unlikely(PyBytes_AsStringAndSize(s2, &ps2, &length2) == -1)) return -1; if (length != length2) goto __pyx_return_true; #endif if (length == 0) goto __pyx_return_false; if (ps1[0] != ps2[0]) goto __pyx_return_true; if (length == 1) goto __pyx_return_false; { int cmp; cmp = memcmp(ps1, ps2, (size_t)length); if (cmp != 0) goto __pyx_return_true; else goto __pyx_return_false; } __pyx_return_true: return 1; __pyx_return_false: return 0; } #endif #endif #if !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_GRAAL) #ifndef __Pyx_DEFINED_PyObject_ComparePyByteArrayPyByteArrayBoolNe #define __Pyx_DEFINED_PyObject_ComparePyByteArrayPyByteArrayBoolNe static CYTHON_INLINE int __Pyx_PyObject_ComparePyByteArrayPyByteArrayBoolNe(PyObject* s1, PyObject* s2) { #if CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS const char *ps1, *ps2; Py_ssize_t length = PyByteArray_GET_SIZE(s1); if (length != PyByteArray_GET_SIZE(s2)) goto __pyx_return_true; ps1 = PyByteArray_AS_STRING(s1); ps2 = PyByteArray_AS_STRING(s2); #else char *ps1, *ps2; Py_ssize_t length, length2; ps1 = __Pyx_PyByteArray_AsString(s1); if (unlikely(!ps1)) return -1; length = __Pyx_PyByteArray_GET_SIZE(s1); if (unlikely(length == -1)) return -1; ps2 = __Pyx_PyByteArray_AsString(s2); if (unlikely(!ps2)) return -1; length2 = __Pyx_PyByteArray_GET_SIZE(s2); if (unlikely(length2 == -1)) return -1; if (length != length2) goto __pyx_return_true; #endif if (length == 0) goto __pyx_return_false; if (ps1[0] != ps2[0]) goto __pyx_return_true; if (length == 1) goto __pyx_return_false; { int cmp; cmp = memcmp(ps1, ps2, (size_t)length); if (cmp != 0) goto __pyx_return_true; else goto __pyx_return_false; } __pyx_return_true: return 1; __pyx_return_false: return 0; } #endif #endif #ifndef __Pyx_DEFINED_PyObject_CompareFloatIntBoolNe #define __Pyx_DEFINED_PyObject_CompareFloatIntBoolNe static int __Pyx_PyObject_CompareFloatIntBoolNe(PyObject *op1, PyObject *op2) { double float_op1 = __Pyx_PyFloat_AS_DOUBLE(op1); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely(float_op1 == -1. && PyErr_Occurred())) return -1; #endif #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsCompact(op2)) { Py_ssize_t iop2 = __Pyx_PyLong_CompactValue(op2); if (float_op1 != ((double)iop2)) goto __pyx_return_true; else goto __pyx_return_false; } if (unlikely(!isfinite(float_op1))) { if (float_op1 != 0.0) goto __pyx_return_true; else goto __pyx_return_false; } else { int sign2 = __Pyx_PyLong_Sign(op2); if (float_op1 >= 0.) { if (sign2 < 0) goto __pyx_return_true; if (float_op1 < (double) (1L << PyLong_SHIFT)) goto __pyx_return_true; } else { if (sign2 > 0) goto __pyx_return_true; if (float_op1 > -(double) (1L << PyLong_SHIFT)) goto __pyx_return_true; } } #else if (unlikely(!isfinite(float_op1))) { if (float_op1 != 0.0) goto __pyx_return_true; else goto __pyx_return_false; } else { int overflow2; long iop2 = PyLong_AsLongAndOverflow(op2, &overflow2); if (likely(!overflow2)) { if ((long long) iop2 >= (1LL << 53)) { overflow2 = 1; } else if ((long long) iop2 <= - (1LL << 53)) { overflow2 = -1; } else { if (float_op1 != ((double) iop2)) goto __pyx_return_true; else goto __pyx_return_false; } } if (overflow2 > 0) { if (float_op1 < ((double) (1LL << 53))) goto __pyx_return_true; } else { if (float_op1 > - ((double) (1LL << 53))) goto __pyx_return_true; } } #endif return __Pyx_PyObject_RichCompareBool(op1, op2, Py_NE); __pyx_return_true: return 1; __pyx_return_false: return 0; } #endif #ifndef __Pyx_DEFINED_PyObject_CompareIntFloatBoolNe #define __Pyx_DEFINED_PyObject_CompareIntFloatBoolNe static int __Pyx_PyObject_CompareIntFloatBoolNe(PyObject *op1, PyObject *op2) { double float_op2 = __Pyx_PyFloat_AS_DOUBLE(op2); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely(float_op2 == -1. && PyErr_Occurred())) return -1; #endif #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsCompact(op1)) { Py_ssize_t iop1 = __Pyx_PyLong_CompactValue(op1); if (((double)iop1) != float_op2) goto __pyx_return_true; else goto __pyx_return_false; } if (unlikely(!isfinite(float_op2))) { if (0.0 != float_op2) goto __pyx_return_true; else goto __pyx_return_false; } else { int sign1 = __Pyx_PyLong_Sign(op1); if (float_op2 >= 0.) { if (sign1 < 0) goto __pyx_return_true; if (float_op2 < (double) (1L << PyLong_SHIFT)) goto __pyx_return_true; } else { if (sign1 > 0) goto __pyx_return_true; if (float_op2 > -(double) (1L << PyLong_SHIFT)) goto __pyx_return_true; } } #else if (unlikely(!isfinite(float_op2))) { if (0.0 != float_op2) goto __pyx_return_true; else goto __pyx_return_false; } else { int overflow1; long iop1 = PyLong_AsLongAndOverflow(op1, &overflow1); if (likely(!overflow1)) { if ((long long) iop1 >= (1LL << 53)) { overflow1 = 1; } else if ((long long) iop1 <= - (1LL << 53)) { overflow1 = -1; } else { if (((double) iop1) != float_op2) goto __pyx_return_true; else goto __pyx_return_false; } } if (overflow1 < 0) { if (float_op2 > ((double) (1LL << 53))) goto __pyx_return_true; } else { if (float_op2 < - ((double) (1LL << 53))) goto __pyx_return_true; } } #endif return __Pyx_PyObject_RichCompareBool(op1, op2, Py_NE); __pyx_return_true: return 1; __pyx_return_false: return 0; } #endif #ifndef __Pyx_DEFINED_PyObject_CompareIntIntBoolNe #define __Pyx_DEFINED_PyObject_CompareIntIntBoolNe static int __Pyx_PyObject_CompareIntIntBoolNe(PyObject *op1, PyObject *op2) { #if CYTHON_USE_PYLONG_INTERNALS Py_ssize_t cmp = __Pyx_PyLong_CompareSignAndSize(op1, op2); if (cmp == 0) { Py_ssize_t size = __Pyx_PyLong_DigitCount(op1); if (size > 0) { const digit* digits1 = __Pyx_PyLong_Digits(op1); const digit* digits2 = __Pyx_PyLong_Digits(op2); if (size == 1) { cmp = (Py_ssize_t) digits1[0] - (Py_ssize_t) digits2[0]; } else if ((size == 2) && (8 * sizeof(Py_ssize_t) >= 2 * PyLong_SHIFT)) { cmp = (Py_ssize_t) (((((size_t)digits1[1]) << PyLong_SHIFT) | (size_t)digits1[0])) - (Py_ssize_t) (((((size_t)digits2[1]) << PyLong_SHIFT) | (size_t)digits2[0])); } else { for (Py_ssize_t i=size-1; i >= 0 && !cmp; --i) { cmp = (Py_ssize_t) digits1[i] - (Py_ssize_t) digits2[i]; } } } if (cmp == 0) goto __pyx_return_false; if (__Pyx_PyLong_IsNeg(op1)) cmp = -cmp; } goto __pyx_return_true; #else int overflow1, overflow2; long long iop1 = PyLong_AsLongLongAndOverflow(op1, &overflow1); long long iop2 = PyLong_AsLongLongAndOverflow(op2, &overflow2); if (likely(!(overflow1 | overflow2))) { if (iop1 != iop2) goto __pyx_return_true; else goto __pyx_return_false; } else if (overflow1 != overflow2) { if (overflow1 != overflow2) goto __pyx_return_true; else goto __pyx_return_false; } else { return __Pyx_PyObject_RichCompareBool(op1, op2, Py_NE); } #endif __pyx_return_true: return 1; __pyx_return_false: return 0; } #endif static CYTHON_INLINE int __Pyx_PyObject_CompareBoolNe_object_object(PyObject *op1, PyObject *op2, int pyop) { CYTHON_UNUSED_VAR(pyop); if (PyFloat_CheckExact(op1)) { if (PyFloat_CheckExact(op2)) { double float_op1 = __Pyx_PyFloat_AS_DOUBLE(op1); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely(float_op1 == -1. && PyErr_Occurred())) return -1; #endif double float_op2 = __Pyx_PyFloat_AS_DOUBLE(op2); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely(float_op2 == -1. && PyErr_Occurred())) return -1; #endif if (float_op1 != float_op2) goto __pyx_return_true; else goto __pyx_return_false; } if (PyLong_CheckExact(op2)) { return __Pyx_PyObject_CompareFloatIntBoolNe(op1, op2); } goto __pyx_richcmp; } if (PyLong_CheckExact(op1)) { if (op1 == op2) goto __pyx_return_false; if (PyLong_CheckExact(op2)) { return __Pyx_PyObject_CompareIntIntBoolNe(op1, op2); } if (PyFloat_CheckExact(op2)) { return __Pyx_PyObject_CompareIntFloatBoolNe(op1, op2); } goto __pyx_richcmp; } if (PyUnicode_CheckExact(op1)) { if (op1 == op2) goto __pyx_return_false; if (PyUnicode_CheckExact(op2)) { return __Pyx_PyObject_CompareStrStrBoolNe(op1, op2); } goto __pyx_richcmp; } #if !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_GRAAL) if (PyBytes_CheckExact(op1)) { if (op1 == op2) goto __pyx_return_false; if (PyBytes_CheckExact(op2)) { return __Pyx_PyObject_ComparePyBytesPyBytesBoolNe(op1, op2); } if (PyByteArray_CheckExact(op2)) { return __Pyx_PyObject_ComparePyBytesPyByteArrayBoolNe(op1, op2); } goto __pyx_richcmp; } #endif #if !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_GRAAL) if (PyByteArray_CheckExact(op1)) { if (op1 == op2) goto __pyx_return_false; if (PyByteArray_CheckExact(op2)) { return __Pyx_PyObject_ComparePyByteArrayPyByteArrayBoolNe(op1, op2); } if (PyBytes_CheckExact(op2)) { return __Pyx_PyObject_ComparePyByteArrayPyBytesBoolNe(op1, op2); } goto __pyx_richcmp; } #endif if ((0)) goto __pyx_richcmp; if ((0)) goto __pyx_return_true; if ((0)) goto __pyx_return_false; __pyx_richcmp: return __Pyx_PyObject_RichCompareBool(op1, op2, Py_NE); __pyx_return_true: return 1; __pyx_return_false: return 0; } /* PyDictVersioning (used by GetModuleGlobalName) */ #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_COMPILING_IN_LIMITED_API if (unlikely(!__pyx_m)) { if (!PyErr_Occurred()) PyErr_SetNone(PyExc_NameError); return NULL; } result = PyObject_GetAttr(__pyx_m, name); if (likely(result)) { return result; } if (!__Pyx_IgnoreException(PyExc_Exception)) { return NULL; // BaseException } #elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS if (unlikely(__Pyx_PyDict_GetItemRef(__pyx_mstate_global->__pyx_d, name, &result) == -1)) { if (!__Pyx_IgnoreException(PyExc_Exception)) { return NULL; // BaseException } } __PYX_UPDATE_DICT_CACHE(__pyx_mstate_global->__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return result; } #else result = _PyDict_GetItem_KnownHash(__pyx_mstate_global->__pyx_d, name, ((PyASCIIObject *) name)->hash); __PYX_UPDATE_DICT_CACHE(__pyx_mstate_global->__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } PyObject *exc = PyErr_Occurred(); if (unlikely(exc) && !__Pyx_IgnoreGivenException(exc, PyExc_Exception)) { return NULL; // BaseException } #endif return __Pyx_GetBuiltinName(name); } /* PyFrozenDict (used by GetItemInt) */ #if CYTHON_COMPILING_IN_LIMITED_API static CYTHON_INLINE PyObject* __Pyx__PyFrozenDict_New(PyObject* frozendict_type, PyObject* it) { return PyObject_CallFunctionObjArgs(frozendict_type, it, NULL); } #endif /* GettItemInt_wraparound (used by GetItemInt) */ #if CYTHON_USE_TYPE_SLOTS && !CYTHON_COMPILING_IN_PYPY static int __Pyx_GetItemInt_wraparound(PyObject *o, PySequenceMethods *sm, Py_ssize_t *i) { assert(*i < 0); if (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 -1; PyErr_Clear(); } } return 0; } #endif /* GetItemInt */ static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { PyObject *r; if (unlikely(!j)) return NULL; r = PyObject_GetItem(o, j); Py_DECREF(j); return r; } static PyObject *__Pyx_GetItemInt_Generic_size(PyObject *o, Py_ssize_t i) { return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i)); } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck, int unsafe_shared) { CYTHON_MAYBE_UNUSED_VAR(unsafe_shared); #if CYTHON_AVOID_BORROWED_REFS CYTHON_UNUSED_VAR(boundscheck); Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { Py_ssize_t size = __Pyx_PyList_GET_SIZE(o); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely(size < 0)) return NULL; #endif wrapped_i += size; } return __Pyx_PyList_GetItemRef(o, wrapped_i); #elif CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS Py_ssize_t wrapped_i = i; Py_ssize_t size = (wraparound | boundscheck) ? PyList_GET_SIZE(o) : -1; if (wraparound & unlikely(i < 0)) { wrapped_i += size; } if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, size))) { return __Pyx_PyList_GET_ITEM_REF(o, wrapped_i, unsafe_shared); } return __Pyx_GetItemInt_Generic_size(o, i); #else (void)wraparound; (void)boundscheck; return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck, int unsafe_shared) { CYTHON_MAYBE_UNUSED_VAR(unsafe_shared); #if CYTHON_AVOID_BORROWED_REFS CYTHON_UNUSED_VAR(boundscheck); Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(o); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely(size < 0)) return NULL; #endif wrapped_i += size; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_COMPILING_IN_LIMITED_API return PySequence_ITEM(o, wrapped_i); #else if (unlikely(wrapped_i < 0)) { PyErr_SetString(PyExc_IndexError, "tuple index out of range"); return NULL; } return PySequence_GetItem(o, wrapped_i); #endif #elif CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS Py_ssize_t wrapped_i = i; Py_ssize_t size = (wraparound | boundscheck) ? PyTuple_GET_SIZE(o) : -1; if (wraparound & unlikely(i < 0)) { wrapped_i += size; } if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, size))) { return __Pyx_NewRef(__Pyx_PyTuple_GET_ITEM(o, wrapped_i)); } return __Pyx_GetItemInt_Generic_size(o, i); #else (void)wraparound; (void)boundscheck; return PySequence_GetItem(o, i); #endif } #if CYTHON_USE_TYPE_SLOTS && !CYTHON_COMPILING_IN_PYPY static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast_mapping(PyObject *o, binaryfunc getitem, Py_ssize_t i) { PyObject *r, *key = PyLong_FromSsize_t(i); if (unlikely(!key)) return NULL; r = getitem(o, key); Py_DECREF(key); return r; } #endif static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck, int unsafe_shared) { CYTHON_MAYBE_UNUSED_VAR(unsafe_shared); #if CYTHON_ASSUME_SAFE_SIZE if (PyList_CheckExact(o)) { return __Pyx_GetItemInt_List_Fast(o, i, wraparound, boundscheck, unsafe_shared); } else #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (PyTuple_CheckExact(o)) { return __Pyx_GetItemInt_Tuple_Fast(o, i, wraparound, boundscheck, unsafe_shared); } else #endif #else if ((!wraparound || i >= 0) & PyList_CheckExact(o)) { return boundscheck ? __Pyx_PyList_GetItemRef(o, i) : __Pyx_PyList_GET_ITEM_REF(o, i, unsafe_shared); } else #endif #if CYTHON_USE_TYPE_SLOTS && !CYTHON_COMPILING_IN_PYPY if (PyDict_CheckExact(o)) { return __Pyx_GetItemInt_Fast_mapping(o, PyDict_Type.tp_as_mapping->mp_subscript, i); #if defined(PyFrozenDict_CheckExact) } else if (PyFrozenDict_CheckExact(o)) { return __Pyx_GetItemInt_Fast_mapping(o, PyFrozenDict_Type.tp_as_mapping->mp_subscript, i); #endif } else { PyTypeObject *obj_type = Py_TYPE(o); int seq_or_mapping = __Pyx_PyType_GetFlags(obj_type) & (Py_TPFLAGS_SEQUENCE|Py_TPFLAGS_MAPPING); if (seq_or_mapping != Py_TPFLAGS_SEQUENCE) { PyMappingMethods *mm = obj_type->tp_as_mapping; if (mm && mm->mp_subscript) return __Pyx_GetItemInt_Fast_mapping(o, mm->mp_subscript, i); } PySequenceMethods *sm = obj_type->tp_as_sequence; if (likely(sm && sm->sq_item)) { if (wraparound && (i < 0) && unlikely(__Pyx_GetItemInt_wraparound(o, sm, &i) == -1)) return NULL; return sm->sq_item(o, i); } if (seq_or_mapping == Py_TPFLAGS_SEQUENCE) { PyMappingMethods *mm = obj_type->tp_as_mapping; if (likely(mm && mm->mp_subscript)) return __Pyx_GetItemInt_Fast_mapping(o, mm->mp_subscript, i); } } #else if (!PyMapping_Check(o)) { return PySequence_GetItem(o, i); } #endif (void)wraparound; (void)boundscheck; return __Pyx_GetItemInt_Generic_size(o, i); } /* RaiseErrorWithObjectType (used by ObjectGetItem) */ static void __Pyx_RaiseErrorWithType(PyObject* exc_type, const char* message, PyTypeObject *type_obj) { __Pyx_TypeName type_name = __Pyx_PyType_GetFullyQualifiedName(type_obj); #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 if (unlikely(!type_name)) return; #endif PyErr_Format(exc_type, message, type_name); __Pyx_DECREF_TypeName(type_name); } /* ObjectGetItem */ #if CYTHON_USE_TYPE_SLOTS static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject *index) { PyObject *runerr = NULL; Py_ssize_t key_value; key_value = __Pyx_PyIndex_AsSsize_t(index); if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) { return __Pyx_GetItemInt_Fast(obj, key_value, 1, 1, 1); } if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { PyErr_Clear(); __Pyx_RaiseErrorWithObjectType( PyExc_IndexError, "cannot fit '" __Pyx_FMT_TYPENAME "' into an index-sized integer", index); } return NULL; } static PyObject *__Pyx_PyObject_GetItem_Slow(PyObject *obj, PyObject *key) { if (likely(PyType_Check(obj))) { if ((PyTypeObject*)obj == &PyType_Type) { return Py_GenericAlias(obj, key); } PyObject *meth = __Pyx_PyObject_GetAttrStrNoError(obj, __pyx_mstate_global->__pyx_n_u_class_getitem); if (!meth) { if (PyErr_Occurred()) { return NULL; } } else { PyObject *result = __Pyx_PyObject_CallOneArg(meth, key); Py_DECREF(meth); return result; } } __Pyx_RaiseTypeErrorWithObjectType( "'" __Pyx_FMT_TYPENAME "' object is not subscriptable", obj); return NULL; } static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key) { PyTypeObject *tp = Py_TYPE(obj); PyMappingMethods *mm = tp->tp_as_mapping; PySequenceMethods *sm = tp->tp_as_sequence; if (likely(mm && mm->mp_subscript)) { return mm->mp_subscript(obj, key); } if (likely(sm && sm->sq_item)) { return __Pyx_PyObject_GetIndex(obj, key); } return __Pyx_PyObject_GetItem_Slow(obj, key); } #endif /* PyObjectVectorcallKwds */ #if CYTHON_VECTORCALL CYTHON_UNUSED static int __Pyx_CheckVectorcallKwarg(PyObject *kwnames, Py_ssize_t i) { PyObject *key = __Pyx_PyTuple_GET_ITEM(kwnames, i); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely(!key)) return -1; #endif if (unlikely(!PyUnicode_Check(key))) { PyErr_SetString(PyExc_TypeError, "keywords must be strings"); return -1; } return 0; } #else CYTHON_UNUSED static PyObject *__Pyx_MakeKwargDict(PyObject **keys, PyObject **values, Py_ssize_t n) { PyObject *out = PyDict_New(); if (unlikely(!out)) return NULL; for (Py_ssize_t i=0; i 0) { i = 0; if (prepend_sign) { __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, 0, '-'); i++; } for (; i < uoffset; i++) { __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, i, padding_char); } } for (i=0; i < clength; i++) { __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, uoffset+i, chars[i]); } #else { PyObject *sign = NULL, *padding = NULL; uval = NULL; if (uoffset > 0) { prepend_sign = !!prepend_sign; if (uoffset > prepend_sign) { padding = PyUnicode_FromOrdinal(padding_char); if (likely(padding) && uoffset > prepend_sign + 1) { PyObject *tmp = PySequence_Repeat(padding, uoffset - prepend_sign); Py_DECREF(padding); padding = tmp; } if (unlikely(!padding)) goto done_or_error; } if (prepend_sign) { sign = PyUnicode_FromOrdinal('-'); if (unlikely(!sign)) goto done_or_error; } } uval = PyUnicode_DecodeASCII(chars, clength, NULL); if (likely(uval) && padding) { PyObject *tmp = PyUnicode_Concat(padding, uval); Py_DECREF(uval); uval = tmp; } if (likely(uval) && sign) { PyObject *tmp = PyUnicode_Concat(sign, uval); Py_DECREF(uval); uval = tmp; } done_or_error: Py_XDECREF(padding); Py_XDECREF(sign); } #endif return uval; } /* COrdinalToPyUnicode (used by CIntToPyUnicode) */ static CYTHON_INLINE int __Pyx_CheckUnicodeValue(int value) { return value <= 1114111; } static PyObject* __Pyx_PyUnicode_FromOrdinal_Padded(int value, Py_ssize_t ulength, char padding_char) { Py_ssize_t padding_length = ulength - 1; if (likely((padding_length <= 250) && (value < 0xD800 || value > 0xDFFF))) { char chars[256]; if (value <= 255) { memset(chars, padding_char, (size_t) padding_length); chars[ulength-1] = (char) value; return PyUnicode_DecodeLatin1(chars, ulength, NULL); } char *cpos = chars + sizeof(chars); if (value < 0x800) { *--cpos = (char) (0x80 | (value & 0x3f)); value >>= 6; *--cpos = (char) (0xc0 | (value & 0x1f)); } else if (value < 0x10000) { *--cpos = (char) (0x80 | (value & 0x3f)); value >>= 6; *--cpos = (char) (0x80 | (value & 0x3f)); value >>= 6; *--cpos = (char) (0xe0 | (value & 0x0f)); } else { *--cpos = (char) (0x80 | (value & 0x3f)); value >>= 6; *--cpos = (char) (0x80 | (value & 0x3f)); value >>= 6; *--cpos = (char) (0x80 | (value & 0x3f)); value >>= 6; *--cpos = (char) (0xf0 | (value & 0x07)); } cpos -= padding_length; memset(cpos, padding_char, (size_t) padding_length); return PyUnicode_DecodeUTF8(cpos, chars + sizeof(chars) - cpos, NULL); } if (value <= 127 && CYTHON_USE_UNICODE_INTERNALS) { const char chars[1] = {(char) value}; return __Pyx_PyUnicode_BuildFromAscii(ulength, chars, 1, 0, padding_char); } { PyObject *uchar, *padding_uchar, *padding, *result; padding_uchar = PyUnicode_FromOrdinal(padding_char); if (unlikely(!padding_uchar)) return NULL; padding = PySequence_Repeat(padding_uchar, padding_length); Py_DECREF(padding_uchar); if (unlikely(!padding)) return NULL; uchar = PyUnicode_FromOrdinal(value); if (unlikely(!uchar)) { Py_DECREF(padding); return NULL; } result = PyUnicode_Concat(padding, uchar); Py_DECREF(padding); Py_DECREF(uchar); return result; } } /* CIntToPyUnicode */ static CYTHON_INLINE PyObject* __Pyx_uchar___Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const int neg_one = (int) -1, const_zero = (int) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (unlikely(!(is_unsigned || value == 0 || value > 0) || !(sizeof(value) <= 2 || value & ~ (int) 0x01fffff || __Pyx_CheckUnicodeValue((int) value)))) { PyErr_SetString(PyExc_OverflowError, "%c arg not in range(0x110000)"); return NULL; } if (width <= 1) { return PyUnicode_FromOrdinal((int) value); } return __Pyx_PyUnicode_FromOrdinal_Padded((int) value, width, padding_char); } static CYTHON_INLINE PyObject* __Pyx____Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char, char format_char) { char digits[sizeof(int)*3+2]; char *dpos, *end = digits + sizeof(int)*3+2; const char *hex_digits = DIGITS_HEX; Py_ssize_t length, ulength; int prepend_sign, last_one_off; int remaining; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const int neg_one = (int) -1, const_zero = (int) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (format_char == 'X') { hex_digits += 16; format_char = 'x'; } remaining = value; last_one_off = 0; dpos = end; do { int digit_pos; switch (format_char) { case 'o': digit_pos = abs((int)(remaining % (8*8))); remaining = (int) (remaining / (8*8)); dpos -= 2; memcpy(dpos, DIGIT_PAIRS_8 + digit_pos * 2, 2); last_one_off = (digit_pos < 8); break; case 'd': digit_pos = abs((int)(remaining % (10*10))); remaining = (int) (remaining / (10*10)); dpos -= 2; memcpy(dpos, DIGIT_PAIRS_10 + digit_pos * 2, 2); last_one_off = (digit_pos < 10); break; case 'x': *(--dpos) = hex_digits[abs((int)(remaining % 16))]; remaining = (int) (remaining / 16); break; default: assert(0); break; } } while (unlikely(remaining != 0)); assert(!last_one_off || *dpos == '0'); dpos += last_one_off; length = end - dpos; ulength = length; prepend_sign = 0; if (!is_unsigned && value <= neg_one) { if (padding_char == ' ' || width <= length + 1) { *(--dpos) = '-'; ++length; } else { prepend_sign = 1; } ++ulength; } if (width > ulength) { ulength = width; } if (ulength == 1) { return PyUnicode_FromOrdinal(*dpos); } return __Pyx_PyUnicode_BuildFromAscii(ulength, dpos, (int) length, prepend_sign, padding_char); } /* JoinPyUnicode */ static PyObject* __Pyx_PyUnicode_Join(PyObject** values, Py_ssize_t value_count, Py_ssize_t result_ulength, int kind) { #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH && CYTHON_USE_UNICODE_INTERNALS PyObject *result_uval; int result_ukind, kind_shift; Py_ssize_t i, char_pos; void *result_udata; static const Py_UCS4 max_char[5] = {0x7fU, 0xffU, 0xffffU, 0xffffU, 0x10ffffU}; assert (kind >= 0); if (kind > PyUnicode_4BYTE_KIND) kind = PyUnicode_4BYTE_KIND; result_uval = PyUnicode_New(result_ulength, max_char[kind]); if (unlikely(!result_uval)) return NULL; kind_shift = kind >> 1; // 0, 1, 2 result_ukind = 1 << kind_shift; // 1, 2, 4 result_udata = PyUnicode_DATA(result_uval); assert(kind_shift == 2 || kind_shift == 1 || kind_shift == 0); if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - result_ulength < 0)) goto overflow; char_pos = 0; for (i=0; i < value_count; i++) { int ukind; Py_ssize_t ulength; void *udata; PyObject *uval = values[i]; if (__Pyx_PyUnicode_READY(uval) == (-1)) goto bad; ulength = __Pyx_PyUnicode_GET_LENGTH(uval); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely(ulength < 0)) goto bad; #endif if (unlikely(!ulength)) continue; if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - ulength < char_pos)) goto overflow; ukind = __Pyx_PyUnicode_KIND(uval); udata = __Pyx_PyUnicode_DATA(uval); if (ukind == result_ukind) { memcpy((char *)result_udata + (char_pos << kind_shift), udata, (size_t) (ulength << kind_shift)); } else { #if PY_VERSION_HEX >= 0x030d0000 if (unlikely(PyUnicode_CopyCharacters(result_uval, char_pos, uval, 0, ulength) < 0)) goto bad; #elif CYTHON_COMPILING_IN_CPYTHON || defined(_PyUnicode_FastCopyCharacters) _PyUnicode_FastCopyCharacters(result_uval, char_pos, uval, 0, ulength); #else Py_ssize_t j; for (j=0; j < ulength; j++) { Py_UCS4 uchar = __Pyx_PyUnicode_READ(ukind, udata, j); __Pyx_PyUnicode_WRITE(result_ukind, result_udata, char_pos+j, uchar); } #endif } char_pos += ulength; } return result_uval; overflow: PyErr_SetString(PyExc_OverflowError, "join() result is too long for a Python string"); bad: Py_DECREF(result_uval); return NULL; #else Py_ssize_t i; PyObject *result = NULL; PyObject *value_tuple = PyTuple_New(value_count); if (unlikely(!value_tuple)) return NULL; CYTHON_UNUSED_VAR(kind); CYTHON_UNUSED_VAR(result_ulength); for (i=0; i__pyx_empty_unicode, value_tuple); bad: Py_DECREF(value_tuple); return result; #endif } /* RaiseErrorWithObjectType1 (used by RaiseUnexpectedTypeError) */ static void __Pyx_RaiseErrorWithType1(PyObject* exc_type, const char* message, const char *arg, PyTypeObject *type_obj) { __Pyx_TypeName type_name = __Pyx_PyType_GetFullyQualifiedName(type_obj); #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 if (unlikely(!type_name)) return; #endif PyErr_Format(exc_type, message, arg, type_name); __Pyx_DECREF_TypeName(type_name); } /* RaiseUnexpectedTypeError */ static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj) { __Pyx_RaiseTypeErrorWithObjectType1( "Expected %.42s, got " __Pyx_FMT_TYPENAME, expected, obj); return 0; } /* PyObjectVectorcallMethodKwds */ #if !CYTHON_VECTORCALL static PyObject *__Pyx_Object_VectorcallMethodKwds(PyObject *name, PyObject *const *args, size_t nargsf, PyObject *kwnames) { PyObject *result; PyObject *obj = PyObject_GetAttr(args[0], name); if (unlikely(!obj)) return NULL; result = __Pyx_Object_VectorcallKwds(obj, args+1, nargsf-1, kwnames); Py_DECREF(obj); return result; } #endif /* RaiseTooManyValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { PyErr_Format(PyExc_ValueError, "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); } /* 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"); } /* 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; } /* 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(); } /* GetTopmostException (used by SaveResetException) */ #if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate) { _PyErr_StackItem *exc_info = tstate->exc_info; while ((exc_info->exc_value == NULL || exc_info->exc_value == Py_None) && exc_info->previous_item != NULL) { exc_info = exc_info->previous_item; } return exc_info; } #endif /* SaveResetException */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { #if CYTHON_USE_EXC_INFO_STACK && 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; Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); #else *type = tstate->exc_type; *value = tstate->exc_value; *tb = tstate->exc_traceback; Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); #endif } static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 _PyErr_StackItem *exc_info = tstate->exc_info; PyObject *tmp_value = exc_info->exc_value; exc_info->exc_value = value; Py_XDECREF(tmp_value); Py_XDECREF(type); Py_XDECREF(tb); #else PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = type; exc_info->exc_value = value; exc_info->exc_traceback = tb; #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = type; tstate->exc_value = value; tstate->exc_traceback = tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #endif } #endif /* PyObjectCallMethod0 (used by dict_iter_common) */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { #if CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || !CYTHON_COMPILING_IN_LIMITED_API) return PyObject_VectorcallMethod(method_name, &obj, 1 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); #elif CYTHON_COMPILING_IN_LIMITED_API return PyObject_CallMethodObjArgs(obj, method_name, NULL); #else return PyObject_CallMethodNoArgs(obj, method_name); #endif } /* RaiseNoneIterError (used by UnpackTupleError) */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); } /* UnpackTupleError (used by UnpackTuple2) */ static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) { if (t == Py_None) { __Pyx_RaiseNoneNotIterableError(); } else { Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(t); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely(size < 0)) return; #endif if (size < index) { __Pyx_RaiseNeedMoreValuesError(size); } else { __Pyx_RaiseTooManyValuesError(index); } } } /* UnpackTuple2 (used by dict_iter_common) */ static CYTHON_INLINE int __Pyx_unpack_tuple2( PyObject* tuple, PyObject** value1, PyObject** value2, int is_tuple, int has_known_size, int decref_tuple) { if (likely(is_tuple || PyTuple_Check(tuple))) { Py_ssize_t size; if (has_known_size) { return __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple); } size = __Pyx_PyTuple_GET_SIZE(tuple); if (likely(size == 2)) { return __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple); } if (size >= 0) { __Pyx_UnpackTupleError(tuple, 2); } return -1; } else { return __Pyx_unpack_tuple2_generic(tuple, value1, value2, has_known_size, decref_tuple); } } static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int decref_tuple) { PyObject *value1 = NULL, *value2 = NULL; #if CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS value1 = __Pyx_PySequence_ITEM(tuple, 0); if (unlikely(!value1)) goto bad; value2 = __Pyx_PySequence_ITEM(tuple, 1); if (unlikely(!value2)) goto bad; #else value1 = PyTuple_GET_ITEM(tuple, 0); Py_INCREF(value1); value2 = PyTuple_GET_ITEM(tuple, 1); Py_INCREF(value2); #endif if (decref_tuple) { Py_DECREF(tuple); } *pvalue1 = value1; *pvalue2 = value2; return 0; #if CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS bad: Py_XDECREF(value1); Py_XDECREF(value2); if (decref_tuple) { Py_XDECREF(tuple); } return -1; #endif } static int __Pyx_unpack_tuple2_generic(PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int has_known_size, int decref_tuple) { Py_ssize_t index; PyObject *value1 = NULL, *value2 = NULL, *iter = NULL; iternextfunc iternext; iter = PyObject_GetIter(tuple); if (unlikely(!iter)) goto bad; if (decref_tuple) { Py_DECREF(tuple); tuple = NULL; } iternext = __Pyx_PyObject_GetIterNextFunc(iter); value1 = iternext(iter); if (unlikely(!value1)) { index = 0; goto unpacking_failed; } value2 = iternext(iter); if (unlikely(!value2)) { index = 1; goto unpacking_failed; } if (!has_known_size && unlikely(__Pyx_IternextUnpackEndCheck(iternext(iter), 2))) goto bad; Py_DECREF(iter); *pvalue1 = value1; *pvalue2 = value2; return 0; unpacking_failed: if (!has_known_size && __Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); bad: Py_XDECREF(iter); Py_XDECREF(value1); Py_XDECREF(value2); if (decref_tuple) { Py_XDECREF(tuple); } return -1; } /* dict_iter_common (used by dict_iter) */ static PyObject *__Pyx_dict_call_to_get_iterable(PyObject* iterable, PyObject* method_name) { PyObject* iter; iterable = __Pyx_PyObject_CallMethod0(iterable, method_name); if (!iterable) return NULL; #if !CYTHON_AVOID_BORROWED_REFS if (PyTuple_CheckExact(iterable) || PyList_CheckExact(iterable)) return iterable; #endif iter = PyObject_GetIter(iterable); Py_DECREF(iterable); return iter; } #if !CYTHON_AVOID_BORROWED_REFS static CYTHON_INLINE int __Pyx_dict_iter_next_source_is_dict( PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos, PyObject** pkey, PyObject** pvalue, PyObject** pitem) { PyObject *key, *value; if (unlikely(orig_length != PyDict_Size(iter_obj))) { PyErr_SetString(PyExc_RuntimeError, "dictionary changed size during iteration"); return -1; } if (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); #if CYTHON_ASSUME_SAFE_MACROS PyTuple_SET_ITEM(tuple, 0, key); PyTuple_SET_ITEM(tuple, 1, value); #else if (unlikely(PyTuple_SetItem(tuple, 0, key) < 0)) { Py_DECREF(value); Py_DECREF(tuple); return -1; } if (unlikely(PyTuple_SetItem(tuple, 1, value) < 0)) { Py_DECREF(tuple); return -1; } #endif *pitem = tuple; } else { if (pkey) { Py_INCREF(key); *pkey = key; } if (pvalue) { Py_INCREF(value); *pvalue = value; } } return 1; } #endif static CYTHON_INLINE int __Pyx_dict_iter_next( PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos, PyObject** pkey, PyObject** pvalue, PyObject** pitem, int source_is_dict) { PyObject* next_item; #if !CYTHON_AVOID_BORROWED_REFS if (source_is_dict) { int result; #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API Py_BEGIN_CRITICAL_SECTION(iter_obj); #endif result = __Pyx_dict_iter_next_source_is_dict(iter_obj, orig_length, ppos, pkey, pvalue, pitem); #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API Py_END_CRITICAL_SECTION(); #endif return result; } else if (PyTuple_CheckExact(iter_obj)) { Py_ssize_t pos = *ppos; Py_ssize_t tuple_size = __Pyx_PyTuple_GET_SIZE(iter_obj); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely(tuple_size < 0)) return -1; #endif if (unlikely(pos >= tuple_size)) return 0; *ppos = pos + 1; #if CYTHON_ASSUME_SAFE_MACROS next_item = PyTuple_GET_ITEM(iter_obj, pos); #else next_item = PyTuple_GetItem(iter_obj, pos); if (unlikely(!next_item)) return -1; #endif Py_INCREF(next_item); } else if (PyList_CheckExact(iter_obj)) { Py_ssize_t pos = *ppos; Py_ssize_t list_size = __Pyx_PyList_GET_SIZE(iter_obj); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely(list_size < 0)) return -1; #endif if (unlikely(pos >= list_size)) return 0; *ppos = pos + 1; next_item = __Pyx_PyList_GET_ITEM_REF(iter_obj, pos, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!next_item)) return -1; } 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; } /* 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(__Pyx_PyAnyDict_CheckExact(iterable)); *p_source_is_dict = is_dict; #if !CYTHON_AVOID_BORROWED_REFS if (is_dict) { *p_orig_length = PyDict_Size(iterable); Py_INCREF(iterable); return iterable; } #endif *p_orig_length = 0; if (method_name) { return __Pyx_dict_call_to_get_iterable(iterable, method_name); } else { return PyObject_GetIter(iterable); } } /* HasAttr */ #if __PYX_LIMITED_VERSION_HEX < 0x030d0000 static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { PyObject *r; if (unlikely(!PyUnicode_Check(n))) { PyErr_SetString(PyExc_TypeError, "hasattr(): attribute name must be string"); return -1; } r = __Pyx_PyObject_GetAttrStrNoError(o, n); if (!r) { return (unlikely(PyErr_Occurred())) ? -1 : 0; } else { Py_DECREF(r); return 1; } } #endif /* PyObjectLookupSpecial */ #if CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx__PyObject_LookupSpecial(PyObject* obj, PyObject* attr_name, int with_error) { PyObject *res; PyTypeObject *tp = Py_TYPE(obj); res = _PyType_Lookup(tp, attr_name); if (likely(res)) { descrgetfunc f = Py_TYPE(res)->tp_descr_get; if (!f) { Py_INCREF(res); } else { res = f(res, obj, (PyObject *)tp); } } else if (with_error) { PyErr_SetObject(PyExc_AttributeError, attr_name); } return res; } #endif /* PyLongBinop */ #if !CYTHON_COMPILING_IN_PYPY static PyObject* __Pyx_Fallback___Pyx_PyLong_AddObjC(PyObject *op1, PyObject *op2, int inplace) { return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2); } #if CYTHON_USE_PYLONG_INTERNALS static PyObject* __Pyx_Unpacked___Pyx_PyLong_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) { CYTHON_MAYBE_UNUSED_VAR(inplace); CYTHON_UNUSED_VAR(zerodivision_check); const long b = intval; long a; const PY_LONG_LONG llb = intval; PY_LONG_LONG lla; if (unlikely(__Pyx_PyLong_IsZero(op1))) { return __Pyx_NewRef(op2); } const int is_positive = __Pyx_PyLong_IsPos(op1); const digit* digits = __Pyx_PyLong_Digits(op1); const Py_ssize_t size = __Pyx_PyLong_DigitCount(op1); if (likely(size == 1)) { a = (long) digits[0]; if (!is_positive) a *= -1; } else { if (size == 2 && 8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); if (!is_positive) a *= -1; goto calculate_long; } else if (size == 2 && 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])); if (!is_positive) lla *= -1; goto calculate_long_long; } else if (size == 3 && 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])); if (!is_positive) a *= -1; goto calculate_long; } else if (size == 3 && 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])); if (!is_positive) lla *= -1; goto calculate_long_long; } else if (size == 4 && 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])); if (!is_positive) a *= -1; goto calculate_long; } else if (size == 4 && 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])); if (!is_positive) lla *= -1; goto calculate_long_long; } else {} return PyLong_Type.tp_as_number->nb_add(op1, op2); } calculate_long: { long x; x = a + b; return PyLong_FromLong(x); } calculate_long_long: { PY_LONG_LONG llx; llx = lla + llb; return PyLong_FromLongLong(llx); } } #endif static PyObject* __Pyx_Float___Pyx_PyLong_AddObjC(PyObject *float_val, long intval, int zerodivision_check) { CYTHON_UNUSED_VAR(zerodivision_check); const long b = intval; double a = __Pyx_PyFloat_AS_DOUBLE(float_val); double result; result = ((double)a) + (double)b; return PyFloat_FromDouble(result); } static CYTHON_INLINE PyObject* __Pyx_PyLong_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) { CYTHON_MAYBE_UNUSED_VAR(intval); CYTHON_UNUSED_VAR(zerodivision_check); #if CYTHON_USE_PYLONG_INTERNALS if (likely(PyLong_CheckExact(op1))) { return __Pyx_Unpacked___Pyx_PyLong_AddObjC(op1, op2, intval, inplace, zerodivision_check); } #endif if (PyFloat_CheckExact(op1)) { return __Pyx_Float___Pyx_PyLong_AddObjC(op1, intval, zerodivision_check); } return __Pyx_Fallback___Pyx_PyLong_AddObjC(op1, op2, inplace); } #endif /* PyObjectCompare */ #ifndef __Pyx_DEFINED_PyObject_CompareIntFloatBoolEq #define __Pyx_DEFINED_PyObject_CompareIntFloatBoolEq static int __Pyx_PyObject_CompareIntFloatBoolEq(PyObject *op1, PyObject *op2) { double float_op2 = __Pyx_PyFloat_AS_DOUBLE(op2); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely(float_op2 == -1. && PyErr_Occurred())) return -1; #endif #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsCompact(op1)) { Py_ssize_t iop1 = __Pyx_PyLong_CompactValue(op1); if (((double)iop1) == float_op2) goto __pyx_return_true; else goto __pyx_return_false; } if (unlikely(!isfinite(float_op2))) { if (0.0 == float_op2) goto __pyx_return_true; else goto __pyx_return_false; } else { int sign1 = __Pyx_PyLong_Sign(op1); if (float_op2 >= 0.) { if (sign1 < 0) goto __pyx_return_false; if (float_op2 < (double) (1L << PyLong_SHIFT)) goto __pyx_return_false; } else { if (sign1 > 0) goto __pyx_return_false; if (float_op2 > -(double) (1L << PyLong_SHIFT)) goto __pyx_return_false; } } #else if (unlikely(!isfinite(float_op2))) { if (0.0 == float_op2) goto __pyx_return_true; else goto __pyx_return_false; } else { int overflow1; long iop1 = PyLong_AsLongAndOverflow(op1, &overflow1); if (likely(!overflow1)) { if ((long long) iop1 >= (1LL << 53)) { overflow1 = 1; } else if ((long long) iop1 <= - (1LL << 53)) { overflow1 = -1; } else { if (((double) iop1) == float_op2) goto __pyx_return_true; else goto __pyx_return_false; } } if (overflow1 < 0) { if (float_op2 > ((double) (1LL << 53))) goto __pyx_return_false; } else { if (float_op2 < - ((double) (1LL << 53))) goto __pyx_return_false; } } #endif return __Pyx_PyObject_RichCompareBool(op1, op2, Py_EQ); __pyx_return_true: return 1; __pyx_return_false: return 0; } #endif #ifndef __Pyx_DEFINED_PyObject_CompareIntIntBoolEq #define __Pyx_DEFINED_PyObject_CompareIntIntBoolEq static int __Pyx_PyObject_CompareIntIntBoolEq(PyObject *op1, PyObject *op2) { #if CYTHON_USE_PYLONG_INTERNALS Py_ssize_t cmp = __Pyx_PyLong_CompareSignAndSize(op1, op2); if (cmp == 0) { Py_ssize_t size = __Pyx_PyLong_DigitCount(op1); if (size > 0) { const digit* digits1 = __Pyx_PyLong_Digits(op1); const digit* digits2 = __Pyx_PyLong_Digits(op2); if (size == 1) { cmp = (Py_ssize_t) digits1[0] - (Py_ssize_t) digits2[0]; } else if ((size == 2) && (8 * sizeof(Py_ssize_t) >= 2 * PyLong_SHIFT)) { cmp = (Py_ssize_t) (((((size_t)digits1[1]) << PyLong_SHIFT) | (size_t)digits1[0])) - (Py_ssize_t) (((((size_t)digits2[1]) << PyLong_SHIFT) | (size_t)digits2[0])); } else { for (Py_ssize_t i=size-1; i >= 0 && !cmp; --i) { cmp = (Py_ssize_t) digits1[i] - (Py_ssize_t) digits2[i]; } } } if (cmp == 0) goto __pyx_return_true; if (__Pyx_PyLong_IsNeg(op1)) cmp = -cmp; } goto __pyx_return_false; #else int overflow1, overflow2; long long iop1 = PyLong_AsLongLongAndOverflow(op1, &overflow1); long long iop2 = PyLong_AsLongLongAndOverflow(op2, &overflow2); if (likely(!(overflow1 | overflow2))) { if (iop1 == iop2) goto __pyx_return_true; else goto __pyx_return_false; } else if (overflow1 != overflow2) { if (overflow1 == overflow2) goto __pyx_return_true; else goto __pyx_return_false; } else { return __Pyx_PyObject_RichCompareBool(op1, op2, Py_EQ); } #endif __pyx_return_true: return 1; __pyx_return_false: return 0; } #endif static CYTHON_INLINE int __Pyx_PyObject_CompareBoolEq_int_object(PyObject *op1, PyObject *op2, int pyop) { CYTHON_UNUSED_VAR(pyop); if (unlikely(op1 == Py_None)) { if (op2 == Py_None) goto __pyx_return_true; else goto __pyx_richcmp; } if (op1 == op2) goto __pyx_return_true; if (likely(op1 != Py_None)) { if (op1 == op2) goto __pyx_return_true; if (likely(PyLong_CheckExact(op2))) { return __Pyx_PyObject_CompareIntIntBoolEq(op1, op2); } if (PyFloat_CheckExact(op2)) { return __Pyx_PyObject_CompareIntFloatBoolEq(op1, op2); } goto __pyx_richcmp; } if ((0)) goto __pyx_richcmp; if ((0)) goto __pyx_return_true; if ((0)) goto __pyx_return_false; __pyx_richcmp: return __Pyx_PyObject_RichCompareBool(op1, op2, Py_EQ); __pyx_return_true: return 1; __pyx_return_false: return 0; } /* PyObjectCompare */ #ifndef __Pyx_DEFINED_PyObject_CompareIntFloatBoolLt #define __Pyx_DEFINED_PyObject_CompareIntFloatBoolLt static int __Pyx_PyObject_CompareIntFloatBoolLt(PyObject *op1, PyObject *op2) { double float_op2 = __Pyx_PyFloat_AS_DOUBLE(op2); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely(float_op2 == -1. && PyErr_Occurred())) return -1; #endif #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsCompact(op1)) { Py_ssize_t iop1 = __Pyx_PyLong_CompactValue(op1); if (((double)iop1) < float_op2) goto __pyx_return_true; else goto __pyx_return_false; } if (unlikely(!isfinite(float_op2))) { if (0.0 < float_op2) goto __pyx_return_true; else goto __pyx_return_false; } else { int sign1 = __Pyx_PyLong_Sign(op1); if (float_op2 >= 0.) { if (sign1 < 0) goto __pyx_return_true; if (float_op2 < (double) (1L << PyLong_SHIFT)) goto __pyx_return_false; } else { if (sign1 > 0) goto __pyx_return_false; if (float_op2 > -(double) (1L << PyLong_SHIFT)) goto __pyx_return_true; } } #else if (unlikely(!isfinite(float_op2))) { if (0.0 < float_op2) goto __pyx_return_true; else goto __pyx_return_false; } else { int overflow1; long iop1 = PyLong_AsLongAndOverflow(op1, &overflow1); if (likely(!overflow1)) { if ((long long) iop1 >= (1LL << 53)) { overflow1 = 1; } else if ((long long) iop1 <= - (1LL << 53)) { overflow1 = -1; } else { if (((double) iop1) < float_op2) goto __pyx_return_true; else goto __pyx_return_false; } } if (overflow1 < 0) { if (float_op2 > ((double) (1LL << 53))) goto __pyx_return_true; } else { if (float_op2 < - ((double) (1LL << 53))) goto __pyx_return_false; } } #endif return __Pyx_PyObject_RichCompareBool(op1, op2, Py_LT); __pyx_return_true: return 1; __pyx_return_false: return 0; } #endif #ifndef __Pyx_DEFINED_PyObject_CompareIntIntBoolLt #define __Pyx_DEFINED_PyObject_CompareIntIntBoolLt static int __Pyx_PyObject_CompareIntIntBoolLt(PyObject *op1, PyObject *op2) { #if CYTHON_USE_PYLONG_INTERNALS Py_ssize_t cmp = __Pyx_PyLong_CompareSignAndSize(op1, op2); if (cmp == 0) { Py_ssize_t size = __Pyx_PyLong_DigitCount(op1); if (size > 0) { const digit* digits1 = __Pyx_PyLong_Digits(op1); const digit* digits2 = __Pyx_PyLong_Digits(op2); if (size == 1) { cmp = (Py_ssize_t) digits1[0] - (Py_ssize_t) digits2[0]; } else if ((size == 2) && (8 * sizeof(Py_ssize_t) >= 2 * PyLong_SHIFT)) { cmp = (Py_ssize_t) (((((size_t)digits1[1]) << PyLong_SHIFT) | (size_t)digits1[0])) - (Py_ssize_t) (((((size_t)digits2[1]) << PyLong_SHIFT) | (size_t)digits2[0])); } else { for (Py_ssize_t i=size-1; i >= 0 && !cmp; --i) { cmp = (Py_ssize_t) digits1[i] - (Py_ssize_t) digits2[i]; } } } if (cmp == 0) goto __pyx_return_false; if (__Pyx_PyLong_IsNeg(op1)) cmp = -cmp; } if (cmp < 0) goto __pyx_return_true; else goto __pyx_return_false; #else int overflow1, overflow2; long long iop1 = PyLong_AsLongLongAndOverflow(op1, &overflow1); long long iop2 = PyLong_AsLongLongAndOverflow(op2, &overflow2); if (likely(!(overflow1 | overflow2))) { if (iop1 < iop2) goto __pyx_return_true; else goto __pyx_return_false; } else if (overflow1 != overflow2) { if (overflow1 < overflow2) goto __pyx_return_true; else goto __pyx_return_false; } else { return __Pyx_PyObject_RichCompareBool(op1, op2, Py_LT); } #endif __pyx_return_true: return 1; __pyx_return_false: return 0; } #endif static CYTHON_INLINE int __Pyx_PyObject_CompareBoolLt_int_object(PyObject *op1, PyObject *op2, int pyop) { CYTHON_UNUSED_VAR(pyop); if (unlikely(op1 == Py_None)) { goto __pyx_richcmp; } if (op1 == op2) goto __pyx_return_false; if (likely(op1 != Py_None)) { if (op1 == op2) goto __pyx_return_false; if (likely(PyLong_CheckExact(op2))) { return __Pyx_PyObject_CompareIntIntBoolLt(op1, op2); } if (PyFloat_CheckExact(op2)) { return __Pyx_PyObject_CompareIntFloatBoolLt(op1, op2); } goto __pyx_richcmp; } if ((0)) goto __pyx_richcmp; if ((0)) goto __pyx_return_true; if ((0)) goto __pyx_return_false; __pyx_richcmp: return __Pyx_PyObject_RichCompareBool(op1, op2, Py_LT); __pyx_return_true: return 1; __pyx_return_false: 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); } /* DictGetItem */ #if !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { PyObject *value; if (unlikely(__Pyx_PyDict_GetItemRef(d, key, &value) == 0)) { // no value, no error if (unlikely(PyTuple_Check(key))) { PyObject* args = PyTuple_Pack(1, key); if (likely(args)) { PyErr_SetObject(PyExc_KeyError, args); Py_DECREF(args); } } else { PyErr_SetObject(PyExc_KeyError, key); } } return value; } #endif /* RaiseErrorWithObjectTypes (used by PyNumberBinop) */ static void __Pyx_RaiseErrorWithTypes1(PyObject* exc_type, const char *message, const char *arg, PyTypeObject *type_obj1, PyTypeObject *type_obj2) { __Pyx_TypeName type_name1 = __Pyx_PyType_GetFullyQualifiedName(type_obj1); #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 if (unlikely(!type_name1)) return; #endif __Pyx_TypeName type_name2 = __Pyx_PyType_GetFullyQualifiedName(type_obj2); #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 if (unlikely(!type_name2)) goto type2_failed; #endif PyErr_Format(exc_type, message, arg, type_name1, type_name2); __Pyx_DECREF_TypeName(type_name2); #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 type2_failed: #endif __Pyx_DECREF_TypeName(type_name1); } /* PyNumberBinop */ #if !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_GRAAL || CYTHON_COMPILING_IN_LIMITED_API) #if CYTHON_USE_TYPE_SLOTS || __PYX_LIMITED_VERSION_HEX >= 0x030A0000 #ifndef __Pyx_DEFINED_BinopTypeError #define __Pyx_DEFINED_BinopTypeError static void __Pyx_BinopTypeError(PyObject *op1, PyObject *op2, const char* op, int inplace) { char opname[4] = {op[0], op[1], 0, 0}; if (inplace) { opname[op[1] ? 2 : 1] = '='; } __Pyx_RaiseErrorWithObjectTypes1( PyExc_TypeError, "unsupported operand type(s) for %.3s: '" __Pyx_FMT_TYPENAME "' and '" __Pyx_FMT_TYPENAME "'", opname, op1, op2); } #endif #endif #ifndef __Pyx_DEFINED_PyNumber_Multiply_xfloat_int #define __Pyx_DEFINED_PyNumber_Multiply_xfloat_int static PyObject* __Pyx_PyNumber_Multiply_xfloat_int(PyObject *op1, PyObject *op2, int inplace) { if (likely(op2 != Py_None)) { double int_op2; #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsCompact(op2)) { Py_ssize_t compact_op2 = __Pyx_PyLong_CompactValue(op2); int_op2 = (double) compact_op2; } else #endif { int_op2 = PyLong_AsDouble(op2); if (unlikely((int_op2 == -1.) && PyErr_Occurred())) return NULL; } double float_op1 = __Pyx_PyFloat_AS_DOUBLE(op1); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely((float_op1 == -1.) && PyErr_Occurred())) return NULL; #endif if (float_op1 == 0.) return __Pyx_NewRef(op1); return PyFloat_FromDouble(float_op1 * int_op2); } #if CYTHON_USE_TYPE_SLOTS || __PYX_LIMITED_VERSION_HEX >= 0x030A0000 { PyTypeObject *type_op2 = Py_TYPE(op2); binaryfunc slot_func = __Pyx_PyType_GetSubSlot(type_op2, tp_as_number, nb_multiply, binaryfunc); if (likely(slot_func)) { PyObject *result = slot_func(op1, op2); if (likely(result != Py_NotImplemented)) { return result; } Py_DECREF(result); } __Pyx_BinopTypeError(op1, op2, "*", inplace); return NULL; } #else return (inplace) ? PyNumber_InPlaceMultiply(op1, op2) : PyNumber_Multiply(op1, op2); #endif } #endif #ifndef __Pyx_DEFINED_PyNumber_Multiply_xint_int #define __Pyx_DEFINED_PyNumber_Multiply_xint_int static PyObject* __Pyx_PyNumber_Multiply_xint_int(PyObject *op1, PyObject *op2, int inplace) { #if CYTHON_USE_TYPE_SLOTS || __PYX_LIMITED_VERSION_HEX >= 0x030A0000 { PyTypeObject *type_op2 = Py_TYPE(op2); binaryfunc slot_func = __Pyx_PyType_GetSubSlot(type_op2, tp_as_number, nb_multiply, binaryfunc); if (likely(slot_func)) { PyObject *result = slot_func(op1, op2); if (likely(result != Py_NotImplemented)) { return result; } Py_DECREF(result); } ssizeargfunc repeat_func = __Pyx_PyType_GetSubSlot(type_op2, tp_as_sequence, sq_repeat, ssizeargfunc); if (likely(repeat_func)) { Py_ssize_t count; #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsCompact(op1)) { count = __Pyx_PyLong_CompactValue(op1); } else #endif { count = PyLong_AsSsize_t(op1); if (unlikely((count == -1) && PyErr_Occurred())) return NULL; } return repeat_func(op2, count); } __Pyx_BinopTypeError(op1, op2, "*", inplace); return NULL; } #else return (inplace) ? PyNumber_InPlaceMultiply(op1, op2) : PyNumber_Multiply(op1, op2); #endif } #endif static CYTHON_INLINE PyObject* __Pyx__PyNumber_Multiply_object_int(PyObject *op1, PyObject *op2, int inplace) { if (PyFloat_CheckExact(op1)) { return __Pyx_PyNumber_Multiply_xfloat_int(op1, op2, inplace); } if (likely(PyLong_CheckExact(op1))) { if (likely(op2 != Py_None)) { #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsCompact(op1)) { long long int_op1 = (long long) __Pyx_PyLong_CompactValue(op1); if (int_op1 == 0) return __Pyx_NewRef(op1); if (__Pyx_PyLong_IsCompact(op2)) { long long int_op2 = (long long) __Pyx_PyLong_CompactValue(op2); if (int_op2 == 0) return __Pyx_NewRef(op2); return PyLong_FromLongLong(int_op1 * int_op2); } } else if (__Pyx_PyLong_IsZero(op2)) return __Pyx_NewRef(op2); #endif binaryfunc slot_func = __Pyx_PyType_GetSubSlot(&PyLong_Type, tp_as_number, nb_multiply, binaryfunc); if (likely(slot_func)) { return slot_func(op1, op2); } } return __Pyx_PyNumber_Multiply_xint_int(op1, op2, inplace); } return (inplace) ? PyNumber_InPlaceMultiply(op1, op2) : PyNumber_Multiply(op1, op2); } #endif /* PyNumberBinop */ #if !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_GRAAL || CYTHON_COMPILING_IN_LIMITED_API) #if CYTHON_USE_TYPE_SLOTS || __PYX_LIMITED_VERSION_HEX >= 0x030A0000 #ifndef __Pyx_DEFINED_BinopTypeError #define __Pyx_DEFINED_BinopTypeError static void __Pyx_BinopTypeError(PyObject *op1, PyObject *op2, const char* op, int inplace) { char opname[4] = {op[0], op[1], 0, 0}; if (inplace) { opname[op[1] ? 2 : 1] = '='; } __Pyx_RaiseErrorWithObjectTypes1( PyExc_TypeError, "unsupported operand type(s) for %.3s: '" __Pyx_FMT_TYPENAME "' and '" __Pyx_FMT_TYPENAME "'", opname, op1, op2); } #endif #endif #ifndef __Pyx_DEFINED_PyNumber_Add_xfloat_int #define __Pyx_DEFINED_PyNumber_Add_xfloat_int static PyObject* __Pyx_PyNumber_Add_xfloat_int(PyObject *op1, PyObject *op2, int inplace) { if (likely(op2 != Py_None)) { double int_op2; #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsCompact(op2)) { Py_ssize_t compact_op2 = __Pyx_PyLong_CompactValue(op2); if (compact_op2 == 0) return __Pyx_NewRef(op1); int_op2 = (double) compact_op2; } else #endif { int_op2 = PyLong_AsDouble(op2); if (unlikely((int_op2 == -1.) && PyErr_Occurred())) return NULL; #if !CYTHON_USE_PYLONG_INTERNALS if (int_op2 == 0.) return __Pyx_NewRef(op1); #endif } double float_op1 = __Pyx_PyFloat_AS_DOUBLE(op1); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely((float_op1 == -1.) && PyErr_Occurred())) return NULL; #endif return PyFloat_FromDouble(float_op1 + int_op2); } #if CYTHON_USE_TYPE_SLOTS || __PYX_LIMITED_VERSION_HEX >= 0x030A0000 { PyTypeObject *type_op2 = Py_TYPE(op2); binaryfunc slot_func = __Pyx_PyType_GetSubSlot(type_op2, tp_as_number, nb_add, binaryfunc); if (likely(slot_func)) { PyObject *result = slot_func(op1, op2); if (likely(result != Py_NotImplemented)) { return result; } Py_DECREF(result); } __Pyx_BinopTypeError(op1, op2, "+", inplace); return NULL; } #else return (inplace) ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2); #endif } #endif #ifndef __Pyx_DEFINED_PyNumber_Add_xint_int #define __Pyx_DEFINED_PyNumber_Add_xint_int static PyObject* __Pyx_PyNumber_Add_xint_int(PyObject *op1, PyObject *op2, int inplace) { #if CYTHON_USE_TYPE_SLOTS || __PYX_LIMITED_VERSION_HEX >= 0x030A0000 { PyTypeObject *type_op2 = Py_TYPE(op2); binaryfunc slot_func = __Pyx_PyType_GetSubSlot(type_op2, tp_as_number, nb_add, binaryfunc); if (likely(slot_func)) { PyObject *result = slot_func(op1, op2); if (likely(result != Py_NotImplemented)) { return result; } Py_DECREF(result); } __Pyx_BinopTypeError(op1, op2, "+", inplace); return NULL; } #else return (inplace) ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2); #endif } #endif static CYTHON_INLINE PyObject* __Pyx__PyNumber_Add_object_int(PyObject *op1, PyObject *op2, int inplace) { if (PyFloat_CheckExact(op1)) { return __Pyx_PyNumber_Add_xfloat_int(op1, op2, inplace); } if (likely(PyLong_CheckExact(op1))) { if (likely(op2 != Py_None)) { #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsCompact(op1)) { Py_ssize_t int_op1 = __Pyx_PyLong_CompactValue(op1); if (int_op1 == 0) return __Pyx_NewRef(op2); if (__Pyx_PyLong_IsCompact(op2)) { Py_ssize_t int_op2 = __Pyx_PyLong_CompactValue(op2); if (int_op2 == 0) return __Pyx_NewRef(op1); return PyLong_FromSsize_t(int_op1 + int_op2); } } else if (__Pyx_PyLong_IsZero(op2)) return __Pyx_NewRef(op1); #endif binaryfunc slot_func = __Pyx_PyType_GetSubSlot(&PyLong_Type, tp_as_number, nb_add, binaryfunc); if (likely(slot_func)) { return slot_func(op1, op2); } } return __Pyx_PyNumber_Add_xint_int(op1, op2, inplace); } return (inplace) ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2); } #endif /* GetAttr3 */ #if __PYX_LIMITED_VERSION_HEX < 0x030d0000 static PyObject *__Pyx_GetAttr3Default(PyObject *d) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) return NULL; __Pyx_PyErr_Clear(); Py_INCREF(d); return d; } #endif static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { PyObject *r; #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 int res = PyObject_GetOptionalAttr(o, n, &r); return (res != 0) ? r : __Pyx_NewRef(d); #else #if CYTHON_USE_TYPE_SLOTS if (likely(PyUnicode_Check(n))) { r = __Pyx_PyObject_GetAttrStrNoError(o, n); if (unlikely(!r) && likely(!PyErr_Occurred())) { r = __Pyx_NewRef(d); } return r; } #endif r = PyObject_GetAttr(o, n); return (likely(r)) ? r : __Pyx_GetAttr3Default(d); #endif } /* AllocateExtensionType */ static PyObject *__Pyx_AllocateExtensionType(PyTypeObject *t, int is_final) { if (is_final || likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { allocfunc alloc_func = __Pyx_PyType_GetSlot(t, tp_alloc, allocfunc); return alloc_func(t, 0); } else { newfunc tp_new = __Pyx_PyType_TryGetSlot(&PyBaseObject_Type, tp_new, newfunc); #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 if (!tp_new) { PyObject *new_str = PyUnicode_FromString("__new__"); if (likely(new_str)) { PyObject *o = PyObject_CallMethodObjArgs((PyObject *)&PyBaseObject_Type, new_str, t, NULL); Py_DECREF(new_str); return o; } else return NULL; } else #endif return tp_new(t, __pyx_mstate_global->__pyx_empty_tuple, 0); } } /* CallSlotAsVectorcallUnpackDict (used by CallSlotAsVectorcall) */ static CYTHON_INLINE int __Pyx_CallSlotAsVectorcallUnpackDict(Py_ssize_t args_size, PyObject *keys_dict, PyObject **args, PyObject *kwnames) { Py_ssize_t pos = 0, i = 0; PyObject *key, *value; while (PyDict_Next(keys_dict, &pos, &key, &value)) { Py_INCREF(value); args[args_size+i] = value; Py_INCREF(key); if (unlikely(__Pyx_PyTuple_SET_ITEM(kwnames, i, key) == -1)) { return -1; } ++i; } return 0; } /* CallSlotAsVectorcall */ #if CYTHON_VECTORCALL_TPNEW static PyObject * __Pyx_CallTpnewAsVectorcall(__Pyx_tpnewvectorcallfunc f, PyTypeObject* o, PyObject *a, PyObject *k) { Py_ssize_t k_size = k ? __Pyx_PyDict_GET_SIZE(k) : 0; #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely(k_size < 0)) return NULL; #endif Py_ssize_t a_size = __Pyx_PyTuple_GET_SIZE(a); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely(a_size < 0)) return NULL; #endif #if CYTHON_ASSUME_SAFE_MACROS if (k_size == 0) { return f(o, &PyTuple_GET_ITEM(a, 0), a_size, NULL); } #else if (k_size == 0 && a_size == 0) { return f(o, NULL, 0, NULL); } #endif PyObject *stack_args[5]; PyObject **args = stack_args; Py_ssize_t maxnargs = PY_SSIZE_T_MAX / sizeof(PyObject*) - 1; if (a_size > maxnargs - k_size) { PyErr_NoMemory(); return NULL; } Py_ssize_t total_size = a_size + k_size; if (total_size > 5) { args = (PyObject**)PyMem_Malloc(((size_t)total_size)*sizeof(PyObject*)); if (unlikely(!args)) { PyErr_NoMemory(); return NULL; } } PyObject * result = NULL; PyObject *kwnames = NULL; int unpack_dict_result; Py_ssize_t i = 0; for (; i < a_size; ++i) { args[i] = __Pyx_PyTuple_GET_ITEM(a, i); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely(!args[i])) goto cleanup; #endif } #if !CYTHON_ASSUME_SAFE_MACROS if (k) // There's a specific shortcut earlier for ASSUME_SAFE_MACROS with no keywords #endif { kwnames = PyTuple_New(k_size); if (unlikely(!kwnames)) goto cleanup; __Pyx_BEGIN_CRITICAL_SECTION(k); unpack_dict_result = __Pyx_CallSlotAsVectorcallUnpackDict(a_size, k, args, kwnames); __Pyx_END_CRITICAL_SECTION(); if (unlikely(unpack_dict_result == -1)) goto cleanup; } result = f(o, args, a_size, kwnames); cleanup: Py_XDECREF(kwnames); for (i=a_size; i__pyx_empty_tuple); } result = tp_new(t, args_tuple, kwds_dict); if (unlikely(!result)) { goto end; } if (PyObject_TypeCheck(result, t)) { initproc tp_init = __Pyx_PyObject_GetSlot(result, tp_init, initproc); if (tp_init && unlikely(tp_init(result, args_tuple, kwds_dict) < 0)) { Py_CLEAR(result); } } end: Py_XDECREF(args_tuple); Py_XDECREF(kwds_dict); return result; } #endif /* CallSlotAsVectorcall */ #if CYTHON_VECTORCALL_TPNEW static int __Pyx_CallTpinitAsVectorcall(__Pyx_tpinitvectorcallfunc f, PyObject* o, PyObject *a, PyObject *k) { Py_ssize_t k_size = k ? __Pyx_PyDict_GET_SIZE(k) : 0; #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely(k_size < 0)) return -1; #endif Py_ssize_t a_size = __Pyx_PyTuple_GET_SIZE(a); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely(a_size < 0)) return -1; #endif #if CYTHON_ASSUME_SAFE_MACROS if (k_size == 0) { return f(o, &PyTuple_GET_ITEM(a, 0), a_size, NULL); } #else if (k_size == 0 && a_size == 0) { return f(o, NULL, 0, NULL); } #endif PyObject *stack_args[5]; PyObject **args = stack_args; Py_ssize_t maxnargs = PY_SSIZE_T_MAX / sizeof(PyObject*) - 1; if (a_size > maxnargs - k_size) { PyErr_NoMemory(); return -1; } Py_ssize_t total_size = a_size + k_size; if (total_size > 5) { args = (PyObject**)PyMem_Malloc(((size_t)total_size)*sizeof(PyObject*)); if (unlikely(!args)) { PyErr_NoMemory(); return -1; } } int result = -1; PyObject *kwnames = NULL; int unpack_dict_result; Py_ssize_t i = 0; for (; i < a_size; ++i) { args[i] = __Pyx_PyTuple_GET_ITEM(a, i); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely(!args[i])) goto cleanup; #endif } #if !CYTHON_ASSUME_SAFE_MACROS if (k) // There's a specific shortcut earlier for ASSUME_SAFE_MACROS with no keywords #endif { kwnames = PyTuple_New(k_size); if (unlikely(!kwnames)) goto cleanup; __Pyx_BEGIN_CRITICAL_SECTION(k); unpack_dict_result = __Pyx_CallSlotAsVectorcallUnpackDict(a_size, k, args, kwnames); __Pyx_END_CRITICAL_SECTION(); if (unlikely(unpack_dict_result == -1)) goto cleanup; } result = f(o, args, a_size, kwnames); cleanup: Py_XDECREF(kwnames); for (i=a_size; itp_dictoffset != 0; #else Py_ssize_t dictoffset = __Pyx_GetTypeDictOffset(b, 0); has_dictoffset = dictoffset != 0; #endif #if CYTHON_AVOID_BORROWED_REFS Py_DECREF(b); #endif #if !CYTHON_USE_TYPE_SLOTS if (dictoffset == -1 && PyErr_Occurred()) return -1; #endif } for (i = 1; i < n; i++) { PyTypeObject *b; #if CYTHON_AVOID_BORROWED_REFS PyObject *b0 = PySequence_GetItem(bases, i); if (!b0) return -1; #elif CYTHON_ASSUME_SAFE_MACROS PyObject *b0 = PyTuple_GET_ITEM(bases, i); #else PyObject *b0 = PyTuple_GetItem(bases, i); if (!b0) return -1; #endif b = (PyTypeObject*) b0; if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) { __Pyx_RaiseErrorWithType( PyExc_TypeError, "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b); #if CYTHON_AVOID_BORROWED_REFS Py_DECREF(b0); #endif return -1; } if (!has_dictoffset) { Py_ssize_t b_dictoffset = 0; #if CYTHON_USE_TYPE_SLOTS b_dictoffset = b->tp_dictoffset; #else b_dictoffset = __Pyx_GetTypeDictOffset((PyObject*)b, 0); if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return; #endif if (b_dictoffset) { __Pyx_RaiseErrorWithType1( 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); #if !CYTHON_USE_TYPE_SLOTS dictoffset_return: #endif #if CYTHON_AVOID_BORROWED_REFS Py_DECREF(b0); #endif return -1; } } #if CYTHON_AVOID_BORROWED_REFS Py_DECREF(b0); #endif } return 0; } #endif /* PyType_Ready */ CYTHON_UNUSED static int __Pyx_PyType_HasMultipleInheritance(PyTypeObject *t) { while (t) { PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); if (bases) { return 1; } t = __Pyx_PyType_GetSlot(t, tp_base, PyTypeObject*); } return 0; } static int __Pyx_PyType_Ready(PyTypeObject *t) { #if CYTHON_USE_TYPE_SPECS || !CYTHON_COMPILING_IN_CPYTHON (void)__Pyx_PyObject_CallMethod0; #if CYTHON_USE_TYPE_SPECS (void)__Pyx_validate_bases_tuple; #endif return PyType_Ready(t); #else int r; if (!__Pyx_PyType_HasMultipleInheritance(t)) { return PyType_Ready(t); } PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset != 0, bases) == -1)) return -1; { int gc_was_enabled; #if PY_VERSION_HEX >= 0x030A00b1 gc_was_enabled = PyGC_Disable(); (void)__Pyx_PyObject_CallMethod0; #else PyObject *ret, *py_status; PyObject *gc = NULL; #if (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) &&\ !CYTHON_COMPILING_IN_GRAAL gc = PyImport_GetModule(__pyx_mstate_global->__pyx_kp_u_gc); #endif if (unlikely(!gc)) gc = PyImport_Import(__pyx_mstate_global->__pyx_kp_u_gc); if (unlikely(!gc)) return -1; py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_isenabled); if (unlikely(!py_status)) { Py_DECREF(gc); return -1; } gc_was_enabled = __Pyx_PyObject_IsTrue(py_status); Py_DECREF(py_status); if (gc_was_enabled > 0) { ret = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_disable); if (unlikely(!ret)) { Py_DECREF(gc); return -1; } Py_DECREF(ret); } else if (unlikely(gc_was_enabled == -1)) { Py_DECREF(gc); return -1; } #endif t->tp_flags |= Py_TPFLAGS_HEAPTYPE; #if PY_VERSION_HEX >= 0x030A0000 t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE; #endif r = PyType_Ready(t); t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE; #if PY_VERSION_HEX >= 0x030A00b1 if (gc_was_enabled) PyGC_Enable(); #else if (gc_was_enabled) { PyObject *tp, *v, *tb; PyErr_Fetch(&tp, &v, &tb); ret = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_enable); if (likely(ret || r == -1)) { Py_XDECREF(ret); PyErr_Restore(tp, v, tb); } else { Py_XDECREF(tp); Py_XDECREF(v); Py_XDECREF(tb); r = -1; } } Py_DECREF(gc); #endif } return r; #endif } /* LimitedApiGetTypeTypeDict (used by DelItemOnTypeDict) */ #if CYTHON_COMPILING_IN_LIMITED_API static PyObject *__Pyx_GetTypeTypeDict(PyTypeObject *tp) { static Py_ssize_t tp_dictoffset = 0; if (unlikely(tp_dictoffset == 0)) { tp_dictoffset = __Pyx_GetTypeDictOffset((PyObject*)(&PyType_Type), 1); if (unlikely(tp_dictoffset == -1 && PyErr_Occurred())) { tp_dictoffset = 0; // try again next time? return NULL; } } return *(PyObject**)((char*)tp + tp_dictoffset); } #endif /* DelItemOnTypeDict (used by SetupReduce) */ static int __Pyx__DelItemOnTypeDict(PyTypeObject *tp, PyObject *k) { int result; PyObject *tp_dict; #if CYTHON_COMPILING_IN_LIMITED_API tp_dict = __Pyx_GetTypeTypeDict(tp); if (unlikely(!tp_dict)) return -1; #else tp_dict = tp->tp_dict; #endif result = PyDict_DelItem(tp_dict, k); if (likely(!result)) PyType_Modified(tp); return result; } /* SetItemOnTypeDict (used by SetupReduce) */ static int __Pyx__SetItemOnTypeDict(PyTypeObject *tp, PyObject *k, PyObject *v) { int result; PyObject *tp_dict; #if CYTHON_COMPILING_IN_LIMITED_API tp_dict = __Pyx_GetTypeTypeDict(tp); if (unlikely(!tp_dict)) return -1; #else tp_dict = tp->tp_dict; #endif result = PyDict_SetItem(tp_dict, k, v); if (likely(!result)) { PyType_Modified(tp); if (unlikely(PyObject_HasAttr(v, __pyx_mstate_global->__pyx_n_u_set_name))) { PyObject *setNameResult = PyObject_CallMethodObjArgs(v, __pyx_mstate_global->__pyx_n_u_set_name, (PyObject *) tp, k, NULL); if (!setNameResult) return -1; Py_DECREF(setNameResult); } } return result; } /* SetupReduce */ static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { int ret; PyObject *name_attr; name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_mstate_global->__pyx_n_u_name); if (likely(name_attr)) { ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); } else { ret = -1; } if (unlikely(ret < 0) && __Pyx_IgnoreException(PyExc_Exception)) { ret = 0; // But BaseException is still propagated. } Py_XDECREF(name_attr); return ret; } static PyObject *__Pyx_setup_reduce_get_reduce_attribute(PyObject *type_obj, PyObject *name, int allow_not_present) { #if CYTHON_USE_PYTYPE_LOOKUP CYTHON_UNUSED_VAR(allow_not_present); return _PyType_Lookup((PyTypeObject*)type_obj, name); #else if (allow_not_present) { return __Pyx_PyObject_GetAttrStrNoError(type_obj, name); } else { return __Pyx_PyObject_GetAttrStr(type_obj, name); } #endif } 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; getstate = __Pyx_setup_reduce_get_reduce_attribute(type_obj, __pyx_mstate_global->__pyx_n_u_getstate, 1); if (!getstate && PyErr_Occurred()) { goto __PYX_BAD; } if (getstate) { object_getstate = __Pyx_setup_reduce_get_reduce_attribute((PyObject*)&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_getstate, 1); if (!object_getstate && PyErr_Occurred()) { goto __PYX_BAD; } if (object_getstate != getstate) { goto __PYX_GOOD; } } object_reduce_ex = __Pyx_setup_reduce_get_reduce_attribute((PyObject*)&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_reduce_ex, 0); if (unlikely(!object_reduce_ex)) goto __PYX_BAD; reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_mstate_global->__pyx_n_u_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; if (reduce_ex == object_reduce_ex) { object_reduce = __Pyx_setup_reduce_get_reduce_attribute((PyObject*)&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_reduce, 0); if (!object_reduce) goto __PYX_BAD; reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_mstate_global->__pyx_n_u_reduce); if (unlikely(!reduce)) goto __PYX_BAD; int try_to_replace_reduce = (reduce == object_reduce); if (!try_to_replace_reduce) { try_to_replace_reduce = __Pyx_setup_reduce_is_named(reduce, __pyx_mstate_global->__pyx_n_u_reduce_cython); if (unlikely(try_to_replace_reduce < 0)) { goto __PYX_BAD; } } if (try_to_replace_reduce) { reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_reduce_cython); if (likely(reduce_cython)) { ret = __Pyx_SetItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; ret = __Pyx_DelItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; } else if (reduce == object_reduce || PyErr_Occurred()) { goto __PYX_BAD; } setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_setstate); int try_to_replace_setstate; if (!setstate) { PyObject *exc = PyErr_Occurred(); if (exc && !__Pyx_IgnoreGivenException(exc, PyExc_Exception)) { goto __PYX_BAD; } try_to_replace_setstate = 1; } else { try_to_replace_setstate = __Pyx_setup_reduce_is_named(setstate, __pyx_mstate_global->__pyx_n_u_setstate_cython); if (unlikely(try_to_replace_setstate < 0)) { goto __PYX_BAD; } } if (try_to_replace_setstate) { setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_setstate_cython); if (likely(setstate_cython)) { ret = __Pyx_SetItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; ret = __Pyx_DelItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; } else if (!setstate || PyErr_Occurred()) { goto __PYX_BAD; } } PyType_Modified((PyTypeObject*)type_obj); } } goto __PYX_GOOD; __PYX_BAD: if (!PyErr_Occurred()) { __Pyx_RaiseErrorWithType( PyExc_RuntimeError, "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, (PyTypeObject*)type_obj); } 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; } /* TupleOrListFromArrayImpl (used by ListFromArray) */ CYTHON_UNUSED static PyObject * __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n) { PyObject *res = PyList_New(n); if (unlikely(res == NULL)) return NULL; #if CYTHON_COMPILING_IN_CPYTHON __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n); #else Py_ssize_t i; for (i = 0; i < n; i++) { Py_INCREF(src[i]); if (unlikely(__Pyx_PyList_SET_ITEM(res, i, src[i]) < (0))) { Py_DECREF(res); return NULL; } } #endif return res; } /* ImportImpl (used by Import) */ static int __Pyx__Import_GetModule(PyObject *qualname, PyObject **module) { PyObject *imported_module = PyImport_GetModule(qualname); if (unlikely(!imported_module)) { *module = NULL; if (PyErr_Occurred()) { return -1; } return 0; } *module = imported_module; return 1; } static int __Pyx__Import_Lookup(PyObject *qualname, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject **module) { PyObject *imported_module; PyObject *top_level_package_name; Py_ssize_t i; int status, module_found; Py_ssize_t dot_index; module_found = __Pyx__Import_GetModule(qualname, &imported_module); if (unlikely(!module_found || module_found == -1)) { *module = NULL; return module_found; } if (imported_names) { for (i = 0; i < len_imported_names; i++) { PyObject *imported_name = imported_names[i]; #if __PYX_LIMITED_VERSION_HEX < 0x030d0000 int has_imported_attribute = PyObject_HasAttr(imported_module, imported_name); #else int has_imported_attribute = PyObject_HasAttrWithError(imported_module, imported_name); if (unlikely(has_imported_attribute == -1)) goto error; #endif if (!has_imported_attribute) { goto not_found; } } *module = imported_module; return 1; } dot_index = PyUnicode_FindChar(qualname, '.', 0, PY_SSIZE_T_MAX, 1); if (dot_index == -1) { *module = imported_module; return 1; } if (unlikely(dot_index == -2)) goto error; top_level_package_name = PyUnicode_Substring(qualname, 0, dot_index); if (unlikely(!top_level_package_name)) goto error; Py_DECREF(imported_module); status = __Pyx__Import_GetModule(top_level_package_name, module); Py_DECREF(top_level_package_name); return status; error: Py_DECREF(imported_module); *module = NULL; return -1; not_found: Py_DECREF(imported_module); *module = NULL; return 0; } static PyObject *__Pyx__Import(PyObject *name, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject *qualname, PyObject *moddict, int level) { PyObject *module = 0; PyObject *empty_dict = 0; PyObject *from_list = 0; int module_found; if (!qualname) { qualname = name; } module_found = __Pyx__Import_Lookup(qualname, imported_names, len_imported_names, &module); if (likely(module_found == 1)) { return module; } else if (unlikely(module_found == -1)) { return NULL; } #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030f00a6 empty_dict = PyFrozenDict_New(NULL); #else empty_dict = PyDict_New(); #endif if (unlikely(!empty_dict)) goto bad; if (imported_names) { from_list = __Pyx_PyList_FromArray(imported_names, len_imported_names); if (unlikely(!from_list)) goto bad; } if (level == -1) { const char* package_sep = strchr(__Pyx_MODULE_NAME, '.'); if (package_sep != (0)) { module = PyImport_ImportModuleLevelObject( name, moddict, empty_dict, from_list, 1); if (unlikely(!module)) { if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError))) goto bad; PyErr_Clear(); } } level = 0; } if (!module) { module = PyImport_ImportModuleLevelObject( name, moddict, empty_dict, from_list, level); } bad: Py_XDECREF(from_list); Py_XDECREF(empty_dict); return module; } /* Import */ static PyObject *__Pyx_Import(PyObject *name, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject *qualname, int level) { return __Pyx__Import(name, imported_names, len_imported_names, qualname, __pyx_mstate_global->__pyx_d, level); } /* ImportFrom */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { const char* module_name_str = 0; PyObject* module_name = 0; PyObject* module_dot = 0; PyObject* full_name = 0; PyErr_Clear(); module_name_str = PyModule_GetName(module); if (unlikely(!module_name_str)) { goto modbad; } module_name = PyUnicode_FromString(module_name_str); if (unlikely(!module_name)) { goto modbad; } module_dot = PyUnicode_Concat(module_name, __pyx_mstate_global->__pyx_kp_u__6); if (unlikely(!module_dot)) { goto modbad; } full_name = PyUnicode_Concat(module_dot, name); if (unlikely(!full_name)) { goto modbad; } #if (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) ||\ CYTHON_COMPILING_IN_GRAAL { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) goto modbad; value = PyObject_GetItem(modules, full_name); } #else value = PyImport_GetModule(full_name); #endif modbad: Py_XDECREF(full_name); Py_XDECREF(module_dot); Py_XDECREF(module_name); } if (unlikely(!value)) { PyErr_Format(PyExc_ImportError, "cannot import name %S", name); } return value; } /* dict_setdefault (used by FetchCommonType) */ static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value) { PyObject* value; #if __PYX_LIMITED_VERSION_HEX >= 0x030F0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4) PyDict_SetDefaultRef(d, key, default_value, &value); #elif CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX >= 0x030C0000 PyObject *args[] = {d, key, default_value}; value = PyObject_VectorcallMethod(__pyx_mstate_global->__pyx_n_u_setdefault, args, 3 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); #elif CYTHON_COMPILING_IN_LIMITED_API value = PyObject_CallMethodObjArgs(d, __pyx_mstate_global->__pyx_n_u_setdefault, key, default_value, NULL); #else value = PyDict_SetDefault(d, key, default_value); if (unlikely(!value)) return NULL; Py_INCREF(value); #endif return value; } /* AddModuleRef (used by FetchSharedCythonModule) */ #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && PY_VERSION_HEX < 0x030F00a3 static PyObject *__Pyx_PyImport_AddModuleObjectRef(PyObject *name) { PyObject *module_dict = PyImport_GetModuleDict(); PyObject *m; if (PyMapping_GetOptionalItem(module_dict, name, &m) < 0) { return NULL; } if (m != NULL && PyModule_Check(m)) { return m; } Py_XDECREF(m); m = PyModule_NewObject(name); if (m == NULL) return NULL; if (PyDict_CheckExact(module_dict)) { PyObject *new_m; (void)PyDict_SetDefaultRef(module_dict, name, m, &new_m); Py_DECREF(m); return new_m; } else { if (PyObject_SetItem(module_dict, name, m) != 0) { Py_DECREF(m); return NULL; } return m; } } static PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { if ((PY_VERSION_HEX >= 0x030E0000) && Py_Version >= 0x030E0100) { return PyImport_AddModuleRef(name); } PyObject *py_name = PyUnicode_FromString(name); if (!py_name) return NULL; PyObject *module = __Pyx_PyImport_AddModuleObjectRef(py_name); Py_DECREF(py_name); return module; } #elif __PYX_LIMITED_VERSION_HEX < 0x030d0000 static PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { PyObject *module = PyImport_AddModule(name); Py_XINCREF(module); return module; } #endif /* FetchSharedCythonModule (used by FetchCommonType) */ static PyObject *__Pyx_FetchSharedCythonABIModule(void) { return __Pyx_PyImport_AddModuleRef(__PYX_ABI_MODULE_NAME); } /* VerifyCachedType (used by FetchCommonType) */ static int __Pyx_VerifyCachedType(PyObject *cached_type, const char *name, Py_ssize_t expected_basicsize) { Py_ssize_t basicsize; if (!PyType_Check(cached_type)) { PyErr_Format(PyExc_TypeError, "Shared Cython type %.200s is not a type object", name); return -1; } if (expected_basicsize == 0) { return 0; // size is inherited, nothing useful to check } #if CYTHON_COMPILING_IN_LIMITED_API && CYTHON_OPAQUE_OBJECTS if (expected_basicsize < 0) { basicsize = PyType_GetTypeDataSize((PyTypeObject*)cached_type); } else #endif { #if CYTHON_COMPILING_IN_LIMITED_API PyObject *py_basicsize; py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); if (unlikely(!py_basicsize)) return -1; basicsize = PyLong_AsSsize_t(py_basicsize); Py_DECREF(py_basicsize); py_basicsize = NULL; if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) return -1; #else basicsize = ((PyTypeObject*) cached_type)->tp_basicsize; #endif } if ((expected_basicsize >= 0) ? (basicsize != expected_basicsize) : (basicsize < -expected_basicsize)) { PyErr_Format(PyExc_TypeError, "Shared Cython type %.200s has the wrong size, try recompiling", name); return -1; } return 0; } /* FetchCommonType (used by CommonTypesMetaclass) */ #if __PYX_LIMITED_VERSION_HEX < 0x030C0000 static PyObject* __Pyx_PyType_FromMetaclass(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases) { PyObject *result = __Pyx_PyType_FromModuleAndSpec(module, spec, bases); if (result && metaclass) { PyObject *old_tp = (PyObject*)Py_TYPE(result); Py_INCREF((PyObject*)metaclass); Py_SET_TYPE(result, metaclass); Py_DECREF(old_tp); PyType_Modified((PyTypeObject*)result); } return result; } #else #define __Pyx_PyType_FromMetaclass(me, mo, s, b) PyType_FromMetaclass(me, mo, s, b) #endif static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases) { PyObject *abi_module = NULL, *cached_type = NULL, *abi_module_dict, *new_cached_type, *py_object_name; int get_item_ref_result; const char* object_name = strrchr(spec->name, '.'); object_name = object_name ? object_name+1 : spec->name; py_object_name = PyUnicode_FromString(object_name); if (!py_object_name) return NULL; abi_module = __Pyx_FetchSharedCythonABIModule(); if (!abi_module) goto done; abi_module_dict = PyModule_GetDict(abi_module); if (!abi_module_dict) goto done; get_item_ref_result = __Pyx_PyDict_GetItemRef(abi_module_dict, py_object_name, &cached_type); if (get_item_ref_result == 1) { if (__Pyx_VerifyCachedType( cached_type, object_name, spec->basicsize) < 0) { goto bad; } goto done; } else if (unlikely(get_item_ref_result == -1)) { goto bad; } cached_type = __Pyx_PyType_FromMetaclass( metaclass, CYTHON_USE_MODULE_STATE ? module : abi_module, spec, bases); if (unlikely(!cached_type)) goto bad; new_cached_type = __Pyx_PyDict_SetDefault(abi_module_dict, py_object_name, cached_type); if (unlikely(new_cached_type != cached_type)) { if (unlikely(!new_cached_type)) goto bad; Py_DECREF(cached_type); cached_type = new_cached_type; if (__Pyx_VerifyCachedType( cached_type, object_name, spec->basicsize) < 0) { goto bad; } goto done; } else { Py_DECREF(new_cached_type); } done: Py_XDECREF(abi_module); Py_DECREF(py_object_name); assert(cached_type == NULL || PyType_Check(cached_type)); return (PyTypeObject *) cached_type; bad: Py_XDECREF(cached_type); cached_type = NULL; goto done; } /* CommonTypesMetaclass (used by CythonFunctionShared) */ static PyObject* __pyx_CommonTypesMetaclass_get_module(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED void* context) { return PyUnicode_FromString(__PYX_ABI_MODULE_NAME); } #if __PYX_LIMITED_VERSION_HEX < 0x030A0000 static PyObject* __pyx_CommonTypesMetaclass_call(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED PyObject *args, CYTHON_UNUSED PyObject *kwds) { PyErr_SetString(PyExc_TypeError, "Cannot instantiate Cython internal types"); return NULL; } static int __pyx_CommonTypesMetaclass_setattr(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED PyObject *attr, CYTHON_UNUSED PyObject *value) { PyErr_SetString(PyExc_TypeError, "Cython internal types are immutable"); return -1; } #endif static PyGetSetDef __pyx_CommonTypesMetaclass_getset[] = { {"__module__", __pyx_CommonTypesMetaclass_get_module, NULL, NULL, NULL}, {0, 0, 0, 0, 0} }; static PyType_Slot __pyx_CommonTypesMetaclass_slots[] = { {Py_tp_getset, (void *)__pyx_CommonTypesMetaclass_getset}, #if __PYX_LIMITED_VERSION_HEX < 0x030A0000 {Py_tp_call, (void*)__pyx_CommonTypesMetaclass_call}, {Py_tp_new, (void*)__pyx_CommonTypesMetaclass_call}, {Py_tp_setattro, (void*)__pyx_CommonTypesMetaclass_setattr}, #endif {0, 0} }; static PyType_Spec __pyx_CommonTypesMetaclass_spec = { __PYX_TYPE_MODULE_PREFIX "_common_types_metatype", 0, 0, Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION | Py_TPFLAGS_DEFAULT, __pyx_CommonTypesMetaclass_slots }; static int __pyx_CommonTypesMetaclass_init(PyObject *module) { __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module); PyObject *bases = PyTuple_Pack(1, &PyType_Type); if (unlikely(!bases)) { return -1; } mstate->__pyx_CommonTypesMetaclassType = __Pyx_FetchCommonTypeFromSpec(NULL, module, &__pyx_CommonTypesMetaclass_spec, bases); Py_DECREF(bases); if (unlikely(mstate->__pyx_CommonTypesMetaclassType == NULL)) { return -1; } return 0; } /* CythonFunctionPerModule (used by CythonFunctionShared) */ #if CYTHON_COMPILING_IN_LIMITED_API static CYTHON_INLINE int __Pyx__IsSameCyOrCFunctionNoMethod(PyObject *func, void (*cfunc)(void)) { if (__Pyx_CyFunction_Check(func)) { return __Pyx_as_CyFunctionObject(func)->func_methoddef->ml_meth == (PyCFunction) cfunc; } else if (PyCFunction_Check(func)) { return PyCFunction_GetFunction(func) == (PyCFunction) cfunc; } return 0; } static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) { if ((PyObject*)Py_TYPE(func) == __pyx_mstate_global->__Pyx_CachedMethodType) { int result; PyObject *newFunc = PyObject_GetAttr(func, __pyx_mstate_global->__pyx_n_u_func); if (unlikely(!newFunc)) { PyErr_Clear(); // It's only an optimization, so don't throw an error return 0; } result = __Pyx__IsSameCyOrCFunctionNoMethod(newFunc, cfunc); Py_DECREF(newFunc); return result; } return __Pyx__IsSameCyOrCFunctionNoMethod(func, cfunc); } #else static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) { if (PyMethod_Check(func)) { func = PyMethod_GET_FUNCTION(func); } return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; } #endif static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) { #if 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 CYTHON_INLINE PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func, PyTypeObject *defaults_type) { __pyx_CyFunctionObject *m = __Pyx_as_CyFunctionObject(func); m->defaults = PyObject_CallObject((PyObject*)defaults_type, NULL); // _PyObject_New(defaults_type); if (unlikely(!m->defaults)) return NULL; return m->defaults; } static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { __pyx_CyFunctionObject *m = __Pyx_as_CyFunctionObject(func); m->defaults_tuple = tuple; Py_INCREF(tuple); } static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { __pyx_CyFunctionObject *m = __Pyx_as_CyFunctionObject(func); m->defaults_kwdict = dict; Py_INCREF(dict); } static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { __pyx_CyFunctionObject *m = __Pyx_as_CyFunctionObject(func); m->func_annotations = dict; Py_INCREF(dict); } /* PyMethodNew (used by CythonFunctionShared) */ #if CYTHON_COMPILING_IN_LIMITED_API static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { PyObject *result; CYTHON_UNUSED_VAR(typ); if (!self) return __Pyx_NewRef(func); #if __PYX_LIMITED_VERSION_HEX >= 0x030C0000 { PyObject *args[] = {func, self}; result = PyObject_Vectorcall(__pyx_mstate_global->__Pyx_CachedMethodType, args, 2, NULL); } #else result = PyObject_CallFunctionObjArgs(__pyx_mstate_global->__Pyx_CachedMethodType, func, self, NULL); #endif return result; } #else static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { CYTHON_UNUSED_VAR(typ); if (!self) return __Pyx_NewRef(func); return PyMethod_New(func, self); } #endif /* PyVectorcallFastCallDict (used by CythonFunctionShared) */ #if CYTHON_VECTORCALL static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) { PyObject *res = NULL; PyObject *kwnames; PyObject **newargs; PyObject **kwvalues; Py_ssize_t i; #if CYTHON_AVOID_BORROWED_REFS PyObject *pos; #else Py_ssize_t pos; #endif size_t j; PyObject *key, *value; unsigned long keys_are_strings; #if !CYTHON_ASSUME_SAFE_SIZE Py_ssize_t nkw = PyDict_Size(kw); if (unlikely(nkw == -1)) return NULL; #else Py_ssize_t nkw = PyDict_GET_SIZE(kw); #endif newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0])); if (unlikely(newargs == NULL)) { PyErr_NoMemory(); return NULL; } for (j = 0; j < nargs; j++) newargs[j] = args[j]; kwnames = PyTuple_New(nkw); if (unlikely(kwnames == NULL)) { PyMem_Free(newargs); return NULL; } kwvalues = newargs + nargs; pos = 0; i = 0; keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS; while (__Pyx_PyDict_NextRef(kw, &pos, &key, &value)) { keys_are_strings &= #if CYTHON_COMPILING_IN_LIMITED_API PyType_GetFlags(Py_TYPE(key)); #else Py_TYPE(key)->tp_flags; #endif #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely(PyTuple_SetItem(kwnames, i, key) < 0)) goto cleanup; #else PyTuple_SET_ITEM(kwnames, i, key); #endif kwvalues[i] = value; i++; } if (unlikely(!keys_are_strings)) { PyErr_SetString(PyExc_TypeError, "keywords must be strings"); goto cleanup; } res = vc(func, newargs, nargs, kwnames); cleanup: #if CYTHON_AVOID_BORROWED_REFS Py_DECREF(pos); #endif Py_DECREF(kwnames); for (i = 0; i < nkw; i++) Py_DECREF(kwvalues[i]); PyMem_Free(newargs); return res; } static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) { Py_ssize_t kw_size = likely(kw == NULL) ? 0 : #if !CYTHON_ASSUME_SAFE_SIZE PyDict_Size(kw); #else PyDict_GET_SIZE(kw); #endif if (kw_size == 0) { return vc(func, args, nargs, NULL); } #if !CYTHON_ASSUME_SAFE_SIZE else if (unlikely(kw_size == -1)) { return NULL; } #endif return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); } #endif /* CythonFunctionShared (used by CythonFunction) */ static PyObject * __Pyx_CyFunction_get_doc_locked(__pyx_CyFunctionObject *op) { if (unlikely(op->func_doc == NULL)) { #if CYTHON_COMPILING_IN_LIMITED_API const char *doc = op->func_methoddef->ml_doc; #else const char *doc = ((PyCFunctionObject*)op)->m_ml->ml_doc; #endif if (doc) { op->func_doc = PyUnicode_FromString(doc); if (unlikely(op->func_doc == NULL)) return NULL; } else { Py_INCREF(Py_None); return Py_None; } } Py_INCREF(op->func_doc); return op->func_doc; } static PyObject * __Pyx_CyFunction_get_doc(PyObject *op_in, void *closure) { PyObject *result; __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); CYTHON_UNUSED_VAR(closure); __Pyx_BEGIN_CRITICAL_SECTION(op_in); result = __Pyx_CyFunction_get_doc_locked(op); __Pyx_END_CRITICAL_SECTION(); return result; } static int __Pyx_CyFunction_set_doc(PyObject *op_in, PyObject *value, void *context) { __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); CYTHON_UNUSED_VAR(context); if (value == NULL) { value = Py_None; } Py_INCREF(value); __Pyx_BEGIN_CRITICAL_SECTION(op_in); __Pyx_Py_XDECREF_SET(op->func_doc, value); __Pyx_END_CRITICAL_SECTION(); return 0; } static PyObject * __Pyx_CyFunction_get_name_locked(__pyx_CyFunctionObject *op) { if (unlikely(op->func_name == NULL)) { #if CYTHON_COMPILING_IN_LIMITED_API const char *name = op->func_methoddef->ml_name; #else const char *name = ((PyCFunctionObject*)op)->m_ml->ml_name; #endif op->func_name = PyUnicode_InternFromString(name); if (unlikely(op->func_name == NULL)) return NULL; } Py_INCREF(op->func_name); return op->func_name; } static PyObject * __Pyx_CyFunction_get_name(PyObject *op, void *context) { PyObject *result = NULL; CYTHON_UNUSED_VAR(context); __Pyx_BEGIN_CRITICAL_SECTION(op); result = __Pyx_CyFunction_get_name_locked(__Pyx_as_CyFunctionObject(op)); __Pyx_END_CRITICAL_SECTION(); return result; } static int __Pyx_CyFunction_set_name(PyObject *op_in, PyObject *value, void *context) { CYTHON_UNUSED_VAR(context); if (unlikely(value == NULL || !PyUnicode_Check(value))) { PyErr_SetString(PyExc_TypeError, "__name__ must be set to a string object"); return -1; } __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); Py_INCREF(value); __Pyx_BEGIN_CRITICAL_SECTION(op_in); __Pyx_Py_XDECREF_SET(op->func_name, value); __Pyx_END_CRITICAL_SECTION(); return 0; } static PyObject * __Pyx_CyFunction_get_qualname(PyObject *op_in, void *context) { CYTHON_UNUSED_VAR(context); __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); PyObject *result; __Pyx_BEGIN_CRITICAL_SECTION(op_in); Py_INCREF(op->func_qualname); result = op->func_qualname; __Pyx_END_CRITICAL_SECTION(); return result; } static int __Pyx_CyFunction_set_qualname(PyObject *op_in, PyObject *value, void *context) { CYTHON_UNUSED_VAR(context); if (unlikely(value == NULL || !PyUnicode_Check(value))) { PyErr_SetString(PyExc_TypeError, "__qualname__ must be set to a string object"); return -1; } __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); Py_INCREF(value); __Pyx_BEGIN_CRITICAL_SECTION(op_in); __Pyx_Py_XDECREF_SET(op->func_qualname, value); __Pyx_END_CRITICAL_SECTION(); return 0; } #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 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; } #endif static PyObject * __Pyx_CyFunction_get_globals(PyObject *op_in, void *context) { CYTHON_UNUSED_VAR(context); __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); Py_INCREF(op->func_globals); return op->func_globals; } static PyObject * __Pyx_CyFunction_get_closure(PyObject *op, void *context) { CYTHON_UNUSED_VAR(op); CYTHON_UNUSED_VAR(context); Py_INCREF(Py_None); return Py_None; } static PyObject * __Pyx_CyFunction_get_code(PyObject *op_in, void *context) { __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); 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, PyObject *op_obj) { int result = 0; PyObject *res = op->defaults_getter(op_obj); 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(PyObject *op_in, PyObject* value, void *context) { __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); CYTHON_UNUSED_VAR(context); if (!value) { value = Py_None; } else if (unlikely(value != Py_None && !PyTuple_Check(value))) { PyErr_SetString(PyExc_TypeError, "__defaults__ must be set to a tuple object"); return -1; } PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not " "currently affect the values used in function calls", 1); Py_INCREF(value); __Pyx_BEGIN_CRITICAL_SECTION(op_in); __Pyx_Py_XDECREF_SET(op->defaults_tuple, value); __Pyx_END_CRITICAL_SECTION(); return 0; } static PyObject * __Pyx_CyFunction_get_defaults_locked(PyObject *op_in) { __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); PyObject* result = op->defaults_tuple; if (unlikely(!result)) { if (op->defaults_getter) { if (unlikely(__Pyx_CyFunction_init_defaults(op, op_in) < 0)) return NULL; result = op->defaults_tuple; } else { result = Py_None; } } Py_INCREF(result); return result; } static PyObject * __Pyx_CyFunction_get_defaults(PyObject *op, void *context) { PyObject* result = NULL; CYTHON_UNUSED_VAR(context); __Pyx_BEGIN_CRITICAL_SECTION(op); result = __Pyx_CyFunction_get_defaults_locked(op); __Pyx_END_CRITICAL_SECTION(); return result; } static int __Pyx_CyFunction_set_kwdefaults(PyObject *op_in, PyObject* value, void *context) { __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); CYTHON_UNUSED_VAR(context); if (!value) { value = Py_None; } else if (unlikely(value != Py_None && !PyDict_Check(value))) { PyErr_SetString(PyExc_TypeError, "__kwdefaults__ must be set to a dict object"); return -1; } PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not " "currently affect the values used in function calls", 1); Py_INCREF(value); __Pyx_BEGIN_CRITICAL_SECTION(op_in); __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value); __Pyx_END_CRITICAL_SECTION(); return 0; } static PyObject * __Pyx_CyFunction_get_kwdefaults_locked(PyObject *op_in) { __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); PyObject* result = op->defaults_kwdict; if (unlikely(!result)) { if (op->defaults_getter) { if (unlikely(__Pyx_CyFunction_init_defaults(op, op_in) < 0)) return NULL; result = op->defaults_kwdict; } else { result = Py_None; } } Py_INCREF(result); return result; } static PyObject * __Pyx_CyFunction_get_kwdefaults(PyObject *op, void *context) { PyObject* result; CYTHON_UNUSED_VAR(context); __Pyx_BEGIN_CRITICAL_SECTION(op); result = __Pyx_CyFunction_get_kwdefaults_locked(op); __Pyx_END_CRITICAL_SECTION(); return result; } static int __Pyx_CyFunction_set_annotate_in_dict_if_exists(PyObject *op_in, PyObject *value); static int __Pyx_CyFunction_set_annotations(PyObject *op_in, 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; } __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); Py_XINCREF(value); __Pyx_BEGIN_CRITICAL_SECTION(op_in); __Pyx_Py_XDECREF_SET(op->func_annotations, value); __Pyx_END_CRITICAL_SECTION(); if (unlikely(__Pyx_CyFunction_set_annotate_in_dict_if_exists(op_in, Py_None) < 0)) return -1; return 0; } static int __Pyx_CyFunction_get_dict_if_exists(PyObject *op_in, PyObject **dict) { /* Return 1 if the function dict exists, 0 otherwise. This cannot fail: * _PyObject_GetDictPtr() may clear errors internally, but never reports them. */ #if CYTHON_COMPILING_IN_PYPY *dict = PyObject_GenericGetDict(op_in, NULL); #elif CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX < 0x030C0000 *dict = __Pyx_as_CyFunctionObject(op_in)->func_dict; #else PyObject **dictptr = _PyObject_GetDictPtr(op_in); *dict = likely(dictptr) ? *dictptr : NULL; #endif return *dict ? 1 : 0; } static int __Pyx_CyFunction_get_annotate_from_dict_if_exists(PyObject *op_in, PyObject **annotate) { PyObject *dict; int dict_found; *annotate = NULL; dict_found = __Pyx_CyFunction_get_dict_if_exists(op_in, &dict); if (!dict_found) return 0; return __Pyx_PyDict_GetItemRef(dict, __pyx_mstate_global->__pyx_n_u_annotate, annotate); } static int __Pyx_CyFunction_set_annotate_in_dict_if_exists(PyObject *op_in, PyObject *value) { PyObject *dict; int dict_found; dict_found = __Pyx_CyFunction_get_dict_if_exists(op_in, &dict); if (!dict_found) return 0; if (value) { return PyDict_SetItem(dict, __pyx_mstate_global->__pyx_n_u_annotate, value); } else { #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d0000 return PyDict_Pop(dict, __pyx_mstate_global->__pyx_n_u_annotate, NULL); #else int result = PyDict_Contains(dict, __pyx_mstate_global->__pyx_n_u_annotate); if (result == 1) { result = PyDict_DelItem(dict, __pyx_mstate_global->__pyx_n_u_annotate); } return result; #endif } } static int __Pyx_CyFunction_set_annotate_in_dict(PyObject *op_in, PyObject *value) { PyObject *dict; int result; #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 dict = __Pyx_CyFunction_get_dict(__Pyx_as_CyFunctionObject(op_in), NULL); #else dict = PyObject_GenericGetDict(op_in, NULL); #endif if (unlikely(!dict)) return -1; result = PyDict_SetItem(dict, __pyx_mstate_global->__pyx_n_u_annotate, value); Py_DECREF(dict); return result; } static PyObject * __Pyx_CyFunction_get_annotations_locked(__pyx_CyFunctionObject *op) { PyObject* result = op->func_annotations; if (unlikely(!result)) { result = PyDict_New(); if (unlikely(!result)) return NULL; op->func_annotations = result; } Py_INCREF(result); return result; } static PyObject * __Pyx_CyFunction_get_annotations(PyObject *op_in, void *context) { PyObject *annotate = NULL; PyObject *result = NULL; __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); CYTHON_UNUSED_VAR(context); __Pyx_BEGIN_CRITICAL_SECTION(op_in); result = __Pyx_XNewRef(op->func_annotations); __Pyx_END_CRITICAL_SECTION(); if (result) return result; if (unlikely(__Pyx_CyFunction_get_annotate_from_dict_if_exists(op_in, &annotate) < 0)) return NULL; if (!annotate || annotate == Py_None) { Py_XDECREF(annotate); __Pyx_BEGIN_CRITICAL_SECTION(op_in); result = __Pyx_CyFunction_get_annotations_locked(op); __Pyx_END_CRITICAL_SECTION(); return result; } PyObject *format = PyLong_FromLong(1L); // annotationlib.Format.VALUE if (likely(format)) { if (!Py_EnterRecursiveCall(" cyfunction __annotations__.__get__")) { result = __Pyx_PyObject_CallOneArg(annotate, format); Py_LeaveRecursiveCall(); Py_DECREF(format); } } Py_DECREF(annotate); if (unlikely(!result)) return NULL; if (unlikely(!PyDict_Check(result))) { PyErr_SetString(PyExc_TypeError, "__annotate__ must return a dict"); Py_DECREF(result); return NULL; } __Pyx_BEGIN_CRITICAL_SECTION(op_in); __Pyx_Py_XDECREF_SET(op->func_annotations, __Pyx_NewRef(result)); __Pyx_END_CRITICAL_SECTION(); return result; } static PyObject *__Pyx_CyFunction_annotate_impl(PyObject *self, PyObject *arg) { CYTHON_UNUSED_VAR(arg); if (unlikely(!self)) { PyErr_SetString(PyExc_SystemError, "cython __annotate__ called without 'self' argument"); return NULL; } PyObject *result; if (Py_EnterRecursiveCall(" in cyfunction annotate")) { return NULL; } result = __Pyx_CyFunction_get_annotations(self, NULL); Py_LeaveRecursiveCall(); return result; } static PyObject * __Pyx_CyFunction_get_annotate(PyObject *op_in, void *context); static int __Pyx_CyFunction_set_annotate(PyObject *op_in, PyObject* value, void *context) { CYTHON_UNUSED_VAR(context); if (value == NULL) { PyErr_SetString(PyExc_TypeError, "__annotate__ cannot be deleted"); return -1; } if (unlikely(value != Py_None && !PyCallable_Check(value))) { PyErr_SetString(PyExc_TypeError, "__annotate__ must be callable or None"); return -1; } if (unlikely(__Pyx_TypeCheck(value, &PyCFunction_Type))) { #if !CYTHON_ASSUME_SAFE_MACROS && !CYTHON_COMPILING_IN_PYPY PyCFunction cfunction = PyCFunction_GetFunction(value); if (unlikely(!cfunction)) return -1; PyObject *value_self = PyCFunction_GetSelf(value); if (unlikely(!value_self && PyErr_Occurred())) return -1; #else PyCFunction cfunction = PyCFunction_GET_FUNCTION(value); PyObject *value_self = PyCFunction_GET_SELF(value); #endif if (cfunction == __Pyx_CyFunction_annotate_impl && value_self == op_in) { return __Pyx_CyFunction_set_annotate_in_dict_if_exists(op_in, NULL); } } if (value != Py_None) { __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); __Pyx_BEGIN_CRITICAL_SECTION(op_in); Py_CLEAR(op->func_annotations); __Pyx_END_CRITICAL_SECTION(); } return __Pyx_CyFunction_set_annotate_in_dict(op_in, value); } #if __PYX_LIMITED_VERSION_HEX < 0x030B0000 static PyObject * __Pyx_CyFunction_get_is_coroutine_value(__pyx_CyFunctionObject *op) { int is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; if (is_coroutine) { PyObject *is_coroutine_value, *module, *fromlist, *marker = __pyx_mstate_global->__pyx_n_u_is_coroutine; fromlist = PyList_New(1); if (unlikely(!fromlist)) return NULL; Py_INCREF(marker); #if CYTHON_ASSUME_SAFE_MACROS PyList_SET_ITEM(fromlist, 0, marker); #else if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) { Py_DECREF(fromlist); return NULL; } #endif module = PyImport_ImportModuleLevelObject(__pyx_mstate_global->__pyx_n_u_asyncio_coroutines, NULL, NULL, fromlist, 0); Py_DECREF(fromlist); if (unlikely(!module)) { goto ignore_or_error; } is_coroutine_value = __Pyx_PyObject_GetAttrStr(module, marker); Py_DECREF(module); if (likely(is_coroutine_value)) { return is_coroutine_value; } ignore_or_error: if (!__Pyx_IgnoreException(PyExc_Exception)) { return NULL; } } return __Pyx_PyBool_FromLong(is_coroutine); } static PyObject * __Pyx_CyFunction_get_is_coroutine(PyObject *op_in, void *context) { __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); PyObject *result; CYTHON_UNUSED_VAR(context); if (op->func_is_coroutine) { return __Pyx_NewRef(op->func_is_coroutine); } result = __Pyx_CyFunction_get_is_coroutine_value(op); if (unlikely(!result)) return NULL; __Pyx_BEGIN_CRITICAL_SECTION(op_in); if (op->func_is_coroutine) { Py_DECREF(result); result = __Pyx_NewRef(op->func_is_coroutine); } else { op->func_is_coroutine = __Pyx_NewRef(result); } __Pyx_END_CRITICAL_SECTION(); return result; } #endif static void __Pyx_CyFunction_raise_argument_count_error(PyObject *func, const char* message, Py_ssize_t size) { #if CYTHON_COMPILING_IN_LIMITED_API PyObject *py_name = __Pyx_CyFunction_get_name(func, NULL); if (!py_name) return; PyErr_Format(PyExc_TypeError, "%.200S() %s (%" CYTHON_FORMAT_SSIZE_T "d given)", py_name, message, size); Py_DECREF(py_name); #else const char* name = ((PyCFunctionObject*)func)->m_ml->ml_name; PyErr_Format(PyExc_TypeError, "%.200s() %s (%" CYTHON_FORMAT_SSIZE_T "d given)", name, message, size); #endif } static void __Pyx_CyFunction_raise_type_error(PyObject *func, const char* message) { #if CYTHON_COMPILING_IN_LIMITED_API PyObject *py_name = __Pyx_CyFunction_get_name(func, NULL); if (!py_name) return; PyErr_Format(PyExc_TypeError, "%.200S() %s", py_name, message); Py_DECREF(py_name); #else const char* name = ((PyCFunctionObject*)func)->m_ml->ml_name; PyErr_Format(PyExc_TypeError, "%.200s() %s", name, message); #endif } #if CYTHON_COMPILING_IN_LIMITED_API static PyObject * __Pyx_CyFunction_get_module(PyObject *op_in, void *context) { CYTHON_UNUSED_VAR(context); __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); Py_INCREF(op->func_module); return op->func_module; } static int __Pyx_CyFunction_set_module(PyObject *op_in, PyObject* value, void *context) { CYTHON_UNUSED_VAR(context); __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); if (value == NULL) { value = Py_None; } Py_INCREF(value); PyObject *old = op->func_module; op->func_module = value; Py_DECREF(old); return 0; } #endif static PyGetSetDef __pyx_CyFunction_getsets[] = { {"func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, {"__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, {"func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, {"__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, {"__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 {"func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)PyObject_GenericSetDict, 0, 0}, {"__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)PyObject_GenericSetDict, 0, 0}, #else {"func_dict", (getter)PyObject_GenericGetDict, (setter)PyObject_GenericSetDict, 0, 0}, {"__dict__", (getter)PyObject_GenericGetDict, (setter)PyObject_GenericSetDict, 0, 0}, #endif {"func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, {"__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, {"func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, {"__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, {"func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, {"__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, {"func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, {"__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, {"__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, {"__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, {"__annotate__", (getter)__Pyx_CyFunction_get_annotate, (setter)__Pyx_CyFunction_set_annotate, 0, 0}, #if __PYX_LIMITED_VERSION_HEX < 0x030B0000 {"_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0}, #endif #if CYTHON_COMPILING_IN_LIMITED_API {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0}, #endif {0, 0, 0, 0, 0} }; static PyMemberDef __pyx_CyFunction_members[] = { #if !CYTHON_COMPILING_IN_LIMITED_API {"__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, #endif #if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API {"__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), __PYX_SHARED_RELATIVE_OFFSET | READONLY, 0}, #endif #if CYTHON_VECTORCALL #if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY {"__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), __PYX_SHARED_RELATIVE_OFFSET | READONLY, 0}, #else {"__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, #endif #if CYTHON_COMPILING_IN_LIMITED_API {"__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), __PYX_SHARED_RELATIVE_OFFSET | READONLY, 0}, #else {"__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, #endif #endif {0, 0, 0, 0, 0} }; static PyObject * __Pyx_CyFunction_reduce(PyObject *m_in, PyObject *args) { PyObject *result = NULL; __pyx_CyFunctionObject *m = __Pyx_as_CyFunctionObject(m_in); CYTHON_UNUSED_VAR(args); __Pyx_BEGIN_CRITICAL_SECTION(m_in); Py_INCREF(m->func_qualname); result = m->func_qualname; __Pyx_END_CRITICAL_SECTION(); return result; } static PyMethodDef __pyx_CyFunction_methods[] = { {"__annotate_cython__", __Pyx_CyFunction_annotate_impl, METH_O, "Placeholder __annotate__ function to allow 'functools.wraps' to work " "on Cython functions."}, {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_NOARGS, 0}, {0, 0, 0, 0} }; static PyObject * __Pyx_CyFunction_get_annotate(PyObject *op_in, void *context) { PyObject *annotate = NULL; CYTHON_UNUSED_VAR(context); if (unlikely(__Pyx_CyFunction_get_annotate_from_dict_if_exists(op_in, &annotate) < 0)) return NULL; if (annotate) return annotate; PyObject *method = PyCFunction_New( &__pyx_CyFunction_methods[0], op_in); return method; } #if CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) #else #define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist) #endif static PyObject *__Pyx_CyFunction_Init(PyObject *op_in, PyMethodDef *ml, int flags, PyObject* qualname, PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { __pyx_CyFunctionObject* op = __Pyx_as_CyFunctionObject(op_in); #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_methoddef = ml; Py_INCREF(module); op->func_module = module; #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 #if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API op->func_dict = NULL; #endif op->func_name = NULL; Py_INCREF(qualname); op->func_qualname = qualname; op->func_doc = NULL; #if CYTHON_COMPILING_IN_LIMITED_API op->func_classobj = NULL; #else ((PyCMethodObject*)op)->mm_class = NULL; #endif op->func_globals = globals; Py_INCREF(op->func_globals); Py_XINCREF(code); op->func_code = code; op->defaults = NULL; op->defaults_tuple = NULL; op->defaults_kwdict = NULL; op->defaults_getter = NULL; op->func_annotations = NULL; #if __PYX_LIMITED_VERSION_HEX < 0x030B0000 op->func_is_coroutine = NULL; #endif #if CYTHON_VECTORCALL 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_in); return NULL; } #endif return op_in; } static int __Pyx__CyFunction_clear(__pyx_CyFunctionObject *m) { Py_CLEAR(m->func_closure); #if CYTHON_COMPILING_IN_LIMITED_API Py_CLEAR(m->func_module); #else Py_CLEAR(((PyCFunctionObject*)m)->m_module); #endif #if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API Py_CLEAR(m->func_dict); #elif PY_VERSION_HEX < 0x030d0000 _PyObject_ClearManagedDict((PyObject*)m); #else PyObject_ClearManagedDict((PyObject*)m); #endif 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 Py_CLEAR(m->func_classobj); #else { PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class; ((PyCMethodObject *) (m))->mm_class = NULL; Py_XDECREF(cls); } #endif Py_CLEAR(m->defaults_tuple); Py_CLEAR(m->defaults_kwdict); Py_CLEAR(m->func_annotations); #if __PYX_LIMITED_VERSION_HEX < 0x030B0000 Py_CLEAR(m->func_is_coroutine); #endif Py_CLEAR(m->defaults); return 0; } static int __Pyx_CyFunction_clear(PyObject *m) { return __Pyx__CyFunction_clear(__Pyx_as_CyFunctionObject(m)); } static void __Pyx__CyFunction_dealloc(PyObject *m) { __pyx_CyFunctionObject *cyfunc = __Pyx_as_CyFunctionObject(m); if (__Pyx_CyFunction_weakreflist(cyfunc) != NULL) PyObject_ClearWeakRefs(m); __Pyx__CyFunction_clear(cyfunc); __Pyx_PyHeapTypeObject_GC_Del(m); } static void __Pyx_CyFunction_dealloc(PyObject *m) { PyObject_GC_UnTrack(m); __Pyx__CyFunction_dealloc(m); } static int __Pyx_CyFunction_traverse(PyObject *m_in, visitproc visit, void *arg) { __pyx_CyFunctionObject *m = __Pyx_as_CyFunctionObject(m_in); { int e = __Pyx_call_type_traverse(m_in, 1, visit, arg); if (e) return e; } Py_VISIT(m->func_closure); #if CYTHON_COMPILING_IN_LIMITED_API Py_VISIT(m->func_module); #else Py_VISIT(((PyCFunctionObject*)m)->m_module); #endif #if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API Py_VISIT(m->func_dict); #else { int e = #if PY_VERSION_HEX < 0x030d0000 _PyObject_VisitManagedDict #else PyObject_VisitManagedDict #endif ((PyObject*)m, visit, arg); if (e != 0) return e; } #endif __Pyx_VISIT_CONST(m->func_name); __Pyx_VISIT_CONST(m->func_qualname); Py_VISIT(m->func_doc); Py_VISIT(m->func_globals); __Pyx_VISIT_CONST(m->func_code); Py_VISIT(__Pyx__CyFunction_GetClassObj(m)); Py_VISIT(m->defaults_tuple); Py_VISIT(m->defaults_kwdict); Py_VISIT(m->func_annotations); #if __PYX_LIMITED_VERSION_HEX < 0x030B0000 Py_VISIT(m->func_is_coroutine); #endif Py_VISIT(m->defaults); return 0; } static PyObject* __Pyx_CyFunction_repr(PyObject *op_in) { __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); PyObject *repr; __Pyx_BEGIN_CRITICAL_SECTION(op_in); repr = PyUnicode_FromFormat("", op->func_qualname, (void *)op); __Pyx_END_CRITICAL_SECTION(); return repr; } static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { #if CYTHON_COMPILING_IN_LIMITED_API __pyx_CyFunctionObject *cyfunc = __Pyx_as_CyFunctionObject(func); PyCFunction meth = cyfunc->func_methoddef->ml_meth; int flags = cyfunc->func_methoddef->ml_flags; #else PyCFunctionObject* f = (PyCFunctionObject*)func; PyCFunction meth = f->m_ml->ml_meth; int flags = f->m_ml->ml_flags; #endif Py_ssize_t size; switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { case METH_VARARGS: if (likely(kw == NULL || PyDict_Size(kw) == 0)) return (*meth)(self, arg); break; case METH_VARARGS | METH_KEYWORDS: return (*(PyCFunctionWithKeywords)(void(*)(void))meth)(self, arg, kw); case METH_NOARGS: if (likely(kw == NULL || PyDict_Size(kw) == 0)) { #if CYTHON_ASSUME_SAFE_SIZE size = PyTuple_GET_SIZE(arg); #else size = PyTuple_Size(arg); if (unlikely(size < 0)) return NULL; #endif if (likely(size == 0)) return (*meth)(self, NULL); __Pyx_CyFunction_raise_argument_count_error( func, "takes no arguments", size); return NULL; } break; case METH_O: if (likely(kw == NULL || PyDict_Size(kw) == 0)) { #if CYTHON_ASSUME_SAFE_SIZE size = PyTuple_GET_SIZE(arg); #else size = PyTuple_Size(arg); if (unlikely(size < 0)) return NULL; #endif if (likely(size == 1)) { PyObject *result, *arg0; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS arg0 = PyTuple_GET_ITEM(arg, 0); #else arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL; #endif result = (*meth)(self, arg0); #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) Py_DECREF(arg0); #endif return result; } __Pyx_CyFunction_raise_argument_count_error( func, "takes exactly one argument", size); return NULL; } break; default: PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); return NULL; } __Pyx_CyFunction_raise_type_error( func, "takes no keyword arguments"); return NULL; } static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *result; result = __Pyx_CyFunction_CallMethod(func, func, arg, kw); return result; } static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { PyObject *result; __pyx_CyFunctionObject *cyfunc = __Pyx_as_CyFunctionObject(func); #if CYTHON_VECTORCALL __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); if (vc) { #if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw); #else (void) &__Pyx_PyVectorcall_FastCallDict; return PyVectorcall_Call(func, args, kw); #endif } #endif if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { Py_ssize_t argc; PyObject *new_args; PyObject *self; #if CYTHON_ASSUME_SAFE_SIZE argc = PyTuple_GET_SIZE(args); #else argc = PyTuple_Size(args); if (unlikely(argc < 0)) return NULL; #endif new_args = PyTuple_GetSlice(args, 1, argc); if (unlikely(!new_args)) return NULL; self = PyTuple_GetItem(args, 0); if (unlikely(!self)) { Py_DECREF(new_args); PyErr_Format(PyExc_TypeError, "unbound method %.200S() needs an argument", cyfunc->func_qualname); return NULL; } result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); Py_DECREF(new_args); } else { result = __Pyx_CyFunction_Call(func, args, kw); } return result; } #if CYTHON_VECTORCALL static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(PyObject *func, __pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames) { int ret = 0; if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { if (unlikely(nargs < 1)) { __Pyx_CyFunction_raise_type_error( func, "needs an argument"); return -1; } ret = 1; } if (unlikely(kwnames) && unlikely(__Pyx_PyTuple_GET_SIZE(kwnames))) { __Pyx_CyFunction_raise_type_error( func, "takes no keyword arguments"); return -1; } return ret; } static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) { __pyx_CyFunctionObject *cyfunc = __Pyx_as_CyFunctionObject(func); Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); PyObject *self; #if CYTHON_COMPILING_IN_LIMITED_API PyCFunction meth = cyfunc->func_methoddef->ml_meth; if (unlikely(!meth)) return NULL; #else PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; #endif switch (__Pyx_CyFunction_Vectorcall_CheckArgs(func, cyfunc, nargs, kwnames)) { case 1: self = args[0]; args += 1; nargs -= 1; break; case 0: self = func; break; default: return NULL; } if (unlikely(nargs != 0)) { __Pyx_CyFunction_raise_argument_count_error( func, "takes no arguments", nargs); return NULL; } return meth(self, NULL); } static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) { __pyx_CyFunctionObject *cyfunc = __Pyx_as_CyFunctionObject(func); Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); PyObject *self; #if CYTHON_COMPILING_IN_LIMITED_API PyCFunction meth = cyfunc->func_methoddef->ml_meth; if (unlikely(!meth)) return NULL; #else PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; #endif switch (__Pyx_CyFunction_Vectorcall_CheckArgs(func, cyfunc, nargs, kwnames)) { case 1: self = args[0]; args += 1; nargs -= 1; break; case 0: self = func; break; default: return NULL; } if (unlikely(nargs != 1)) { __Pyx_CyFunction_raise_argument_count_error( func, "takes exactly one argument", nargs); return NULL; } return meth(self, args[0]); } static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) { __pyx_CyFunctionObject *cyfunc = __Pyx_as_CyFunctionObject(func); Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); PyObject *self; #if CYTHON_COMPILING_IN_LIMITED_API PyCFunction meth = cyfunc->func_methoddef->ml_meth; if (unlikely(!meth)) return NULL; #else PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; #endif switch (__Pyx_CyFunction_Vectorcall_CheckArgs(func, cyfunc, nargs, NULL)) { case 1: self = args[0]; args += 1; nargs -= 1; break; case 0: self = func; break; default: return NULL; } return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))meth)(self, args, nargs, kwnames); } static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) { __pyx_CyFunctionObject *cyfunc = __Pyx_as_CyFunctionObject(func); PyTypeObject *cls = (PyTypeObject *) __Pyx__CyFunction_GetClassObj(cyfunc); Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); PyObject *self; #if CYTHON_COMPILING_IN_LIMITED_API PyCFunction meth = cyfunc->func_methoddef->ml_meth; if (unlikely(!meth)) return NULL; #else PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; #endif switch (__Pyx_CyFunction_Vectorcall_CheckArgs(func, cyfunc, nargs, NULL)) { case 1: self = args[0]; args += 1; nargs -= 1; break; case 0: self = func; break; default: return NULL; } #if PY_VERSION_HEX < 0x030e00A6 size_t nargs_value = (size_t) nargs; #else Py_ssize_t nargs_value = nargs; #endif return ((__Pyx_PyCMethod)(void(*)(void))meth)(self, cls, args, nargs_value, kwnames); } #endif static PyType_Slot __pyx_CyFunctionType_slots[] = { {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc}, {Py_tp_repr, (void *)__Pyx_CyFunction_repr}, {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod}, {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse}, {Py_tp_clear, (void *)__Pyx_CyFunction_clear}, {Py_tp_methods, (void *)__pyx_CyFunction_methods}, {Py_tp_members, (void *)__pyx_CyFunction_members}, {Py_tp_getset, (void *)__pyx_CyFunction_getsets}, {Py_tp_descr_get, (void *)__Pyx_PyMethod_New}, {0, 0}, }; static PyType_Spec __pyx_CyFunctionType_spec = { __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", __PYX_SHARED_SIZEOF(__pyx_CyFunctionObject), 0, #ifdef Py_TPFLAGS_METHOD_DESCRIPTOR Py_TPFLAGS_METHOD_DESCRIPTOR | #endif #if CYTHON_VECTORCALL #if defined(Py_TPFLAGS_HAVE_VECTORCALL) Py_TPFLAGS_HAVE_VECTORCALL | #elif defined(_Py_TPFLAGS_HAVE_VECTORCALL) _Py_TPFLAGS_HAVE_VECTORCALL | #endif #endif // CYTHON_VECTORCALL #if PY_VERSION_HEX >= 0x030C0000 && !CYTHON_COMPILING_IN_LIMITED_API Py_TPFLAGS_MANAGED_DICT | #endif Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION | Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, __pyx_CyFunctionType_slots }; static int __pyx_CyFunction_init(PyObject *module) { __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module); mstate->__pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec( mstate->__pyx_CommonTypesMetaclassType, module, &__pyx_CyFunctionType_spec, NULL); if (unlikely(mstate->__pyx_CyFunctionType == NULL)) { return -1; } return 0; } /* CythonFunction */ static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { (void)&__Pyx_Get_CyFunction_Type; PyObject *op = __Pyx_CyFunction_Init( PyObject_GC_New(PyObject, __pyx_mstate_global->__pyx_CyFunctionType), ml, flags, qualname, closure, module, globals, code ); if (likely(op)) { PyObject_GC_Track(op); } return op; } static PyTypeObject *__Pyx_Get_CyFunction_Type(void) { PyTypeObject *tp = __pyx_mstate_global->__pyx_CyFunctionType; Py_INCREF((PyObject*)tp); return tp; } /* ClassMethod */ static PyObject* __Pyx_Method_ClassMethod(PyObject *method) { #if CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM <= 0x05080000 if (PyObject_TypeCheck(method, &PyWrapperDescr_Type)) { return PyClassMethod_New(method); } #else #if CYTHON_COMPILING_IN_PYPY if (PyMethodDescr_Check(method)) #else if (__Pyx_TypeCheck(method, &PyMethodDescr_Type)) #endif { #if CYTHON_COMPILING_IN_LIMITED_API return PyErr_Format( PyExc_SystemError, "Cython cannot yet handle classmethod on a MethodDescriptorType (%S) in limited API mode. " "This is most likely a classmethod in a cdef class method with binding=False. " "Try setting 'binding' to True.", method); #elif CYTHON_COMPILING_IN_GRAAL && defined(GRAALPY_VERSION_NUM) && GRAALPY_VERSION_NUM > 0x19000000 PyTypeObject *d_type = GraalPyDescrObject_GetType(method); return PyDescr_NewClassMethod(d_type, GraalPyMethodDescrObject_GetMethod(method)); #elif CYTHON_COMPILING_IN_GRAAL PyTypeObject *d_type = PyDescrObject_GetType(method); return PyDescr_NewClassMethod(d_type, PyMethodDescrObject_GetMethod(method)); #else PyMethodDescrObject *descr = (PyMethodDescrObject *)method; PyTypeObject *d_type = descr->d_common.d_type; return PyDescr_NewClassMethod(d_type, descr->d_method); #endif } #endif #if !CYTHON_COMPILING_IN_LIMITED_API else if (PyMethod_Check(method)) { return PyClassMethod_New(PyMethod_GET_FUNCTION(method)); } else { return PyClassMethod_New(method); } #else { PyObject *func=NULL; PyObject *builtins, *classmethod, *classmethod_str, *result=NULL; if (__Pyx_TypeCheck(method, __pyx_mstate_global->__Pyx_CachedMethodType)) { func = PyObject_GetAttrString(method, "__func__"); if (!func) goto bad; } else { func = method; Py_INCREF(func); } builtins = PyEval_GetBuiltins(); // borrowed if (unlikely(!builtins)) goto bad; classmethod_str = PyUnicode_FromString("classmethod"); if (unlikely(!classmethod_str)) goto bad; classmethod = PyObject_GetItem(builtins, classmethod_str); Py_DECREF(classmethod_str); if (unlikely(!classmethod)) goto bad; result = PyObject_CallFunctionObjArgs(classmethod, func, NULL); Py_DECREF(classmethod); bad: Py_XDECREF(func); return result; } #endif } /* GetNameInClass */ static PyObject *__Pyx__GetNameInClass(PyObject *nmspace, PyObject *name) { PyObject *result; PyObject *dict; assert(PyType_Check(nmspace)); #if CYTHON_USE_TYPE_SLOTS dict = ((PyTypeObject*)nmspace)->tp_dict; Py_XINCREF(dict); #else dict = PyObject_GetAttr(nmspace, __pyx_mstate_global->__pyx_n_u_dict); #endif if (likely(dict)) { result = PyObject_GetItem(dict, name); Py_DECREF(dict); if (result) { return result; } } if (!__Pyx_IgnoreException(PyExc_Exception)) { return NULL; // BaseException } __Pyx_GetModuleGlobalNameUncached(result, name); return result; } /* CLineInTraceback (used by AddTraceback) */ #if CYTHON_CLINE_IN_TRACEBACK && CYTHON_CLINE_IN_TRACEBACK_RUNTIME #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 #define __Pyx_PyProbablyModule_GetDict(o) __Pyx_XNewRef(PyModule_GetDict(o)) #elif !CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_CPYTHON_FREETHREADING #define __Pyx_PyProbablyModule_GetDict(o) PyObject_GenericGetDict(o, NULL); #else PyObject* __Pyx_PyProbablyModule_GetDict(PyObject *o) { PyObject **dict_ptr = _PyObject_GetDictPtr(o); return dict_ptr ? __Pyx_XNewRef(*dict_ptr) : NULL; } #endif static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { PyObject *use_cline = NULL; PyObject *ptype, *pvalue, *ptraceback; PyObject *cython_runtime_dict; CYTHON_MAYBE_UNUSED_VAR(tstate); if (unlikely(!__pyx_mstate_global->__pyx_cython_runtime)) { return c_line; } __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); cython_runtime_dict = __Pyx_PyProbablyModule_GetDict(__pyx_mstate_global->__pyx_cython_runtime); if (likely(cython_runtime_dict)) { __PYX_PY_DICT_LOOKUP_IF_MODIFIED( use_cline, cython_runtime_dict, __Pyx_PyDict_SetDefault(cython_runtime_dict, __pyx_mstate_global->__pyx_n_u_cline_in_traceback, Py_False)) } if (use_cline == NULL || use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { c_line = 0; } Py_XDECREF(use_cline); Py_XDECREF(cython_runtime_dict); __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); return c_line; } #endif /* CodeObjectCache (used by AddTraceback) */ 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 __Pyx_CachedCodeObjectType *__pyx__find_code_object(struct __Pyx_CodeObjectCache *code_cache, int code_line) { __Pyx_CachedCodeObjectType* code_object; int pos; if (unlikely(!code_line) || unlikely(!code_cache->entries)) { return NULL; } pos = __pyx_bisect_code_objects(code_cache->entries, code_cache->count, code_line); if (unlikely(pos >= code_cache->count) || unlikely(code_cache->entries[pos].code_line != code_line)) { return NULL; } code_object = code_cache->entries[pos].code_object; Py_INCREF(code_object); return code_object; } static __Pyx_CachedCodeObjectType *__pyx_find_code_object(int code_line) { #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && !CYTHON_ATOMICS (void)__pyx__find_code_object; return NULL; // Most implementation should have atomics. But otherwise, don't make it thread-safe, just miss. #else struct __Pyx_CodeObjectCache *code_cache = &__pyx_mstate_global->__pyx_code_cache; #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING __pyx_nonatomic_int_type old_count = __pyx_atomic_incr_acq_rel(&code_cache->accessor_count); if (old_count < 0) { __pyx_atomic_decr_acq_rel(&code_cache->accessor_count); return NULL; } #endif __Pyx_CachedCodeObjectType *result = __pyx__find_code_object(code_cache, code_line); #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING __pyx_atomic_decr_acq_rel(&code_cache->accessor_count); #endif return result; #endif } static void __pyx__insert_code_object(struct __Pyx_CodeObjectCache *code_cache, int code_line, __Pyx_CachedCodeObjectType* code_object) { int pos, i; __Pyx_CodeObjectCacheEntry* entries = code_cache->entries; if (unlikely(!code_line)) { return; } if (unlikely(!entries)) { entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); if (likely(entries)) { code_cache->entries = entries; code_cache->max_count = 64; code_cache->count = 1; entries[0].code_line = code_line; entries[0].code_object = code_object; Py_INCREF(code_object); } return; } pos = __pyx_bisect_code_objects(code_cache->entries, code_cache->count, code_line); if ((pos < code_cache->count) && unlikely(code_cache->entries[pos].code_line == code_line)) { __Pyx_CachedCodeObjectType* tmp = entries[pos].code_object; entries[pos].code_object = code_object; Py_INCREF(code_object); Py_DECREF(tmp); return; } if (code_cache->count == code_cache->max_count) { int new_max = code_cache->max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( code_cache->entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } code_cache->entries = entries; code_cache->max_count = new_max; } for (i=code_cache->count; i>pos; i--) { entries[i] = entries[i-1]; } entries[pos].code_line = code_line; entries[pos].code_object = code_object; code_cache->count++; Py_INCREF(code_object); } static void __pyx_insert_code_object(int code_line, __Pyx_CachedCodeObjectType* code_object) { #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && !CYTHON_ATOMICS (void)__pyx__insert_code_object; return; // Most implementation should have atomics. But otherwise, don't make it thread-safe, just fail. #else struct __Pyx_CodeObjectCache *code_cache = &__pyx_mstate_global->__pyx_code_cache; #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING __pyx_nonatomic_int_type expected = 0; if (!__pyx_atomic_int_cmp_exchange(&code_cache->accessor_count, &expected, INT_MIN)) { return; } #endif __pyx__insert_code_object(code_cache, code_line, code_object); #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING __pyx_atomic_sub(&code_cache->accessor_count, INT_MIN); #endif #endif } /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" #if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API && !defined(PYPY_VERSION) #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif #if CYTHON_COMPILING_IN_LIMITED_API static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict, PyObject *firstlineno, PyObject *name) { PyObject *replace = NULL; if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL; if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL; replace = PyObject_GetAttrString(code, "replace"); if (likely(replace)) { PyObject *result = PyObject_Call(replace, __pyx_mstate_global->__pyx_empty_tuple, scratch_dict); Py_DECREF(replace); return result; } return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL; PyObject *replace = NULL, *getframe = NULL, *frame = NULL; PyObject *exc_type, *exc_value, *exc_traceback; int success = 0; if (c_line) { c_line = __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); } __Pyx_PyErr_FetchException(&exc_type, &exc_value, &exc_traceback); code_object = __pyx_find_code_object(c_line ? -c_line : py_line); if (!code_object) { code_object = Py_CompileString("_getframe()", filename, Py_eval_input); if (unlikely(!code_object)) goto bad; py_py_line = PyLong_FromLong(py_line); if (unlikely(!py_py_line)) goto bad; if (c_line) { py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); } else { py_funcname = PyUnicode_FromString(funcname); } if (unlikely(!py_funcname)) goto bad; dict = PyDict_New(); if (unlikely(!dict)) goto bad; { PyObject *old_code_object = code_object; code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname); Py_DECREF(old_code_object); } if (unlikely(!code_object)) goto bad; __pyx_insert_code_object(c_line ? -c_line : py_line, code_object); } else { dict = PyDict_New(); } getframe = PySys_GetObject("_getframe"); if (unlikely(!getframe)) goto bad; if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad; frame = PyEval_EvalCode(code_object, dict, dict); if (unlikely(!frame) || frame == Py_None) goto bad; success = 1; bad: __Pyx_PyErr_RestoreException(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 (c_line) { 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; } py_code = PyCode_NewEmpty(filename, funcname, py_line); Py_XDECREF(py_funcname); return py_code; bad: Py_XDECREF(py_funcname); return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyFrameObject *py_frame = 0; PyThreadState *tstate = __Pyx_PyThreadState_Current; 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_mstate_global->__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;\ } /* PyObjectCallMethod1 */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) { #if CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || !CYTHON_COMPILING_IN_LIMITED_API) PyObject *args[2] = {obj, arg}; return PyObject_VectorcallMethod(method_name, args, 2 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); #elif CYTHON_COMPILING_IN_LIMITED_API return PyObject_CallMethodObjArgs(obj, method_name, arg, NULL); #else return PyObject_CallMethodOneArg(obj, method_name, arg); #endif } /* CheckUnpickleChecksumError */ static void __Pyx_RaiseUnpickleChecksumError(long checksum, long checksum1, long checksum2, long checksum3, const char *members) { PyObject *pickle_module = PyImport_ImportModule("pickle"); if (unlikely(!pickle_module)) return; PyObject *pickle_error = PyObject_GetAttrString(pickle_module, "PickleError"); Py_DECREF(pickle_module); if (unlikely(!pickle_error)) return; if (checksum2 == checksum1) { PyErr_Format(pickle_error, "Incompatible checksums (0x%x vs (0x%x) = (%s))", checksum, checksum1, members); } else if (checksum3 == checksum2) { PyErr_Format(pickle_error, "Incompatible checksums (0x%x vs (0x%x, 0x%x) = (%s))", checksum, checksum1, checksum2, members); } else { PyErr_Format(pickle_error, "Incompatible checksums (0x%x vs (0x%x, 0x%x, 0x%x) = (%s))", checksum, checksum1, checksum2, checksum3, members); } Py_DECREF(pickle_error); } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_int(int value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const int neg_one = (int) -1, const_zero = (int) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(int) < sizeof(long)) { return PyLong_FromLong((long) value); } else if (sizeof(int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #if !CYTHON_COMPILING_IN_PYPY } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(int) <= sizeof(long)) { return PyLong_FromLong((long) value); } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); } } { unsigned char *bytes = (unsigned char *)&value; #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 if (is_unsigned) { return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); } else { return PyLong_FromNativeBytes(bytes, sizeof(value), -1); } #elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 int one = 1; int little = (int)*(unsigned char *)&one; return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); #else int one = 1; int little = (int)*(unsigned char *)&one; PyObject *result = NULL, *kwds = NULL; PyObject *py_bytes = NULL, *order_str = NULL, *from_bytes_str = NULL;; py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int)); if (!py_bytes) goto limited_bad; from_bytes_str = PyUnicode_FromStringAndSize("from_bytes", 10); if (!from_bytes_str) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; { PyObject *args[] = { (PyObject*)&PyLong_Type, py_bytes, order_str, Py_True }; if (!is_unsigned) { PyObject *signed_str = PyUnicode_FromStringAndSize("signed", 6); if (!signed_str) goto limited_bad; #if CYTHON_VECTORCALL kwds = PyTuple_Pack(1, signed_str); #else { PyObject *keys[] = {signed_str}; PyObject *values[] = {Py_True}; kwds = __Pyx_MakeKwargDict(keys, values, 1); } #endif Py_DECREF(signed_str); if (unlikely(!kwds)) goto limited_bad; } result = __Pyx_Object_VectorcallMethodKwds(from_bytes_str, args, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); } limited_bad: Py_XDECREF(kwds); Py_XDECREF(order_str); Py_XDECREF(py_bytes); Py_XDECREF(from_bytes_str); return result; #endif } } /* CIntFromPy */ static int __Pyx_LargePyLong___Pyx_PyLong_As_int(PyObject *x); static int __Pyx_raise_neg_overflow___Pyx_PyLong_As_int(void) { const char* type_name = "int"; PyErr_Format(PyExc_OverflowError, "can't convert negative value to %.200s", type_name); return (int) -1; } static int __Pyx_raise_overflow___Pyx_PyLong_As_int(void) { const char* type_name = "int"; PyErr_Format(PyExc_OverflowError, "value too large to convert to %.200s", type_name); return (int) -1; } static CYTHON_INLINE int __Pyx_PyULong___Pyx_PyLong_As_int(PyObject *x) { const int is_unsigned = 1; #if CYTHON_USE_PYLONG_INTERNALS { const digit* digits = __Pyx_PyLong_Digits(x); const Py_ssize_t size = __Pyx_PyLong_DigitCount(x); if (size == 2 && (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])); } } else if (size == 3 && (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])); } } else if (size == 4 && (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])); } } else {} } #elif 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)) } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) } return __Pyx_LargePyLong___Pyx_PyLong_As_int(x); raise_neg_overflow: return __Pyx_raise_neg_overflow___Pyx_PyLong_As_int(); raise_overflow: return __Pyx_raise_overflow___Pyx_PyLong_As_int(); } static CYTHON_INLINE int __Pyx_PySLong___Pyx_PyLong_As_int(PyObject *x) { const int is_unsigned = 0; #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsNeg(x)) { const Py_ssize_t size = __Pyx_PyLong_DigitCount(x); const digit* digits = __Pyx_PyLong_Digits(x); if (size == 2 && (8 * sizeof(int) > 1 * PyLong_SHIFT)) { if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { long ival = - (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); __PYX_VERIFY_RETURN_INT(int, long, ival) } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { return (int) (((int) -1) * (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } else if (size == 3 && (8 * sizeof(int) > 2 * PyLong_SHIFT)) { if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { long ival = - (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); __PYX_VERIFY_RETURN_INT(int, long, ival) } 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]))); } } else if (size == 4 && (8 * sizeof(int) > 3 * PyLong_SHIFT)) { if ((8 * sizeof(long) > 4 * PyLong_SHIFT)) { long ival = - (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); __PYX_VERIFY_RETURN_INT(int, long, ival) } 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]))); } } else {} } else { const Py_ssize_t size = __Pyx_PyLong_DigitCount(x); const digit* digits = __Pyx_PyLong_Digits(x); if (size == 2 && (8 * sizeof(int) > 1 * PyLong_SHIFT)) { if ((8 * sizeof(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])); } } else if (size == 3 && (8 * sizeof(int) > 2 * PyLong_SHIFT)) { if ((8 * sizeof(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])); } } else if (size == 4 && (8 * sizeof(int) > 3 * PyLong_SHIFT)) { if ((8 * sizeof(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])); } } else {} } #endif #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 if ((sizeof(int) <= sizeof(int)) && (sizeof(int) < sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(int, int, PyLong_AsInt(x)) } else #endif if ((sizeof(int) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) } return __Pyx_LargePyLong___Pyx_PyLong_As_int(x); raise_neg_overflow: return __Pyx_raise_neg_overflow___Pyx_PyLong_As_int(); raise_overflow: return __Pyx_raise_overflow___Pyx_PyLong_As_int(); } static int __Pyx_LargePyLong___Pyx_PyLong_As_int(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const int neg_one = (int) -1, const_zero = (int) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; int val; int ret = -1; #if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API Py_ssize_t bytes_copied = PyLong_AsNativeBytes( x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); if (unlikely(bytes_copied == -1)) { } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { goto raise_overflow; } else { ret = 0; } #elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; ret = _PyLong_AsByteArray((PyLongObject *)x, bytes, sizeof(val), is_little, !is_unsigned); if ((0)) goto raise_overflow; #else PyObject *v; PyObject *stepval = NULL, *mask = NULL, *shift = NULL; int bits, remaining_bits, is_negative = 0; int chunk_size = (sizeof(long) < 8) ? 30 : 62; if (likely(PyLong_CheckExact(x))) { v = __Pyx_NewRef(x); } else { v = PyNumber_Long(x); if (unlikely(!v)) return (int) -1; assert(PyLong_CheckExact(v)); } { int result = PyObject_RichCompareBool(v, Py_False, Py_LT); if (unlikely(result < 0)) { Py_DECREF(v); return (int) -1; } is_negative = result == 1; } if (is_unsigned && unlikely(is_negative)) { Py_DECREF(v); PyErr_SetString(PyExc_OverflowError, "can't convert negative value to int"); return (int) -1; } else if (is_negative) { stepval = PyNumber_Invert(v); Py_DECREF(v); if (unlikely(!stepval)) return (int) -1; } else { stepval = v; } v = NULL; val = (int) 0; mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) { PyObject *tmp, *digit; long idigit; digit = PyNumber_And(stepval, mask); if (unlikely(!digit)) goto done; idigit = PyLong_AsLong(digit); Py_DECREF(digit); if (unlikely(idigit < 0)) goto done; val |= ((int) idigit) << bits; tmp = PyNumber_Rshift(stepval, shift); if (unlikely(!tmp)) goto done; Py_DECREF(stepval); stepval = tmp; } Py_DECREF(shift); shift = NULL; Py_DECREF(mask); mask = NULL; { long idigit = PyLong_AsLong(stepval); if (unlikely(idigit < 0)) goto done; remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); if (unlikely(idigit >= (1L << remaining_bits))) goto raise_overflow; val |= ((int) idigit) << bits; } if (!is_unsigned) { if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1)))) goto raise_overflow; if (is_negative) val = ~val; } ret = 0; done: Py_XDECREF(shift); Py_XDECREF(mask); Py_XDECREF(stepval); #endif if (unlikely(ret)) return (int) -1; return val; raise_overflow: return __Pyx_raise_overflow___Pyx_PyLong_As_int(); } static CYTHON_INLINE int __Pyx_PyLong___Pyx_PyLong_As_int(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const int neg_one = (int) -1, const_zero = (int) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (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 #endif { return __Pyx_PyULong___Pyx_PyLong_As_int(x); } } else { #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) } else #endif { return __Pyx_PySLong___Pyx_PyLong_As_int(x); } } #if CYTHON_USE_PYLONG_INTERNALS raise_neg_overflow: return __Pyx_raise_neg_overflow___Pyx_PyLong_As_int(); raise_overflow: return __Pyx_raise_overflow___Pyx_PyLong_As_int(); #endif } static int __Pyx_NonPyLong___Pyx_PyLong_As_int(PyObject *x) { int val; PyObject *tmp = __Pyx_PyNumber_Long(x); if (!tmp) return (int) -1; val = __Pyx_PyLong_As_int(tmp); Py_DECREF(tmp); return val; } static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *x) { if (likely(PyLong_Check(x))) { return __Pyx_PyLong___Pyx_PyLong_As_int(x); } else { return __Pyx_NonPyLong___Pyx_PyLong_As_int(x); } } /* CIntFromPy */ static long __Pyx_LargePyLong___Pyx_PyLong_As_long(PyObject *x); static long __Pyx_raise_neg_overflow___Pyx_PyLong_As_long(void) { const char* type_name = "long"; PyErr_Format(PyExc_OverflowError, "can't convert negative value to %.200s", type_name); return (long) -1; } static long __Pyx_raise_overflow___Pyx_PyLong_As_long(void) { const char* type_name = "long"; PyErr_Format(PyExc_OverflowError, "value too large to convert to %.200s", type_name); return (long) -1; } static CYTHON_INLINE long __Pyx_PyULong___Pyx_PyLong_As_long(PyObject *x) { const int is_unsigned = 1; #if CYTHON_USE_PYLONG_INTERNALS { const digit* digits = __Pyx_PyLong_Digits(x); const Py_ssize_t size = __Pyx_PyLong_DigitCount(x); if (size == 2 && (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])); } } else if (size == 3 && (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])); } } else if (size == 4 && (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])); } } else {} } #elif 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)) } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) } return __Pyx_LargePyLong___Pyx_PyLong_As_long(x); raise_neg_overflow: return __Pyx_raise_neg_overflow___Pyx_PyLong_As_long(); raise_overflow: return __Pyx_raise_overflow___Pyx_PyLong_As_long(); } static CYTHON_INLINE long __Pyx_PySLong___Pyx_PyLong_As_long(PyObject *x) { const int is_unsigned = 0; #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsNeg(x)) { const Py_ssize_t size = __Pyx_PyLong_DigitCount(x); const digit* digits = __Pyx_PyLong_Digits(x); if (size == 2 && (8 * sizeof(long) > 1 * PyLong_SHIFT)) { if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { long ival = - (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); __PYX_VERIFY_RETURN_INT(long, long, ival) } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { return (long) (((long) -1) * (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } else if (size == 3 && (8 * sizeof(long) > 2 * PyLong_SHIFT)) { if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { long ival = - (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); __PYX_VERIFY_RETURN_INT(long, long, ival) } 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]))); } } else if (size == 4 && (8 * sizeof(long) > 3 * PyLong_SHIFT)) { if ((8 * sizeof(long) > 4 * PyLong_SHIFT)) { long ival = - (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); __PYX_VERIFY_RETURN_INT(long, long, ival) } 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]))); } } else {} } else { const Py_ssize_t size = __Pyx_PyLong_DigitCount(x); const digit* digits = __Pyx_PyLong_Digits(x); if (size == 2 && (8 * sizeof(long) > 1 * PyLong_SHIFT)) { if ((8 * sizeof(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])); } } else if (size == 3 && (8 * sizeof(long) > 2 * PyLong_SHIFT)) { if ((8 * sizeof(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])); } } else if (size == 4 && (8 * sizeof(long) > 3 * PyLong_SHIFT)) { if ((8 * sizeof(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])); } } else {} } #endif #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 if ((sizeof(long) <= sizeof(int)) && (sizeof(int) < sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(long, int, PyLong_AsInt(x)) } else #endif if ((sizeof(long) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) } return __Pyx_LargePyLong___Pyx_PyLong_As_long(x); raise_neg_overflow: return __Pyx_raise_neg_overflow___Pyx_PyLong_As_long(); raise_overflow: return __Pyx_raise_overflow___Pyx_PyLong_As_long(); } static long __Pyx_LargePyLong___Pyx_PyLong_As_long(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const long neg_one = (long) -1, const_zero = (long) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; long val; int ret = -1; #if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API Py_ssize_t bytes_copied = PyLong_AsNativeBytes( x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); if (unlikely(bytes_copied == -1)) { } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { goto raise_overflow; } else { ret = 0; } #elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; ret = _PyLong_AsByteArray((PyLongObject *)x, bytes, sizeof(val), is_little, !is_unsigned); if ((0)) goto raise_overflow; #else PyObject *v; PyObject *stepval = NULL, *mask = NULL, *shift = NULL; int bits, remaining_bits, is_negative = 0; int chunk_size = (sizeof(long) < 8) ? 30 : 62; if (likely(PyLong_CheckExact(x))) { v = __Pyx_NewRef(x); } else { v = PyNumber_Long(x); if (unlikely(!v)) return (long) -1; assert(PyLong_CheckExact(v)); } { int result = PyObject_RichCompareBool(v, Py_False, Py_LT); if (unlikely(result < 0)) { Py_DECREF(v); return (long) -1; } is_negative = result == 1; } if (is_unsigned && unlikely(is_negative)) { Py_DECREF(v); PyErr_SetString(PyExc_OverflowError, "can't convert negative value to long"); return (long) -1; } else if (is_negative) { stepval = PyNumber_Invert(v); Py_DECREF(v); if (unlikely(!stepval)) return (long) -1; } else { stepval = v; } v = NULL; val = (long) 0; mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) { PyObject *tmp, *digit; long idigit; digit = PyNumber_And(stepval, mask); if (unlikely(!digit)) goto done; idigit = PyLong_AsLong(digit); Py_DECREF(digit); if (unlikely(idigit < 0)) goto done; val |= ((long) idigit) << bits; tmp = PyNumber_Rshift(stepval, shift); if (unlikely(!tmp)) goto done; Py_DECREF(stepval); stepval = tmp; } Py_DECREF(shift); shift = NULL; Py_DECREF(mask); mask = NULL; { long idigit = PyLong_AsLong(stepval); if (unlikely(idigit < 0)) goto done; remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); if (unlikely(idigit >= (1L << remaining_bits))) goto raise_overflow; val |= ((long) idigit) << bits; } if (!is_unsigned) { if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1)))) goto raise_overflow; if (is_negative) val = ~val; } ret = 0; done: Py_XDECREF(shift); Py_XDECREF(mask); Py_XDECREF(stepval); #endif if (unlikely(ret)) return (long) -1; return val; raise_overflow: return __Pyx_raise_overflow___Pyx_PyLong_As_long(); } static CYTHON_INLINE long __Pyx_PyLong___Pyx_PyLong_As_long(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const long neg_one = (long) -1, const_zero = (long) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (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 #endif { return __Pyx_PyULong___Pyx_PyLong_As_long(x); } } else { #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) } else #endif { return __Pyx_PySLong___Pyx_PyLong_As_long(x); } } #if CYTHON_USE_PYLONG_INTERNALS raise_neg_overflow: return __Pyx_raise_neg_overflow___Pyx_PyLong_As_long(); raise_overflow: return __Pyx_raise_overflow___Pyx_PyLong_As_long(); #endif } static long __Pyx_NonPyLong___Pyx_PyLong_As_long(PyObject *x) { long val; PyObject *tmp = __Pyx_PyNumber_Long(x); if (!tmp) return (long) -1; val = __Pyx_PyLong_As_long(tmp); Py_DECREF(tmp); return val; } static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *x) { if (likely(PyLong_Check(x))) { return __Pyx_PyLong___Pyx_PyLong_As_long(x); } else { return __Pyx_NonPyLong___Pyx_PyLong_As_long(x); } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const long neg_one = (long) -1, const_zero = (long) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { return PyLong_FromLong((long) value); } else if (sizeof(long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #if !CYTHON_COMPILING_IN_PYPY } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(long) <= sizeof(long)) { return PyLong_FromLong((long) value); } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); } } { unsigned char *bytes = (unsigned char *)&value; #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 if (is_unsigned) { return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); } else { return PyLong_FromNativeBytes(bytes, sizeof(value), -1); } #elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 int one = 1; int little = (int)*(unsigned char *)&one; return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); #else int one = 1; int little = (int)*(unsigned char *)&one; PyObject *result = NULL, *kwds = NULL; PyObject *py_bytes = NULL, *order_str = NULL, *from_bytes_str = NULL;; py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); if (!py_bytes) goto limited_bad; from_bytes_str = PyUnicode_FromStringAndSize("from_bytes", 10); if (!from_bytes_str) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; { PyObject *args[] = { (PyObject*)&PyLong_Type, py_bytes, order_str, Py_True }; if (!is_unsigned) { PyObject *signed_str = PyUnicode_FromStringAndSize("signed", 6); if (!signed_str) goto limited_bad; #if CYTHON_VECTORCALL kwds = PyTuple_Pack(1, signed_str); #else { PyObject *keys[] = {signed_str}; PyObject *values[] = {Py_True}; kwds = __Pyx_MakeKwargDict(keys, values, 1); } #endif Py_DECREF(signed_str); if (unlikely(!kwds)) goto limited_bad; } result = __Pyx_Object_VectorcallMethodKwds(from_bytes_str, args, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); } limited_bad: Py_XDECREF(kwds); Py_XDECREF(order_str); Py_XDECREF(py_bytes); Py_XDECREF(from_bytes_str); return result; #endif } } /* UpdateUnpickledDict */ static int __Pyx__UpdateUnpickledDict(PyObject *obj, PyObject *state, Py_ssize_t index) { PyObject *state_dict = __Pyx_PySequence_ITEM(state, index); if (unlikely(!state_dict)) { return -1; } int non_empty = PyObject_IsTrue(state_dict); if (non_empty == 0) { Py_DECREF(state_dict); return 0; } else if (unlikely(non_empty == -1)) { return -1; } PyObject *dict; #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 dict = PyObject_GetAttrString(obj, "__dict__"); #else dict = PyObject_GenericGetDict(obj, NULL); #endif if (unlikely(!dict)) { Py_DECREF(state_dict); return -1; } int result; if (likely(PyDict_CheckExact(dict))) { result = PyDict_Update(dict, state_dict); } else { PyObject *obj_result = __Pyx_PyObject_CallMethod1(dict, __pyx_mstate_global->__pyx_n_u_update, state_dict); if (likely(obj_result)) { Py_DECREF(obj_result); result = 0; } else { result = -1; } } Py_DECREF(state_dict); Py_DECREF(dict); return result; } static int __Pyx_UpdateUnpickledDict(PyObject *obj, PyObject *state, Py_ssize_t index) { Py_ssize_t state_size = __Pyx_PyTuple_GET_SIZE(state); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely(state_size == -1)) return -1; #endif if (state_size <= index) { return 0; } return __Pyx__UpdateUnpickledDict(obj, state, index); } /* CheckUnpickleChecksum */ static int __Pyx_CheckUnpickleChecksum(long checksum, long checksum1, long checksum2, long checksum3, const char *members) { int found = 0; found |= checksum1 == checksum; found |= checksum2 == checksum; found |= checksum3 == checksum; if (likely(found)) return 0; __Pyx_RaiseUnpickleChecksumError(checksum, checksum1, checksum2, checksum3, members); return -1; } /* GetRuntimeVersion */ #if __PYX_LIMITED_VERSION_HEX < 0x030b0000 void __Pyx_init_runtime_version(void) { if (__Pyx_cached_runtime_version == 0) { const char* rt_version = Py_GetVersion(); unsigned long version = 0; unsigned long factor = 0x01000000UL; unsigned int digit = 0; int i = 0; while (factor) { while ('0' <= rt_version[i] && rt_version[i] <= '9') { digit = digit * 10 + (unsigned int) (rt_version[i] - '0'); ++i; } version += factor * digit; if (rt_version[i] != '.') break; digit = 0; factor >>= 8; ++i; } __Pyx_cached_runtime_version = version; } } #endif static unsigned long __Pyx_get_runtime_version(void) { #if __PYX_LIMITED_VERSION_HEX >= 0x030b0000 return Py_Version & ~0xFFUL; #else return __Pyx_cached_runtime_version; #endif } /* SwapException (used by CoroutineBase) */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 _PyErr_StackItem *exc_info = tstate->exc_info; tmp_value = exc_info->exc_value; exc_info->exc_value = *value; if (tmp_value == NULL || tmp_value == Py_None) { Py_XDECREF(tmp_value); tmp_value = NULL; tmp_type = NULL; tmp_tb = NULL; } else { tmp_type = (PyObject*) Py_TYPE(tmp_value); Py_INCREF(tmp_type); #if CYTHON_COMPILING_IN_CPYTHON tmp_tb = ((PyBaseExceptionObject*) tmp_value)->traceback; Py_XINCREF(tmp_tb); #else tmp_tb = PyException_GetTraceback(tmp_value); #endif } #elif CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = *type; exc_info->exc_value = *value; exc_info->exc_traceback = *tb; #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = *type; tstate->exc_value = *value; tstate->exc_traceback = *tb; #endif *type = tmp_type; *value = tmp_value; *tb = tmp_tb; } #else static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); PyErr_SetExcInfo(*type, *value, *tb); *type = tmp_type; *value = tmp_value; *tb = tmp_tb; } #endif /* IterNextPlain (used by CoroutineBase) */ #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 static PyObject *__Pyx_GetBuiltinNext_LimitedAPI(void) { if (unlikely(!__pyx_mstate_global->__Pyx_GetBuiltinNext_LimitedAPI_cache)) __pyx_mstate_global->__Pyx_GetBuiltinNext_LimitedAPI_cache = __Pyx_GetBuiltinName(__pyx_mstate_global->__pyx_n_u_next); return __pyx_mstate_global->__Pyx_GetBuiltinNext_LimitedAPI_cache; } #endif static CYTHON_INLINE PyObject *__Pyx_PyIter_Next_Plain(PyObject *iterator) { #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 PyObject *result; PyObject *next = __Pyx_GetBuiltinNext_LimitedAPI(); if (unlikely(!next)) return NULL; result = PyObject_CallFunctionObjArgs(next, iterator, NULL); return result; #else (void)__Pyx_GetBuiltinName; // only for early limited API iternextfunc iternext = __Pyx_PyObject_GetIterNextFunc(iterator); assert(iternext); return iternext(iterator); #endif } /* ReturnWithStopIteration (used by CoroutineBase) */ static void __Pyx__ReturnWithStopIteration(PyObject* value, int async); static CYTHON_INLINE void __Pyx_ReturnWithStopIteration(PyObject* value, int async, int iternext) { if (value == Py_None) { if (async || !iternext) PyErr_SetNone(async ? PyExc_StopAsyncIteration : PyExc_StopIteration); return; } __Pyx__ReturnWithStopIteration(value, async); } static void __Pyx__ReturnWithStopIteration(PyObject* value, int async) { #if CYTHON_COMPILING_IN_CPYTHON __Pyx_PyThreadState_declare #endif PyObject *exc; PyObject *exc_type = async ? PyExc_StopAsyncIteration : PyExc_StopIteration; #if CYTHON_COMPILING_IN_CPYTHON if ((PY_VERSION_HEX >= (0x030C00A6)) || unlikely(PyTuple_Check(value) || PyExceptionInstance_Check(value))) { if (PY_VERSION_HEX >= (0x030e00A1)) { exc = __Pyx_PyObject_CallOneArg(exc_type, value); } else { PyObject *args_tuple = PyTuple_New(1); if (unlikely(!args_tuple)) return; Py_INCREF(value); PyTuple_SET_ITEM(args_tuple, 0, value); exc = PyObject_Call(exc_type, args_tuple, NULL); Py_DECREF(args_tuple); } if (unlikely(!exc)) return; } else { Py_INCREF(value); exc = value; } #if CYTHON_FAST_THREAD_STATE __Pyx_PyThreadState_assign #if CYTHON_USE_EXC_INFO_STACK if (!__pyx_tstate->exc_info->exc_value) #else if (!__pyx_tstate->exc_type) #endif { Py_INCREF(exc_type); __Pyx_ErrRestore(exc_type, exc, NULL); return; } #endif #else exc = __Pyx_PyObject_CallOneArg(exc_type, value); if (unlikely(!exc)) return; #endif PyErr_SetObject(exc_type, exc); Py_DECREF(exc); } /* CoroutineBase (used by Generator) */ #if !CYTHON_COMPILING_IN_LIMITED_API #include #if PY_VERSION_HEX >= 0x030b00a6 && !defined(PYPY_VERSION) #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif #endif // CYTHON_COMPILING_IN_LIMITED_API static CYTHON_INLINE void __Pyx_Coroutine_Undelegate(__pyx_CoroutineObject *gen) { #if CYTHON_USE_AM_SEND gen->yieldfrom_am_send = NULL; #endif Py_CLEAR(gen->yieldfrom); } static int __Pyx_PyGen__FetchStopIterationValue(PyThreadState *__pyx_tstate, PyObject **pvalue) { PyObject *et, *ev, *tb; PyObject *value = NULL; CYTHON_UNUSED_VAR(__pyx_tstate); __Pyx_ErrFetch(&et, &ev, &tb); if (!et) { Py_XDECREF(tb); Py_XDECREF(ev); Py_INCREF(Py_None); *pvalue = Py_None; return 0; } if (likely(et == PyExc_StopIteration)) { if (!ev) { Py_INCREF(Py_None); value = Py_None; } else if (likely(Py_IS_TYPE(ev, (PyTypeObject*)PyExc_StopIteration))) { #if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL value = PyObject_GetAttr(ev, __pyx_mstate_global->__pyx_n_u_value); if (unlikely(!value)) goto limited_api_failure; #else value = ((PyStopIterationObject *)ev)->value; Py_INCREF(value); #endif Py_DECREF(ev); } else if (unlikely(PyTuple_Check(ev))) { Py_ssize_t tuple_size = __Pyx_PyTuple_GET_SIZE(ev); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely(tuple_size < 0)) { Py_XDECREF(tb); Py_DECREF(ev); Py_DECREF(et); return -1; } #endif if (tuple_size >= 1) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS value = PyTuple_GET_ITEM(ev, 0); Py_INCREF(value); #elif CYTHON_ASSUME_SAFE_MACROS value = PySequence_ITEM(ev, 0); #else value = PySequence_GetItem(ev, 0); if (!value) goto limited_api_failure; #endif } else { Py_INCREF(Py_None); value = Py_None; } Py_DECREF(ev); } else if (!__Pyx_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration)) { value = ev; } if (likely(value)) { Py_XDECREF(tb); Py_DECREF(et); *pvalue = value; return 0; } } else if (!__Pyx_PyErr_GivenExceptionMatches(et, PyExc_StopIteration)) { __Pyx_ErrRestore(et, ev, tb); return -1; } PyErr_NormalizeException(&et, &ev, &tb); if (unlikely(!PyObject_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration))) { __Pyx_ErrRestore(et, ev, tb); return -1; } Py_XDECREF(tb); Py_DECREF(et); #if CYTHON_COMPILING_IN_LIMITED_API value = PyObject_GetAttr(ev, __pyx_mstate_global->__pyx_n_u_value); #else value = ((PyStopIterationObject *)ev)->value; Py_INCREF(value); #endif Py_DECREF(ev); #if CYTHON_COMPILING_IN_LIMITED_API if (unlikely(!value)) return -1; #endif *pvalue = value; return 0; #if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL || !CYTHON_ASSUME_SAFE_MACROS limited_api_failure: Py_XDECREF(et); Py_XDECREF(tb); Py_XDECREF(ev); return -1; #endif } static CYTHON_INLINE __Pyx_PySendResult __Pyx_Coroutine_status_from_result(PyObject **retval) { if (*retval) { return PYGEN_NEXT; } else if (likely(__Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, retval) == 0)) { return PYGEN_RETURN; } else { return PYGEN_ERROR; } } static CYTHON_INLINE void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *exc_state) { #if PY_VERSION_HEX >= 0x030B00a4 Py_CLEAR(exc_state->exc_value); #else PyObject *t, *v, *tb; t = exc_state->exc_type; v = exc_state->exc_value; tb = exc_state->exc_traceback; exc_state->exc_type = NULL; exc_state->exc_value = NULL; exc_state->exc_traceback = NULL; 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(__pyx_CoroutineObject *gen) { const char *msg; CYTHON_MAYBE_UNUSED_VAR(gen); if ((0)) { #ifdef __Pyx_Coroutine_USED } else if (__Pyx_Coroutine_Check((PyObject*)gen)) { msg = "coroutine already executing"; #endif #ifdef __Pyx_AsyncGen_USED } else if (__Pyx_AsyncGen_CheckExact((PyObject*)gen)) { msg = "async generator already executing"; #endif } else { msg = "generator already executing"; } PyErr_SetString(PyExc_ValueError, msg); } 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"); } else #endif if (value) { #ifdef __Pyx_AsyncGen_USED if (__Pyx_AsyncGen_CheckExact(gen)) PyErr_SetNone(PyExc_StopAsyncIteration); else #endif PyErr_SetNone(PyExc_StopIteration); } } static __Pyx_PySendResult __Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value, PyObject **result, int closing) { __Pyx_PyThreadState_declare PyThreadState *tstate; __Pyx_ExcInfoStruct *exc_state; PyObject *retval; assert(__Pyx_Coroutine_get_is_running(self)); // Callers should ensure is_running if (unlikely(self->resume_label == -1)) { __Pyx_Coroutine_AlreadyTerminatedError((PyObject*)self, value, closing); return PYGEN_ERROR; } #if CYTHON_FAST_THREAD_STATE __Pyx_PyThreadState_assign tstate = __pyx_tstate; #else tstate = __Pyx_PyThreadState_Current; #endif exc_state = &self->gi_exc_state; if (exc_state->exc_value) { #if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY #else PyObject *exc_tb; #if PY_VERSION_HEX >= 0x030B00a4 && !CYTHON_COMPILING_IN_CPYTHON exc_tb = PyException_GetTraceback(exc_state->exc_value); #elif PY_VERSION_HEX >= 0x030B00a4 exc_tb = ((PyBaseExceptionObject*) exc_state->exc_value)->traceback; #else exc_tb = exc_state->exc_traceback; #endif if (exc_tb) { PyTracebackObject *tb = (PyTracebackObject *) exc_tb; PyFrameObject *f = tb->tb_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 } #if CYTHON_USE_EXC_INFO_STACK exc_state->previous_item = tstate->exc_info; tstate->exc_info = exc_state; #else if (exc_state->exc_type) { __Pyx_ExceptionSwap(&exc_state->exc_type, &exc_state->exc_value, &exc_state->exc_traceback); } else { __Pyx_Coroutine_ExceptionClear(exc_state); __Pyx_ExceptionSave(&exc_state->exc_type, &exc_state->exc_value, &exc_state->exc_traceback); } #endif retval = self->body(self, tstate, value); #if CYTHON_USE_EXC_INFO_STACK exc_state = &self->gi_exc_state; tstate->exc_info = exc_state->previous_item; exc_state->previous_item = NULL; __Pyx_Coroutine_ResetFrameBackpointer(exc_state); #endif *result = retval; if (self->resume_label == -1) { return likely(retval) ? PYGEN_RETURN : PYGEN_ERROR; } return PYGEN_NEXT; } static CYTHON_INLINE void __Pyx_Coroutine_ResetFrameBackpointer(__Pyx_ExcInfoStruct *exc_state) { #if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API CYTHON_UNUSED_VAR(exc_state); #else PyObject *exc_tb; #if PY_VERSION_HEX >= 0x030B00a4 if (!exc_state->exc_value) return; exc_tb = PyException_GetTraceback(exc_state->exc_value); #else exc_tb = exc_state->exc_traceback; #endif if (likely(exc_tb)) { PyTracebackObject *tb = (PyTracebackObject *) exc_tb; PyFrameObject *f = tb->tb_frame; Py_CLEAR(f->f_back); #if PY_VERSION_HEX >= 0x030B00a4 Py_DECREF(exc_tb); #endif } #endif } #define __Pyx_Coroutine_MethodReturnFromResult(gen, result, retval, iternext)\ ((result) == PYGEN_NEXT ? (retval) : __Pyx__Coroutine_MethodReturnFromResult(gen, result, retval, iternext)) static PyObject * __Pyx__Coroutine_MethodReturnFromResult(PyObject* gen, __Pyx_PySendResult result, PyObject *retval, int iternext) { CYTHON_MAYBE_UNUSED_VAR(gen); if (likely(result == PYGEN_RETURN)) { int is_async = 0; #ifdef __Pyx_AsyncGen_USED is_async = __Pyx_AsyncGen_CheckExact(gen); #endif __Pyx_ReturnWithStopIteration(retval, is_async, iternext); Py_XDECREF(retval); } return NULL; } #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject *__Pyx_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 __Pyx_PySendResult __Pyx_Coroutine_FinishDelegation(__pyx_CoroutineObject *gen, PyObject** retval) { __Pyx_PySendResult result; PyObject *val = NULL; assert(__Pyx_Coroutine_get_is_running(gen)); __Pyx_Coroutine_Undelegate(gen); __Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, &val); result = __Pyx_Coroutine_SendEx(gen, val, retval, 0); Py_XDECREF(val); return result; } #if CYTHON_USE_AM_SEND static __Pyx_PySendResult __Pyx_Coroutine_SendToDelegate(__pyx_CoroutineObject *gen, __Pyx_pyiter_sendfunc gen_am_send, PyObject *value, PyObject **retval) { PyObject *ret = NULL; __Pyx_PySendResult delegate_result, result; assert(__Pyx_Coroutine_get_is_running(gen)); delegate_result = gen_am_send(gen->yieldfrom, value, &ret); if (delegate_result == PYGEN_NEXT) { assert (ret != NULL); *retval = ret; return PYGEN_NEXT; } assert (delegate_result != PYGEN_ERROR || ret == NULL); __Pyx_Coroutine_Undelegate(gen); result = __Pyx_Coroutine_SendEx(gen, ret, retval, 0); Py_XDECREF(ret); return result; } #endif static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value) { PyObject *retval = NULL; __Pyx_PySendResult result = __Pyx_Coroutine_AmSend(self, value, &retval); return __Pyx_Coroutine_MethodReturnFromResult(self, result, retval, 0); } static __Pyx_PySendResult __Pyx_Coroutine_AmSend(PyObject *self, PyObject *value, PyObject **retval) { __Pyx_PySendResult result; __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) { *retval = __Pyx_Coroutine_AlreadyRunningError(gen); return PYGEN_ERROR; } #if CYTHON_USE_AM_SEND if (gen->yieldfrom_am_send) { result = __Pyx_Coroutine_SendToDelegate(gen, gen->yieldfrom_am_send, value, retval); } else #endif if (gen->yieldfrom) { PyObject *yf = gen->yieldfrom; PyObject *ret; #if !CYTHON_USE_AM_SEND #ifdef __Pyx_Generator_USED if (__Pyx_Generator_CheckExact(yf)) { ret = __Pyx_Coroutine_Send(yf, value); } else #endif #ifdef __Pyx_Coroutine_USED if (__Pyx_Coroutine_Check(yf)) { ret = __Pyx_Coroutine_Send(yf, value); } else #endif #ifdef __Pyx_AsyncGen_USED if (__pyx_PyAsyncGenASend_CheckExact(yf)) { ret = __Pyx_async_gen_asend_send(yf, value); } else #endif #if CYTHON_COMPILING_IN_CPYTHON if (PyGen_CheckExact(yf)) { ret = __Pyx_PyGen_Send((PyGenObject*)yf, value == Py_None ? NULL : value); } else if (PyCoro_CheckExact(yf)) { ret = __Pyx_PyGen_Send((PyGenObject*)yf, value == Py_None ? NULL : value); } else #endif #endif { if (value == Py_None && PyIter_Check(yf)) ret = __Pyx_PyIter_Next_Plain(yf); else ret = __Pyx_PyObject_CallMethod1(yf, __pyx_mstate_global->__pyx_n_u_send, value); } if (likely(ret)) { __Pyx_Coroutine_unset_is_running(gen); *retval = ret; return PYGEN_NEXT; } result = __Pyx_Coroutine_FinishDelegation(gen, retval); } else { result = __Pyx_Coroutine_SendEx(gen, value, retval, 0); } __Pyx_Coroutine_unset_is_running(gen); return result; } static int __Pyx_Coroutine_CloseIter(__pyx_CoroutineObject *gen, PyObject *yf) { __Pyx_PySendResult result; PyObject *retval = NULL; CYTHON_UNUSED_VAR(gen); assert(__Pyx_Coroutine_get_is_running(gen)); #ifdef __Pyx_Generator_USED if (__Pyx_Generator_CheckExact(yf)) { result = __Pyx_Coroutine_Close(yf, &retval); } else #endif #ifdef __Pyx_Coroutine_USED if (__Pyx_Coroutine_Check(yf)) { result = __Pyx_Coroutine_Close(yf, &retval); } else if (__Pyx_CoroutineAwait_CheckExact(yf)) { result = __Pyx_CoroutineAwait_Close((__pyx_CoroutineAwaitObject*)yf); } else #endif #ifdef __Pyx_AsyncGen_USED if (__pyx_PyAsyncGenASend_CheckExact(yf)) { retval = __Pyx_async_gen_asend_close(yf, NULL); result = PYGEN_RETURN; } else if (__pyx_PyAsyncGenAThrow_CheckExact(yf)) { retval = __Pyx_async_gen_athrow_close(yf, NULL); result = PYGEN_RETURN; } else #endif { PyObject *meth; result = PYGEN_RETURN; meth = __Pyx_PyObject_GetAttrStrNoError(yf, __pyx_mstate_global->__pyx_n_u_close); if (unlikely(!meth)) { if (unlikely(PyErr_Occurred())) { PyErr_WriteUnraisable(yf); } } else { retval = __Pyx_PyObject_CallNoArg(meth); Py_DECREF(meth); if (unlikely(!retval)) { result = PYGEN_ERROR; } } } Py_XDECREF(retval); return result == PYGEN_ERROR ? -1 : 0; } static PyObject *__Pyx_Generator_Next(PyObject *self) { __Pyx_PySendResult result; PyObject *retval = NULL; __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) { return __Pyx_Coroutine_AlreadyRunningError(gen); } #if CYTHON_USE_AM_SEND if (gen->yieldfrom_am_send) { result = __Pyx_Coroutine_SendToDelegate(gen, gen->yieldfrom_am_send, Py_None, &retval); } else #endif if (gen->yieldfrom) { PyObject *yf = gen->yieldfrom; PyObject *ret; #ifdef __Pyx_Generator_USED if (__Pyx_Generator_CheckExact(yf)) { ret = __Pyx_Generator_Next(yf); } else #endif #ifdef __Pyx_Coroutine_USED if (__Pyx_Coroutine_CheckExact(yf)) { ret = __Pyx_Coroutine_Send(yf, Py_None); } else #endif #if CYTHON_COMPILING_IN_CPYTHON && (PY_VERSION_HEX < 0x030A00A3 || !CYTHON_USE_AM_SEND) if (PyGen_CheckExact(yf)) { ret = __Pyx_PyGen_Send((PyGenObject*)yf, NULL); } else #endif ret = __Pyx_PyIter_Next_Plain(yf); if (likely(ret)) { __Pyx_Coroutine_unset_is_running(gen); return ret; } result = __Pyx_Coroutine_FinishDelegation(gen, &retval); } else { result = __Pyx_Coroutine_SendEx(gen, Py_None, &retval, 0); } __Pyx_Coroutine_unset_is_running(gen); return __Pyx_Coroutine_MethodReturnFromResult(self, result, retval, 1); } static PyObject *__Pyx_Coroutine_Close_Method(PyObject *self, PyObject *arg) { PyObject *retval = NULL; __Pyx_PySendResult result; CYTHON_UNUSED_VAR(arg); result = __Pyx_Coroutine_Close(self, &retval); if (unlikely(result == PYGEN_ERROR)) return NULL; Py_XDECREF(retval); Py_RETURN_NONE; } static __Pyx_PySendResult __Pyx_Coroutine_Close(PyObject *self, PyObject **retval) { __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; __Pyx_PySendResult result; PyObject *yf; int err = 0; if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) { *retval = __Pyx_Coroutine_AlreadyRunningError(gen); return PYGEN_ERROR; } yf = gen->yieldfrom; if (yf) { Py_INCREF(yf); err = __Pyx_Coroutine_CloseIter(gen, yf); __Pyx_Coroutine_Undelegate(gen); Py_DECREF(yf); } if (err == 0) PyErr_SetNone(PyExc_GeneratorExit); result = __Pyx_Coroutine_SendEx(gen, NULL, retval, 1); if (result == PYGEN_ERROR) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_Coroutine_unset_is_running(gen); if (!__Pyx_PyErr_Occurred()) { return PYGEN_RETURN; } else if (likely(__Pyx_PyErr_ExceptionMatches2(PyExc_GeneratorExit, PyExc_StopIteration))) { __Pyx_PyErr_Clear(); return PYGEN_RETURN; } return PYGEN_ERROR; } else if (likely(result == PYGEN_RETURN && *retval == Py_None)) { __Pyx_Coroutine_unset_is_running(gen); return PYGEN_RETURN; } else { const char *msg; Py_DECREF(*retval); *retval = NULL; if ((0)) { #ifdef __Pyx_Coroutine_USED } else if (__Pyx_Coroutine_Check(self)) { msg = "coroutine ignored GeneratorExit"; #endif #ifdef __Pyx_AsyncGen_USED } else if (__Pyx_AsyncGen_CheckExact(self)) { msg = "async generator ignored GeneratorExit"; #endif } else { msg = "generator ignored GeneratorExit"; } PyErr_SetString(PyExc_RuntimeError, msg); __Pyx_Coroutine_unset_is_running(gen); return PYGEN_ERROR; } } static PyObject *__Pyx__Coroutine_Throw(PyObject *self, PyObject *typ, PyObject *val, PyObject *tb, PyObject *args, int close_on_genexit) { __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; PyObject *yf; if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) return __Pyx_Coroutine_AlreadyRunningError(gen); yf = gen->yieldfrom; if (yf) { __Pyx_PySendResult result; PyObject *ret; Py_INCREF(yf); if (__Pyx_PyErr_GivenExceptionMatches(typ, PyExc_GeneratorExit) && close_on_genexit) { int err = __Pyx_Coroutine_CloseIter(gen, yf); Py_DECREF(yf); __Pyx_Coroutine_Undelegate(gen); if (err < 0) goto propagate_exception; goto throw_here; } if (0 #ifdef __Pyx_Generator_USED || __Pyx_Generator_CheckExact(yf) #endif #ifdef __Pyx_Coroutine_USED || __Pyx_Coroutine_Check(yf) #endif ) { ret = __Pyx__Coroutine_Throw(yf, typ, val, tb, args, close_on_genexit); #ifdef __Pyx_Coroutine_USED } else if (__Pyx_CoroutineAwait_CheckExact(yf)) { ret = __Pyx__Coroutine_Throw(((__pyx_CoroutineAwaitObject*)yf)->coroutine, typ, val, tb, args, close_on_genexit); #endif } else { PyObject *meth = __Pyx_PyObject_GetAttrStrNoError(yf, __pyx_mstate_global->__pyx_n_u_throw); if (unlikely(!meth)) { Py_DECREF(yf); if (unlikely(PyErr_Occurred())) { __Pyx_Coroutine_unset_is_running(gen); return NULL; } __Pyx_Coroutine_Undelegate(gen); goto throw_here; } if (args) { ret = __Pyx_PyObject_Call(meth, args, NULL); } else { PyObject *cargs[4] = {NULL, typ, val, tb}; size_t nargs = 1U + (val != NULL) + (tb != NULL); ret = __Pyx_PyObject_FastCall(meth, cargs+1, nargs | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); } Py_DECREF(meth); } Py_DECREF(yf); if (ret) { __Pyx_Coroutine_unset_is_running(gen); return ret; } result = __Pyx_Coroutine_FinishDelegation(gen, &ret); __Pyx_Coroutine_unset_is_running(gen); return __Pyx_Coroutine_MethodReturnFromResult(self, result, ret, 0); } throw_here: __Pyx_Raise(typ, val, tb, NULL); propagate_exception: { PyObject *retval = NULL; __Pyx_PySendResult result = __Pyx_Coroutine_SendEx(gen, NULL, &retval, 0); __Pyx_Coroutine_unset_is_running(gen); return __Pyx_Coroutine_MethodReturnFromResult(self, result, retval, 0); } } static PyObject *__Pyx_Coroutine_Throw(PyObject *self, #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 PyObject *args #else PyObject *const *args, Py_ssize_t nargs #endif ) { PyObject *typ; PyObject *val = NULL; PyObject *tb = NULL; #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 if (unlikely(!PyArg_UnpackTuple(args, "throw", 1, 3, &typ, &val, &tb))) return NULL; #else switch (nargs) { case 3: tb = args[2]; CYTHON_FALLTHROUGH; case 2: val = args[1]; CYTHON_FALLTHROUGH; case 1: typ = args[0]; break; default: PyErr_SetString(PyExc_TypeError, "throw takes between 1 and 3 positional arguments"); return NULL; } #endif return __Pyx__Coroutine_Throw(self, typ, val, tb, #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 args, #else NULL, #endif 1); } static CYTHON_INLINE int __Pyx_Coroutine_traverse_excstate(__Pyx_ExcInfoStruct *exc_state, visitproc visit, void *arg) { #if PY_VERSION_HEX >= 0x030B00a4 Py_VISIT(exc_state->exc_value); #else Py_VISIT(exc_state->exc_type); Py_VISIT(exc_state->exc_value); Py_VISIT(exc_state->exc_traceback); #endif return 0; } static int __Pyx_Coroutine_traverse(__pyx_CoroutineObject *gen, visitproc visit, void *arg) { { int e = __Pyx_call_type_traverse((PyObject*)gen, 1, visit, arg); if (e) return e; } Py_VISIT(gen->closure); Py_VISIT(gen->classobj); Py_VISIT(gen->yieldfrom); return __Pyx_Coroutine_traverse_excstate(&gen->gi_exc_state, visit, arg); } static int __Pyx_Coroutine_clear(PyObject *self) { __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; Py_CLEAR(gen->closure); Py_CLEAR(gen->classobj); __Pyx_Coroutine_Undelegate(gen); __Pyx_Coroutine_ExceptionClear(&gen->gi_exc_state); #ifdef __Pyx_AsyncGen_USED if (__Pyx_AsyncGen_CheckExact(self)) { Py_CLEAR(((__pyx_PyAsyncGenObject*)gen)->ag_finalizer); } #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); return 0; } static void __Pyx_Coroutine_dealloc(PyObject *self) { __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; PyObject_GC_UnTrack(gen); #if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API if (gen->gi_weakreflist != NULL) #endif PyObject_ClearWeakRefs(self); if (gen->resume_label >= 0) { #if CYTHON_USE_TP_FINALIZE PyObject_GC_Track(self); if (unlikely(PyObject_CallFinalizerFromDealloc(self))) { return; } PyObject_GC_UnTrack(self); #endif } #ifdef __Pyx_AsyncGen_USED if (__Pyx_AsyncGen_CheckExact(self)) { /* We have to handle this case for asynchronous generators right here, because this code has to be between UNTRACK and GC_Del. */ Py_CLEAR(((__pyx_PyAsyncGenObject*)self)->ag_finalizer); } #endif __Pyx_Coroutine_clear(self); __Pyx_PyHeapTypeObject_GC_Del(gen); } #if CYTHON_USE_TP_FINALIZE static void __Pyx_Coroutine_del(PyObject *self) { PyObject *error_type, *error_value, *error_traceback; __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; __Pyx_PyThreadState_declare if (gen->resume_label < 0) { return; } __Pyx_PyThreadState_assign __Pyx_ErrFetch(&error_type, &error_value, &error_traceback); #ifdef __Pyx_AsyncGen_USED if (__Pyx_AsyncGen_CheckExact(self)) { __pyx_PyAsyncGenObject *agen = (__pyx_PyAsyncGenObject*)self; PyObject *finalizer = agen->ag_finalizer; if (finalizer && !agen->ag_closed) { PyObject *res = __Pyx_PyObject_CallOneArg(finalizer, self); if (unlikely(!res)) { PyErr_WriteUnraisable(self); } else { Py_DECREF(res); } __Pyx_ErrRestore(error_type, error_value, error_traceback); return; } } #endif if (unlikely(gen->resume_label == 0 && !error_value)) { #ifdef __Pyx_Coroutine_USED #ifdef __Pyx_Generator_USED if (!__Pyx_Generator_CheckExact(self)) #endif { PyObject_GC_UnTrack(self); if (unlikely(PyErr_WarnFormat(PyExc_RuntimeWarning, 1, "coroutine '%.50S' was never awaited", gen->gi_qualname) < 0)) PyErr_WriteUnraisable(self); PyObject_GC_Track(self); } #endif } else { PyObject *retval = NULL; __Pyx_PySendResult result = __Pyx_Coroutine_Close(self, &retval); if (result == PYGEN_ERROR) { PyErr_WriteUnraisable(self); } else { Py_XDECREF(retval); } } __Pyx_ErrRestore(error_type, error_value, error_traceback); } #endif static PyObject * __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, void *context) { CYTHON_UNUSED_VAR(context); if (unlikely(value == NULL || !PyUnicode_Check(value))) { PyErr_SetString(PyExc_TypeError, "__name__ must be set to a string object"); return -1; } Py_INCREF(value); __Pyx_Py_XDECREF_SET(self->gi_name, value); return 0; } static PyObject * __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, void *context) { CYTHON_UNUSED_VAR(context); if (unlikely(value == NULL || !PyUnicode_Check(value))) { PyErr_SetString(PyExc_TypeError, "__qualname__ must be set to a string object"); return -1; } Py_INCREF(value); __Pyx_Py_XDECREF_SET(self->gi_qualname, value); return 0; } #if !CYTHON_COMPILING_IN_LIMITED_API static PyObject * __Pyx__Coroutine_get_frame_locked(__pyx_CoroutineObject *self) { PyObject *frame; frame = self->gi_frame; if (!frame) { if (unlikely(!self->gi_code)) { Py_RETURN_NONE; } PyObject *globals = PyDict_New(); if (unlikely(!globals)) return NULL; frame = (PyObject *) PyFrame_New( PyThreadState_Get(), /*PyThreadState *tstate,*/ (PyCodeObject*) self->gi_code, /*PyCodeObject *code,*/ globals, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); Py_DECREF(globals); if (unlikely(!frame)) return NULL; if (unlikely(self->gi_frame)) { Py_DECREF(frame); frame = self->gi_frame; } else { self->gi_frame = frame; } } Py_INCREF(frame); return frame; } #endif static PyObject * __Pyx__Coroutine_get_frame(__pyx_CoroutineObject *self) { #if !CYTHON_COMPILING_IN_LIMITED_API PyObject *frame; __Pyx_BEGIN_CRITICAL_SECTION((PyObject*)self); frame = __Pyx__Coroutine_get_frame_locked(self); __Pyx_END_CRITICAL_SECTION(); return frame; #else CYTHON_UNUSED_VAR(self); Py_RETURN_NONE; #endif } static PyObject * __Pyx_Coroutine_get_frame(__pyx_CoroutineObject *self, void *context) { CYTHON_UNUSED_VAR(context); PyObject *frame = self->gi_frame; if (frame) return __Pyx_NewRef(frame); return __Pyx__Coroutine_get_frame(self); } static __pyx_CoroutineObject *__Pyx__Coroutine_New( PyTypeObject* type, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, PyObject *name, PyObject *qualname, PyObject *module_name) { __pyx_CoroutineObject *gen = PyObject_GC_New(__pyx_CoroutineObject, type); if (unlikely(!gen)) return NULL; return __Pyx__Coroutine_NewInit(gen, body, code, closure, name, qualname, module_name); } static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit( __pyx_CoroutineObject *gen, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, PyObject *name, PyObject *qualname, PyObject *module_name) { gen->body = body; gen->closure = closure; Py_XINCREF(closure); gen->is_running = 0; gen->resume_label = 0; gen->classobj = NULL; gen->yieldfrom = NULL; gen->yieldfrom_am_send = NULL; #if PY_VERSION_HEX >= 0x030B00a4 && !CYTHON_COMPILING_IN_LIMITED_API gen->gi_exc_state.exc_value = NULL; #else gen->gi_exc_state.exc_type = NULL; gen->gi_exc_state.exc_value = NULL; gen->gi_exc_state.exc_traceback = NULL; #endif #if CYTHON_USE_EXC_INFO_STACK gen->gi_exc_state.previous_item = NULL; #endif #if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API gen->gi_weakreflist = NULL; #endif Py_XINCREF(qualname); gen->gi_qualname = qualname; Py_XINCREF(name); gen->gi_name = name; Py_XINCREF(module_name); gen->gi_modulename = module_name; Py_XINCREF(code); gen->gi_code = code; gen->gi_frame = NULL; #if CYTHON_USE_SYS_MONITORING && (CYTHON_PROFILE || CYTHON_TRACE) memset(gen->__pyx_pymonitoring_state, 0, sizeof(gen->__pyx_pymonitoring_state)); gen->__pyx_pymonitoring_version = 0; #endif PyObject_GC_Track(gen); return gen; } static char __Pyx_Coroutine_test_and_set_is_running(__pyx_CoroutineObject *gen) { char result; __Pyx_BEGIN_CRITICAL_SECTION((PyObject*)gen); result = gen->is_running; gen->is_running = 1; __Pyx_END_CRITICAL_SECTION(); return result; } static void __Pyx_Coroutine_unset_is_running(__pyx_CoroutineObject *gen) { __Pyx_BEGIN_CRITICAL_SECTION((PyObject*)gen); assert(gen->is_running); gen->is_running = 0; __Pyx_END_CRITICAL_SECTION(); } static char __Pyx_Coroutine_get_is_running(__pyx_CoroutineObject *gen) { char result; __Pyx_BEGIN_CRITICAL_SECTION((PyObject*)gen); result = gen->is_running; __Pyx_END_CRITICAL_SECTION(); return result; } static PyObject *__Pyx_Coroutine_get_is_running_getter(PyObject *gen, void *closure) { CYTHON_UNUSED_VAR(closure); char result = __Pyx_Coroutine_get_is_running((__pyx_CoroutineObject*)gen); if (result) Py_RETURN_TRUE; else Py_RETURN_FALSE; } #if __PYX_HAS_PY_AM_SEND == 2 static void __Pyx_SetBackportTypeAmSend(PyTypeObject *type, __Pyx_PyAsyncMethodsStruct *static_amsend_methods, __Pyx_pyiter_sendfunc am_send) { Py_ssize_t ptr_offset = (char*)(type->tp_as_async) - (char*)type; if (ptr_offset < 0 || ptr_offset > type->tp_basicsize) { return; } memcpy((void*)static_amsend_methods, (void*)(type->tp_as_async), sizeof(*type->tp_as_async)); static_amsend_methods->am_send = am_send; type->tp_as_async = __Pyx_SlotTpAsAsync(static_amsend_methods); } #endif static PyObject *__Pyx_Coroutine_fail_reduce_ex(PyObject *self, PyObject *arg) { CYTHON_UNUSED_VAR(arg); __Pyx_RaiseTypeErrorWithObjectType( "cannot pickle '" __Pyx_FMT_TYPENAME "' object", self); return NULL; } /* Generator */ static PyMethodDef __pyx_Generator_methods[] = { {"send", (PyCFunction) __Pyx_Coroutine_Send, METH_O, PyDoc_STR("send(arg) -> send 'arg' into generator,\nreturn next yielded value or raise StopIteration.")}, {"throw", __PYX_REINTERPRET_FUNCION(PyCFunction, __Pyx_Coroutine_Throw), #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 METH_VARARGS, #else METH_FASTCALL, #endif PyDoc_STR("throw(typ[,val[,tb]]) -> raise exception in generator,\nreturn next yielded value or raise StopIteration.")}, {"close", (PyCFunction) __Pyx_Coroutine_Close_Method, METH_NOARGS, PyDoc_STR("close() -> raise GeneratorExit inside generator.")}, {"__reduce_ex__", (PyCFunction) __Pyx_Coroutine_fail_reduce_ex, METH_O, 0}, {"__reduce__", (PyCFunction) __Pyx_Coroutine_fail_reduce_ex, METH_NOARGS, 0}, {0, 0, 0, 0} }; static PyMemberDef __pyx_Generator_memberlist[] = { {"gi_yieldfrom", T_OBJECT, offsetof(__pyx_CoroutineObject, yieldfrom), READONLY, PyDoc_STR("object being iterated by 'yield from', or None")}, {"gi_code", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_code), READONLY, NULL}, {"__module__", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_modulename), 0, 0}, #if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API {"__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CoroutineObject, gi_weakreflist), READONLY, 0}, #endif {0, 0, 0, 0, 0} }; static PyGetSetDef __pyx_Generator_getsets[] = { {"__name__", (getter)__Pyx_Coroutine_get_name, (setter)__Pyx_Coroutine_set_name, PyDoc_STR("name of the generator"), 0}, {"__qualname__", (getter)__Pyx_Coroutine_get_qualname, (setter)__Pyx_Coroutine_set_qualname, PyDoc_STR("qualified name of the generator"), 0}, {"gi_frame", (getter)__Pyx_Coroutine_get_frame, NULL, PyDoc_STR("Frame of the generator"), 0}, {"gi_running", __Pyx_Coroutine_get_is_running_getter, NULL, NULL, NULL}, {0, 0, 0, 0, 0} }; static PyType_Slot __pyx_GeneratorType_slots[] = { {Py_tp_dealloc, (void *)__Pyx_Coroutine_dealloc}, {Py_tp_traverse, (void *)__Pyx_Coroutine_traverse}, {Py_tp_iter, (void *)PyObject_SelfIter}, {Py_tp_iternext, (void *)__Pyx_Generator_Next}, {Py_tp_methods, (void *)__pyx_Generator_methods}, {Py_tp_members, (void *)__pyx_Generator_memberlist}, {Py_tp_getset, (void *)__pyx_Generator_getsets}, {Py_tp_getattro, (void *) PyObject_GenericGetAttr}, #if CYTHON_USE_TP_FINALIZE {Py_tp_finalize, (void *)__Pyx_Coroutine_del}, #endif #if __PYX_HAS_PY_AM_SEND == 1 {Py_am_send, (void *)__Pyx_Coroutine_AmSend}, #endif {0, 0}, }; static PyType_Spec __pyx_GeneratorType_spec = { __PYX_TYPE_MODULE_PREFIX "generator", sizeof(__pyx_CoroutineObject), 0, #if PY_VERSION_HEX >= 0x030C0000 && !CYTHON_COMPILING_IN_LIMITED_API Py_TPFLAGS_MANAGED_WEAKREF | #endif Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION | Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | __Pyx_TPFLAGS_HAVE_AM_SEND, __pyx_GeneratorType_slots }; #if __PYX_HAS_PY_AM_SEND == 2 static __Pyx_PyAsyncMethodsStruct __pyx_Generator_as_async; #endif static int __pyx_Generator_init(PyObject *module) { __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module); mstate->__pyx_GeneratorType = __Pyx_FetchCommonTypeFromSpec( mstate->__pyx_CommonTypesMetaclassType, module, &__pyx_GeneratorType_spec, NULL); if (unlikely(!mstate->__pyx_GeneratorType)) { return -1; } #if __PYX_HAS_PY_AM_SEND == 2 __Pyx_SetBackportTypeAmSend(mstate->__pyx_GeneratorType, &__pyx_Generator_as_async, &__Pyx_Coroutine_AmSend); #endif return 0; } static PyObject *__Pyx_Generator_GetInlinedResult(PyObject *self) { __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; PyObject *retval = NULL; if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) { return __Pyx_Coroutine_AlreadyRunningError(gen); } __Pyx_PySendResult result = __Pyx_Coroutine_SendEx(gen, Py_None, &retval, 0); __Pyx_Coroutine_unset_is_running(gen); (void) result; assert (result == PYGEN_RETURN || result == PYGEN_ERROR); assert ((result == PYGEN_RETURN && retval != NULL) || (result == PYGEN_ERROR && retval == NULL)); return retval; } /* CheckBinaryVersion */ 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); } } /* NewCodeObj */ #if CYTHON_COMPILING_IN_LIMITED_API static PyObject* __Pyx__PyCode_New(int a, int p, int k, int l, int s, int f, PyObject *code, PyObject *c, PyObject* n, PyObject *v, PyObject *fv, PyObject *cell, PyObject* fn, PyObject *name, int fline, PyObject *lnos) { PyObject *exception_table = NULL; PyObject *types_module=NULL, *code_type=NULL, *result=NULL; #if __PYX_LIMITED_VERSION_HEX < 0x030b0000 PyObject *version_info; PyObject *py_minor_version = NULL; #endif long minor_version = 0; #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 <= 10) { result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOOO", 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, "iiiiiiOOOOOOOiOOOO", 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 (!result) { PyObject *exc_type, *exc_value, *exc_tb; PyErr_Fetch(&exc_type, &exc_value, &exc_tb); if (PyErr_WarnFormat( PyExc_RuntimeWarning, 1, "Code object creation failed in Cython module: %S\nTry recompiling with a more recent version of Cython.", exc_value ? exc_value : exc_type) == 0) { result = Py_None; Py_INCREF(result); } Py_DECREF(exc_type); Py_XDECREF(exc_value); Py_XDECREF(exc_tb); } return result; } #elif PY_VERSION_HEX >= 0x030B0000 static PyCodeObject* __Pyx__PyCode_New(int a, int p, int k, int l, int s, int f, PyObject *code, PyObject *c, PyObject* n, PyObject *v, PyObject *fv, PyObject *cell, PyObject* fn, PyObject *name, int fline, PyObject *lnos) { PyCodeObject *result; result = #if PY_VERSION_HEX >= 0x030C0000 PyUnstable_Code_NewWithPosOnlyArgs #else PyCode_NewWithPosOnlyArgs #endif (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, __pyx_mstate_global->__pyx_empty_bytes); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030c00A1 if (likely(result)) result->_co_firsttraceable = 0; #endif return result; } #elif !CYTHON_COMPILING_IN_PYPY #define __Pyx__PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else #define __Pyx__PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #endif static PyObject* __Pyx_PyCode_New( const __Pyx_PyCode_New_function_description descr, PyObject * const *varnames, PyObject *filename, PyObject *funcname, PyObject *line_table, PyObject *tuple_dedup_map ) { PyObject *code_obj = NULL, *varnames_tuple_dedup = NULL, *code_bytes = NULL; Py_ssize_t var_count = (Py_ssize_t) descr.nlocals; PyObject *varnames_tuple = PyTuple_New(var_count); if (unlikely(!varnames_tuple)) return NULL; for (Py_ssize_t i=0; i < var_count; i++) { Py_INCREF(varnames[i]); if (__Pyx_PyTuple_SET_ITEM(varnames_tuple, i, varnames[i]) != (0)) goto done; } #if CYTHON_COMPILING_IN_LIMITED_API varnames_tuple_dedup = PyDict_GetItem(tuple_dedup_map, varnames_tuple); if (!varnames_tuple_dedup) { if (unlikely(PyDict_SetItem(tuple_dedup_map, varnames_tuple, varnames_tuple) < 0)) goto done; varnames_tuple_dedup = varnames_tuple; } #else varnames_tuple_dedup = PyDict_SetDefault(tuple_dedup_map, varnames_tuple, varnames_tuple); if (unlikely(!varnames_tuple_dedup)) goto done; #endif #if CYTHON_AVOID_BORROWED_REFS Py_INCREF(varnames_tuple_dedup); #endif if (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table != NULL && !CYTHON_COMPILING_IN_GRAAL) { Py_ssize_t line_table_length = __Pyx_PyBytes_GET_SIZE(line_table); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely(line_table_length == -1)) goto done; #endif Py_ssize_t code_len = (line_table_length * 2 + 4) & ~3LL; code_bytes = PyBytes_FromStringAndSize(NULL, code_len); if (unlikely(!code_bytes)) goto done; char* c_code_bytes = PyBytes_AsString(code_bytes); if (unlikely(!c_code_bytes)) goto done; memset(c_code_bytes, 0, (size_t) code_len); } code_obj = (PyObject*) __Pyx__PyCode_New( (int) descr.argcount, (int) descr.num_posonly_args, (int) descr.num_kwonly_args, (int) descr.nlocals, 0, (int) descr.flags, code_bytes ? code_bytes : __pyx_mstate_global->__pyx_empty_bytes, __pyx_mstate_global->__pyx_empty_tuple, __pyx_mstate_global->__pyx_empty_tuple, varnames_tuple_dedup, __pyx_mstate_global->__pyx_empty_tuple, __pyx_mstate_global->__pyx_empty_tuple, filename, funcname, (int) descr.first_line, (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table) ? line_table : __pyx_mstate_global->__pyx_empty_bytes ); done: Py_XDECREF(code_bytes); #if CYTHON_AVOID_BORROWED_REFS Py_XDECREF(varnames_tuple_dedup); #endif Py_DECREF(varnames_tuple); return code_obj; } /* DecompressString */ CYTHON_UNUSED static CYTHON_SMALL_CODE PyObject *__Pyx_DecompressString(const char *s, Py_ssize_t length, int algo) { #ifdef __Pyx_DecompressString_UNUSED CYTHON_UNUSED_VAR(s); CYTHON_UNUSED_VAR(length); CYTHON_UNUSED_VAR(algo); return NULL; #else PyObject *module = NULL, *decompress, *compressed_bytes, *decompressed; const char* module_name = algo == 3 ? "compression.zstd" : algo == 2 ? "bz2" : "zlib"; PyObject *methodname = PyUnicode_FromString("decompress"); if (unlikely(!methodname)) return NULL; #if __PYX_LIMITED_VERSION_HEX >= 0x030e0000 if (algo == 3) { PyObject *fromlist = Py_BuildValue("[O]", methodname); if (unlikely(!fromlist)) goto bad; module = PyImport_ImportModuleLevel("compression.zstd", NULL, NULL, fromlist, 0); Py_DECREF(fromlist); } else #endif module = PyImport_ImportModule(module_name); if (unlikely(!module)) goto import_failed; decompress = PyObject_GetAttr(module, methodname); if (unlikely(!decompress)) goto import_failed; { #ifdef __cplusplus char *memview_bytes = const_cast(s); #else #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wcast-qual" #elif !defined(__INTEL_COMPILER) && defined(__GNUC__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wcast-qual" #endif char *memview_bytes = (char*) s; #if defined(__clang__) #pragma clang diagnostic pop #elif !defined(__INTEL_COMPILER) && defined(__GNUC__) #pragma GCC diagnostic pop #endif #endif #if CYTHON_COMPILING_IN_LIMITED_API && !defined(PyBUF_READ) int memview_flags = 0x100; #else int memview_flags = PyBUF_READ; #endif compressed_bytes = PyMemoryView_FromMemory(memview_bytes, length, memview_flags); } if (unlikely(!compressed_bytes)) { Py_DECREF(decompress); goto bad; } decompressed = PyObject_CallFunctionObjArgs(decompress, compressed_bytes, NULL); Py_DECREF(compressed_bytes); Py_DECREF(decompress); Py_DECREF(module); Py_DECREF(methodname); return decompressed; import_failed: PyErr_Format(PyExc_ImportError, "Failed to import '%.20s.decompress' - cannot initialise module strings. " "String compression was configured with the C macro 'CYTHON_COMPRESS_STRINGS=%d'.", module_name, algo); bad: Py_XDECREF(module); Py_DECREF(methodname); return NULL; #endif } /* DecompressString_LZSS */ #ifndef __Pyx_DecompressString_LZSS_UNUSED CYTHON_UNUSED static CYTHON_SMALL_CODE size_t __pyx_lzss_decompress(const uint8_t* src, uint8_t* dst, size_t dst_len) { size_t pos = 0, out_pos = 0; while (1) { uint32_t flags = src[pos++] | 0xFF00; while (flags & 0x100) { if (flags & 1) { dst[out_pos++] = src[pos++]; } else { uint32_t lo = src[pos++], hi = src[pos++]; uint32_t end_offset_of_last_occurrence, match_length; if (!(lo & 0x80)) { end_offset_of_last_occurrence = lo; match_length = hi; } else if (!(hi & 0x80)) { end_offset_of_last_occurrence = 0x80 + (((hi << 2) & 0x180) | (lo & 0x7F)); match_length = hi & 0x1F; } else { end_offset_of_last_occurrence = 0x80 + ((hi & 0x7F) << 7 | (lo & 0x7F)); match_length = src[pos++]; } match_length += 3; size_t ref_pos = out_pos - end_offset_of_last_occurrence - match_length; memcpy(dst + out_pos, dst + ref_pos, match_length); out_pos += match_length; } if (out_pos >= dst_len) return pos; flags >>= 1; } } } #endif static CYTHON_SMALL_CODE PyObject *__Pyx_DecompressString_LZSS(const char *s, size_t compressed_length, size_t uncompressed_length) { #ifdef __Pyx_DecompressString_LZSS_UNUSED CYTHON_UNUSED_VAR(s); CYTHON_UNUSED_VAR(compressed_length); CYTHON_UNUSED_VAR(uncompressed_length); return NULL; #else PyObject *result; unsigned char *result_data; size_t src_length; result = PyBytes_FromStringAndSize(NULL, (Py_ssize_t) uncompressed_length); if (unlikely(!result)) return NULL; result_data = __Pyx_PyBytes_AsWritableUString(result); if (unlikely(!result_data)) goto bad; src_length = __pyx_lzss_decompress((const uint8_t*) s, result_data, uncompressed_length); if (unlikely(src_length != compressed_length)) goto decompression_failed; return result; decompression_failed: PyErr_SetString(PyExc_RuntimeError, "LZSS string data decompression failed"); bad: Py_DECREF(result); return NULL; #endif } #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_UTF8 static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; #if CYTHON_COMPILING_IN_LIMITED_API { const char* result; Py_ssize_t unicode_length; CYTHON_MAYBE_UNUSED_VAR(unicode_length); // only for __PYX_DEFAULT_STRING_ENCODING_IS_ASCII #if __PYX_LIMITED_VERSION_HEX < 0x030A0000 if (unlikely(PyArg_Parse(o, "s#", &result, length) < 0)) return NULL; #else result = PyUnicode_AsUTF8AndSize(o, length); #endif #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII unicode_length = PyUnicode_GetLength(o); if (unlikely(unicode_length < 0)) return NULL; if (unlikely(unicode_length != *length)) { PyUnicode_AsASCIIString(o); return NULL; } #endif return result; } #else #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_UTF8 if (PyUnicode_Check(o)) { return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif if (PyByteArray_Check(o)) { #if (CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS) || (CYTHON_COMPILING_IN_PYPY && (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))) *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); #else *length = PyByteArray_Size(o); if (*length == -1) return NULL; return PyByteArray_AsString(o); #endif } else { 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_LongWrongResultType(PyObject* result) { __Pyx_TypeName result_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(result)); #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 if (unlikely(!result_type_name)) goto bad; #endif 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); goto bad; } __Pyx_DECREF_TypeName(result_type_name); return result; } PyErr_Format(PyExc_TypeError, "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ")", result_type_name); __Pyx_DECREF_TypeName(result_type_name); bad: Py_DECREF(result); return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyNumber_Long(PyObject* x) { #if CYTHON_USE_TYPE_SLOTS PyNumberMethods *m; #endif PyObject *res = NULL; if (likely(PyLong_Check(x))) return __Pyx_NewRef(x); #if CYTHON_USE_TYPE_SLOTS m = Py_TYPE(x)->tp_as_number; if (likely(m && m->nb_int)) { res = m->nb_int(x); } #else if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { res = PyNumber_Long(x); } #endif if (likely(res)) { if (unlikely(!PyLong_CheckExact(res))) { return __Pyx_PyNumber_LongWrongResultType(res); } } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, "an integer is required"); } return res; } static CYTHON_INLINE Py_ssize_t __Pyx_PyLong_AsSsize_t(PyObject* b) { #if CYTHON_USE_PYLONG_INTERNALS Py_ssize_t ival; const Py_ssize_t size = __Pyx_PyLong_DigitCount(b); const int is_neg = __Pyx_PyLong_IsNeg(b); const digit* digits = __Pyx_PyLong_Digits(b); if (size == 0) return 0; #if SIZEOF_SIZE_T * 8 > 1 * PyLong_SHIFT if (size == 1) { ival = (Py_ssize_t) (((size_t)digits[0])); } else #endif #if SIZEOF_SIZE_T * 8 > 2 * PyLong_SHIFT if (size == 2) { ival = (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } else #endif #if SIZEOF_SIZE_T * 8 > 3 * PyLong_SHIFT if (size == 3) { ival = (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } else #endif #if SIZEOF_SIZE_T * 8 > 4 * PyLong_SHIFT if (size == 4) { ival = (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])); } else #endif return PyLong_AsSsize_t(b); return is_neg ? -ival : ival; #else return PyLong_AsSsize_t(b); #endif } static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { if (likely(PyLong_Check(b))) { return __Pyx_PyLong_AsSsize_t(b); } else { Py_ssize_t ival; PyObject *x = PyNumber_Index(b); if (unlikely(!x)) return -1; ival = __Pyx_PyLong_AsSsize_t(x); Py_DECREF(x); return ival; } } static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o); } else { Py_ssize_t ival; PyObject *x; x = PyNumber_Index(o); if (!x) return -1; ival = PyLong_AsLong(x); Py_DECREF(x); return ival; } } static CYTHON_INLINE PyObject *__Pyx_Owned_Py_None(int b) { CYTHON_UNUSED_VAR(b); return __Pyx_NewRef(Py_None); } static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { return __Pyx_NewRef(b ? Py_True: Py_False); } static CYTHON_INLINE PyObject * __Pyx_PyLong_FromSize_t(size_t ival) { return PyLong_FromSize_t(ival); } /* MultiPhaseInitModuleState */ #if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE #ifndef CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE #if (CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX >= 0x030C0000) #define CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE 1 #else #define CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE 0 #endif #endif #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE && !CYTHON_ATOMICS #error "Module state with PEP489 requires atomics. Currently that's one of\ C11, C++11, gcc atomic intrinsics or MSVC atomic intrinsics" #endif #if !CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE #define __Pyx_ModuleStateLookup_Lock() #define __Pyx_ModuleStateLookup_Unlock() #elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d0000 static PyMutex __Pyx_ModuleStateLookup_mutex = {0}; #define __Pyx_ModuleStateLookup_Lock() PyMutex_Lock(&__Pyx_ModuleStateLookup_mutex) #define __Pyx_ModuleStateLookup_Unlock() PyMutex_Unlock(&__Pyx_ModuleStateLookup_mutex) #elif defined(__cplusplus) && __cplusplus >= 201103L #include static std::mutex __Pyx_ModuleStateLookup_mutex; #define __Pyx_ModuleStateLookup_Lock() __Pyx_ModuleStateLookup_mutex.lock() #define __Pyx_ModuleStateLookup_Unlock() __Pyx_ModuleStateLookup_mutex.unlock() #elif defined(__STDC_VERSION__) && (__STDC_VERSION__ > 201112L) && !defined(__STDC_NO_THREADS__) #include static mtx_t __Pyx_ModuleStateLookup_mutex; static once_flag __Pyx_ModuleStateLookup_mutex_once_flag = ONCE_FLAG_INIT; static void __Pyx_ModuleStateLookup_initialize_mutex(void) { mtx_init(&__Pyx_ModuleStateLookup_mutex, mtx_plain); } #define __Pyx_ModuleStateLookup_Lock()\ call_once(&__Pyx_ModuleStateLookup_mutex_once_flag, __Pyx_ModuleStateLookup_initialize_mutex);\ mtx_lock(&__Pyx_ModuleStateLookup_mutex) #define __Pyx_ModuleStateLookup_Unlock() mtx_unlock(&__Pyx_ModuleStateLookup_mutex) #elif defined(HAVE_PTHREAD_H) #include static pthread_mutex_t __Pyx_ModuleStateLookup_mutex = PTHREAD_MUTEX_INITIALIZER; #define __Pyx_ModuleStateLookup_Lock() pthread_mutex_lock(&__Pyx_ModuleStateLookup_mutex) #define __Pyx_ModuleStateLookup_Unlock() pthread_mutex_unlock(&__Pyx_ModuleStateLookup_mutex) #elif defined(_WIN32) #include // synchapi.h on its own doesn't work static SRWLOCK __Pyx_ModuleStateLookup_mutex = SRWLOCK_INIT; #define __Pyx_ModuleStateLookup_Lock() AcquireSRWLockExclusive(&__Pyx_ModuleStateLookup_mutex) #define __Pyx_ModuleStateLookup_Unlock() ReleaseSRWLockExclusive(&__Pyx_ModuleStateLookup_mutex) #else #error "No suitable lock available for CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE.\ Requires C standard >= C11, or C++ standard >= C++11,\ or pthreads, or the Windows 32 API, or Python >= 3.13." #endif typedef struct { int64_t id; PyObject *module; } __Pyx_InterpreterIdAndModule; typedef struct { char interpreter_id_as_index; Py_ssize_t count; Py_ssize_t allocated; __Pyx_InterpreterIdAndModule table[1]; } __Pyx_ModuleStateLookupData; #define __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE 32 #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE static __pyx_atomic_int_type __Pyx_ModuleStateLookup_read_counter = 0; #endif #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE static __pyx_atomic_ptr_type __Pyx_ModuleStateLookup_data = 0; #else static __Pyx_ModuleStateLookupData* __Pyx_ModuleStateLookup_data = NULL; #endif static __Pyx_InterpreterIdAndModule* __Pyx_State_FindModuleStateLookupTableLowerBound( __Pyx_InterpreterIdAndModule* table, Py_ssize_t count, int64_t interpreterId) { __Pyx_InterpreterIdAndModule* begin = table; __Pyx_InterpreterIdAndModule* end = begin + count; if (begin->id == interpreterId) { return begin; } while ((end - begin) > __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE) { __Pyx_InterpreterIdAndModule* halfway = begin + (end - begin)/2; if (halfway->id == interpreterId) { return halfway; } if (halfway->id < interpreterId) { begin = halfway; } else { end = halfway; } } for (; begin < end; ++begin) { if (begin->id >= interpreterId) return begin; } return begin; } static PyObject *__Pyx_State_FindModule(CYTHON_UNUSED void* dummy) { int64_t interpreter_id = PyInterpreterState_GetID(PyInterpreterState_Get()); if (interpreter_id == -1) return NULL; #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE __Pyx_ModuleStateLookupData* data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data); { __pyx_atomic_incr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); if (likely(data)) { __Pyx_ModuleStateLookupData* new_data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_acquire(&__Pyx_ModuleStateLookup_data); if (likely(data == new_data)) { goto read_finished; } } __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); __Pyx_ModuleStateLookup_Lock(); __pyx_atomic_incr_relaxed(&__Pyx_ModuleStateLookup_read_counter); data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data); __Pyx_ModuleStateLookup_Unlock(); } read_finished:; #else __Pyx_ModuleStateLookupData* data = __Pyx_ModuleStateLookup_data; #endif __Pyx_InterpreterIdAndModule* found = NULL; if (unlikely(!data)) goto end; if (data->interpreter_id_as_index) { if (interpreter_id < data->count) { found = data->table+interpreter_id; } } else { found = __Pyx_State_FindModuleStateLookupTableLowerBound( data->table, data->count, interpreter_id); } end: { PyObject *result=NULL; if (found && found->id == interpreter_id) { result = found->module; } #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); #endif return result; } } #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE static void __Pyx_ModuleStateLookup_wait_until_no_readers(void) { while (__pyx_atomic_load(&__Pyx_ModuleStateLookup_read_counter) != 0); } #else #define __Pyx_ModuleStateLookup_wait_until_no_readers() #endif static int __Pyx_State_AddModuleInterpIdAsIndex(__Pyx_ModuleStateLookupData **old_data, PyObject* module, int64_t interpreter_id) { Py_ssize_t to_allocate = (*old_data)->allocated; while (to_allocate <= interpreter_id) { if (to_allocate == 0) to_allocate = 1; else to_allocate *= 2; } __Pyx_ModuleStateLookupData *new_data = *old_data; if (to_allocate != (*old_data)->allocated) { new_data = (__Pyx_ModuleStateLookupData *)realloc( *old_data, sizeof(__Pyx_ModuleStateLookupData)+(to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule)); if (!new_data) { PyErr_NoMemory(); return -1; } for (Py_ssize_t i = new_data->allocated; i < to_allocate; ++i) { new_data->table[i].id = i; new_data->table[i].module = NULL; } new_data->allocated = to_allocate; } new_data->table[interpreter_id].module = module; if (new_data->count < interpreter_id+1) { new_data->count = interpreter_id+1; } *old_data = new_data; return 0; } static void __Pyx_State_ConvertFromInterpIdAsIndex(__Pyx_ModuleStateLookupData *data) { __Pyx_InterpreterIdAndModule *read = data->table; __Pyx_InterpreterIdAndModule *write = data->table; __Pyx_InterpreterIdAndModule *end = read + data->count; for (; readmodule) { write->id = read->id; write->module = read->module; ++write; } } data->count = write - data->table; for (; writeid = 0; write->module = NULL; } data->interpreter_id_as_index = 0; } static int __Pyx_State_AddModule(PyObject* module, CYTHON_UNUSED void* dummy) { int64_t interpreter_id = PyInterpreterState_GetID(PyInterpreterState_Get()); if (interpreter_id == -1) return -1; int result = 0; __Pyx_ModuleStateLookup_Lock(); #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE __Pyx_ModuleStateLookupData *old_data = (__Pyx_ModuleStateLookupData *) __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0); #else __Pyx_ModuleStateLookupData *old_data = __Pyx_ModuleStateLookup_data; #endif __Pyx_ModuleStateLookupData *new_data = old_data; if (!new_data) { new_data = (__Pyx_ModuleStateLookupData *)calloc(1, sizeof(__Pyx_ModuleStateLookupData)); if (!new_data) { result = -1; PyErr_NoMemory(); goto end; } new_data->allocated = 1; new_data->interpreter_id_as_index = 1; } __Pyx_ModuleStateLookup_wait_until_no_readers(); if (new_data->interpreter_id_as_index) { if (interpreter_id < __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE) { result = __Pyx_State_AddModuleInterpIdAsIndex(&new_data, module, interpreter_id); goto end; } __Pyx_State_ConvertFromInterpIdAsIndex(new_data); } { Py_ssize_t insert_at = 0; { __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound( new_data->table, new_data->count, interpreter_id); assert(lower_bound); insert_at = lower_bound - new_data->table; if (unlikely(insert_at < new_data->count && lower_bound->id == interpreter_id)) { lower_bound->module = module; goto end; // already in table, nothing more to do } } if (new_data->count+1 >= new_data->allocated) { Py_ssize_t to_allocate = (new_data->count+1)*2; new_data = (__Pyx_ModuleStateLookupData*)realloc( new_data, sizeof(__Pyx_ModuleStateLookupData) + (to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule)); if (!new_data) { result = -1; new_data = old_data; PyErr_NoMemory(); goto end; } new_data->allocated = to_allocate; } ++new_data->count; int64_t last_id = interpreter_id; PyObject *last_module = module; for (Py_ssize_t i=insert_at; icount; ++i) { int64_t current_id = new_data->table[i].id; new_data->table[i].id = last_id; last_id = current_id; PyObject *current_module = new_data->table[i].module; new_data->table[i].module = last_module; last_module = current_module; } } end: #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, new_data); #else __Pyx_ModuleStateLookup_data = new_data; #endif __Pyx_ModuleStateLookup_Unlock(); return result; } static int __Pyx_State_RemoveModule(CYTHON_UNUSED void* dummy) { int64_t interpreter_id = PyInterpreterState_GetID(PyInterpreterState_Get()); if (interpreter_id == -1) return -1; __Pyx_ModuleStateLookup_Lock(); #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE __Pyx_ModuleStateLookupData *data = (__Pyx_ModuleStateLookupData *) __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0); #else __Pyx_ModuleStateLookupData *data = __Pyx_ModuleStateLookup_data; #endif if (data->interpreter_id_as_index) { if (interpreter_id < data->count) { data->table[interpreter_id].module = NULL; } goto done; } { __Pyx_ModuleStateLookup_wait_until_no_readers(); __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound( data->table, data->count, interpreter_id); if (!lower_bound) goto done; if (lower_bound->id != interpreter_id) goto done; __Pyx_InterpreterIdAndModule *end = data->table+data->count; for (;lower_boundid = (lower_bound+1)->id; lower_bound->module = (lower_bound+1)->module; } } --data->count; if (data->count == 0) { free(data); data = NULL; } done: #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, data); #else __Pyx_ModuleStateLookup_data = data; #endif __Pyx_ModuleStateLookup_Unlock(); return 0; } #endif /* #### Code section: utility_code_pragmas_end ### */ #ifdef _MSC_VER #pragma warning( pop ) #endif /* #### Code section: end ### */ #endif /* Py_PYTHON_H */ ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788210425.9466708 borghash-0.2.1/src/borghash/HashTableNT.pxd0000644000175100017510000000031415245366372020166 0ustar00runnerrunnercdef class HashTableNT: cdef int key_size cdef object byte_order cdef object value_type cdef object value_format cdef object value_struct cdef int value_size cdef object inner ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788210425.9466708 borghash-0.2.1/src/borghash/HashTableNT.pyx0000644000175100017510000002234715245366372020225 0ustar00runnerrunner""" HashTableNT: wrapper around HashTable, providing namedtuple values and serialization. """ from __future__ import annotations from collections.abc import Mapping from typing import BinaryIO, Iterator, Any from collections import namedtuple import json import struct from .HashTable import HashTable, MIN_CAPACITY, _fill MAGIC = b"BORGHASH" assert len(MAGIC) == 8 VERSION = 1 # version of the on-disk (serialized) format produced by .write(). HEADER_FMT = "<8sII" # magic, version, meta length BYTE_ORDER = dict(big=">", little="<", network="!", native="=") # struct format chars _NoDefault = object() cdef class HashTableNT: def __init__(self, items=None, *, key_size: int, value_type: Any, value_format: Any, capacity: int = MIN_CAPACITY, byte_order="little") -> None: if not isinstance(key_size, int) or not key_size >= 4: raise ValueError("key_size must be an integer and >= 4.") if type(value_type) is not type: raise TypeError("value_type must be a namedtuple type.") if not isinstance(value_format, tuple): raise TypeError("value_format must be a namedtuple instance.") if value_format._fields != value_type._fields: raise TypeError("value_format's and value_type's element names must correspond.") if not all(isinstance(fmt, str) and len(fmt) > 0 for fmt in value_format): raise ValueError("value_format's elements must be str and non-empty.") if byte_order not in BYTE_ORDER: raise ValueError(f"byte_order must be one of: {', '.join(BYTE_ORDER.keys())}") self.key_size = key_size self.value_type = value_type self.value_format = value_format self.byte_order = byte_order self.value_struct = struct.Struct(BYTE_ORDER[byte_order] + "".join(value_format)) self.value_size = self.value_struct.size self.inner = HashTable(key_size=self.key_size, value_size=self.value_size, capacity=capacity) _fill(self, items) def clear(self) -> None: self.inner.clear() def _check_key(self, key: bytes) -> None: if not isinstance(key, bytes): raise TypeError(f"Expected an instance of bytes, got {type(key)}") if len(key) != self.key_size: raise ValueError(f"Key must be {self.key_size} bytes long") def _to_binary_value(self, value: Any) -> bytes: if not isinstance(value, self.value_type): if isinstance(value, tuple): value = self.value_type(*value) else: raise TypeError(f"Expected an instance of {self.value_type}, got {type(value)}") return self.value_struct.pack(*value) def _to_namedtuple_value(self, binary_value: bytes) -> Any: unpacked_data = self.value_struct.unpack(binary_value) return self.value_type(*unpacked_data) def _set_raw(self, key: bytes, value: bytes) -> None: self.inner[key] = value def _get_raw(self, key: bytes) -> bytes: return self.inner[key] def __setitem__(self, key: bytes, value: Any) -> None: self._check_key(key) self.inner[key] = self._to_binary_value(value) def __getitem__(self, key: bytes) -> Any: self._check_key(key) binary_value = self.inner[key] return self._to_namedtuple_value(binary_value) def __delitem__(self, key: bytes) -> None: self._check_key(key) del self.inner[key] def __contains__(self, key: bytes) -> bool: self._check_key(key) return key in self.inner def items(self, *, prefix_bits: int = 0, prefix: int = 0) -> Iterator[tuple[bytes, Any]]: """ Iterate over items, optionally only over items whose key starts with the given bit prefix. See HashTable.items for the prefix_bits / prefix semantics. """ for key, binary_value in self.inner.items(prefix_bits=prefix_bits, prefix=prefix): yield (key, self._to_namedtuple_value(binary_value)) def __len__(self) -> int: return len(self.inner) def get(self, key: bytes, default: Any = None) -> Any: self._check_key(key) try: binary_value = self.inner[key] except KeyError: return default else: return self._to_namedtuple_value(binary_value) def setdefault(self, key: bytes, default: Any) -> Any: self._check_key(key) binary_default = self._to_binary_value(default) binary_value = self.inner.setdefault(key, binary_default) return self._to_namedtuple_value(binary_value) def pop(self, key: bytes, default: Any = _NoDefault) -> Any: self._check_key(key) try: binary_value = self.inner.pop(key) except KeyError: if default is _NoDefault: raise return default else: return self._to_namedtuple_value(binary_value) def update(self, other=(), /, **kwds): """Like dict.update(), but 'other' can also be a HashTableNT instance.""" if isinstance(other, HashTableNT): for key, value in other.items(): self[key] = value elif isinstance(other, Mapping): for key in other: self[key] = other[key] elif hasattr(other, "keys"): for key in other.keys(): self[key] = other[key] else: for key, value in other: self[key] = value for key, value in kwds.items(): self[key] = value def k_to_idx(self, key: bytes) -> int: return self.inner.k_to_idx(key) def idx_to_k(self, idx: int) -> bytes: return self.inner.idx_to_k(idx) def kv_to_idx(self, key: bytes, value: Any) -> int: binary_value = self._to_binary_value(value) return self.inner.kv_to_idx(key, binary_value) def idx_to_kv(self, idx: int) -> tuple[bytes, Any]: key, binary_value = self.inner.idx_to_kv(idx) return key, self._to_namedtuple_value(binary_value) @property def stats(self) -> dict[str, int]: return self.inner.stats def write(self, file: BinaryIO|str|bytes): if isinstance(file, (str, bytes)): with open(file, 'wb') as fd: self._write_fd(fd) else: self._write_fd(file) def _write_fd(self, fd: BinaryIO): meta = { 'key_size': self.key_size, 'value_size': self.value_size, 'byte_order': self.byte_order, 'value_type_name': self.value_type.__name__, 'value_type_fields': self.value_type._fields, 'value_format_name': self.value_format.__class__.__name__, 'value_format_fields': self.value_format._fields, 'value_format': self.value_format, 'capacity': self.inner.capacity, 'used': self.inner.used, # count of keys / values } meta_bytes = json.dumps(meta).encode("utf-8") meta_size = len(meta_bytes) header_bytes = struct.pack(HEADER_FMT, MAGIC, VERSION, meta_size) fd.write(header_bytes) fd.write(meta_bytes) count = 0 for key, value in self.inner.items(): fd.write(key) fd.write(value) count += 1 assert count == self.inner.used @classmethod def read(cls, file: BinaryIO|str|bytes): if isinstance(file, (str, bytes)): with open(file, 'rb') as fd: return cls._read_fd(fd) else: return cls._read_fd(file) @classmethod def _read_fd(cls, fd: BinaryIO): header_size = struct.calcsize(HEADER_FMT) header_bytes = fd.read(header_size) if len(header_bytes) < header_size: raise ValueError(f"Invalid file, file is too short.") magic, version, meta_size = struct.unpack(HEADER_FMT, header_bytes) if magic != MAGIC: raise ValueError(f"Invalid file, magic {MAGIC.decode()} not found.") if version != VERSION: raise ValueError(f"Unsupported file version {version}.") meta_bytes = fd.read(meta_size) if len(meta_bytes) < meta_size: raise ValueError(f"Invalid file, file is too short.") meta = json.loads(meta_bytes.decode("utf-8")) value_type = namedtuple(meta['value_type_name'], meta['value_type_fields']) value_format_t = namedtuple(meta['value_format_name'], meta['value_format_fields']) value_format = value_format_t(*meta['value_format']) ht = cls(key_size=meta['key_size'], value_format=value_format, value_type=value_type, capacity=meta['capacity'], byte_order=meta['byte_order']) count = 0 ksize, vsize = meta['key_size'], meta['value_size'] for i in range(meta['used']): key = fd.read(ksize) value = fd.read(vsize) ht._set_raw(key, value) return ht def size(self) -> int: """ Do a rough worst-case estimate of the on-disk size when using .write(). The serialized size of the metadata is a bit hard to predict, but we cover that with one_time_overheads. """ one_time_overheads = 4096 # very rough N = self.inner.used return int(N * (self.key_size + self.value_size) + one_time_overheads) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788210425.9466708 borghash-0.2.1/src/borghash/__init__.pxd0000644000175100017510000000000015245366372017620 0ustar00runnerrunner././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788210425.9466708 borghash-0.2.1/src/borghash/__init__.py0000644000175100017510000000017615245366372017473 0ustar00runnerrunner""" borghash - hashtable implementations in Cython. """ from .HashTable import HashTable from .HashTableNT import HashTableNT ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788210425.9466708 borghash-0.2.1/src/borghash/__main__.py0000644000175100017510000000372715245366372017461 0ustar00runnerrunner""" Demonstration of BorgHash. """ def demo(): print("BorgHash demo") print("=============") print("Code:") code = """ from tempfile import NamedTemporaryFile from time import time from collections import namedtuple from .HashTableNT import HashTableNT count = 50000 value_type = namedtuple("Chunk", ["refcount", "size"]) value_format_t = namedtuple("ChunkFormat", ["refcount", "size"]) value_format = value_format_t(refcount="I", size="I") # 256-bit (32-byte) key, 2x 32-bit (4-byte) values ht = HashTableNT(key_size=32, value_type=value_type, value_format=value_format) t0 = time() for i in range(count): # Make up a 256-bit key from i; the first 32 bits need to be well distributed. key = f"{i:4x}{' '*28}".encode() value = value_type(refcount=i, size=i * 2) ht[key] = value assert len(ht) == count t1 = time() found = 0 for key, value in ht.items(): i = int(key.decode(), 16) expected_value = value_type(refcount=i, size=i * 2) assert ht[key] == expected_value found += 1 assert found == count t2 = time() ht_written = ht with NamedTemporaryFile(prefix="borghash-demo-ht-read", suffix=".tmp", delete=False) as tmpfile: ht_written.write(tmpfile) filename = tmpfile.name assert len(ht_written) == count, f"{len(ht_written)} != {count}" t3 = time() ht_read = HashTableNT.read(filename) assert len(ht_read) == count, f"{len(ht_read)} != {count}" t4 = time() for i in range(count): # Make up a 256-bit key from i; the first 32 bits need to be well distributed. key = f"{i:4x}{' '*28}".encode() expected_value = value_type(refcount=i, size=i * 2) assert ht_read.pop(key) == expected_value assert len(ht_read) == 0 t5 = time() print("Result:") print(f"HashTableNT in-memory ops (count={count}): insert: {t1-t0:.3f}s, lookup: {t2-t1:.3f}s, pop: {t5-t4:.3f}s.") print(f"HashTableNT serialization (count={count}): write: {t3-t2:.3f}s, read: {t4-t3:.3f}s.") """ print(code) exec(code) if __name__ == "__main__": demo() ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788210447.7957935 borghash-0.2.1/src/borghash.egg-info/0000755000175100017510000000000015245366420017042 5ustar00runnerrunner././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788210447.7722497 borghash-0.2.1/src/borghash.egg-info/PKG-INFO0000644000175100017510000000205715245366420020143 0ustar00runnerrunnerMetadata-Version: 2.4 Name: borghash Version: 0.2.1 Summary: Memory-efficient hash table (implemented in Cython) Author: The Borg Collective (see AUTHORS file) Maintainer-email: Thomas Waldmann License-Expression: BSD-3-Clause Project-URL: Homepage, https://github.com/borgbackup/borghash Project-URL: Changelog, https://github.com/borgbackup/borghash/blob/main/CHANGES.rst Keywords: hashtable,memory,efficient,dense Classifier: Development Status :: 4 - Beta Classifier: Intended Audience :: Developers Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.11 Classifier: Programming Language :: Python :: 3.12 Classifier: Programming Language :: Python :: 3.13 Classifier: Programming Language :: Python :: 3.14 Classifier: Programming Language :: Python :: 3.15 Classifier: Topic :: Software Development :: Libraries Classifier: Topic :: Software Development :: Libraries :: Python Modules Requires-Python: >=3.11 License-File: LICENSE.rst Dynamic: license-file ././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1788210447.786333 borghash-0.2.1/src/borghash.egg-info/SOURCES.txt0000644000175100017510000000107115245366420020725 0ustar00runnerrunnerAUTHORS CHANGES.rst LICENSE.rst README.rst pyproject.toml setup.py src/borghash/HashTable.c src/borghash/HashTable.pxd src/borghash/HashTable.pyx src/borghash/HashTableNT.c src/borghash/HashTableNT.pxd src/borghash/HashTableNT.pyx src/borghash/__init__.pxd src/borghash/__init__.py src/borghash/__main__.py src/borghash.egg-info/PKG-INFO src/borghash.egg-info/SOURCES.txt src/borghash.egg-info/dependency_links.txt src/borghash.egg-info/entry_points.txt src/borghash.egg-info/scm_file_list.json src/borghash.egg-info/scm_version.json src/borghash.egg-info/top_level.txt././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788210447.7730494 borghash-0.2.1/src/borghash.egg-info/dependency_links.txt0000644000175100017510000000000115245366420023110 0ustar00runnerrunner ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788210447.7733498 borghash-0.2.1/src/borghash.egg-info/entry_points.txt0000644000175100017510000000007115245366420022336 0ustar00runnerrunner[console_scripts] borghash-demo = borghash.__main__:demo ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788210447.7707665 borghash-0.2.1/src/borghash.egg-info/scm_file_list.json0000644000175100017510000000126215245366420022552 0ustar00runnerrunner{ "files": [ ".github/dependabot.yml", ".github/workflows/ci.yml", ".github/workflows/release.yml", ".gitignore", "AUTHORS", "CHANGES.rst", "LICENSE.rst", "MANIFEST.in", "README.rst", "pyproject.toml", "requirements.d/dev.txt", "setup.py", "src/borghash/HashTable.pxd", "src/borghash/HashTable.pyx", "src/borghash/HashTableNT.pxd", "src/borghash/HashTableNT.pyx", "src/borghash/__init__.pxd", "src/borghash/__init__.py", "src/borghash/__main__.py", "tests/__init__.py", "tests/benchmark_test.py", "tests/hashtable_stress_test.py", "tests/hashtable_test.py", "tests/hashtablent_test.py" ] } ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788210447.7642498 borghash-0.2.1/src/borghash.egg-info/scm_version.json0000644000175100017510000000024015245366420022260 0ustar00runnerrunner{ "tag": "0.2.1", "distance": 0, "node": "g377c7c33f76f8805ba6e6d3c62c7617fb75a0dfe", "dirty": false, "branch": "HEAD", "node_date": "2026-08-31" } ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788210447.7735856 borghash-0.2.1/src/borghash.egg-info/top_level.txt0000644000175100017510000000001115245366420021564 0ustar00runnerrunnerborghash