From d155d1afad1da5cc9d13e74e84870c96259d83cc Mon Sep 17 00:00:00 2001 From: foefl Date: Tue, 16 Dec 2025 13:43:48 +0100 Subject: [PATCH] major refactoring inlcuding renaming --- pdm.lock | 99 +- pyproject.toml | 4 +- setup.py | 4 +- .../__init__.py | 0 .../block.hpp | 0 .../block.pxd | 0 src/dopt_pollublock_blockchain/blockchain.cpp | 21001 ++++++++++++++++ .../blockchain.pyx} | 320 +- src/dopt_pollublock_blockchain/db.py | 16 + .../openssl_evp.pxd | 0 .../placeholder.c | 0 .../placeholder.py | 0 .../placeholder_native.cpp | 7331 ++++-- .../python.py | 0 .../python_translate.c | 0 .../python_translate.py | 0 16 files changed, 27004 insertions(+), 1771 deletions(-) rename src/{polluck_blockchain => dopt_pollublock_blockchain}/__init__.py (100%) rename src/{polluck_blockchain => dopt_pollublock_blockchain}/block.hpp (100%) rename src/{polluck_blockchain => dopt_pollublock_blockchain}/block.pxd (100%) create mode 100644 src/dopt_pollublock_blockchain/blockchain.cpp rename src/{polluck_blockchain/placeholder_native.pyx => dopt_pollublock_blockchain/blockchain.pyx} (62%) create mode 100644 src/dopt_pollublock_blockchain/db.py rename src/{polluck_blockchain => dopt_pollublock_blockchain}/openssl_evp.pxd (100%) rename src/{polluck_blockchain => dopt_pollublock_blockchain}/placeholder.c (100%) rename src/{polluck_blockchain => dopt_pollublock_blockchain}/placeholder.py (100%) rename src/{polluck_blockchain => dopt_pollublock_blockchain}/placeholder_native.cpp (72%) rename src/{polluck_blockchain => dopt_pollublock_blockchain}/python.py (100%) rename src/{polluck_blockchain => dopt_pollublock_blockchain}/python_translate.c (100%) rename src/{polluck_blockchain => dopt_pollublock_blockchain}/python_translate.py (100%) diff --git a/pdm.lock b/pdm.lock index ce94e02..6ffd566 100644 --- a/pdm.lock +++ b/pdm.lock @@ -5,7 +5,7 @@ groups = ["default", "dev", "lint", "nb", "tests"] strategy = ["inherit_metadata"] lock_version = "4.5.0" -content_hash = "sha256:c0680aa00cf7474d542ab72daaea39fe9f3c23b3b68f724f49da67b2d74ff588" +content_hash = "sha256:813bab76055ae1081c8e05c3f2d6b429ac1caf20ae5353aa06c90e70a17f75cb" [[metadata.targets]] requires_python = ">=3.11" @@ -831,6 +831,56 @@ files = [ {file = "fqdn-1.5.1.tar.gz", hash = "sha256:105ed3677e767fb5ca086a0c1f4bb66ebc3c100be518f0e0d755d9eae164d89f"}, ] +[[package]] +name = "greenlet" +version = "3.3.0" +requires_python = ">=3.10" +summary = "Lightweight in-process concurrent programming" +groups = ["default"] +marker = "platform_machine == \"win32\" or platform_machine == \"WIN32\" or platform_machine == \"AMD64\" or platform_machine == \"amd64\" or platform_machine == \"x86_64\" or platform_machine == \"ppc64le\" or platform_machine == \"aarch64\"" +files = [ + {file = "greenlet-3.3.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:e29f3018580e8412d6aaf5641bb7745d38c85228dacf51a73bd4e26ddf2a6a8e"}, + {file = "greenlet-3.3.0-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a687205fb22794e838f947e2194c0566d3812966b41c78709554aa883183fb62"}, + {file = "greenlet-3.3.0-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4243050a88ba61842186cb9e63c7dfa677ec146160b0efd73b855a3d9c7fcf32"}, + {file = "greenlet-3.3.0-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:670d0f94cd302d81796e37299bcd04b95d62403883b24225c6b5271466612f45"}, + {file = "greenlet-3.3.0-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6cb3a8ec3db4a3b0eb8a3c25436c2d49e3505821802074969db017b87bc6a948"}, + {file = "greenlet-3.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2de5a0b09eab81fc6a382791b995b1ccf2b172a9fec934747a7a23d2ff291794"}, + {file = "greenlet-3.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4449a736606bd30f27f8e1ff4678ee193bc47f6ca810d705981cfffd6ce0d8c5"}, + {file = "greenlet-3.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:7652ee180d16d447a683c04e4c5f6441bae7ba7b17ffd9f6b3aff4605e9e6f71"}, + {file = "greenlet-3.3.0-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:b01548f6e0b9e9784a2c99c5651e5dc89ffcbe870bc5fb2e5ef864e9cc6b5dcb"}, + {file = "greenlet-3.3.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:349345b770dc88f81506c6861d22a6ccd422207829d2c854ae2af8025af303e3"}, + {file = "greenlet-3.3.0-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e8e18ed6995e9e2c0b4ed264d2cf89260ab3ac7e13555b8032b25a74c6d18655"}, + {file = "greenlet-3.3.0-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c024b1e5696626890038e34f76140ed1daf858e37496d33f2af57f06189e70d7"}, + {file = "greenlet-3.3.0-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:047ab3df20ede6a57c35c14bf5200fcf04039d50f908270d3f9a7a82064f543b"}, + {file = "greenlet-3.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2d9ad37fc657b1102ec880e637cccf20191581f75c64087a549e66c57e1ceb53"}, + {file = "greenlet-3.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:83cd0e36932e0e7f36a64b732a6f60c2fc2df28c351bae79fbaf4f8092fe7614"}, + {file = "greenlet-3.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:a7a34b13d43a6b78abf828a6d0e87d3385680eaf830cd60d20d52f249faabf39"}, + {file = "greenlet-3.3.0-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:a1e41a81c7e2825822f4e068c48cb2196002362619e2d70b148f20a831c00739"}, + {file = "greenlet-3.3.0-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9f515a47d02da4d30caaa85b69474cec77b7929b2e936ff7fb853d42f4bf8808"}, + {file = "greenlet-3.3.0-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7d2d9fd66bfadf230b385fdc90426fcd6eb64db54b40c495b72ac0feb5766c54"}, + {file = "greenlet-3.3.0-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:30a6e28487a790417d036088b3bcb3f3ac7d8babaa7d0139edbaddebf3af9492"}, + {file = "greenlet-3.3.0-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:087ea5e004437321508a8d6f20efc4cfec5e3c30118e1417ea96ed1d93950527"}, + {file = "greenlet-3.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ab97cf74045343f6c60a39913fa59710e4bd26a536ce7ab2397adf8b27e67c39"}, + {file = "greenlet-3.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5375d2e23184629112ca1ea89a53389dddbffcf417dad40125713d88eb5f96e8"}, + {file = "greenlet-3.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:9ee1942ea19550094033c35d25d20726e4f1c40d59545815e1128ac58d416d38"}, + {file = "greenlet-3.3.0-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:60c2ef0f578afb3c8d92ea07ad327f9a062547137afe91f38408f08aacab667f"}, + {file = "greenlet-3.3.0-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0a5d554d0712ba1de0a6c94c640f7aeba3f85b3a6e1f2899c11c2c0428da9365"}, + {file = "greenlet-3.3.0-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3a898b1e9c5f7307ebbde4102908e6cbfcb9ea16284a3abe15cab996bee8b9b3"}, + {file = "greenlet-3.3.0-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:dcd2bdbd444ff340e8d6bdf54d2f206ccddbb3ccfdcd3c25bf4afaa7b8f0cf45"}, + {file = "greenlet-3.3.0-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5773edda4dc00e173820722711d043799d3adb4f01731f40619e07ea2750b955"}, + {file = "greenlet-3.3.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ac0549373982b36d5fd5d30beb8a7a33ee541ff98d2b502714a09f1169f31b55"}, + {file = "greenlet-3.3.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d198d2d977460358c3b3a4dc844f875d1adb33817f0613f663a656f463764ccc"}, + {file = "greenlet-3.3.0-cp314-cp314-win_amd64.whl", hash = "sha256:73f51dd0e0bdb596fb0417e475fa3c5e32d4c83638296e560086b8d7da7c4170"}, + {file = "greenlet-3.3.0-cp314-cp314t-macosx_11_0_universal2.whl", hash = "sha256:d6ed6f85fae6cdfdb9ce04c9bf7a08d666cfcfb914e7d006f44f840b46741931"}, + {file = "greenlet-3.3.0-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d9125050fcf24554e69c4cacb086b87b3b55dc395a8b3ebe6487b045b2614388"}, + {file = "greenlet-3.3.0-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:87e63ccfa13c0a0f6234ed0add552af24cc67dd886731f2261e46e241608bee3"}, + {file = "greenlet-3.3.0-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2662433acbca297c9153a4023fe2161c8dcfdcc91f10433171cf7e7d94ba2221"}, + {file = "greenlet-3.3.0-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3c6e9b9c1527a78520357de498b0e709fb9e2f49c3a513afd5a249007261911b"}, + {file = "greenlet-3.3.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:286d093f95ec98fdd92fcb955003b8a3d054b4e2cab3e2707a5039e7b50520fd"}, + {file = "greenlet-3.3.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c10513330af5b8ae16f023e8ddbfb486ab355d04467c4679c5cfe4659975dd9"}, + {file = "greenlet-3.3.0.tar.gz", hash = "sha256:a82bb225a4e9e4d653dd2fb7b8b2d36e4fb25bc0165422a11e48b88e9e6f78fb"}, +] + [[package]] name = "h11" version = "0.16.0" @@ -2426,6 +2476,51 @@ files = [ {file = "soupsieve-2.8.tar.gz", hash = "sha256:e2dd4a40a628cb5f28f6d4b0db8800b8f581b65bb380b97de22ba5ca8d72572f"}, ] +[[package]] +name = "sqlalchemy" +version = "2.0.45" +requires_python = ">=3.7" +summary = "Database Abstraction Library" +groups = ["default"] +dependencies = [ + "greenlet>=1; platform_machine == \"win32\" or platform_machine == \"WIN32\" or platform_machine == \"AMD64\" or platform_machine == \"amd64\" or platform_machine == \"x86_64\" or platform_machine == \"ppc64le\" or platform_machine == \"aarch64\"", + "importlib-metadata; python_version < \"3.8\"", + "typing-extensions>=4.6.0", +] +files = [ + {file = "sqlalchemy-2.0.45-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2e90a344c644a4fa871eb01809c32096487928bd2038bf10f3e4515cb688cc56"}, + {file = "sqlalchemy-2.0.45-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b8c8b41b97fba5f62349aa285654230296829672fc9939cd7f35aab246d1c08b"}, + {file = "sqlalchemy-2.0.45-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:12c694ed6468333a090d2f60950e4250b928f457e4962389553d6ba5fe9951ac"}, + {file = "sqlalchemy-2.0.45-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f7d27a1d977a1cfef38a0e2e1ca86f09c4212666ce34e6ae542f3ed0a33bc606"}, + {file = "sqlalchemy-2.0.45-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d62e47f5d8a50099b17e2bfc1b0c7d7ecd8ba6b46b1507b58cc4f05eefc3bb1c"}, + {file = "sqlalchemy-2.0.45-cp311-cp311-win32.whl", hash = "sha256:3c5f76216e7b85770d5bb5130ddd11ee89f4d52b11783674a662c7dd57018177"}, + {file = "sqlalchemy-2.0.45-cp311-cp311-win_amd64.whl", hash = "sha256:a15b98adb7f277316f2c276c090259129ee4afca783495e212048daf846654b2"}, + {file = "sqlalchemy-2.0.45-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b3ee2aac15169fb0d45822983631466d60b762085bc4535cd39e66bea362df5f"}, + {file = "sqlalchemy-2.0.45-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba547ac0b361ab4f1608afbc8432db669bd0819b3e12e29fb5fa9529a8bba81d"}, + {file = "sqlalchemy-2.0.45-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:215f0528b914e5c75ef2559f69dca86878a3beeb0c1be7279d77f18e8d180ed4"}, + {file = "sqlalchemy-2.0.45-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:107029bf4f43d076d4011f1afb74f7c3e2ea029ec82eb23d8527d5e909e97aa6"}, + {file = "sqlalchemy-2.0.45-cp312-cp312-win32.whl", hash = "sha256:0c9f6ada57b58420a2c0277ff853abe40b9e9449f8d7d231763c6bc30f5c4953"}, + {file = "sqlalchemy-2.0.45-cp312-cp312-win_amd64.whl", hash = "sha256:8defe5737c6d2179c7997242d6473587c3beb52e557f5ef0187277009f73e5e1"}, + {file = "sqlalchemy-2.0.45-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fe187fc31a54d7fd90352f34e8c008cf3ad5d064d08fedd3de2e8df83eb4a1cf"}, + {file = "sqlalchemy-2.0.45-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:672c45cae53ba88e0dad74b9027dddd09ef6f441e927786b05bec75d949fbb2e"}, + {file = "sqlalchemy-2.0.45-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:470daea2c1ce73910f08caf10575676a37159a6d16c4da33d0033546bddebc9b"}, + {file = "sqlalchemy-2.0.45-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9c6378449e0940476577047150fd09e242529b761dc887c9808a9a937fe990c8"}, + {file = "sqlalchemy-2.0.45-cp313-cp313-win32.whl", hash = "sha256:4b6bec67ca45bc166c8729910bd2a87f1c0407ee955df110d78948f5b5827e8a"}, + {file = "sqlalchemy-2.0.45-cp313-cp313-win_amd64.whl", hash = "sha256:afbf47dc4de31fa38fd491f3705cac5307d21d4bb828a4f020ee59af412744ee"}, + {file = "sqlalchemy-2.0.45-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:83d7009f40ce619d483d26ac1b757dfe3167b39921379a8bd1b596cf02dab4a6"}, + {file = "sqlalchemy-2.0.45-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:d8a2ca754e5415cde2b656c27900b19d50ba076aa05ce66e2207623d3fe41f5a"}, + {file = "sqlalchemy-2.0.45-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7f46ec744e7f51275582e6a24326e10c49fbdd3fc99103e01376841213028774"}, + {file = "sqlalchemy-2.0.45-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:883c600c345123c033c2f6caca18def08f1f7f4c3ebeb591a63b6fceffc95cce"}, + {file = "sqlalchemy-2.0.45-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2c0b74aa79e2deade948fe8593654c8ef4228c44ba862bb7c9585c8e0db90f33"}, + {file = "sqlalchemy-2.0.45-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:8a420169cef179d4c9064365f42d779f1e5895ad26ca0c8b4c0233920973db74"}, + {file = "sqlalchemy-2.0.45-cp314-cp314-win32.whl", hash = "sha256:e50dcb81a5dfe4b7b4a4aa8f338116d127cb209559124f3694c70d6cd072b68f"}, + {file = "sqlalchemy-2.0.45-cp314-cp314-win_amd64.whl", hash = "sha256:4748601c8ea959e37e03d13dcda4a44837afcd1b21338e637f7c935b8da06177"}, + {file = "sqlalchemy-2.0.45-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cd337d3526ec5298f67d6a30bbbe4ed7e5e68862f0bf6dd21d289f8d37b7d60b"}, + {file = "sqlalchemy-2.0.45-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:9a62b446b7d86a3909abbcd1cd3cc550a832f99c2bc37c5b22e1925438b9367b"}, + {file = "sqlalchemy-2.0.45-py3-none-any.whl", hash = "sha256:5225a288e4c8cc2308dbdd874edad6e7d0fd38eac1e9e5f23503425c8eee20d0"}, + {file = "sqlalchemy-2.0.45.tar.gz", hash = "sha256:1632a4bda8d2d25703fdad6363058d882541bdaaee0e5e3ddfa0cd3229efce88"}, +] + [[package]] name = "stack-data" version = "0.6.3" @@ -2519,7 +2614,7 @@ name = "typing-extensions" version = "4.15.0" requires_python = ">=3.9" summary = "Backported and Experimental Type Hints for Python 3.9+" -groups = ["dev", "nb"] +groups = ["default", "dev", "nb"] files = [ {file = "typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548"}, {file = "typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466"}, diff --git a/pyproject.toml b/pyproject.toml index e8c8a37..c109dd2 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,11 +1,11 @@ [project] -name = "polluck-blockchain" +name = "dopt-pollublock-blockchain" version = "0.1.0" description = "blockchain module of the research project >Polluck<" authors = [ {name = "d-opt GmbH, resp. Florian Foerster", email = "f.foerster@d-opt.com"}, ] -dependencies = ["dopt-basics>=0.2.4"] +dependencies = ["dopt-basics>=0.2.4", "sqlalchemy>=2.0.45"] requires-python = ">=3.11" readme = "README.md" license = {text = "LicenseRef-Proprietary"} diff --git a/setup.py b/setup.py index 49d96d1..93ebfae 100644 --- a/setup.py +++ b/setup.py @@ -27,8 +27,8 @@ openssl_lib = OPENSSL_DIR / "lib" assert openssl_lib.exists() ext = Extension( - name="polluck_blockchain.placeholder_native", - sources=["src/polluck_blockchain/placeholder_native.pyx"], + name="dopt_pollublock_blockchain.blockchain", + sources=["src/dopt_pollublock_blockchain/blockchain.pyx"], include_dirs=[str(openssl_include)], library_dirs=[str(openssl_lib)], libraries=["libssl", "libcrypto"], diff --git a/src/polluck_blockchain/__init__.py b/src/dopt_pollublock_blockchain/__init__.py similarity index 100% rename from src/polluck_blockchain/__init__.py rename to src/dopt_pollublock_blockchain/__init__.py diff --git a/src/polluck_blockchain/block.hpp b/src/dopt_pollublock_blockchain/block.hpp similarity index 100% rename from src/polluck_blockchain/block.hpp rename to src/dopt_pollublock_blockchain/block.hpp diff --git a/src/polluck_blockchain/block.pxd b/src/dopt_pollublock_blockchain/block.pxd similarity index 100% rename from src/polluck_blockchain/block.pxd rename to src/dopt_pollublock_blockchain/block.pxd diff --git a/src/dopt_pollublock_blockchain/blockchain.cpp b/src/dopt_pollublock_blockchain/blockchain.cpp new file mode 100644 index 0000000..612306e --- /dev/null +++ b/src/dopt_pollublock_blockchain/blockchain.cpp @@ -0,0 +1,21001 @@ +/* Generated by Cython 3.2.3 */ + +/* BEGIN: Cython Metadata +{ + "distutils": { + "depends": [ + "A:\\Arbeitsaufgaben\\Pollu-Block-projects\\blockchain\\openssl\\include\\openssl\\evp.h", + "src\\dopt_pollublock_blockchain\\block.hpp" + ], + "include_dirs": [ + "src\\dopt_pollublock_blockchain", + "A:\\Arbeitsaufgaben\\Pollu-Block-projects\\blockchain\\openssl\\include" + ], + "language": "c++", + "libraries": [ + "libssl", + "libcrypto" + ], + "library_dirs": [ + "A:\\Arbeitsaufgaben\\Pollu-Block-projects\\blockchain\\openssl\\lib" + ], + "name": "dopt_pollublock_blockchain.blockchain", + "sources": [ + "src/dopt_pollublock_blockchain/blockchain.pyx" + ] + }, + "module_name": "dopt_pollublock_blockchain.blockchain" +} +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 < 0x03080000 + #error Cython requires Python 3.8+. +#else +#define __PYX_ABI_VERSION "3_2_3" +#define CYTHON_HEX_VERSION 0x030203F0 +#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 +#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(GRAALVM_PYTHON) + /* For very preliminary testing purposes. Most variables are set the same as PyPy. + The existence of this section does not imply that anything works or is even tested */ + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 1 + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #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 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 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 + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 + #undef CYTHON_IMMORTAL_CONSTANTS + #define CYTHON_IMMORTAL_CONSTANTS 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 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #if PY_VERSION_HEX < 0x03090000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PYPY_VERSION_NUM >= 0x07030C00) + #endif + #undef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_NUM >= 0x07031100) + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 + #undef CYTHON_IMMORTAL_CONSTANTS + #define CYTHON_IMMORTAL_CONSTANTS 0 +#elif defined(CYTHON_LIMITED_API) + #ifdef Py_LIMITED_API + #undef __PYX_LIMITED_VERSION_HEX + #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API + #endif + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 1 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + #undef CYTHON_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_METH_FASTCALL + #define CYTHON_METH_FASTCALL (__PYX_LIMITED_VERSION_HEX >= 0x030C0000) + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif + #undef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #endif + #ifndef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND (__PYX_LIMITED_VERSION_HEX >= 0x030A0000) + #endif + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 1 + #endif + #undef CYTHON_IMMORTAL_CONSTANTS + #define CYTHON_IMMORTAL_CONSTANTS 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_METH_FASTCALL + #define CYTHON_METH_FASTCALL 1 + #endif + #ifndef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 1 + #endif + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 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_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 +#endif +#ifndef CYTHON_COMPRESS_STRINGS + #define CYTHON_COMPRESS_STRINGS 1 +#endif +#ifndef CYTHON_FAST_PYCCALL +#define CYTHON_FAST_PYCCALL CYTHON_FAST_PYCALL +#endif +#ifndef CYTHON_VECTORCALL +#if CYTHON_COMPILING_IN_LIMITED_API +#define CYTHON_VECTORCALL (__PYX_LIMITED_VERSION_HEX >= 0x030C0000) +#else +#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL) +#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 + #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 +#ifndef Py_UNREACHABLE + #define Py_UNREACHABLE() assert(0); abort() +#endif +#ifdef __cplusplus + template + struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; + #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) +#else + #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) +#endif +#if CYTHON_COMPILING_IN_PYPY == 1 + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX < 0x030A0000) +#else + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX < 0x03090000) +#endif +#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) + +/* CppInitCode */ +#ifndef __cplusplus + #error "Cython files generated with the C++ option must be compiled with a C++ compiler." +#endif +#ifndef CYTHON_INLINE + #if defined(__clang__) + #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) + #else + #define CYTHON_INLINE inline + #endif +#endif +template +void __Pyx_call_destructor(T& x) { + x.~T(); +} +template +class __Pyx_FakeReference { + public: + __Pyx_FakeReference() : ptr(NULL) { } + __Pyx_FakeReference(const T& ref) : ptr(const_cast(&ref)) { } + T *operator->() { return ptr; } + T *operator&() { return ptr; } + operator T&() { return *ptr; } + template bool operator ==(const U& other) const { return *ptr == other; } + template bool operator !=(const U& other) const { return *ptr != other; } + template bool operator==(const __Pyx_FakeReference& other) const { return *ptr == *other.ptr; } + template bool operator!=(const __Pyx_FakeReference& other) const { return *ptr != *other.ptr; } + private: + T *ptr; +}; + +/* 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 >= 0x030900A4 || defined(Py_IS_TYPE) + #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) +#else + #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) + #define __Pyx_Py_Is(x, y) Py_Is(x, y) +#else + #define __Pyx_Py_Is(x, y) ((x) == (y)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) + #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) +#else + #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) + #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) +#else + #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) + #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) +#else + #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) +#endif +#define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) +#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) +#else + #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#ifndef Py_TPFLAGS_SEQUENCE + #define Py_TPFLAGS_SEQUENCE 0 +#endif +#ifndef Py_TPFLAGS_MAPPING + #define Py_TPFLAGS_MAPPING 0 +#endif +#ifndef 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 +#ifndef METH_FASTCALL + #ifndef METH_FASTCALL + #define METH_FASTCALL 0x80 + #endif + typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); + typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, + Py_ssize_t nargs, PyObject *kwnames); +#else + #if PY_VERSION_HEX >= 0x030d00A4 + # define __Pyx_PyCFunctionFast PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords + #else + # define __Pyx_PyCFunctionFast _PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #endif +#endif +#if CYTHON_METH_FASTCALL + #define __Pyx_METH_FASTCALL METH_FASTCALL + #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast + #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords +#else + #define __Pyx_METH_FASTCALL METH_VARARGS + #define __Pyx_PyCFunction_FastCall PyCFunction + #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords +#endif +#if CYTHON_VECTORCALL + #define __pyx_vectorcallfunc vectorcallfunc + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET + #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) +#else + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) +#endif +#if PY_VERSION_HEX >= 0x030900B1 +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) +#else +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) +#endif +#define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) +#elif !CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) +#endif +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) +static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { + return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; +} +#endif +static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void (*cfunc)(void)) { +#if CYTHON_COMPILING_IN_LIMITED_API + return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; +#else + return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +#endif +} +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) +#if PY_VERSION_HEX < 0x03090000 || (CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000) + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) + typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); +#else + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) + #define __Pyx_PyCMethod PyCMethod +#endif +#ifndef METH_METHOD + #define METH_METHOD 0x200 +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) + #define PyObject_Malloc(s) PyMem_Malloc(s) + #define PyObject_Free(p) PyMem_Free(p) + #define PyObject_Realloc(p) PyMem_Realloc(p) +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_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_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_Clear(); + return res; +} +#elif !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000 +#define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#else +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { +#if CYTHON_COMPILING_IN_PYPY + return PyDict_GetItem(dict, name); +#else + PyDictEntry *ep; + PyDictObject *mp = (PyDictObject*) dict; + long hash = ((PyStringObject *) name)->ob_shash; + assert(hash != -1); + ep = (mp->ma_lookup)(mp, name, hash); + if (ep == NULL) { + return NULL; + } + return ep->me_value; +#endif +} +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#endif +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) + #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) +#else + #define __Pyx_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_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 && PY_VERSION_HEX >= 0x03090000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #endif + #endif +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #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) __Pyx_IS_TYPE(obj, &PySet_Type) +#endif +#if PY_VERSION_HEX >= 0x030900A4 + #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) +#else + #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) +#endif +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 CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + #define __Pyx_PyList_GetItemRef(o, i) PyList_GetItemRef(o, i) + #elif CYTHON_COMPILING_IN_LIMITED_API || !CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PyList_GetItemRef(o, i) (likely((i) >= 0) ? PySequence_GetItem(o, i) : (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) + #else + #define __Pyx_PyList_GetItemRef(o, i) PySequence_ITEM(o, i) + #endif +#elif CYTHON_COMPILING_IN_LIMITED_API || !CYTHON_ASSUME_SAFE_MACROS + #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + #define __Pyx_PyList_GetItemRef(o, i) PyList_GetItemRef(o, i) + #else + #define __Pyx_PyList_GetItemRef(o, i) __Pyx_XNewRef(PyList_GetItem(o, i)) + #endif +#else + #define __Pyx_PyList_GetItemRef(o, i) __Pyx_NewRef(PyList_GET_ITEM(o, i)) +#endif +#if CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS && !CYTHON_COMPILING_IN_LIMITED_API && CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PyList_GetItemRefFast(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_GetItemRefFast(o, i, unsafe_shared) __Pyx_PyList_GetItemRef(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_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) + #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GET_LENGTH(o) +#else + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) + #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GetLength(o) +#endif +#if 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 PY_VERSION_HEX >= 0x03090000 +#define __Pyx_PyInterpreterState_Get() PyInterpreterState_Get() +#else +#define __Pyx_PyInterpreterState_Get() PyThreadState_Get()->interp +#endif +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030A0000 +#ifdef __cplusplus +extern "C" +#endif +PyAPI_FUNC(void *) PyMem_Calloc(size_t nelem, size_t elsize); +#endif +#if CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_init_co_variable(PyObject *inspect, const char* name, int *write_to) { + int value; + PyObject *py_value = PyObject_GetAttrString(inspect, name); + if (!py_value) return 0; + value = (int) PyLong_AsLong(py_value); + Py_DECREF(py_value); + *write_to = value; + return value != -1 || !PyErr_Occurred(); +} +static int __Pyx_init_co_variables(void) { + PyObject *inspect; + int result; + inspect = PyImport_ImportModule("inspect"); + result = +#if !defined(CO_OPTIMIZED) + __Pyx_init_co_variable(inspect, "CO_OPTIMIZED", &CO_OPTIMIZED) && +#endif +#if !defined(CO_NEWLOCALS) + __Pyx_init_co_variable(inspect, "CO_NEWLOCALS", &CO_NEWLOCALS) && +#endif +#if !defined(CO_VARARGS) + __Pyx_init_co_variable(inspect, "CO_VARARGS", &CO_VARARGS) && +#endif +#if !defined(CO_VARKEYWORDS) + __Pyx_init_co_variable(inspect, "CO_VARKEYWORDS", &CO_VARKEYWORDS) && +#endif +#if !defined(CO_ASYNC_GENERATOR) + __Pyx_init_co_variable(inspect, "CO_ASYNC_GENERATOR", &CO_ASYNC_GENERATOR) && +#endif +#if !defined(CO_GENERATOR) + __Pyx_init_co_variable(inspect, "CO_GENERATOR", &CO_GENERATOR) && +#endif +#if !defined(CO_COROUTINE) + __Pyx_init_co_variable(inspect, "CO_COROUTINE", &CO_COROUTINE) && +#endif + 1; + Py_DECREF(inspect); + return result ? 0 : -1; +} +#else +static int __Pyx_init_co_variables(void) { + return 0; // It's a limited API-only feature +} +#endif + +/* 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 + #define __PYX_EXTERN_C extern "C++" +#endif + +#define __PYX_HAVE__dopt_pollublock_blockchain__blockchain +#define __PYX_HAVE_API__dopt_pollublock_blockchain__blockchain +/* Early includes */ +#include +#include +#include "ios" +#include "new" +#include "stdexcept" +#include "typeinfo" +#include +#include +#include "block.hpp" +#include + + #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600) + // move should be defined for these versions of MSVC, but __cplusplus isn't set usefully + #include + + namespace cython_std { + template typename std::remove_reference::type&& move(T& t) noexcept { return std::move(t); } + template typename std::remove_reference::type&& move(T&& t) noexcept { return std::move(t); } + } + + #endif + +#include +#include +#include +#include "openssl/evp.h" +#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_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) +#else +#define __Pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#define __Pyx_PyFloat_AS_DOUBLE(x) PyFloat_AsDouble(x) +#endif +#define __Pyx_PyFloat_AsFloat(x) ((float) __Pyx_PyFloat_AsDouble(x)) +#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_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK) + #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) + #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) + #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) + #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_SignedDigitCount(x)\ + ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) + #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) + #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) + #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) + #else + #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) + #endif + typedef Py_ssize_t __Pyx_compact_pylong; + typedef size_t __Pyx_compact_upylong; + #else + #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) + #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) + #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) + #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) + #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) + #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) + #define __Pyx_PyLong_CompactValue(x)\ + ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) + typedef sdigit __Pyx_compact_pylong; + typedef digit __Pyx_compact_upylong; + #endif + #if PY_VERSION_HEX >= 0x030C00A5 + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) + #else + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) + #endif +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#elif __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeASCII(c_str, size, NULL) +#else + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#endif + + +/* 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 int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * const __pyx_cfilenm = __FILE__; +static const char *__pyx_filename; + +/* #### Code section: filename_table ### */ + +static const char* const __pyx_f[] = { + "src/dopt_pollublock_blockchain/blockchain.pyx", + "", +}; +/* #### 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 + +/* ForceInitThreads.proto */ +#ifndef __PYX_FORCE_INIT_THREADS + #define __PYX_FORCE_INIT_THREADS 0 +#endif + +/* NoFastGil.proto */ +#define __Pyx_PyGILState_Ensure PyGILState_Ensure +#define __Pyx_PyGILState_Release PyGILState_Release +#define __Pyx_FastGIL_Remember() +#define __Pyx_FastGIL_Forget() +#define __Pyx_FastGilFuncInit() + +/* IncludeStructmemberH.proto (used by FixUpExtensionType) */ +#include + +/* #### Code section: numeric_typedefs ### */ + +/* "dopt_pollublock_blockchain/blockchain.pyx":26 + * + * + * ctypedef unsigned long ULong # <<<<<<<<<<<<<< + * ctypedef unordered_map[uint64_t, Block*] BcHashmap + * cdef const size_t NONCE_OFFSET = 16 +*/ +typedef unsigned long __pyx_t_26dopt_pollublock_blockchain_10blockchain_ULong; +/* #### Code section: complex_type_declarations ### */ +/* #### Code section: type_declarations ### */ + +/*--- Type declarations ---*/ +struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock; +struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain; +struct __pyx_opt_args_26dopt_pollublock_blockchain_10blockchain_7PyBlock_from_ptr; +struct __pyx_opt_args_26dopt_pollublock_blockchain_10blockchain_mine_block; + +/* "dopt_pollublock_blockchain/blockchain.pyx":27 + * + * ctypedef unsigned long ULong + * ctypedef unordered_map[uint64_t, Block*] BcHashmap # <<<<<<<<<<<<<< + * cdef const size_t NONCE_OFFSET = 16 + * +*/ +typedef std::unordered_map __pyx_t_26dopt_pollublock_blockchain_10blockchain_BcHashmap; + +/* "dopt_pollublock_blockchain/blockchain.pyx":122 + * + * @staticmethod + * cdef PyBlock from_ptr(Block *block, bint owner=False): # <<<<<<<<<<<<<< + * cdef PyBlock py_block = PyBlock.__new__( + * PyBlock, +*/ +struct __pyx_opt_args_26dopt_pollublock_blockchain_10blockchain_7PyBlock_from_ptr { + int __pyx_n; + int owner; +}; + +/* "dopt_pollublock_blockchain/blockchain.pyx":292 + * + * + * cdef int mine_block(Block *block, unsigned int difficulty, uint64_t *nonce_solution, unsigned int max_nonce=0xFFFFFFFF) nogil: # <<<<<<<<<<<<<< + * cdef: + * unsigned char *serial_buf +*/ +struct __pyx_opt_args_26dopt_pollublock_blockchain_10blockchain_mine_block { + int __pyx_n; + unsigned int max_nonce; +}; + +/* "dopt_pollublock_blockchain/blockchain.pyx":86 + * + * + * cdef class PyBlock: # <<<<<<<<<<<<<< + * cdef: + * Block *BlockC +*/ +struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock { + PyObject_HEAD + struct __pyx_vtabstruct_26dopt_pollublock_blockchain_10blockchain_PyBlock *__pyx_vtab; + ::Block *BlockC; + int ptr_owner; +}; + + +/* "dopt_pollublock_blockchain/blockchain.pyx":323 + * + * + * cdef class Blockchain: # <<<<<<<<<<<<<< + * cdef: + * unsigned int _difficulty +*/ +struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain { + PyObject_HEAD + struct __pyx_vtabstruct_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_vtab; + unsigned int _difficulty; + uint64_t _index; + __pyx_t_26dopt_pollublock_blockchain_10blockchain_BcHashmap *_chain_map; + std::vector<::Block *> *_chain; + int _genesis_done; + int _loaded; + PyObject *db_path; + PyObject *_engine; +}; + + + +/* "dopt_pollublock_blockchain/blockchain.pyx":86 + * + * + * cdef class PyBlock: # <<<<<<<<<<<<<< + * cdef: + * Block *BlockC +*/ + +struct __pyx_vtabstruct_26dopt_pollublock_blockchain_10blockchain_PyBlock { + struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *(*from_ptr)(::Block *, struct __pyx_opt_args_26dopt_pollublock_blockchain_10blockchain_7PyBlock_from_ptr *__pyx_optional_args); +}; +static struct __pyx_vtabstruct_26dopt_pollublock_blockchain_10blockchain_PyBlock *__pyx_vtabptr_26dopt_pollublock_blockchain_10blockchain_PyBlock; + + +/* "dopt_pollublock_blockchain/blockchain.pyx":323 + * + * + * cdef class Blockchain: # <<<<<<<<<<<<<< + * cdef: + * unsigned int _difficulty +*/ + +struct __pyx_vtabstruct_26dopt_pollublock_blockchain_10blockchain_Blockchain { + ::Block *(*get_block_c)(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *, uint64_t); + void (*add_block_from_loading)(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *, ::Block *); + int (*add_block)(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *, ::Block *); + std::string (*hash_data)(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *, PyObject *); + PyObject *(*load_from_batch)(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *, PyObject *); +}; +static struct __pyx_vtabstruct_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_vtabptr_26dopt_pollublock_blockchain_10blockchain_Blockchain; +/* #### 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) + +/* 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 + +/* 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 PyObjectGetAttrStrNoError) */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6 +#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) +#else +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#endif +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + +/* PyObjectGetAttrStr.proto (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); + +/* 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 + +/* 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 PyObjectFastCallMethod) */ +#define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject * const*args, size_t nargs, PyObject *kwargs); + +/* PyObjectFastCallMethod.proto */ +#if CYTHON_VECTORCALL && PY_VERSION_HEX >= 0x03090000 +#define __Pyx_PyObject_FastCallMethod(name, args, nargsf) PyObject_VectorcallMethod(name, args, nargsf, NULL) +#else +static PyObject *__Pyx_PyObject_FastCallMethod(PyObject *name, PyObject *const *args, size_t nargsf); +#endif + +/* PyObjectVectorCallKwBuilder.proto (used by PyObjectVectorCallMethodKwBuilder) */ +CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n); +#if CYTHON_VECTORCALL +#if PY_VERSION_HEX >= 0x03090000 +#define __Pyx_Object_Vectorcall_CallFromBuilder PyObject_Vectorcall +#else +#define __Pyx_Object_Vectorcall_CallFromBuilder _PyObject_Vectorcall +#endif +#define __Pyx_MakeVectorcallBuilderKwds(n) PyTuple_New(n) +static int __Pyx_VectorcallBuilder_AddArg(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n); +static int __Pyx_VectorcallBuilder_AddArgStr(const char *key, PyObject *value, PyObject *builder, PyObject **args, int n); +#else +#define __Pyx_Object_Vectorcall_CallFromBuilder __Pyx_PyObject_FastCallDict +#define __Pyx_MakeVectorcallBuilderKwds(n) __Pyx_PyDict_NewPresized(n) +#define __Pyx_VectorcallBuilder_AddArg(key, value, builder, args, n) PyDict_SetItem(builder, key, value) +#define __Pyx_VectorcallBuilder_AddArgStr(key, value, builder, args, n) PyDict_SetItemString(builder, key, value) +#endif + +/* PyObjectVectorCallMethodKwBuilder.proto */ +#if CYTHON_VECTORCALL && PY_VERSION_HEX >= 0x03090000 +#define __Pyx_Object_VectorcallMethod_CallFromBuilder PyObject_VectorcallMethod +#else +static PyObject *__Pyx_Object_VectorcallMethod_CallFromBuilder(PyObject *name, PyObject *const *args, size_t nargsf, PyObject *kwnames); +#endif + +/* DivInt[long].proto */ +static CYTHON_INLINE long __Pyx_div_long(long, long, int b_is_constant); + +/* ModInt[long].proto */ +static CYTHON_INLINE long __Pyx_mod_long(long, long, int b_is_constant); + +/* TupleAndListFromArray.proto (used by fastcall) */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); +#endif +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); +#endif + +/* IncludeStringH.proto (used by BytesEquals) */ +#include + +/* BytesEquals.proto (used by UnicodeEquals) */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); + +/* UnicodeEquals.proto (used by fastcall) */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); + +/* fastcall.proto */ +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_PySequence_ITEM(args, i) +#elif CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_NewRef(__Pyx_PyTuple_GET_ITEM(args, i)) +#else + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_XNewRef(PyTuple_GetItem(args, i)) +#endif +#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) +#define __Pyx_KwValues_VARARGS(args, nargs) NULL +#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) +#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) +#if CYTHON_METH_FASTCALL + #define __Pyx_ArgRef_FASTCALL(args, i) __Pyx_NewRef(args[i]) + #define __Pyx_NumKwargs_FASTCALL(kwds) __Pyx_PyTuple_GET_SIZE(kwds) + #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) + static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API + CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); + #else + #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) + #endif +#else + #define __Pyx_ArgRef_FASTCALL __Pyx_ArgRef_VARARGS + #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS + #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS + #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS + #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS +#endif +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) +#if CYTHON_METH_FASTCALL || (CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(args + start, stop - start) +#else +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) +#endif + +/* py_dict_items.proto (used by OwnedDictNext) */ +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) + +/* PyObjectCallOneArg.proto (used by CallUnboundCMethod0) */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* UnpackUnboundCMethod.proto (used by CallUnboundCMethod0) */ +typedef struct { + PyObject *type; + PyObject **method_name; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && CYTHON_ATOMICS + __pyx_atomic_int_type initialized; +#endif + PyCFunction func; + PyObject *method; + int flag; +} __Pyx_CachedCFunction; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +static CYTHON_INLINE int __Pyx_CachedCFunction_GetAndSetInitializing(__Pyx_CachedCFunction *cfunc) { +#if !CYTHON_ATOMICS + return 1; +#else + __pyx_nonatomic_int_type expected = 0; + if (__pyx_atomic_int_cmp_exchange(&cfunc->initialized, &expected, 1)) { + return 0; + } + return expected; +#endif +} +static CYTHON_INLINE void __Pyx_CachedCFunction_SetFinishedInitializing(__Pyx_CachedCFunction *cfunc) { +#if CYTHON_ATOMICS + __pyx_atomic_store(&cfunc->initialized, 2); +#endif +} +#else +#define __Pyx_CachedCFunction_GetAndSetInitializing(cfunc) 2 +#define __Pyx_CachedCFunction_SetFinishedInitializing(cfunc) +#endif + +/* 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) */ +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.proto */ +static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, + Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); + +/* KeywordStringCheck.proto */ +static CYTHON_INLINE int __Pyx_CheckKeywordStrings(const char* function_name, PyObject *kw); + +/* 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 + +/* JoinPyUnicode.export */ +static PyObject* __Pyx_PyUnicode_Join(PyObject** values, Py_ssize_t value_count, Py_ssize_t result_ulength, + Py_UCS4 max_char); + +/* RejectKeywords.export */ +static void __Pyx_RejectKeywords(const char* function_name, PyObject *kwds); + +/* IncludeCppStringH.proto (used by decode_cpp_string) */ +#include + +/* decode_c_string_utf16.proto (used by decode_c_bytes) */ +static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16(const char *s, Py_ssize_t size, const char *errors) { + int byteorder = 0; + return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); +} +static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16LE(const char *s, Py_ssize_t size, const char *errors) { + int byteorder = -1; + return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); +} +static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16BE(const char *s, Py_ssize_t size, const char *errors) { + int byteorder = 1; + return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); +} + +/* decode_c_bytes.proto (used by decode_cpp_string) */ +static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes( + const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)); + +/* decode_cpp_string.proto */ +static CYTHON_INLINE PyObject* __Pyx_decode_cpp_string( + std::string cppstring, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { + return __Pyx_decode_c_bytes( + cppstring.data(), (Py_ssize_t) cppstring.size(), start, stop, encoding, errors, decode_func); +} + +/* 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 + +/* SwapException.proto */ +#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 + +/* 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 + +/* MoveIfSupported.proto */ +#if CYTHON_USE_CPP_STD_MOVE + #include + #define __PYX_STD_MOVE_IF_SUPPORTED(x) std::move(x) +#else + #define __PYX_STD_MOVE_IF_SUPPORTED(x) x +#endif + +/* PyTypeError_Check.proto */ +#define __Pyx_PyExc_TypeError_Check(obj) __Pyx_TypeCheck(obj, PyExc_TypeError) + +/* RaiseException.export */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* ErrOccurredWithGIL.proto */ +static CYTHON_INLINE int __Pyx_ErrOccurredWithGIL(void); + +/* ReleaseUnknownGil.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 +typedef struct { + PyThreadState* ts; + PyGILState_STATE gil_state; +} __Pyx_UnknownThreadState; +#else +#define __Pyx_UnknownThreadState PyThreadState* +#endif +static __Pyx_UnknownThreadState __Pyx_SaveUnknownThread(void); +static void __Pyx_RestoreUnknownThread(__Pyx_UnknownThreadState state); +static CYTHON_INLINE int __Pyx_UnknownThreadStateDefinitelyHadGil(__Pyx_UnknownThreadState state); +static CYTHON_INLINE int __Pyx_UnknownThreadStateMayHaveHadGil(__Pyx_UnknownThreadState state); + +/* PyMemoryError_Check.proto */ +#define __Pyx_PyExc_MemoryError_Check(obj) __Pyx_TypeCheck(obj, PyExc_MemoryError) + +/* PyFileNotFoundError_Check.proto */ +#define __Pyx_PyExc_FileNotFoundError_Check(obj) __Pyx_TypeCheck(obj, PyExc_FileNotFoundError) + +/* PyObject_Unicode.proto */ +#define __Pyx_PyObject_Unicode(obj)\ + (likely(PyUnicode_CheckExact(obj)) ? __Pyx_NewRef(obj) : PyObject_Str(obj)) + +/* PyRuntimeError_Check.proto */ +#define __Pyx_PyExc_RuntimeError_Check(obj) __Pyx_TypeCheck(obj, PyExc_RuntimeError) + +/* GetItemInt.proto */ +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil, unsafe_shared)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck, unsafe_shared) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ + __Pyx_GetItemInt_Generic(o, to_py_func(i)))) +#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil, 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, is_list, 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 is_list, int wraparound, int boundscheck, int unsafe_shared); + +/* PyValueError_Check.proto */ +#define __Pyx_PyExc_ValueError_Check(obj) __Pyx_TypeCheck(obj, PyExc_ValueError) + +/* PyIndexError_Check.proto */ +#define __Pyx_PyExc_IndexError_Check(obj) __Pyx_TypeCheck(obj, PyExc_IndexError) + +/* 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); + +/* ListAppend.proto */ +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS +static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { + PyListObject* L = (PyListObject*) list; + Py_ssize_t len = Py_SIZE(list); + if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { + Py_INCREF(x); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 + L->ob_item[len] = x; + #else + PyList_SET_ITEM(list, len, x); + #endif + __Pyx_SET_SIZE(list, len + 1); + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_PyList_Append(L,x) PyList_Append(L,x) +#endif + +/* 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 + +/* RaiseUnboundLocalError.proto */ +static void __Pyx_RaiseUnboundLocalError(const char *varname); + +/* AllocateExtensionType.proto */ +static PyObject *__Pyx_AllocateExtensionType(PyTypeObject *t, int is_final); + +/* CallTypeTraverse.proto */ +#if !CYTHON_USE_TYPE_SPECS || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x03090000) +#define __Pyx_call_type_traverse(o, always_call, visit, arg) 0 +#else +static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg); +#endif + +/* LimitedApiGetTypeDict.proto (used by SetItemOnTypeDict) */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_GetTypeDict(PyTypeObject *tp); +#endif + +/* SetItemOnTypeDict.proto (used by FixUpExtensionType) */ +static int __Pyx__SetItemOnTypeDict(PyTypeObject *tp, PyObject *k, PyObject *v); +#define __Pyx_SetItemOnTypeDict(tp, k, v) __Pyx__SetItemOnTypeDict((PyTypeObject*)tp, k, v) + +/* FixUpExtensionType.proto */ +static CYTHON_INLINE int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); + +/* PyObjectCallNoArg.proto (used by PyObjectCallMethod0) */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); + +/* PyObjectGetMethod.proto (used by PyObjectCallMethod0) */ +#if !(CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000))) +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); +#endif + +/* PyObjectCallMethod0.proto (used by PyType_Ready) */ +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); + +/* 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, Py_ssize_t dictoffset, PyObject *bases); +#endif + +/* PyType_Ready.proto */ +CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t); + +/* SetVTable.proto */ +static int __Pyx_SetVtable(PyTypeObject* typeptr , void* vtable); + +/* GetVTable.proto (used by MergeVTables) */ +static void* __Pyx_GetVtable(PyTypeObject *type); + +/* MergeVTables.proto */ +static int __Pyx_MergeVtables(PyTypeObject *type); + +/* DelItemOnTypeDict.proto (used by SetupReduce) */ +static int __Pyx__DelItemOnTypeDict(PyTypeObject *tp, PyObject *k); +#define __Pyx_DelItemOnTypeDict(tp, k) __Pyx__DelItemOnTypeDict((PyTypeObject*)tp, k) + +/* SetupReduce.proto */ +static int __Pyx_setup_reduce(PyObject* type_obj); + +/* HasAttr.proto (used by ImportImpl) */ +#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 + +/* 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.proto */ +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 ) ||\ + __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); + +/* 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 + +/* PyMethodNew.proto (used by CythonFunctionShared) */ +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ); + +/* PyVectorcallFastCallDict.proto (used by CythonFunctionShared) */ +#if CYTHON_METH_FASTCALL && 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) */ +#define __Pyx_CyFunction_USED +#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 +#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 +#define __Pyx_CYFUNCTION_CCLASS 0x04 +#define __Pyx_CYFUNCTION_COROUTINE 0x08 +#define __Pyx_CyFunction_GetClosure(f)\ + (((__pyx_CyFunctionObject *) (f))->func_closure) +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_CyFunction_GetClassObj(f)\ + (((__pyx_CyFunctionObject *) (f))->func_classobj) +#else + #define __Pyx_CyFunction_GetClassObj(f)\ + ((PyObject*) ((PyCMethodObject *) (f))->mm_class) +#endif +#define __Pyx_CyFunction_SetClassObj(f, classobj)\ + __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj)) +#define __Pyx_CyFunction_Defaults(type, f)\ + ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) +#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ + ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) +typedef struct { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject_HEAD + PyObject *func; +#elif PY_VERSION_HEX < 0x030900B1 + PyCFunctionObject func; +#else + PyCMethodObject func; +#endif +#if CYTHON_COMPILING_IN_LIMITED_API && CYTHON_METH_FASTCALL + __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 PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_classobj; +#endif + PyObject *defaults; + int flags; + PyObject *defaults_tuple; + PyObject *defaults_kwdict; + PyObject *(*defaults_getter)(PyObject *); + PyObject *func_annotations; + PyObject *func_is_coroutine; +} __pyx_CyFunctionObject; +#undef __Pyx_CyOrPyCFunction_Check +#define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_mstate_global->__pyx_CyFunctionType) +#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_mstate_global->__pyx_CyFunctionType, &PyCFunction_Type) +#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_mstate_global->__pyx_CyFunctionType) +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)); +#undef __Pyx_IsSameCFunction +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCyOrCFunction(func, cfunc) +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); +static CYTHON_INLINE PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func, + PyTypeObject *defaults_type); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, + PyObject *tuple); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, + PyObject *dict); +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, + PyObject *dict); +static int __pyx_CyFunction_init(PyObject *module); +#if CYTHON_METH_FASTCALL +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +#if CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall) +#else +#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall) +#endif +#endif + +/* CythonFunction.proto */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); + +/* CLineInTraceback.proto (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); + +/* CppExceptionConversion.proto */ +#ifndef __Pyx_CppExn2PyErr +#include +#include +#include +#include +static void __Pyx_CppExn2PyErr() { + try { + if (PyErr_Occurred()) + ; // let the latest Python exn pass through and ignore the current one + else + throw; + } catch (const std::bad_alloc& exn) { + PyErr_SetString(PyExc_MemoryError, exn.what()); + } catch (const std::bad_cast& exn) { + PyErr_SetString(PyExc_TypeError, exn.what()); + } catch (const std::bad_typeid& exn) { + PyErr_SetString(PyExc_TypeError, exn.what()); + } catch (const std::domain_error& exn) { + PyErr_SetString(PyExc_ValueError, exn.what()); + } catch (const std::invalid_argument& exn) { + PyErr_SetString(PyExc_ValueError, exn.what()); + } catch (const std::ios_base::failure& exn) { + PyErr_SetString(PyExc_IOError, exn.what()); + } catch (const std::out_of_range& exn) { + PyErr_SetString(PyExc_IndexError, exn.what()); + } catch (const std::overflow_error& exn) { + PyErr_SetString(PyExc_OverflowError, exn.what()); + } catch (const std::range_error& exn) { + PyErr_SetString(PyExc_ArithmeticError, exn.what()); + } catch (const std::underflow_error& exn) { + PyErr_SetString(PyExc_ArithmeticError, exn.what()); + } catch (const std::exception& exn) { + PyErr_SetString(PyExc_RuntimeError, exn.what()); + } + catch (...) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown exception"); + } +} +#endif + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_uint64_t(uint64_t value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE uint64_t __Pyx_PyLong_As_uint64_t(PyObject *); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_int(int value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_unsigned_int(unsigned int value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE unsigned int __Pyx_PyLong_As_unsigned_int(PyObject *); + +/* FormatTypeName.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%U" +#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 +#define __Pyx_PyType_GetFullyQualifiedName PyType_GetFullyQualifiedName +#else +static __Pyx_TypeName __Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp); +#endif +#else // !LIMITED_API +typedef const char *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%.200s" +#define __Pyx_PyType_GetFullyQualifiedName(tp) ((tp)->tp_name) +#define __Pyx_DECREF_TypeName(obj) +#endif + +/* CIntFromPy.proto */ +static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *); + +/* FastTypeChecks.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); +#else +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) +#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2) { + return PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2); +} +#endif +#define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) +#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) +#ifdef PyExceptionInstance_Check + #define __Pyx_PyBaseException_Check(obj) PyExceptionInstance_Check(obj) +#else + #define __Pyx_PyBaseException_Check(obj) __Pyx_TypeCheck(obj, PyExc_BaseException) +#endif + +/* GetRuntimeVersion.proto */ +#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); + +/* 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); + +/* MultiPhaseInitModuleState.proto */ +#if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE +static PyObject *__Pyx_State_FindModule(void*); +static int __Pyx_State_AddModule(PyObject* module, void*); +static int __Pyx_State_RemoveModule(void*); +#elif CYTHON_USE_MODULE_STATE +#define __Pyx_State_FindModule PyState_FindModule +#define __Pyx_State_AddModule PyState_AddModule +#define __Pyx_State_RemoveModule PyState_RemoveModule +#endif + +/* #### Code section: module_declarations ### */ +/* CythonABIVersion.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API + #if CYTHON_METH_FASTCALL + #define __PYX_FASTCALL_ABI_SUFFIX "_fastcall" + #else + #define __PYX_FASTCALL_ABI_SUFFIX + #endif + #define __PYX_LIMITED_ABI_SUFFIX "limited" __PYX_FASTCALL_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX +#else + #define __PYX_LIMITED_ABI_SUFFIX +#endif +#if __PYX_HAS_PY_AM_SEND == 1 + #define __PYX_AM_SEND_ABI_SUFFIX +#elif __PYX_HAS_PY_AM_SEND == 2 + #define __PYX_AM_SEND_ABI_SUFFIX "amsendbackport" +#else + #define __PYX_AM_SEND_ABI_SUFFIX "noamsend" +#endif +#ifndef __PYX_MONITORING_ABI_SUFFIX + #define __PYX_MONITORING_ABI_SUFFIX +#endif +#if CYTHON_USE_TP_FINALIZE + #define __PYX_TP_FINALIZE_ABI_SUFFIX +#else + #define __PYX_TP_FINALIZE_ABI_SUFFIX "nofinalize" +#endif +#if CYTHON_USE_FREELISTS || !defined(__Pyx_AsyncGen_USED) + #define __PYX_FREELISTS_ABI_SUFFIX +#else + #define __PYX_FREELISTS_ABI_SUFFIX "nofreelists" +#endif +#define CYTHON_ABI __PYX_ABI_VERSION __PYX_LIMITED_ABI_SUFFIX __PYX_MONITORING_ABI_SUFFIX __PYX_TP_FINALIZE_ABI_SUFFIX __PYX_FREELISTS_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX +#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI +#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." + +static struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__pyx_f_26dopt_pollublock_blockchain_10blockchain_7PyBlock_from_ptr(::Block *__pyx_v_block, struct __pyx_opt_args_26dopt_pollublock_blockchain_10blockchain_7PyBlock_from_ptr *__pyx_optional_args); /* proto*/ +static ::Block *__pyx_f_26dopt_pollublock_blockchain_10blockchain_10Blockchain_get_block_c(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self, uint64_t __pyx_v_idx); /* proto*/ +static void __pyx_f_26dopt_pollublock_blockchain_10blockchain_10Blockchain_add_block_from_loading(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self, ::Block *__pyx_v_block); /* proto*/ +static int __pyx_f_26dopt_pollublock_blockchain_10blockchain_10Blockchain_add_block(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self, ::Block *__pyx_v_block); /* proto*/ +static std::string __pyx_f_26dopt_pollublock_blockchain_10blockchain_10Blockchain_hash_data(CYTHON_UNUSED struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self, PyObject *__pyx_v_data); /* proto*/ +static PyObject *__pyx_f_26dopt_pollublock_blockchain_10blockchain_10Blockchain_load_from_batch(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self, PyObject *__pyx_v_batch); /* proto*/ + +/* Module declarations from "libc.string" */ + +/* Module declarations from "libcpp.string_view" */ + +/* Module declarations from "libcpp.string" */ + +/* Module declarations from "libc" */ + +/* Module declarations from "libc.stdint" */ + +/* Module declarations from "dopt_pollublock_blockchain.block" */ + +/* Module declarations from "libcpp.utility" */ + +/* Module declarations from "libcpp.unordered_map" */ + +/* Module declarations from "libcpp.vector" */ + +/* Module declarations from "libc.stdlib" */ + +/* Module declarations from "dopt_pollublock_blockchain.openssl_evp" */ + +/* Module declarations from "dopt_pollublock_blockchain.blockchain" */ +static size_t const __pyx_v_26dopt_pollublock_blockchain_10blockchain_NONCE_OFFSET = ((size_t)16); +static PyObject *__pyx_f_26dopt_pollublock_blockchain_10blockchain_timestamp_to_datetime(uint64_t); /*proto*/ +static uint64_t __pyx_f_26dopt_pollublock_blockchain_10blockchain_current_timestamp_integer(void); /*proto*/ +static int __pyx_f_26dopt_pollublock_blockchain_10blockchain_serialize_uint64(unsigned char *, unsigned PY_LONG_LONG); /*proto*/ +static CYTHON_INLINE int __pyx_f_26dopt_pollublock_blockchain_10blockchain_has_leading_zero_bits(unsigned char const *, int); /*proto*/ +static unsigned char *__pyx_f_26dopt_pollublock_blockchain_10blockchain_bytes_serialize_c(::Block *, size_t *); /*proto*/ +static unsigned char *__pyx_f_26dopt_pollublock_blockchain_10blockchain_SHA256_digest(void const *, size_t, size_t *); /*proto*/ +static unsigned char *__pyx_f_26dopt_pollublock_blockchain_10blockchain_perform_hash_c(::Block *, size_t *); /*proto*/ +static int __pyx_f_26dopt_pollublock_blockchain_10blockchain_mine_block(::Block *, unsigned int, uint64_t *, struct __pyx_opt_args_26dopt_pollublock_blockchain_10blockchain_mine_block *__pyx_optional_args); /*proto*/ +static std::string __pyx_convert_string_from_py_6libcpp_6string_std__in_string(PyObject *); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_convert_PyObject_string_to_py_6libcpp_6string_std__in_string(std::string const &); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string(std::string const &); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_convert_PyBytes_string_to_py_6libcpp_6string_std__in_string(std::string const &); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_convert_PyByteArray_string_to_py_6libcpp_6string_std__in_string(std::string const &); /*proto*/ +/* #### Code section: typeinfo ### */ +/* #### Code section: before_global_var ### */ +#define __Pyx_MODULE_NAME "dopt_pollublock_blockchain.blockchain" +extern int __pyx_module_is_main_dopt_pollublock_blockchain__blockchain; +int __pyx_module_is_main_dopt_pollublock_blockchain__blockchain = 0; + +/* Implementation of "dopt_pollublock_blockchain.blockchain" */ +/* #### Code section: global_var ### */ +static PyObject *__pyx_builtin_print; +/* #### Code section: string_decls ### */ +/* #### Code section: decls ### */ +static int __pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock___cinit__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_nonce, PyObject *__pyx_v_data, PyObject *__pyx_v_previous_hash, PyObject *__pyx_v_from_ptr); /* proto */ +static int __pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_2__init__(CYTHON_UNUSED struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */ +static void __pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_4__dealloc__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_6__repr__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_8__str__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_10serialize_dict(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_5index___get__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_9timestamp___get__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_4data___get__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_9prev_hash___get__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_5nonce___get__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_4hash___get__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_12bytes_serialize(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_14perform_hash(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_16__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_18__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain___cinit__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */ +static int __pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_2__init__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self, PyObject *__pyx_v_db_path); /* proto */ +static void __pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_4__dealloc__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self); /* proto */ +static Py_ssize_t __pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_6__len__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_10difficulty___get__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self); /* proto */ +static int __pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_10difficulty_2__set__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_12genesis_done___get__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_5index___get__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_8_print_key_value_pair(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_10print_blocks(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self, PyObject *__pyx_v_max_num); /* proto */ +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_12get_block(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self, PyObject *__pyx_v_idx); /* proto */ +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_14create_genesis_block(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_16new_block(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self, PyObject *__pyx_v_data); /* proto */ +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_18validate(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_20get_saving_entries(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self, PyObject *__pyx_v_max_idx); /* proto */ +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_22save(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_24close_db_connections(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_26load(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self, PyObject *__pyx_v_batch_size); /* proto */ +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_7db_path___get__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_7_engine___get__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_28__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_30__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_tp_new_26dopt_pollublock_blockchain_10blockchain_PyBlock(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_26dopt_pollublock_blockchain_10blockchain_Blockchain(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +/* #### Code section: late_includes ### */ +/* #### Code section: module_state ### */ +/* SmallCodeConfig */ +#ifndef CYTHON_SMALL_CODE +#if defined(__clang__) + #define CYTHON_SMALL_CODE +#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) + #define CYTHON_SMALL_CODE __attribute__((cold)) +#else + #define CYTHON_SMALL_CODE +#endif +#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_26dopt_pollublock_blockchain_10blockchain_PyBlock; + PyObject *__pyx_type_26dopt_pollublock_blockchain_10blockchain_Blockchain; + PyTypeObject *__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_PyBlock; + PyTypeObject *__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_Blockchain; + __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_items; + __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_pop; + __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_values; + PyObject *__pyx_tuple[1]; + PyObject *__pyx_codeobj_tab[17]; + PyObject *__pyx_string_tab[188]; + PyObject *__pyx_number_tab[1]; +/* #### Code section: module_state_contents ### */ +/* CommonTypesMetaclass.module_state_decls */ +PyTypeObject *__pyx_CommonTypesMetaclassType; + +/* CachedMethodType.module_state_decls */ +#if CYTHON_COMPILING_IN_LIMITED_API +PyObject *__Pyx_CachedMethodType; +#endif + +/* CythonFunctionShared.module_state_decls */ +PyTypeObject *__pyx_CyFunctionType; + +/* CodeObjectCache.module_state_decls */ +struct __Pyx_CodeObjectCache __pyx_code_cache; + +/* #### Code section: module_state_end ### */ +} __pyx_mstatetype; + +#if CYTHON_USE_MODULE_STATE +#ifdef __cplusplus +namespace { +extern struct PyModuleDef __pyx_moduledef; +} /* anonymous namespace */ +#else +static struct PyModuleDef __pyx_moduledef; +#endif + +#define __pyx_mstate_global (__Pyx_PyModule_GetState(__Pyx_State_FindModule(&__pyx_moduledef))) + +#define __pyx_m (__Pyx_State_FindModule(&__pyx_moduledef)) +#else +static __pyx_mstatetype __pyx_mstate_global_static = +#ifdef __cplusplus + {}; +#else + {0}; +#endif +static __pyx_mstatetype * const __pyx_mstate_global = &__pyx_mstate_global_static; +#endif +/* #### Code section: constant_name_defines ### */ +#define __pyx_kp_u_Blockchain_already_has_a_genesis __pyx_string_tab[0] +#define __pyx_kp_u_Blockchain_was_already_loaded __pyx_string_tab[1] +#define __pyx_kp_u_Could_not_allocate_hasmap __pyx_string_tab[2] +#define __pyx_kp_u_Could_not_allocate_vector __pyx_string_tab[3] +#define __pyx_kp_u_Could_not_mine_block_No_nonce_fo __pyx_string_tab[4] +#define __pyx_kp_u_Create_a_genesis_block_first __pyx_string_tab[5] +#define __pyx_kp_u_Data __pyx_string_tab[6] +#define __pyx_kp_u_Data_must_be_a_string __pyx_string_tab[7] +#define __pyx_kp_u_Difficulty_must_be_greater_than __pyx_string_tab[8] +#define __pyx_kp_u_Difficulty_must_be_integer_value __pyx_string_tab[9] +#define __pyx_kp_u_Failed_to_hash_data __pyx_string_tab[10] +#define __pyx_kp_u_Genesis_Block __pyx_string_tab[11] +#define __pyx_kp_u_Hash __pyx_string_tab[12] +#define __pyx_kp_u_Hash_mismatch_Hash_of_previous __pyx_string_tab[13] +#define __pyx_kp_u_Hashes_to_not_match_Abort __pyx_string_tab[14] +#define __pyx_kp_u_Index __pyx_string_tab[15] +#define __pyx_kp_u_Index_value_is_out_of_bounds __pyx_string_tab[16] +#define __pyx_kp_u_Maximum_number_must_be_greater_t __pyx_string_tab[17] +#define __pyx_kp_u_Prev_Hash __pyx_string_tab[18] +#define __pyx_kp_u_Provided_index_not_found __pyx_string_tab[19] +#define __pyx_kp_u_PyBlock_Index __pyx_string_tab[20] +#define __pyx_kp_u_The_parent_directory_of_the_prov __pyx_string_tab[21] +#define __pyx_kp_u_UTF_8 __pyx_string_tab[22] +#define __pyx_kp_u__2 __pyx_string_tab[23] +#define __pyx_kp_u__3 __pyx_string_tab[24] +#define __pyx_kp_u__4 __pyx_string_tab[25] +#define __pyx_kp_u_disable __pyx_string_tab[26] +#define __pyx_kp_u_enable __pyx_string_tab[27] +#define __pyx_kp_u_gc __pyx_string_tab[28] +#define __pyx_kp_u_isenabled __pyx_string_tab[29] +#define __pyx_kp_u_no_default___reduce___due_to_non __pyx_string_tab[30] +#define __pyx_kp_u_nonce_2 __pyx_string_tab[31] +#define __pyx_kp_u_sqlite __pyx_string_tab[32] +#define __pyx_kp_u_src_dopt_pollublock_blockchain_b __pyx_string_tab[33] +#define __pyx_kp_u_stringsource __pyx_string_tab[34] +#define __pyx_kp_u_timestamp_2 __pyx_string_tab[35] +#define __pyx_n_u_Blockchain __pyx_string_tab[36] +#define __pyx_n_u_Blockchain___reduce_cython __pyx_string_tab[37] +#define __pyx_n_u_Blockchain___setstate_cython __pyx_string_tab[38] +#define __pyx_n_u_Blockchain__print_key_value_pair __pyx_string_tab[39] +#define __pyx_n_u_Blockchain_close_db_connections __pyx_string_tab[40] +#define __pyx_n_u_Blockchain_create_genesis_block __pyx_string_tab[41] +#define __pyx_n_u_Blockchain_get_block __pyx_string_tab[42] +#define __pyx_n_u_Blockchain_get_saving_entries __pyx_string_tab[43] +#define __pyx_n_u_Blockchain_load __pyx_string_tab[44] +#define __pyx_n_u_Blockchain_new_block __pyx_string_tab[45] +#define __pyx_n_u_Blockchain_print_blocks __pyx_string_tab[46] +#define __pyx_n_u_Blockchain_save __pyx_string_tab[47] +#define __pyx_n_u_Blockchain_validate __pyx_string_tab[48] +#define __pyx_n_u_Path __pyx_string_tab[49] +#define __pyx_n_u_PyBlock __pyx_string_tab[50] +#define __pyx_n_u_PyBlock___reduce_cython __pyx_string_tab[51] +#define __pyx_n_u_PyBlock___setstate_cython __pyx_string_tab[52] +#define __pyx_n_u_PyBlock_bytes_serialize __pyx_string_tab[53] +#define __pyx_n_u_PyBlock_perform_hash __pyx_string_tab[54] +#define __pyx_n_u_PyBlock_serialize_dict __pyx_string_tab[55] +#define __pyx_n_u_Pyx_PyDict_NextRef __pyx_string_tab[56] +#define __pyx_n_u_TIMEZONE_UTC __pyx_string_tab[57] +#define __pyx_n_u_asc __pyx_string_tab[58] +#define __pyx_n_u_asyncio_coroutines __pyx_string_tab[59] +#define __pyx_n_u_batch __pyx_string_tab[60] +#define __pyx_n_u_batch_size __pyx_string_tab[61] +#define __pyx_n_u_begin __pyx_string_tab[62] +#define __pyx_n_u_block __pyx_string_tab[63] +#define __pyx_n_u_blocks __pyx_string_tab[64] +#define __pyx_n_u_bytes_serialize __pyx_string_tab[65] +#define __pyx_n_u_c __pyx_string_tab[66] +#define __pyx_n_u_cline_in_traceback __pyx_string_tab[67] +#define __pyx_n_u_close_db_connections __pyx_string_tab[68] +#define __pyx_n_u_con __pyx_string_tab[69] +#define __pyx_n_u_conn __pyx_string_tab[70] +#define __pyx_n_u_connect __pyx_string_tab[71] +#define __pyx_n_u_contents __pyx_string_tab[72] +#define __pyx_n_u_create_all __pyx_string_tab[73] +#define __pyx_n_u_create_engine __pyx_string_tab[74] +#define __pyx_n_u_create_genesis_block __pyx_string_tab[75] +#define __pyx_n_u_current_time_tz __pyx_string_tab[76] +#define __pyx_n_u_cut_microseconds __pyx_string_tab[77] +#define __pyx_n_u_data __pyx_string_tab[78] +#define __pyx_n_u_data_digest __pyx_string_tab[79] +#define __pyx_n_u_data_str __pyx_string_tab[80] +#define __pyx_n_u_datetime __pyx_string_tab[81] +#define __pyx_n_u_db __pyx_string_tab[82] +#define __pyx_n_u_db_path __pyx_string_tab[83] +#define __pyx_n_u_digest __pyx_string_tab[84] +#define __pyx_n_u_digest_size __pyx_string_tab[85] +#define __pyx_n_u_dispose __pyx_string_tab[86] +#define __pyx_n_u_dopt_basics __pyx_string_tab[87] +#define __pyx_n_u_dopt_basics_datetime __pyx_string_tab[88] +#define __pyx_n_u_dopt_pollublock_blockchain __pyx_string_tab[89] +#define __pyx_n_u_dopt_pollublock_blockchain_block __pyx_string_tab[90] +#define __pyx_n_u_encode __pyx_string_tab[91] +#define __pyx_n_u_enter __pyx_string_tab[92] +#define __pyx_n_u_entries __pyx_string_tab[93] +#define __pyx_n_u_execute __pyx_string_tab[94] +#define __pyx_n_u_exists __pyx_string_tab[95] +#define __pyx_n_u_exit __pyx_string_tab[96] +#define __pyx_n_u_from_ptr __pyx_string_tab[97] +#define __pyx_n_u_fromhex __pyx_string_tab[98] +#define __pyx_n_u_fromtimestamp __pyx_string_tab[99] +#define __pyx_n_u_func __pyx_string_tab[100] +#define __pyx_n_u_func_2 __pyx_string_tab[101] +#define __pyx_n_u_genesis_prev_hash __pyx_string_tab[102] +#define __pyx_n_u_get_block __pyx_string_tab[103] +#define __pyx_n_u_get_saving_entries __pyx_string_tab[104] +#define __pyx_n_u_getstate __pyx_string_tab[105] +#define __pyx_n_u_hash __pyx_string_tab[106] +#define __pyx_n_u_hex __pyx_string_tab[107] +#define __pyx_n_u_idx __pyx_string_tab[108] +#define __pyx_n_u_index __pyx_string_tab[109] +#define __pyx_n_u_insert __pyx_string_tab[110] +#define __pyx_n_u_is_coroutine __pyx_string_tab[111] +#define __pyx_n_u_it __pyx_string_tab[112] +#define __pyx_n_u_items __pyx_string_tab[113] +#define __pyx_n_u_load __pyx_string_tab[114] +#define __pyx_n_u_main __pyx_string_tab[115] +#define __pyx_n_u_max __pyx_string_tab[116] +#define __pyx_n_u_max_idx __pyx_string_tab[117] +#define __pyx_n_u_max_idx_2 __pyx_string_tab[118] +#define __pyx_n_u_max_num __pyx_string_tab[119] +#define __pyx_n_u_max_nummber __pyx_string_tab[120] +#define __pyx_n_u_max_value __pyx_string_tab[121] +#define __pyx_n_u_metadata_blockchain __pyx_string_tab[122] +#define __pyx_n_u_module __pyx_string_tab[123] +#define __pyx_n_u_name __pyx_string_tab[124] +#define __pyx_n_u_new_block __pyx_string_tab[125] +#define __pyx_n_u_new_idx __pyx_string_tab[126] +#define __pyx_n_u_nonce __pyx_string_tab[127] +#define __pyx_n_u_num __pyx_string_tab[128] +#define __pyx_n_u_order_by __pyx_string_tab[129] +#define __pyx_n_u_parent __pyx_string_tab[130] +#define __pyx_n_u_partitions __pyx_string_tab[131] +#define __pyx_n_u_pathlib __pyx_string_tab[132] +#define __pyx_n_u_perform_hash __pyx_string_tab[133] +#define __pyx_n_u_pop __pyx_string_tab[134] +#define __pyx_n_u_prev_block __pyx_string_tab[135] +#define __pyx_n_u_prev_hash __pyx_string_tab[136] +#define __pyx_n_u_previous_hash __pyx_string_tab[137] +#define __pyx_n_u_print __pyx_string_tab[138] +#define __pyx_n_u_print_blocks __pyx_string_tab[139] +#define __pyx_n_u_print_key_value_pair __pyx_string_tab[140] +#define __pyx_n_u_py_block __pyx_string_tab[141] +#define __pyx_n_u_py_bytes __pyx_string_tab[142] +#define __pyx_n_u_py_bytes_rehashed __pyx_string_tab[143] +#define __pyx_n_u_pyx_state __pyx_string_tab[144] +#define __pyx_n_u_pyx_vtable __pyx_string_tab[145] +#define __pyx_n_u_qualname __pyx_string_tab[146] +#define __pyx_n_u_reduce __pyx_string_tab[147] +#define __pyx_n_u_reduce_cython __pyx_string_tab[148] +#define __pyx_n_u_reduce_ex __pyx_string_tab[149] +#define __pyx_n_u_repr __pyx_string_tab[150] +#define __pyx_n_u_res __pyx_string_tab[151] +#define __pyx_n_u_resolve __pyx_string_tab[152] +#define __pyx_n_u_result __pyx_string_tab[153] +#define __pyx_n_u_save __pyx_string_tab[154] +#define __pyx_n_u_scalar __pyx_string_tab[155] +#define __pyx_n_u_select __pyx_string_tab[156] +#define __pyx_n_u_self __pyx_string_tab[157] +#define __pyx_n_u_serialize_dict __pyx_string_tab[158] +#define __pyx_n_u_serialize_res __pyx_string_tab[159] +#define __pyx_n_u_serialize_size __pyx_string_tab[160] +#define __pyx_n_u_set_name __pyx_string_tab[161] +#define __pyx_n_u_setdefault __pyx_string_tab[162] +#define __pyx_n_u_setstate __pyx_string_tab[163] +#define __pyx_n_u_setstate_cython __pyx_string_tab[164] +#define __pyx_n_u_sql __pyx_string_tab[165] +#define __pyx_n_u_sqlalchemy __pyx_string_tab[166] +#define __pyx_n_u_stmt __pyx_string_tab[167] +#define __pyx_n_u_test __pyx_string_tab[168] +#define __pyx_n_u_timestamp __pyx_string_tab[169] +#define __pyx_n_u_validate __pyx_string_tab[170] +#define __pyx_n_u_values __pyx_string_tab[171] +#define __pyx_kp_b_ __pyx_string_tab[172] +#define __pyx_kp_b_00000000000000000000000000000000 __pyx_string_tab[173] +#define __pyx_kp_b_iso88591_A_1D_wc_xuAV2_b_q_t1 __pyx_string_tab[174] +#define __pyx_kp_b_iso88591_A_1_D_q_G1_D_q_D_4q_4q_q __pyx_string_tab[175] +#define __pyx_kp_b_iso88591_A_4q_a_YgQa_t_Qa_IQ_Q_gQa_t_Qa_4 __pyx_string_tab[176] +#define __pyx_kp_b_iso88591_A_4q_aq_q_XQc_89ARwb_dRS_IS_1A_K __pyx_string_tab[177] +#define __pyx_kp_b_iso88591_A_4r_3d_D_AQ_D_AQ_6_A_AQ_iq_Q __pyx_string_tab[178] +#define __pyx_kp_b_iso88591_A_4t1_aq_4z_1A_4z_T_Qd_Ja_hb_IQ __pyx_string_tab[179] +#define __pyx_kp_b_iso88591_A_HHA __pyx_string_tab[180] +#define __pyx_kp_b_iso88591_A_Qd_1A __pyx_string_tab[181] +#define __pyx_kp_b_iso88591_A_T_F_c_D_4q_c_L_1_iq __pyx_string_tab[182] +#define __pyx_kp_b_iso88591_A_a_1_83a_AQ_G5_WARuA_D_q_1_iq_1 __pyx_string_tab[183] +#define __pyx_kp_b_iso88591_A_a_83a_q_G5_WARuA_t3a_D_q_1_q_A __pyx_string_tab[184] +#define __pyx_kp_b_iso88591_A_a_G5_WARuA_D_q_1_uHAU_waq_1G1A __pyx_string_tab[185] +#define __pyx_kp_b_iso88591_A_s_U_ar_q_T_gQ_4q_vQ_xq_7_2Zq __pyx_string_tab[186] +#define __pyx_kp_b_iso88591_Q __pyx_string_tab[187] +#define __pyx_int_0 __pyx_number_tab[0] +/* #### 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_26dopt_pollublock_blockchain_10blockchain_PyBlock); + Py_CLEAR(clear_module_state->__pyx_type_26dopt_pollublock_blockchain_10blockchain_PyBlock); + Py_CLEAR(clear_module_state->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_Blockchain); + Py_CLEAR(clear_module_state->__pyx_type_26dopt_pollublock_blockchain_10blockchain_Blockchain); + for (int i=0; i<1; ++i) { Py_CLEAR(clear_module_state->__pyx_tuple[i]); } + for (int i=0; i<17; ++i) { Py_CLEAR(clear_module_state->__pyx_codeobj_tab[i]); } + for (int i=0; i<188; ++i) { Py_CLEAR(clear_module_state->__pyx_string_tab[i]); } + for (int i=0; i<1; ++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); + +/* CythonFunctionShared.module_state_clear */ +Py_CLEAR(clear_module_state->__pyx_CyFunctionType); + +/* #### 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_26dopt_pollublock_blockchain_10blockchain_PyBlock); + Py_VISIT(traverse_module_state->__pyx_type_26dopt_pollublock_blockchain_10blockchain_PyBlock); + Py_VISIT(traverse_module_state->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_Blockchain); + Py_VISIT(traverse_module_state->__pyx_type_26dopt_pollublock_blockchain_10blockchain_Blockchain); + for (int i=0; i<1; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_tuple[i]); } + for (int i=0; i<17; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_codeobj_tab[i]); } + for (int i=0; i<188; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_string_tab[i]); } + for (int i=0; i<1; ++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); + +/* CythonFunctionShared.module_state_traverse */ +Py_VISIT(traverse_module_state->__pyx_CyFunctionType); + +/* #### Code section: module_state_traverse_end ### */ +return 0; +} +#endif +/* #### Code section: module_code ### */ + +/* "string.from_py":12 + * cdef const char* __Pyx_PyObject_AsStringAndSize(object, Py_ssize_t*) except NULL + * + * @cname("__pyx_convert_string_from_py_6libcpp_6string_std__in_string") # <<<<<<<<<<<<<< + * cdef string __pyx_convert_string_from_py_6libcpp_6string_std__in_string(object o) except *: + * cdef Py_ssize_t length = 0 +*/ + +static std::string __pyx_convert_string_from_py_6libcpp_6string_std__in_string(PyObject *__pyx_v_o) { + Py_ssize_t __pyx_v_length; + char const *__pyx_v_data; + std::string __pyx_r; + char const *__pyx_t_1; + std::string __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "string.from_py":14 + * @cname("__pyx_convert_string_from_py_6libcpp_6string_std__in_string") + * cdef string __pyx_convert_string_from_py_6libcpp_6string_std__in_string(object o) except *: + * cdef Py_ssize_t length = 0 # <<<<<<<<<<<<<< + * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) + * return string(data, length) +*/ + __pyx_v_length = 0; + + /* "string.from_py":15 + * cdef string __pyx_convert_string_from_py_6libcpp_6string_std__in_string(object o) except *: + * cdef Py_ssize_t length = 0 + * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) # <<<<<<<<<<<<<< + * return string(data, length) + * +*/ + __pyx_t_1 = __Pyx_PyObject_AsStringAndSize(__pyx_v_o, (&__pyx_v_length)); if (unlikely(__pyx_t_1 == ((void *)NULL))) __PYX_ERR(1, 15, __pyx_L1_error) + __pyx_v_data = __pyx_t_1; + + /* "string.from_py":16 + * cdef Py_ssize_t length = 0 + * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) + * return string(data, length) # <<<<<<<<<<<<<< + * +*/ + try { + __pyx_t_2 = std::string(__pyx_v_data, ((size_t)__pyx_v_length)); + } catch(...) { + __Pyx_CppExn2PyErr(); + __PYX_ERR(1, 16, __pyx_L1_error) + } + __pyx_r = __pyx_t_2; + goto __pyx_L0; + + /* "string.from_py":12 + * cdef const char* __Pyx_PyObject_AsStringAndSize(object, Py_ssize_t*) except NULL + * + * @cname("__pyx_convert_string_from_py_6libcpp_6string_std__in_string") # <<<<<<<<<<<<<< + * cdef string __pyx_convert_string_from_py_6libcpp_6string_std__in_string(object o) except *: + * cdef Py_ssize_t length = 0 +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("string.from_py.__pyx_convert_string_from_py_6libcpp_6string_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + return __pyx_r; +} + +/* "string.to_py":31 + * cdef object __Pyx_PyObject_FromStringAndSize(const char*, size_t) + * + * @cname("__pyx_convert_PyObject_string_to_py_6libcpp_6string_std__in_string") # <<<<<<<<<<<<<< + * cdef inline object __pyx_convert_PyObject_string_to_py_6libcpp_6string_std__in_string(const string& s): + * if s.size() > PY_SSIZE_T_MAX: +*/ + +static CYTHON_INLINE PyObject *__pyx_convert_PyObject_string_to_py_6libcpp_6string_std__in_string(std::string const &__pyx_v_s) { + 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("__pyx_convert_PyObject_string_to_py_6libcpp_6string_std__in_string", 0); + + /* "string.to_py":33 + * @cname("__pyx_convert_PyObject_string_to_py_6libcpp_6string_std__in_string") + * cdef inline object __pyx_convert_PyObject_string_to_py_6libcpp_6string_std__in_string(const string& s): + * if s.size() > PY_SSIZE_T_MAX: # <<<<<<<<<<<<<< + * raise MemoryError() + * return __Pyx_PyObject_FromStringAndSize(s.data(), s.size()) +*/ + __pyx_t_1 = (__pyx_v_s.size() > ((size_t)PY_SSIZE_T_MAX)); + if (unlikely(__pyx_t_1)) { + + /* "string.to_py":34 + * cdef inline object __pyx_convert_PyObject_string_to_py_6libcpp_6string_std__in_string(const string& s): + * if s.size() > PY_SSIZE_T_MAX: + * raise MemoryError() # <<<<<<<<<<<<<< + * return __Pyx_PyObject_FromStringAndSize(s.data(), s.size()) + * cdef extern from *: +*/ + PyErr_NoMemory(); __PYX_ERR(1, 34, __pyx_L1_error) + + /* "string.to_py":33 + * @cname("__pyx_convert_PyObject_string_to_py_6libcpp_6string_std__in_string") + * cdef inline object __pyx_convert_PyObject_string_to_py_6libcpp_6string_std__in_string(const string& s): + * if s.size() > PY_SSIZE_T_MAX: # <<<<<<<<<<<<<< + * raise MemoryError() + * return __Pyx_PyObject_FromStringAndSize(s.data(), s.size()) +*/ + } + + /* "string.to_py":35 + * if s.size() > PY_SSIZE_T_MAX: + * raise MemoryError() + * return __Pyx_PyObject_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<< + * cdef extern from *: + * cdef object __Pyx_PyUnicode_FromStringAndSize(const char*, size_t) +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_FromStringAndSize(__pyx_v_s.data(), ((Py_ssize_t)__pyx_v_s.size())); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 35, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "string.to_py":31 + * cdef object __Pyx_PyObject_FromStringAndSize(const char*, size_t) + * + * @cname("__pyx_convert_PyObject_string_to_py_6libcpp_6string_std__in_string") # <<<<<<<<<<<<<< + * cdef inline object __pyx_convert_PyObject_string_to_py_6libcpp_6string_std__in_string(const string& s): + * if s.size() > PY_SSIZE_T_MAX: +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("string.to_py.__pyx_convert_PyObject_string_to_py_6libcpp_6string_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "string.to_py":39 + * cdef object __Pyx_PyUnicode_FromStringAndSize(const char*, size_t) + * + * @cname("__pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string") # <<<<<<<<<<<<<< + * cdef inline object __pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string(const string& s): + * if s.size() > PY_SSIZE_T_MAX: +*/ + +static CYTHON_INLINE PyObject *__pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string(std::string const &__pyx_v_s) { + 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("__pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string", 0); + + /* "string.to_py":41 + * @cname("__pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string") + * cdef inline object __pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string(const string& s): + * if s.size() > PY_SSIZE_T_MAX: # <<<<<<<<<<<<<< + * raise MemoryError() + * return __Pyx_PyUnicode_FromStringAndSize(s.data(), s.size()) +*/ + __pyx_t_1 = (__pyx_v_s.size() > ((size_t)PY_SSIZE_T_MAX)); + if (unlikely(__pyx_t_1)) { + + /* "string.to_py":42 + * cdef inline object __pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string(const string& s): + * if s.size() > PY_SSIZE_T_MAX: + * raise MemoryError() # <<<<<<<<<<<<<< + * return __Pyx_PyUnicode_FromStringAndSize(s.data(), s.size()) + * cdef extern from *: +*/ + PyErr_NoMemory(); __PYX_ERR(1, 42, __pyx_L1_error) + + /* "string.to_py":41 + * @cname("__pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string") + * cdef inline object __pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string(const string& s): + * if s.size() > PY_SSIZE_T_MAX: # <<<<<<<<<<<<<< + * raise MemoryError() + * return __Pyx_PyUnicode_FromStringAndSize(s.data(), s.size()) +*/ + } + + /* "string.to_py":43 + * if s.size() > PY_SSIZE_T_MAX: + * raise MemoryError() + * return __Pyx_PyUnicode_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<< + * cdef extern from *: + * cdef object __Pyx_PyBytes_FromStringAndSize(const char*, size_t) +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyUnicode_FromStringAndSize(__pyx_v_s.data(), ((Py_ssize_t)__pyx_v_s.size())); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 43, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "string.to_py":39 + * cdef object __Pyx_PyUnicode_FromStringAndSize(const char*, size_t) + * + * @cname("__pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string") # <<<<<<<<<<<<<< + * cdef inline object __pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string(const string& s): + * if s.size() > PY_SSIZE_T_MAX: +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("string.to_py.__pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "string.to_py":47 + * cdef object __Pyx_PyBytes_FromStringAndSize(const char*, size_t) + * + * @cname("__pyx_convert_PyBytes_string_to_py_6libcpp_6string_std__in_string") # <<<<<<<<<<<<<< + * cdef inline object __pyx_convert_PyBytes_string_to_py_6libcpp_6string_std__in_string(const string& s): + * if s.size() > PY_SSIZE_T_MAX: +*/ + +static CYTHON_INLINE PyObject *__pyx_convert_PyBytes_string_to_py_6libcpp_6string_std__in_string(std::string const &__pyx_v_s) { + 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("__pyx_convert_PyBytes_string_to_py_6libcpp_6string_std__in_string", 0); + + /* "string.to_py":49 + * @cname("__pyx_convert_PyBytes_string_to_py_6libcpp_6string_std__in_string") + * cdef inline object __pyx_convert_PyBytes_string_to_py_6libcpp_6string_std__in_string(const string& s): + * if s.size() > PY_SSIZE_T_MAX: # <<<<<<<<<<<<<< + * raise MemoryError() + * return __Pyx_PyBytes_FromStringAndSize(s.data(), s.size()) +*/ + __pyx_t_1 = (__pyx_v_s.size() > ((size_t)PY_SSIZE_T_MAX)); + if (unlikely(__pyx_t_1)) { + + /* "string.to_py":50 + * cdef inline object __pyx_convert_PyBytes_string_to_py_6libcpp_6string_std__in_string(const string& s): + * if s.size() > PY_SSIZE_T_MAX: + * raise MemoryError() # <<<<<<<<<<<<<< + * return __Pyx_PyBytes_FromStringAndSize(s.data(), s.size()) + * cdef extern from *: +*/ + PyErr_NoMemory(); __PYX_ERR(1, 50, __pyx_L1_error) + + /* "string.to_py":49 + * @cname("__pyx_convert_PyBytes_string_to_py_6libcpp_6string_std__in_string") + * cdef inline object __pyx_convert_PyBytes_string_to_py_6libcpp_6string_std__in_string(const string& s): + * if s.size() > PY_SSIZE_T_MAX: # <<<<<<<<<<<<<< + * raise MemoryError() + * return __Pyx_PyBytes_FromStringAndSize(s.data(), s.size()) +*/ + } + + /* "string.to_py":51 + * if s.size() > PY_SSIZE_T_MAX: + * raise MemoryError() + * return __Pyx_PyBytes_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<< + * cdef extern from *: + * cdef object __Pyx_PyByteArray_FromStringAndSize(const char*, size_t) +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_s.data(), ((Py_ssize_t)__pyx_v_s.size())); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 51, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "string.to_py":47 + * cdef object __Pyx_PyBytes_FromStringAndSize(const char*, size_t) + * + * @cname("__pyx_convert_PyBytes_string_to_py_6libcpp_6string_std__in_string") # <<<<<<<<<<<<<< + * cdef inline object __pyx_convert_PyBytes_string_to_py_6libcpp_6string_std__in_string(const string& s): + * if s.size() > PY_SSIZE_T_MAX: +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("string.to_py.__pyx_convert_PyBytes_string_to_py_6libcpp_6string_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "string.to_py":55 + * cdef object __Pyx_PyByteArray_FromStringAndSize(const char*, size_t) + * + * @cname("__pyx_convert_PyByteArray_string_to_py_6libcpp_6string_std__in_string") # <<<<<<<<<<<<<< + * cdef inline object __pyx_convert_PyByteArray_string_to_py_6libcpp_6string_std__in_string(const string& s): + * if s.size() > PY_SSIZE_T_MAX: +*/ + +static CYTHON_INLINE PyObject *__pyx_convert_PyByteArray_string_to_py_6libcpp_6string_std__in_string(std::string const &__pyx_v_s) { + 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("__pyx_convert_PyByteArray_string_to_py_6libcpp_6string_std__in_string", 0); + + /* "string.to_py":57 + * @cname("__pyx_convert_PyByteArray_string_to_py_6libcpp_6string_std__in_string") + * cdef inline object __pyx_convert_PyByteArray_string_to_py_6libcpp_6string_std__in_string(const string& s): + * if s.size() > PY_SSIZE_T_MAX: # <<<<<<<<<<<<<< + * raise MemoryError() + * return __Pyx_PyByteArray_FromStringAndSize(s.data(), s.size()) +*/ + __pyx_t_1 = (__pyx_v_s.size() > ((size_t)PY_SSIZE_T_MAX)); + if (unlikely(__pyx_t_1)) { + + /* "string.to_py":58 + * cdef inline object __pyx_convert_PyByteArray_string_to_py_6libcpp_6string_std__in_string(const string& s): + * if s.size() > PY_SSIZE_T_MAX: + * raise MemoryError() # <<<<<<<<<<<<<< + * return __Pyx_PyByteArray_FromStringAndSize(s.data(), s.size()) +*/ + PyErr_NoMemory(); __PYX_ERR(1, 58, __pyx_L1_error) + + /* "string.to_py":57 + * @cname("__pyx_convert_PyByteArray_string_to_py_6libcpp_6string_std__in_string") + * cdef inline object __pyx_convert_PyByteArray_string_to_py_6libcpp_6string_std__in_string(const string& s): + * if s.size() > PY_SSIZE_T_MAX: # <<<<<<<<<<<<<< + * raise MemoryError() + * return __Pyx_PyByteArray_FromStringAndSize(s.data(), s.size()) +*/ + } + + /* "string.to_py":59 + * if s.size() > PY_SSIZE_T_MAX: + * raise MemoryError() + * return __Pyx_PyByteArray_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<< +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyByteArray_FromStringAndSize(__pyx_v_s.data(), ((Py_ssize_t)__pyx_v_s.size())); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 59, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "string.to_py":55 + * cdef object __Pyx_PyByteArray_FromStringAndSize(const char*, size_t) + * + * @cname("__pyx_convert_PyByteArray_string_to_py_6libcpp_6string_std__in_string") # <<<<<<<<<<<<<< + * cdef inline object __pyx_convert_PyByteArray_string_to_py_6libcpp_6string_std__in_string(const string& s): + * if s.size() > PY_SSIZE_T_MAX: +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("string.to_py.__pyx_convert_PyByteArray_string_to_py_6libcpp_6string_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":31 + * + * + * cdef timestamp_to_datetime(uint64_t ts): # <<<<<<<<<<<<<< + * return datetime.datetime.fromtimestamp(float(ts), dopt_basics.datetime.TIMEZONE_UTC) + * +*/ + +static PyObject *__pyx_f_26dopt_pollublock_blockchain_10blockchain_timestamp_to_datetime(uint64_t __pyx_v_ts) { + 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; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("timestamp_to_datetime", 0); + + /* "dopt_pollublock_blockchain/blockchain.pyx":32 + * + * cdef timestamp_to_datetime(uint64_t ts): + * return datetime.datetime.fromtimestamp(float(ts), dopt_basics.datetime.TIMEZONE_UTC) # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __pyx_t_4; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = PyFloat_FromDouble(((double)__pyx_v_ts)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_dopt_basics); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_TIMEZONE_UTC); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_7 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_3, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_fromtimestamp, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (1*__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_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":31 + * + * + * cdef timestamp_to_datetime(uint64_t ts): # <<<<<<<<<<<<<< + * return datetime.datetime.fromtimestamp(float(ts), dopt_basics.datetime.TIMEZONE_UTC) + * +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.timestamp_to_datetime", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":35 + * + * + * cdef uint64_t current_timestamp_integer(): # <<<<<<<<<<<<<< + * cdef uint64_t ts + * dt = dopt_basics.datetime.current_time_tz(cut_microseconds=True) +*/ + +static uint64_t __pyx_f_26dopt_pollublock_blockchain_10blockchain_current_timestamp_integer(void) { + uint64_t __pyx_v_ts; + PyObject *__pyx_v_dt = NULL; + uint64_t __pyx_r; + __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; + uint64_t __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("current_timestamp_integer", 0); + + /* "dopt_pollublock_blockchain/blockchain.pyx":37 + * cdef uint64_t current_timestamp_integer(): + * cdef uint64_t ts + * dt = dopt_basics.datetime.current_time_tz(cut_microseconds=True) # <<<<<<<<<<<<<< + * ts = int(dt.timestamp()) + * return ts +*/ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_dopt_basics); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __pyx_t_4; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_2, NULL}; + __pyx_t_3 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_cut_microseconds, Py_True, __pyx_t_3, __pyx_callargs+1, 0) < (0)) __PYX_ERR(0, 37, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_current_time_tz, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_3); + __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, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_dt = __pyx_t_1; + __pyx_t_1 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":38 + * cdef uint64_t ts + * dt = dopt_basics.datetime.current_time_tz(cut_microseconds=True) + * ts = int(dt.timestamp()) # <<<<<<<<<<<<<< + * return ts + * +*/ + __pyx_t_4 = __pyx_v_dt; + __Pyx_INCREF(__pyx_t_4); + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_timestamp, __pyx_callargs+__pyx_t_5, (1-__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, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_4 = __Pyx_PyNumber_Int(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_6 = __Pyx_PyLong_As_uint64_t(__pyx_t_4); if (unlikely((__pyx_t_6 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 38, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_ts = ((uint64_t)__pyx_t_6); + + /* "dopt_pollublock_blockchain/blockchain.pyx":39 + * dt = dopt_basics.datetime.current_time_tz(cut_microseconds=True) + * ts = int(dt.timestamp()) + * return ts # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = __pyx_v_ts; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":35 + * + * + * cdef uint64_t current_timestamp_integer(): # <<<<<<<<<<<<<< + * cdef uint64_t ts + * dt = dopt_basics.datetime.current_time_tz(cut_microseconds=True) +*/ + + /* 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("dopt_pollublock_blockchain.blockchain.current_timestamp_integer", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1LL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_dt); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":42 + * + * + * cdef int serialize_uint32(unsigned char* out, unsigned int v) except -1 nogil: # <<<<<<<<<<<<<< + * out[0] = (v >> 24) & 0xFF + * out[1] = (v >> 16) & 0xFF +*/ + +static int __pyx_f_26dopt_pollublock_blockchain_10blockchain_serialize_uint32(unsigned char *__pyx_v_out, unsigned int __pyx_v_v) { + int __pyx_r; + + /* "dopt_pollublock_blockchain/blockchain.pyx":43 + * + * cdef int serialize_uint32(unsigned char* out, unsigned int v) except -1 nogil: + * out[0] = (v >> 24) & 0xFF # <<<<<<<<<<<<<< + * out[1] = (v >> 16) & 0xFF + * out[2] = (v >> 8) & 0xFF +*/ + (__pyx_v_out[0]) = ((__pyx_v_v >> 24) & 0xFF); + + /* "dopt_pollublock_blockchain/blockchain.pyx":44 + * cdef int serialize_uint32(unsigned char* out, unsigned int v) except -1 nogil: + * out[0] = (v >> 24) & 0xFF + * out[1] = (v >> 16) & 0xFF # <<<<<<<<<<<<<< + * out[2] = (v >> 8) & 0xFF + * out[3] = v & 0xFF +*/ + (__pyx_v_out[1]) = ((__pyx_v_v >> 16) & 0xFF); + + /* "dopt_pollublock_blockchain/blockchain.pyx":45 + * out[0] = (v >> 24) & 0xFF + * out[1] = (v >> 16) & 0xFF + * out[2] = (v >> 8) & 0xFF # <<<<<<<<<<<<<< + * out[3] = v & 0xFF + * +*/ + (__pyx_v_out[2]) = ((__pyx_v_v >> 8) & 0xFF); + + /* "dopt_pollublock_blockchain/blockchain.pyx":46 + * out[1] = (v >> 16) & 0xFF + * out[2] = (v >> 8) & 0xFF + * out[3] = v & 0xFF # <<<<<<<<<<<<<< + * + * +*/ + (__pyx_v_out[3]) = (__pyx_v_v & 0xFF); + + /* "dopt_pollublock_blockchain/blockchain.pyx":42 + * + * + * cdef int serialize_uint32(unsigned char* out, unsigned int v) except -1 nogil: # <<<<<<<<<<<<<< + * out[0] = (v >> 24) & 0xFF + * out[1] = (v >> 16) & 0xFF +*/ + + /* function exit code */ + __pyx_r = 0; + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":49 + * + * + * cdef int serialize_uint64(unsigned char* out, unsigned long long v) except -1 nogil: # <<<<<<<<<<<<<< + * out[0] = (v >> 56) & 0xFF + * out[1] = (v >> 48) & 0xFF +*/ + +static int __pyx_f_26dopt_pollublock_blockchain_10blockchain_serialize_uint64(unsigned char *__pyx_v_out, unsigned PY_LONG_LONG __pyx_v_v) { + int __pyx_r; + + /* "dopt_pollublock_blockchain/blockchain.pyx":50 + * + * cdef int serialize_uint64(unsigned char* out, unsigned long long v) except -1 nogil: + * out[0] = (v >> 56) & 0xFF # <<<<<<<<<<<<<< + * out[1] = (v >> 48) & 0xFF + * out[2] = (v >> 40) & 0xFF +*/ + (__pyx_v_out[0]) = ((__pyx_v_v >> 56) & 0xFF); + + /* "dopt_pollublock_blockchain/blockchain.pyx":51 + * cdef int serialize_uint64(unsigned char* out, unsigned long long v) except -1 nogil: + * out[0] = (v >> 56) & 0xFF + * out[1] = (v >> 48) & 0xFF # <<<<<<<<<<<<<< + * out[2] = (v >> 40) & 0xFF + * out[3] = (v >> 32) & 0xFF +*/ + (__pyx_v_out[1]) = ((__pyx_v_v >> 48) & 0xFF); + + /* "dopt_pollublock_blockchain/blockchain.pyx":52 + * out[0] = (v >> 56) & 0xFF + * out[1] = (v >> 48) & 0xFF + * out[2] = (v >> 40) & 0xFF # <<<<<<<<<<<<<< + * out[3] = (v >> 32) & 0xFF + * out[4] = (v >> 24) & 0xFF +*/ + (__pyx_v_out[2]) = ((__pyx_v_v >> 40) & 0xFF); + + /* "dopt_pollublock_blockchain/blockchain.pyx":53 + * out[1] = (v >> 48) & 0xFF + * out[2] = (v >> 40) & 0xFF + * out[3] = (v >> 32) & 0xFF # <<<<<<<<<<<<<< + * out[4] = (v >> 24) & 0xFF + * out[5] = (v >> 16) & 0xFF +*/ + (__pyx_v_out[3]) = ((__pyx_v_v >> 32) & 0xFF); + + /* "dopt_pollublock_blockchain/blockchain.pyx":54 + * out[2] = (v >> 40) & 0xFF + * out[3] = (v >> 32) & 0xFF + * out[4] = (v >> 24) & 0xFF # <<<<<<<<<<<<<< + * out[5] = (v >> 16) & 0xFF + * out[6] = (v >> 8) & 0xFF +*/ + (__pyx_v_out[4]) = ((__pyx_v_v >> 24) & 0xFF); + + /* "dopt_pollublock_blockchain/blockchain.pyx":55 + * out[3] = (v >> 32) & 0xFF + * out[4] = (v >> 24) & 0xFF + * out[5] = (v >> 16) & 0xFF # <<<<<<<<<<<<<< + * out[6] = (v >> 8) & 0xFF + * out[7] = v & 0xFF +*/ + (__pyx_v_out[5]) = ((__pyx_v_v >> 16) & 0xFF); + + /* "dopt_pollublock_blockchain/blockchain.pyx":56 + * out[4] = (v >> 24) & 0xFF + * out[5] = (v >> 16) & 0xFF + * out[6] = (v >> 8) & 0xFF # <<<<<<<<<<<<<< + * out[7] = v & 0xFF + * +*/ + (__pyx_v_out[6]) = ((__pyx_v_v >> 8) & 0xFF); + + /* "dopt_pollublock_blockchain/blockchain.pyx":57 + * out[5] = (v >> 16) & 0xFF + * out[6] = (v >> 8) & 0xFF + * out[7] = v & 0xFF # <<<<<<<<<<<<<< + * + * +*/ + (__pyx_v_out[7]) = (__pyx_v_v & 0xFF); + + /* "dopt_pollublock_blockchain/blockchain.pyx":49 + * + * + * cdef int serialize_uint64(unsigned char* out, unsigned long long v) except -1 nogil: # <<<<<<<<<<<<<< + * out[0] = (v >> 56) & 0xFF + * out[1] = (v >> 48) & 0xFF +*/ + + /* function exit code */ + __pyx_r = 0; + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":60 + * + * + * cdef inline bint has_leading_zero_bits(const unsigned char *digest, int num_bits) nogil: # <<<<<<<<<<<<<< + * cdef int i, full_bytes = num_bits // 8 + * cdef int rem_bits = num_bits % 8 +*/ + +static CYTHON_INLINE int __pyx_f_26dopt_pollublock_blockchain_10blockchain_has_leading_zero_bits(unsigned char const *__pyx_v_digest, int __pyx_v_num_bits) { + int __pyx_v_i; + int __pyx_v_full_bytes; + int __pyx_v_rem_bits; + int __pyx_r; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + + /* "dopt_pollublock_blockchain/blockchain.pyx":61 + * + * cdef inline bint has_leading_zero_bits(const unsigned char *digest, int num_bits) nogil: + * cdef int i, full_bytes = num_bits // 8 # <<<<<<<<<<<<<< + * cdef int rem_bits = num_bits % 8 + * +*/ + __pyx_v_full_bytes = __Pyx_div_long(__pyx_v_num_bits, 8, 1); + + /* "dopt_pollublock_blockchain/blockchain.pyx":62 + * cdef inline bint has_leading_zero_bits(const unsigned char *digest, int num_bits) nogil: + * cdef int i, full_bytes = num_bits // 8 + * cdef int rem_bits = num_bits % 8 # <<<<<<<<<<<<<< + * + * for i in range(full_bytes): +*/ + __pyx_v_rem_bits = __Pyx_mod_long(__pyx_v_num_bits, 8, 1); + + /* "dopt_pollublock_blockchain/blockchain.pyx":64 + * cdef int rem_bits = num_bits % 8 + * + * for i in range(full_bytes): # <<<<<<<<<<<<<< + * if digest[i] != 0: + * return False +*/ + __pyx_t_1 = __pyx_v_full_bytes; + __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; + + /* "dopt_pollublock_blockchain/blockchain.pyx":65 + * + * for i in range(full_bytes): + * if digest[i] != 0: # <<<<<<<<<<<<<< + * return False + * +*/ + __pyx_t_4 = ((__pyx_v_digest[__pyx_v_i]) != 0); + if (__pyx_t_4) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":66 + * for i in range(full_bytes): + * if digest[i] != 0: + * return False # <<<<<<<<<<<<<< + * + * if rem_bits: +*/ + __pyx_r = 0; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":65 + * + * for i in range(full_bytes): + * if digest[i] != 0: # <<<<<<<<<<<<<< + * return False + * +*/ + } + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":68 + * return False + * + * if rem_bits: # <<<<<<<<<<<<<< + * if digest[full_bytes] >> (8 - rem_bits) != 0: + * return False +*/ + __pyx_t_4 = (__pyx_v_rem_bits != 0); + if (__pyx_t_4) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":69 + * + * if rem_bits: + * if digest[full_bytes] >> (8 - rem_bits) != 0: # <<<<<<<<<<<<<< + * return False + * +*/ + __pyx_t_4 = (((__pyx_v_digest[__pyx_v_full_bytes]) >> (8 - __pyx_v_rem_bits)) != 0); + if (__pyx_t_4) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":70 + * if rem_bits: + * if digest[full_bytes] >> (8 - rem_bits) != 0: + * return False # <<<<<<<<<<<<<< + * + * return True +*/ + __pyx_r = 0; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":69 + * + * if rem_bits: + * if digest[full_bytes] >> (8 - rem_bits) != 0: # <<<<<<<<<<<<<< + * return False + * +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":68 + * return False + * + * if rem_bits: # <<<<<<<<<<<<<< + * if digest[full_bytes] >> (8 - rem_bits) != 0: + * return False +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":72 + * return False + * + * return True # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = 1; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":60 + * + * + * cdef inline bint has_leading_zero_bits(const unsigned char *digest, int num_bits) nogil: # <<<<<<<<<<<<<< + * cdef int i, full_bytes = num_bits // 8 + * cdef int rem_bits = num_bits % 8 +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":75 + * + * + * cdef inline bint has_leading_zero_bytes(const unsigned char *digest, int num_bytes) nogil: # <<<<<<<<<<<<<< + * cdef int i, full_bytes = num_bytes // 8 + * cdef int rem_bits = num_bytes % 8 +*/ + +static CYTHON_INLINE int __pyx_f_26dopt_pollublock_blockchain_10blockchain_has_leading_zero_bytes(unsigned char const *__pyx_v_digest, int __pyx_v_num_bytes) { + int __pyx_v_i; + CYTHON_UNUSED int __pyx_v_full_bytes; + CYTHON_UNUSED int __pyx_v_rem_bits; + int __pyx_r; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + + /* "dopt_pollublock_blockchain/blockchain.pyx":76 + * + * cdef inline bint has_leading_zero_bytes(const unsigned char *digest, int num_bytes) nogil: + * cdef int i, full_bytes = num_bytes // 8 # <<<<<<<<<<<<<< + * cdef int rem_bits = num_bytes % 8 + * +*/ + __pyx_v_full_bytes = __Pyx_div_long(__pyx_v_num_bytes, 8, 1); + + /* "dopt_pollublock_blockchain/blockchain.pyx":77 + * cdef inline bint has_leading_zero_bytes(const unsigned char *digest, int num_bytes) nogil: + * cdef int i, full_bytes = num_bytes // 8 + * cdef int rem_bits = num_bytes % 8 # <<<<<<<<<<<<<< + * + * for i in range(num_bytes): +*/ + __pyx_v_rem_bits = __Pyx_mod_long(__pyx_v_num_bytes, 8, 1); + + /* "dopt_pollublock_blockchain/blockchain.pyx":79 + * cdef int rem_bits = num_bytes % 8 + * + * for i in range(num_bytes): # <<<<<<<<<<<<<< + * if digest[i] != 0: + * return False +*/ + __pyx_t_1 = __pyx_v_num_bytes; + __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; + + /* "dopt_pollublock_blockchain/blockchain.pyx":80 + * + * for i in range(num_bytes): + * if digest[i] != 0: # <<<<<<<<<<<<<< + * return False + * +*/ + __pyx_t_4 = ((__pyx_v_digest[__pyx_v_i]) != 0); + if (__pyx_t_4) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":81 + * for i in range(num_bytes): + * if digest[i] != 0: + * return False # <<<<<<<<<<<<<< + * + * return True +*/ + __pyx_r = 0; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":80 + * + * for i in range(num_bytes): + * if digest[i] != 0: # <<<<<<<<<<<<<< + * return False + * +*/ + } + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":83 + * return False + * + * return True # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = 1; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":75 + * + * + * cdef inline bint has_leading_zero_bytes(const unsigned char *digest, int num_bytes) nogil: # <<<<<<<<<<<<<< + * cdef int i, full_bytes = num_bytes // 8 + * cdef int rem_bits = num_bytes % 8 +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":91 + * bint ptr_owner + * + * def __cinit__(self, # <<<<<<<<<<<<<< + * index, + * nonce, +*/ + +/* Python wrapper */ +static int __pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_index = 0; + PyObject *__pyx_v_nonce = 0; + PyObject *__pyx_v_data = 0; + PyObject *__pyx_v_previous_hash = 0; + PyObject *__pyx_v_from_ptr = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[5] = {0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_index,&__pyx_mstate_global->__pyx_n_u_nonce,&__pyx_mstate_global->__pyx_n_u_data,&__pyx_mstate_global->__pyx_n_u_previous_hash,&__pyx_mstate_global->__pyx_n_u_from_ptr,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 91, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 5: + values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 91, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 91, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 91, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 91, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 91, __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, "__cinit__", 0) < (0)) __PYX_ERR(0, 91, __pyx_L3_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":96 + * data, + * previous_hash, + * from_ptr=False, # <<<<<<<<<<<<<< + * ): + * self.ptr_owner = False +*/ + if (!values[4]) values[4] = __Pyx_NewRef(((PyObject *)Py_False)); + for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 4, 5, i); __PYX_ERR(0, 91, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 5: + values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 91, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 91, __pyx_L3_error) + values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 91, __pyx_L3_error) + values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 91, __pyx_L3_error) + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 91, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + if (!values[4]) values[4] = __Pyx_NewRef(((PyObject *)Py_False)); + } + __pyx_v_index = values[0]; + __pyx_v_nonce = values[1]; + __pyx_v_data = values[2]; + __pyx_v_previous_hash = values[3]; + __pyx_v_from_ptr = values[4]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 4, 5, __pyx_nargs); __PYX_ERR(0, 91, __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("dopt_pollublock_blockchain.blockchain.PyBlock.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock___cinit__(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *)__pyx_v_self), __pyx_v_index, __pyx_v_nonce, __pyx_v_data, __pyx_v_previous_hash, __pyx_v_from_ptr); + + /* "dopt_pollublock_blockchain/blockchain.pyx":91 + * bint ptr_owner + * + * def __cinit__(self, # <<<<<<<<<<<<<< + * index, + * nonce, +*/ + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock___cinit__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_nonce, PyObject *__pyx_v_data, PyObject *__pyx_v_previous_hash, PyObject *__pyx_v_from_ptr) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + uint64_t __pyx_t_3; + uint64_t __pyx_t_4; + uint64_t __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + size_t __pyx_t_8; + std::string __pyx_t_9; + std::string __pyx_t_10; + std::string __pyx_t_11; + ::Block *__pyx_t_12; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* "dopt_pollublock_blockchain/blockchain.pyx":98 + * from_ptr=False, + * ): + * self.ptr_owner = False # <<<<<<<<<<<<<< + * if not from_ptr: + * self.BlockC = new Block( +*/ + __pyx_v_self->ptr_owner = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":99 + * ): + * self.ptr_owner = False + * if not from_ptr: # <<<<<<<<<<<<<< + * self.BlockC = new Block( + * index, +*/ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_from_ptr); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 99, __pyx_L1_error) + __pyx_t_2 = (!__pyx_t_1); + if (__pyx_t_2) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":101 + * if not from_ptr: + * self.BlockC = new Block( + * index, # <<<<<<<<<<<<<< + * current_timestamp_integer(), + * nonce, +*/ + __pyx_t_3 = __Pyx_PyLong_As_uint64_t(__pyx_v_index); if (unlikely((__pyx_t_3 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 101, __pyx_L1_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":102 + * self.BlockC = new Block( + * index, + * current_timestamp_integer(), # <<<<<<<<<<<<<< + * nonce, + * data.encode("UTF-8"), +*/ + __pyx_t_4 = __pyx_f_26dopt_pollublock_blockchain_10blockchain_current_timestamp_integer(); if (unlikely(__pyx_t_4 == ((uint64_t)-1LL) && PyErr_Occurred())) __PYX_ERR(0, 102, __pyx_L1_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":103 + * index, + * current_timestamp_integer(), + * nonce, # <<<<<<<<<<<<<< + * data.encode("UTF-8"), + * previous_hash.encode("UTF-8"), +*/ + __pyx_t_5 = __Pyx_PyLong_As_uint64_t(__pyx_v_nonce); if (unlikely((__pyx_t_5 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 103, __pyx_L1_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":104 + * current_timestamp_integer(), + * nonce, + * data.encode("UTF-8"), # <<<<<<<<<<<<<< + * previous_hash.encode("UTF-8"), + * "".encode("UTF-8"), +*/ + __pyx_t_7 = __pyx_v_data; + __Pyx_INCREF(__pyx_t_7); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_mstate_global->__pyx_kp_u_UTF_8}; + __pyx_t_6 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_encode, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + } + __pyx_t_9 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_t_6); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 104, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":105 + * nonce, + * data.encode("UTF-8"), + * previous_hash.encode("UTF-8"), # <<<<<<<<<<<<<< + * "".encode("UTF-8"), + * ) +*/ + __pyx_t_7 = __pyx_v_previous_hash; + __Pyx_INCREF(__pyx_t_7); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_mstate_global->__pyx_kp_u_UTF_8}; + __pyx_t_6 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_encode, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + } + __pyx_t_10 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_t_6); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 105, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":106 + * data.encode("UTF-8"), + * previous_hash.encode("UTF-8"), + * "".encode("UTF-8"), # <<<<<<<<<<<<<< + * ) + * if self.BlockC is NULL: +*/ + __pyx_t_11 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_mstate_global->__pyx_kp_b_); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 106, __pyx_L1_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":100 + * self.ptr_owner = False + * if not from_ptr: + * self.BlockC = new Block( # <<<<<<<<<<<<<< + * index, + * current_timestamp_integer(), +*/ + try { + __pyx_t_12 = new ::Block(__pyx_t_3, __pyx_t_4, __pyx_t_5, __pyx_t_9, __pyx_t_10, __pyx_t_11); + } catch(...) { + __Pyx_CppExn2PyErr(); + __PYX_ERR(0, 100, __pyx_L1_error) + } + __pyx_v_self->BlockC = __pyx_t_12; + + /* "dopt_pollublock_blockchain/blockchain.pyx":108 + * "".encode("UTF-8"), + * ) + * if self.BlockC is NULL: # <<<<<<<<<<<<<< + * raise MemoryError() + * +*/ + __pyx_t_2 = (__pyx_v_self->BlockC == NULL); + if (unlikely(__pyx_t_2)) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":109 + * ) + * if self.BlockC is NULL: + * raise MemoryError() # <<<<<<<<<<<<<< + * + * self.ptr_owner = True +*/ + PyErr_NoMemory(); __PYX_ERR(0, 109, __pyx_L1_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":108 + * "".encode("UTF-8"), + * ) + * if self.BlockC is NULL: # <<<<<<<<<<<<<< + * raise MemoryError() + * +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":111 + * raise MemoryError() + * + * self.ptr_owner = True # <<<<<<<<<<<<<< + * + * def __init__(self, *args, **kwargs): +*/ + __pyx_v_self->ptr_owner = 1; + + /* "dopt_pollublock_blockchain/blockchain.pyx":99 + * ): + * self.ptr_owner = False + * if not from_ptr: # <<<<<<<<<<<<<< + * self.BlockC = new Block( + * index, +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":91 + * bint ptr_owner + * + * def __cinit__(self, # <<<<<<<<<<<<<< + * index, + * nonce, +*/ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.PyBlock.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":113 + * self.ptr_owner = True + * + * def __init__(self, *args, **kwargs): # <<<<<<<<<<<<<< + * pass + * +*/ + +/* Python wrapper */ +static int __pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED PyObject *__pyx_v_args = 0; + CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return -1; + if (__pyx_kwds_len > 0) { + if (unlikely(__Pyx_CheckKeywordStrings("__init__", __pyx_kwds) == -1)) return -1; + } + __Pyx_INCREF(__pyx_args); + __pyx_v_args = __pyx_args; + __pyx_r = __pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_2__init__(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *)__pyx_v_self), __pyx_v_args, __pyx_v_kwargs); + + /* function exit code */ + __Pyx_DECREF(__pyx_v_args); + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_2__init__(CYTHON_UNUSED struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs) { + int __pyx_r; + + /* function exit code */ + __pyx_r = 0; + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":116 + * pass + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * if self.BlockC is not NULL and self.ptr_owner is True: + * del self.BlockC +*/ + +/* Python wrapper */ +static void __pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_5__dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_5__dealloc__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_4__dealloc__(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_4__dealloc__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__pyx_v_self) { + int __pyx_t_1; + int __pyx_t_2; + + /* "dopt_pollublock_blockchain/blockchain.pyx":117 + * + * def __dealloc__(self): + * if self.BlockC is not NULL and self.ptr_owner is True: # <<<<<<<<<<<<<< + * del self.BlockC + * self.BlockC = NULL +*/ + __pyx_t_2 = (__pyx_v_self->BlockC != NULL); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = (__pyx_v_self->ptr_owner == 1); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":118 + * def __dealloc__(self): + * if self.BlockC is not NULL and self.ptr_owner is True: + * del self.BlockC # <<<<<<<<<<<<<< + * self.BlockC = NULL + * +*/ + delete __pyx_v_self->BlockC; + + /* "dopt_pollublock_blockchain/blockchain.pyx":119 + * if self.BlockC is not NULL and self.ptr_owner is True: + * del self.BlockC + * self.BlockC = NULL # <<<<<<<<<<<<<< + * + * @staticmethod +*/ + __pyx_v_self->BlockC = NULL; + + /* "dopt_pollublock_blockchain/blockchain.pyx":117 + * + * def __dealloc__(self): + * if self.BlockC is not NULL and self.ptr_owner is True: # <<<<<<<<<<<<<< + * del self.BlockC + * self.BlockC = NULL +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":116 + * pass + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * if self.BlockC is not NULL and self.ptr_owner is True: + * del self.BlockC +*/ + + /* function exit code */ +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":121 + * self.BlockC = NULL + * + * @staticmethod # <<<<<<<<<<<<<< + * cdef PyBlock from_ptr(Block *block, bint owner=False): + * cdef PyBlock py_block = PyBlock.__new__( +*/ + +static struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__pyx_f_26dopt_pollublock_blockchain_10blockchain_7PyBlock_from_ptr(::Block *__pyx_v_block, struct __pyx_opt_args_26dopt_pollublock_blockchain_10blockchain_7PyBlock_from_ptr *__pyx_optional_args) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":122 + * + * @staticmethod + * cdef PyBlock from_ptr(Block *block, bint owner=False): # <<<<<<<<<<<<<< + * cdef PyBlock py_block = PyBlock.__new__( + * PyBlock, +*/ + int __pyx_v_owner = ((int)0); + struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__pyx_v_py_block = 0; + struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__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; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("from_ptr", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_owner = __pyx_optional_args->owner; + } + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":125 + * cdef PyBlock py_block = PyBlock.__new__( + * PyBlock, + * block.index, # <<<<<<<<<<<<<< + * block.nonce, + * block.data, +*/ + __pyx_t_1 = __Pyx_PyLong_From_uint64_t(__pyx_v_block->index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "dopt_pollublock_blockchain/blockchain.pyx":126 + * PyBlock, + * block.index, + * block.nonce, # <<<<<<<<<<<<<< + * block.data, + * block.prev_hash, +*/ + __pyx_t_2 = __Pyx_PyLong_From_uint64_t(__pyx_v_block->nonce); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "dopt_pollublock_blockchain/blockchain.pyx":127 + * block.index, + * block.nonce, + * block.data, # <<<<<<<<<<<<<< + * block.prev_hash, + * True, +*/ + __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_6libcpp_6string_std__in_string(__pyx_v_block->data); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "dopt_pollublock_blockchain/blockchain.pyx":128 + * block.nonce, + * block.data, + * block.prev_hash, # <<<<<<<<<<<<<< + * True, + * ) +*/ + __pyx_t_4 = __pyx_convert_PyBytes_string_to_py_6libcpp_6string_std__in_string(__pyx_v_block->prev_hash); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "dopt_pollublock_blockchain/blockchain.pyx":123 + * @staticmethod + * cdef PyBlock from_ptr(Block *block, bint owner=False): + * cdef PyBlock py_block = PyBlock.__new__( # <<<<<<<<<<<<<< + * PyBlock, + * block.index, +*/ + __pyx_t_5 = PyTuple_New(5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 123, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 123, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 123, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3) != (0)) __PYX_ERR(0, 123, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4) != (0)) __PYX_ERR(0, 123, __pyx_L1_error); + __Pyx_INCREF(Py_True); + __Pyx_GIVEREF(Py_True); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 4, Py_True) != (0)) __PYX_ERR(0, 123, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = ((PyObject *)__pyx_tp_new_26dopt_pollublock_blockchain_10blockchain_PyBlock(((PyTypeObject *)__pyx_mstate_global->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_PyBlock), __pyx_t_5, NULL)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 123, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_py_block = ((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":131 + * True, + * ) + * py_block.BlockC = block # <<<<<<<<<<<<<< + * py_block.ptr_owner = owner + * +*/ + __pyx_v_py_block->BlockC = __pyx_v_block; + + /* "dopt_pollublock_blockchain/blockchain.pyx":132 + * ) + * py_block.BlockC = block + * py_block.ptr_owner = owner # <<<<<<<<<<<<<< + * + * return py_block +*/ + __pyx_v_py_block->ptr_owner = __pyx_v_owner; + + /* "dopt_pollublock_blockchain/blockchain.pyx":134 + * py_block.ptr_owner = owner + * + * return py_block # <<<<<<<<<<<<<< + * + * def __repr__(self): +*/ + __Pyx_XDECREF((PyObject *)__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_py_block); + __pyx_r = __pyx_v_py_block; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":121 + * self.BlockC = NULL + * + * @staticmethod # <<<<<<<<<<<<<< + * cdef PyBlock from_ptr(Block *block, bint owner=False): + * cdef PyBlock py_block = PyBlock.__new__( +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.PyBlock.from_ptr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_py_block); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":136 + * return py_block + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return ( + * f"PyBlock(\n\tIndex:\t\t{self.index}\n\ttimestamp:\t{self.timestamp}\n\tnonce:\t\t{self.nonce}\n\t" +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_7__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_7__repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_6__repr__(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_6__repr__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__pyx_v_self) { + 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; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8[13]; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "dopt_pollublock_blockchain/blockchain.pyx":137 + * + * def __repr__(self): + * return ( # <<<<<<<<<<<<<< + * f"PyBlock(\n\tIndex:\t\t{self.index}\n\ttimestamp:\t{self.timestamp}\n\tnonce:\t\t{self.nonce}\n\t" + * f"Prev Hash:\t{self.prev_hash}\n\tHash:\t\t{self.hash}\n\tData:\t\t{self.data}\n)" +*/ + __Pyx_XDECREF(__pyx_r); + + /* "dopt_pollublock_blockchain/blockchain.pyx":138 + * def __repr__(self): + * return ( + * f"PyBlock(\n\tIndex:\t\t{self.index}\n\ttimestamp:\t{self.timestamp}\n\tnonce:\t\t{self.nonce}\n\t" # <<<<<<<<<<<<<< + * f"Prev Hash:\t{self.prev_hash}\n\tHash:\t\t{self.hash}\n\tData:\t\t{self.data}\n)" + * ) +*/ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_1, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_timestamp); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_t_1, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_nonce); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_t_1, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":139 + * return ( + * f"PyBlock(\n\tIndex:\t\t{self.index}\n\ttimestamp:\t{self.timestamp}\n\tnonce:\t\t{self.nonce}\n\t" + * f"Prev Hash:\t{self.prev_hash}\n\tHash:\t\t{self.hash}\n\tData:\t\t{self.data}\n)" # <<<<<<<<<<<<<< + * ) + * +*/ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_prev_hash); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_FormatSimple(__pyx_t_1, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_hash); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_1, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_1, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_8[0] = __pyx_mstate_global->__pyx_kp_u_PyBlock_Index; + __pyx_t_8[1] = __pyx_t_2; + __pyx_t_8[2] = __pyx_mstate_global->__pyx_kp_u_timestamp_2; + __pyx_t_8[3] = __pyx_t_3; + __pyx_t_8[4] = __pyx_mstate_global->__pyx_kp_u_nonce_2; + __pyx_t_8[5] = __pyx_t_4; + __pyx_t_8[6] = __pyx_mstate_global->__pyx_kp_u_Prev_Hash; + __pyx_t_8[7] = __pyx_t_5; + __pyx_t_8[8] = __pyx_mstate_global->__pyx_kp_u_Hash; + __pyx_t_8[9] = __pyx_t_6; + __pyx_t_8[10] = __pyx_mstate_global->__pyx_kp_u_Data; + __pyx_t_8[11] = __pyx_t_7; + __pyx_t_8[12] = __pyx_mstate_global->__pyx_kp_u__2; + + /* "dopt_pollublock_blockchain/blockchain.pyx":138 + * def __repr__(self): + * return ( + * f"PyBlock(\n\tIndex:\t\t{self.index}\n\ttimestamp:\t{self.timestamp}\n\tnonce:\t\t{self.nonce}\n\t" # <<<<<<<<<<<<<< + * f"Prev Hash:\t{self.prev_hash}\n\tHash:\t\t{self.hash}\n\tData:\t\t{self.data}\n)" + * ) +*/ + __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_8, 13, 18 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2) + 13 * 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + 10 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + 9 * 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7) + 2, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7)); + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":136 + * return py_block + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return ( + * f"PyBlock(\n\tIndex:\t\t{self.index}\n\ttimestamp:\t{self.timestamp}\n\tnonce:\t\t{self.nonce}\n\t" +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.PyBlock.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":142 + * ) + * + * def __str__(self): # <<<<<<<<<<<<<< + * return self.__repr__() + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_9__str__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_9__str__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_8__str__(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_8__str__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__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("__str__", 0); + + /* "dopt_pollublock_blockchain/blockchain.pyx":143 + * + * def __str__(self): + * return self.__repr__() # <<<<<<<<<<<<<< + * + * def serialize_dict(self): +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = ((PyObject *)__pyx_v_self); + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_repr, __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, 143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":142 + * ) + * + * def __str__(self): # <<<<<<<<<<<<<< + * return self.__repr__() + * +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.PyBlock.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":145 + * return self.__repr__() + * + * def serialize_dict(self): # <<<<<<<<<<<<<< + * contents = {} + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_11serialize_dict(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_26dopt_pollublock_blockchain_10blockchain_7PyBlock_11serialize_dict = {"serialize_dict", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_11serialize_dict, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_11serialize_dict(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("serialize_dict (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("serialize_dict", 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("serialize_dict", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_10serialize_dict(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_10serialize_dict(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__pyx_v_self) { + PyObject *__pyx_v_contents = NULL; + 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("serialize_dict", 0); + + /* "dopt_pollublock_blockchain/blockchain.pyx":146 + * + * def serialize_dict(self): + * contents = {} # <<<<<<<<<<<<<< + * + * contents["index"] = self.BlockC.index +*/ + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_contents = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":148 + * contents = {} + * + * contents["index"] = self.BlockC.index # <<<<<<<<<<<<<< + * contents["timestamp"] = self.BlockC.timestamp + * contents["nonce"] = self.BlockC.nonce +*/ + __pyx_t_1 = __Pyx_PyLong_From_uint64_t(__pyx_v_self->BlockC->index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_contents, __pyx_mstate_global->__pyx_n_u_index, __pyx_t_1) < 0))) __PYX_ERR(0, 148, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":149 + * + * contents["index"] = self.BlockC.index + * contents["timestamp"] = self.BlockC.timestamp # <<<<<<<<<<<<<< + * contents["nonce"] = self.BlockC.nonce + * contents["previous_hash"] = self.prev_hash +*/ + __pyx_t_1 = __Pyx_PyLong_From_uint64_t(__pyx_v_self->BlockC->timestamp); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_contents, __pyx_mstate_global->__pyx_n_u_timestamp, __pyx_t_1) < 0))) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":150 + * contents["index"] = self.BlockC.index + * contents["timestamp"] = self.BlockC.timestamp + * contents["nonce"] = self.BlockC.nonce # <<<<<<<<<<<<<< + * contents["previous_hash"] = self.prev_hash + * contents["hash"] = self.hash +*/ + __pyx_t_1 = __Pyx_PyLong_From_uint64_t(__pyx_v_self->BlockC->nonce); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_contents, __pyx_mstate_global->__pyx_n_u_nonce, __pyx_t_1) < 0))) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":151 + * contents["timestamp"] = self.BlockC.timestamp + * contents["nonce"] = self.BlockC.nonce + * contents["previous_hash"] = self.prev_hash # <<<<<<<<<<<<<< + * contents["hash"] = self.hash + * contents["data"] = self.data +*/ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_prev_hash); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_contents, __pyx_mstate_global->__pyx_n_u_previous_hash, __pyx_t_1) < 0))) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":152 + * contents["nonce"] = self.BlockC.nonce + * contents["previous_hash"] = self.prev_hash + * contents["hash"] = self.hash # <<<<<<<<<<<<<< + * contents["data"] = self.data + * +*/ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_hash); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_contents, __pyx_mstate_global->__pyx_n_u_hash, __pyx_t_1) < 0))) __PYX_ERR(0, 152, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":153 + * contents["previous_hash"] = self.prev_hash + * contents["hash"] = self.hash + * contents["data"] = self.data # <<<<<<<<<<<<<< + * + * return contents +*/ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_contents, __pyx_mstate_global->__pyx_n_u_data, __pyx_t_1) < 0))) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":155 + * contents["data"] = self.data + * + * return contents # <<<<<<<<<<<<<< + * + * # Python public API +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_contents); + __pyx_r = __pyx_v_contents; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":145 + * return self.__repr__() + * + * def serialize_dict(self): # <<<<<<<<<<<<<< + * contents = {} + * +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.PyBlock.serialize_dict", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_contents); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":158 + * + * # Python public API + * @property # <<<<<<<<<<<<<< + * def index(self): + * return self.BlockC.index +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_5index_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_5index_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_26dopt_pollublock_blockchain_10blockchain_7PyBlock_5index___get__(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_5index___get__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__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); + + /* "dopt_pollublock_blockchain/blockchain.pyx":160 + * @property + * def index(self): + * return self.BlockC.index # <<<<<<<<<<<<<< + * + * @property +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyLong_From_uint64_t(__pyx_v_self->BlockC->index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":158 + * + * # Python public API + * @property # <<<<<<<<<<<<<< + * def index(self): + * return self.BlockC.index +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.PyBlock.index.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":162 + * return self.BlockC.index + * + * @property # <<<<<<<<<<<<<< + * def timestamp(self): + * return timestamp_to_datetime(self.BlockC.timestamp) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_9timestamp_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_9timestamp_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_26dopt_pollublock_blockchain_10blockchain_7PyBlock_9timestamp___get__(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_9timestamp___get__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__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); + + /* "dopt_pollublock_blockchain/blockchain.pyx":164 + * @property + * def timestamp(self): + * return timestamp_to_datetime(self.BlockC.timestamp) # <<<<<<<<<<<<<< + * + * @property +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_26dopt_pollublock_blockchain_10blockchain_timestamp_to_datetime(__pyx_v_self->BlockC->timestamp); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":162 + * return self.BlockC.index + * + * @property # <<<<<<<<<<<<<< + * def timestamp(self): + * return timestamp_to_datetime(self.BlockC.timestamp) +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.PyBlock.timestamp.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":166 + * return timestamp_to_datetime(self.BlockC.timestamp) + * + * @property # <<<<<<<<<<<<<< + * def data(self): + * return self.BlockC.data.decode("UTF-8") +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_4data_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_4data_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_26dopt_pollublock_blockchain_10blockchain_7PyBlock_4data___get__(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_4data___get__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__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); + + /* "dopt_pollublock_blockchain/blockchain.pyx":168 + * @property + * def data(self): + * return self.BlockC.data.decode("UTF-8") # <<<<<<<<<<<<<< + * + * @property +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_decode_cpp_string(__pyx_v_self->BlockC->data, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 168, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":166 + * return timestamp_to_datetime(self.BlockC.timestamp) + * + * @property # <<<<<<<<<<<<<< + * def data(self): + * return self.BlockC.data.decode("UTF-8") +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.PyBlock.data.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":170 + * return self.BlockC.data.decode("UTF-8") + * + * @property # <<<<<<<<<<<<<< + * def prev_hash(self): + * return self.BlockC.prev_hash.decode("UTF-8") +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_9prev_hash_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_9prev_hash_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_26dopt_pollublock_blockchain_10blockchain_7PyBlock_9prev_hash___get__(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_9prev_hash___get__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__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); + + /* "dopt_pollublock_blockchain/blockchain.pyx":172 + * @property + * def prev_hash(self): + * return self.BlockC.prev_hash.decode("UTF-8") # <<<<<<<<<<<<<< + * + * @property +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_decode_cpp_string(__pyx_v_self->BlockC->prev_hash, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":170 + * return self.BlockC.data.decode("UTF-8") + * + * @property # <<<<<<<<<<<<<< + * def prev_hash(self): + * return self.BlockC.prev_hash.decode("UTF-8") +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.PyBlock.prev_hash.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":174 + * return self.BlockC.prev_hash.decode("UTF-8") + * + * @property # <<<<<<<<<<<<<< + * def nonce(self): + * return self.BlockC.nonce +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_5nonce_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_5nonce_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_26dopt_pollublock_blockchain_10blockchain_7PyBlock_5nonce___get__(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_5nonce___get__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__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); + + /* "dopt_pollublock_blockchain/blockchain.pyx":176 + * @property + * def nonce(self): + * return self.BlockC.nonce # <<<<<<<<<<<<<< + * + * @property +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyLong_From_uint64_t(__pyx_v_self->BlockC->nonce); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":174 + * return self.BlockC.prev_hash.decode("UTF-8") + * + * @property # <<<<<<<<<<<<<< + * def nonce(self): + * return self.BlockC.nonce +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.PyBlock.nonce.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":178 + * return self.BlockC.nonce + * + * @property # <<<<<<<<<<<<<< + * def hash(self): + * return self.BlockC.hash.decode("UTF-8") +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_4hash_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_4hash_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_26dopt_pollublock_blockchain_10blockchain_7PyBlock_4hash___get__(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_4hash___get__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__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); + + /* "dopt_pollublock_blockchain/blockchain.pyx":180 + * @property + * def hash(self): + * return self.BlockC.hash.decode("UTF-8") # <<<<<<<<<<<<<< + * + * def bytes_serialize(self): +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_decode_cpp_string(__pyx_v_self->BlockC->hash, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 180, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":178 + * return self.BlockC.nonce + * + * @property # <<<<<<<<<<<<<< + * def hash(self): + * return self.BlockC.hash.decode("UTF-8") +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.PyBlock.hash.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":182 + * return self.BlockC.hash.decode("UTF-8") + * + * def bytes_serialize(self): # <<<<<<<<<<<<<< + * cdef: + * unsigned char *serialize_res +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_13bytes_serialize(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_26dopt_pollublock_blockchain_10blockchain_7PyBlock_13bytes_serialize = {"bytes_serialize", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_13bytes_serialize, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_13bytes_serialize(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("bytes_serialize (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("bytes_serialize", 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("bytes_serialize", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_12bytes_serialize(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_12bytes_serialize(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__pyx_v_self) { + unsigned char *__pyx_v_serialize_res; + size_t __pyx_v_serialize_size; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + unsigned char *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_t_4; + char const *__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; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("bytes_serialize", 0); + + /* "dopt_pollublock_blockchain/blockchain.pyx":186 + * unsigned char *serialize_res + * size_t serialize_size + * try: # <<<<<<<<<<<<<< + * serialize_res = bytes_serialize_c(self.BlockC, &serialize_size) + * return serialize_res[:serialize_size] +*/ + /*try:*/ { + + /* "dopt_pollublock_blockchain/blockchain.pyx":187 + * size_t serialize_size + * try: + * serialize_res = bytes_serialize_c(self.BlockC, &serialize_size) # <<<<<<<<<<<<<< + * return serialize_res[:serialize_size] + * finally: +*/ + __pyx_t_1 = __pyx_f_26dopt_pollublock_blockchain_10blockchain_bytes_serialize_c(__pyx_v_self->BlockC, (&__pyx_v_serialize_size)); if (unlikely(__pyx_t_1 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 187, __pyx_L4_error) + __pyx_v_serialize_res = __pyx_t_1; + + /* "dopt_pollublock_blockchain/blockchain.pyx":188 + * try: + * serialize_res = bytes_serialize_c(self.BlockC, &serialize_size) + * return serialize_res[:serialize_size] # <<<<<<<<<<<<<< + * finally: + * free(serialize_res) +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyBytes_FromStringAndSize(((char const *)__pyx_v_serialize_res) + 0, __pyx_v_serialize_size - 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 188, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L3_return; + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":190 + * return serialize_res[:serialize_size] + * finally: + * free(serialize_res) # <<<<<<<<<<<<<< + * + * +*/ + /*finally:*/ { + __pyx_L4_error:; + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); + if ( unlikely(__Pyx_GetException(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8) < 0)) __Pyx_ErrFetch(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_11); + __pyx_t_3 = __pyx_lineno; __pyx_t_4 = __pyx_clineno; __pyx_t_5 = __pyx_filename; + { + free(__pyx_v_serialize_res); + } + __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_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_ErrRestore(__pyx_t_6, __pyx_t_7, __pyx_t_8); + __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; + __pyx_lineno = __pyx_t_3; __pyx_clineno = __pyx_t_4; __pyx_filename = __pyx_t_5; + goto __pyx_L1_error; + } + __pyx_L3_return: { + __pyx_t_11 = __pyx_r; + __pyx_r = 0; + free(__pyx_v_serialize_res); + __pyx_r = __pyx_t_11; + __pyx_t_11 = 0; + goto __pyx_L0; + } + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":182 + * return self.BlockC.hash.decode("UTF-8") + * + * def bytes_serialize(self): # <<<<<<<<<<<<<< + * cdef: + * unsigned char *serialize_res +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.PyBlock.bytes_serialize", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":193 + * + * + * def perform_hash(self): # <<<<<<<<<<<<<< + * cdef: + * unsigned char *digest +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_15perform_hash(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_26dopt_pollublock_blockchain_10blockchain_7PyBlock_15perform_hash = {"perform_hash", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_15perform_hash, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_15perform_hash(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("perform_hash (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("perform_hash", 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("perform_hash", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_14perform_hash(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_14perform_hash(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__pyx_v_self) { + unsigned char *__pyx_v_digest; + size_t __pyx_v_digest_size; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + unsigned char *__pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + size_t __pyx_t_8; + std::string __pyx_t_9; + int __pyx_t_10; + int __pyx_t_11; + char const *__pyx_t_12; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + PyObject *__pyx_t_15 = NULL; + PyObject *__pyx_t_16 = NULL; + PyObject *__pyx_t_17 = NULL; + PyObject *__pyx_t_18 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("perform_hash", 0); + + /* "dopt_pollublock_blockchain/blockchain.pyx":198 + * size_t digest_size + * + * try: # <<<<<<<<<<<<<< + * digest = perform_hash_c(self.BlockC, &digest_size) + * if digest is NULL: +*/ + /*try:*/ { + + /* "dopt_pollublock_blockchain/blockchain.pyx":199 + * + * try: + * digest = perform_hash_c(self.BlockC, &digest_size) # <<<<<<<<<<<<<< + * if digest is NULL: + * raise MemoryError() +*/ + __pyx_t_1 = __pyx_f_26dopt_pollublock_blockchain_10blockchain_perform_hash_c(__pyx_v_self->BlockC, (&__pyx_v_digest_size)); if (unlikely(__pyx_t_1 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 199, __pyx_L4_error) + __pyx_v_digest = __pyx_t_1; + + /* "dopt_pollublock_blockchain/blockchain.pyx":200 + * try: + * digest = perform_hash_c(self.BlockC, &digest_size) + * if digest is NULL: # <<<<<<<<<<<<<< + * raise MemoryError() + * # TODO out: hash assignment in blockchain +*/ + __pyx_t_2 = (__pyx_v_digest == NULL); + if (unlikely(__pyx_t_2)) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":201 + * digest = perform_hash_c(self.BlockC, &digest_size) + * if digest is NULL: + * raise MemoryError() # <<<<<<<<<<<<<< + * # TODO out: hash assignment in blockchain + * self.BlockC.hash = bytes(digest[:digest_size]).hex().encode("UTF-8") +*/ + PyErr_NoMemory(); __PYX_ERR(0, 201, __pyx_L4_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":200 + * try: + * digest = perform_hash_c(self.BlockC, &digest_size) + * if digest is NULL: # <<<<<<<<<<<<<< + * raise MemoryError() + * # TODO out: hash assignment in blockchain +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":203 + * raise MemoryError() + * # TODO out: hash assignment in blockchain + * self.BlockC.hash = bytes(digest[:digest_size]).hex().encode("UTF-8") # <<<<<<<<<<<<<< + * finally: + * free(digest) +*/ + __pyx_t_6 = NULL; + __pyx_t_7 = __Pyx_PyBytes_FromStringAndSize(((char const *)__pyx_v_digest) + 0, __pyx_v_digest_size - 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 203, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_7}; + __pyx_t_5 = __Pyx_PyObject_FastCall((PyObject*)(&PyBytes_Type), __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 203, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_5); + } + __pyx_t_4 = __pyx_t_5; + __Pyx_INCREF(__pyx_t_4); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_hex, __pyx_callargs+__pyx_t_8, (1-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 203, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_t_5 = PyUnicode_AsUTF8String(((PyObject*)__pyx_t_3)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 203, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_9 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_t_5); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 203, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_self->BlockC->hash = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_9); + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":205 + * self.BlockC.hash = bytes(digest[:digest_size]).hex().encode("UTF-8") + * finally: + * free(digest) # <<<<<<<<<<<<<< + * # TODO rework + * return self.hash +*/ + /*finally:*/ { + /*normal exit:*/{ + free(__pyx_v_digest); + goto __pyx_L5; + } + __pyx_L4_error:; + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_ExceptionSwap(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18); + if ( unlikely(__Pyx_GetException(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15) < 0)) __Pyx_ErrFetch(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15); + __Pyx_XGOTREF(__pyx_t_13); + __Pyx_XGOTREF(__pyx_t_14); + __Pyx_XGOTREF(__pyx_t_15); + __Pyx_XGOTREF(__pyx_t_16); + __Pyx_XGOTREF(__pyx_t_17); + __Pyx_XGOTREF(__pyx_t_18); + __pyx_t_10 = __pyx_lineno; __pyx_t_11 = __pyx_clineno; __pyx_t_12 = __pyx_filename; + { + free(__pyx_v_digest); + } + __Pyx_XGIVEREF(__pyx_t_16); + __Pyx_XGIVEREF(__pyx_t_17); + __Pyx_XGIVEREF(__pyx_t_18); + __Pyx_ExceptionReset(__pyx_t_16, __pyx_t_17, __pyx_t_18); + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_XGIVEREF(__pyx_t_14); + __Pyx_XGIVEREF(__pyx_t_15); + __Pyx_ErrRestore(__pyx_t_13, __pyx_t_14, __pyx_t_15); + __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; + __pyx_lineno = __pyx_t_10; __pyx_clineno = __pyx_t_11; __pyx_filename = __pyx_t_12; + goto __pyx_L1_error; + } + __pyx_L5:; + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":207 + * free(digest) + * # TODO rework + * return self.hash # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_hash); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":193 + * + * + * def perform_hash(self): # <<<<<<<<<<<<<< + * cdef: + * unsigned char *digest +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.PyBlock.perform_hash", __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, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_17__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_26dopt_pollublock_blockchain_10blockchain_7PyBlock_17__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_17__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_16__reduce_cython__(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_16__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__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, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_TypeError))), __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.PyBlock.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_19__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_26dopt_pollublock_blockchain_10blockchain_7PyBlock_19__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_19__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_19__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 3, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__setstate_cython__", 0) < (0)) __PYX_ERR(1, 3, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 3, __pyx_L3_error) + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.PyBlock.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_26dopt_pollublock_blockchain_10blockchain_7PyBlock_18__setstate_cython__(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *)__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_26dopt_pollublock_blockchain_10blockchain_7PyBlock_18__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__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, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_TypeError))), __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.PyBlock.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":210 + * + * + * cdef unsigned char* bytes_serialize_c(Block *block, size_t *size) nogil: # <<<<<<<<<<<<<< + * cdef: + * size_t total_len +*/ + +static unsigned char *__pyx_f_26dopt_pollublock_blockchain_10blockchain_bytes_serialize_c(::Block *__pyx_v_block, size_t *__pyx_v_size) { + unsigned char *__pyx_v_buf; + size_t __pyx_v_pos; + unsigned char *__pyx_r; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyGILState_STATE __pyx_gilstate_save; + + /* "dopt_pollublock_blockchain/blockchain.pyx":214 + * size_t total_len + * unsigned char* buf + * size_t pos = 0 # <<<<<<<<<<<<<< + * + * # index (8), timestamp (8), nonce (8), data, prev_hash +*/ + __pyx_v_pos = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":217 + * + * # index (8), timestamp (8), nonce (8), data, prev_hash + * size[0] = ( # <<<<<<<<<<<<<< + * (8 * 3) + + * block.data.size() + +*/ + (__pyx_v_size[0]) = ((((size_t)0x18) + __pyx_v_block->data.size()) + __pyx_v_block->prev_hash.size()); + + /* "dopt_pollublock_blockchain/blockchain.pyx":222 + * block.prev_hash.size() + * ) + * buf = malloc(size[0] * sizeof(unsigned char)) # <<<<<<<<<<<<<< + * + * if buf is NULL: +*/ + __pyx_v_buf = ((unsigned char *)malloc(((__pyx_v_size[0]) * (sizeof(unsigned char))))); + + /* "dopt_pollublock_blockchain/blockchain.pyx":224 + * buf = malloc(size[0] * sizeof(unsigned char)) + * + * if buf is NULL: # <<<<<<<<<<<<<< + * return NULL + * +*/ + __pyx_t_1 = (__pyx_v_buf == NULL); + if (__pyx_t_1) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":225 + * + * if buf is NULL: + * return NULL # <<<<<<<<<<<<<< + * + * serialize_uint64(buf + pos, block.index) +*/ + __pyx_r = NULL; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":224 + * buf = malloc(size[0] * sizeof(unsigned char)) + * + * if buf is NULL: # <<<<<<<<<<<<<< + * return NULL + * +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":227 + * return NULL + * + * serialize_uint64(buf + pos, block.index) # <<<<<<<<<<<<<< + * pos += 8 + * serialize_uint64(buf + pos, block.timestamp) +*/ + __pyx_t_2 = __pyx_f_26dopt_pollublock_blockchain_10blockchain_serialize_uint64((__pyx_v_buf + __pyx_v_pos), __pyx_v_block->index); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 227, __pyx_L1_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":228 + * + * serialize_uint64(buf + pos, block.index) + * pos += 8 # <<<<<<<<<<<<<< + * serialize_uint64(buf + pos, block.timestamp) + * pos += 8 +*/ + __pyx_v_pos = (__pyx_v_pos + 8); + + /* "dopt_pollublock_blockchain/blockchain.pyx":229 + * serialize_uint64(buf + pos, block.index) + * pos += 8 + * serialize_uint64(buf + pos, block.timestamp) # <<<<<<<<<<<<<< + * pos += 8 + * serialize_uint64(buf + pos, block.nonce) +*/ + __pyx_t_2 = __pyx_f_26dopt_pollublock_blockchain_10blockchain_serialize_uint64((__pyx_v_buf + __pyx_v_pos), __pyx_v_block->timestamp); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 229, __pyx_L1_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":230 + * pos += 8 + * serialize_uint64(buf + pos, block.timestamp) + * pos += 8 # <<<<<<<<<<<<<< + * serialize_uint64(buf + pos, block.nonce) + * pos += 8 +*/ + __pyx_v_pos = (__pyx_v_pos + 8); + + /* "dopt_pollublock_blockchain/blockchain.pyx":231 + * serialize_uint64(buf + pos, block.timestamp) + * pos += 8 + * serialize_uint64(buf + pos, block.nonce) # <<<<<<<<<<<<<< + * pos += 8 + * # Copy data +*/ + __pyx_t_2 = __pyx_f_26dopt_pollublock_blockchain_10blockchain_serialize_uint64((__pyx_v_buf + __pyx_v_pos), __pyx_v_block->nonce); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 231, __pyx_L1_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":232 + * pos += 8 + * serialize_uint64(buf + pos, block.nonce) + * pos += 8 # <<<<<<<<<<<<<< + * # Copy data + * memcpy( +*/ + __pyx_v_pos = (__pyx_v_pos + 8); + + /* "dopt_pollublock_blockchain/blockchain.pyx":234 + * pos += 8 + * # Copy data + * memcpy( # <<<<<<<<<<<<<< + * buf + pos, + * block.data.c_str(), +*/ + (void)(memcpy((__pyx_v_buf + __pyx_v_pos), __pyx_v_block->data.c_str(), __pyx_v_block->data.size())); + + /* "dopt_pollublock_blockchain/blockchain.pyx":239 + * block.data.size(), + * ) + * pos += block.data.size() # <<<<<<<<<<<<<< + * # Copy prev_hash + * memcpy( +*/ + __pyx_v_pos = (__pyx_v_pos + __pyx_v_block->data.size()); + + /* "dopt_pollublock_blockchain/blockchain.pyx":241 + * pos += block.data.size() + * # Copy prev_hash + * memcpy( # <<<<<<<<<<<<<< + * buf + pos, + * block.prev_hash.c_str(), +*/ + (void)(memcpy((__pyx_v_buf + __pyx_v_pos), __pyx_v_block->prev_hash.c_str(), __pyx_v_block->prev_hash.size())); + + /* "dopt_pollublock_blockchain/blockchain.pyx":246 + * block.prev_hash.size(), + * ) + * pos += block.prev_hash.size() # <<<<<<<<<<<<<< + * + * return buf +*/ + __pyx_v_pos = (__pyx_v_pos + __pyx_v_block->prev_hash.size()); + + /* "dopt_pollublock_blockchain/blockchain.pyx":248 + * pos += block.prev_hash.size() + * + * return buf # <<<<<<<<<<<<<< + * + * cdef unsigned char* SHA256_digest(const void *data, size_t data_size, size_t *digest_size) nogil: +*/ + __pyx_r = __pyx_v_buf; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":210 + * + * + * cdef unsigned char* bytes_serialize_c(Block *block, size_t *size) nogil: # <<<<<<<<<<<<<< + * cdef: + * size_t total_len +*/ + + /* function exit code */ + __pyx_L1_error:; + __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.bytes_serialize_c", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_PyGILState_Release(__pyx_gilstate_save); + __pyx_L0:; + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":250 + * return buf + * + * cdef unsigned char* SHA256_digest(const void *data, size_t data_size, size_t *digest_size) nogil: # <<<<<<<<<<<<<< + * cdef ossl.EVP_MD_CTX *ctx = ossl.EVP_MD_CTX_new() + * if ctx is NULL: +*/ + +static unsigned char *__pyx_f_26dopt_pollublock_blockchain_10blockchain_SHA256_digest(void const *__pyx_v_data, size_t __pyx_v_data_size, size_t *__pyx_v_digest_size) { + EVP_MD_CTX *__pyx_v_ctx; + EVP_MD const *__pyx_v_algo; + unsigned char *__pyx_v_digest; + size_t __pyx_v_dig_buff_len; + unsigned int __pyx_v_digest_len; + unsigned char *__pyx_r; + int __pyx_t_1; + + /* "dopt_pollublock_blockchain/blockchain.pyx":251 + * + * cdef unsigned char* SHA256_digest(const void *data, size_t data_size, size_t *digest_size) nogil: + * cdef ossl.EVP_MD_CTX *ctx = ossl.EVP_MD_CTX_new() # <<<<<<<<<<<<<< + * if ctx is NULL: + * return NULL +*/ + __pyx_v_ctx = EVP_MD_CTX_new(); + + /* "dopt_pollublock_blockchain/blockchain.pyx":252 + * cdef unsigned char* SHA256_digest(const void *data, size_t data_size, size_t *digest_size) nogil: + * cdef ossl.EVP_MD_CTX *ctx = ossl.EVP_MD_CTX_new() + * if ctx is NULL: # <<<<<<<<<<<<<< + * return NULL + * cdef const ossl.EVP_MD *algo = ossl.EVP_sha256() +*/ + __pyx_t_1 = (__pyx_v_ctx == NULL); + if (__pyx_t_1) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":253 + * cdef ossl.EVP_MD_CTX *ctx = ossl.EVP_MD_CTX_new() + * if ctx is NULL: + * return NULL # <<<<<<<<<<<<<< + * cdef const ossl.EVP_MD *algo = ossl.EVP_sha256() + * if algo is NULL: +*/ + __pyx_r = NULL; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":252 + * cdef unsigned char* SHA256_digest(const void *data, size_t data_size, size_t *digest_size) nogil: + * cdef ossl.EVP_MD_CTX *ctx = ossl.EVP_MD_CTX_new() + * if ctx is NULL: # <<<<<<<<<<<<<< + * return NULL + * cdef const ossl.EVP_MD *algo = ossl.EVP_sha256() +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":254 + * if ctx is NULL: + * return NULL + * cdef const ossl.EVP_MD *algo = ossl.EVP_sha256() # <<<<<<<<<<<<<< + * if algo is NULL: + * return NULL +*/ + __pyx_v_algo = EVP_sha256(); + + /* "dopt_pollublock_blockchain/blockchain.pyx":255 + * return NULL + * cdef const ossl.EVP_MD *algo = ossl.EVP_sha256() + * if algo is NULL: # <<<<<<<<<<<<<< + * return NULL + * +*/ + __pyx_t_1 = (__pyx_v_algo == NULL); + if (__pyx_t_1) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":256 + * cdef const ossl.EVP_MD *algo = ossl.EVP_sha256() + * if algo is NULL: + * return NULL # <<<<<<<<<<<<<< + * + * cdef: +*/ + __pyx_r = NULL; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":255 + * return NULL + * cdef const ossl.EVP_MD *algo = ossl.EVP_sha256() + * if algo is NULL: # <<<<<<<<<<<<<< + * return NULL + * +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":263 + * unsigned int digest_len + * + * dig_buff_len = ossl.EVP_MD_size(algo) # <<<<<<<<<<<<<< + * digest_size[0] = dig_buff_len + * digest = malloc(dig_buff_len * sizeof(unsigned char)) +*/ + __pyx_v_dig_buff_len = ((size_t)EVP_MD_size(__pyx_v_algo)); + + /* "dopt_pollublock_blockchain/blockchain.pyx":264 + * + * dig_buff_len = ossl.EVP_MD_size(algo) + * digest_size[0] = dig_buff_len # <<<<<<<<<<<<<< + * digest = malloc(dig_buff_len * sizeof(unsigned char)) + * ossl.EVP_DigestInit_ex(ctx, algo, NULL) +*/ + (__pyx_v_digest_size[0]) = __pyx_v_dig_buff_len; + + /* "dopt_pollublock_blockchain/blockchain.pyx":265 + * dig_buff_len = ossl.EVP_MD_size(algo) + * digest_size[0] = dig_buff_len + * digest = malloc(dig_buff_len * sizeof(unsigned char)) # <<<<<<<<<<<<<< + * ossl.EVP_DigestInit_ex(ctx, algo, NULL) + * ossl.EVP_DigestUpdate(ctx, data, data_size) +*/ + __pyx_v_digest = ((unsigned char *)malloc((__pyx_v_dig_buff_len * (sizeof(unsigned char))))); + + /* "dopt_pollublock_blockchain/blockchain.pyx":266 + * digest_size[0] = dig_buff_len + * digest = malloc(dig_buff_len * sizeof(unsigned char)) + * ossl.EVP_DigestInit_ex(ctx, algo, NULL) # <<<<<<<<<<<<<< + * ossl.EVP_DigestUpdate(ctx, data, data_size) + * ossl.EVP_DigestFinal_ex(ctx, digest, &digest_len) +*/ + (void)(EVP_DigestInit_ex(__pyx_v_ctx, __pyx_v_algo, NULL)); + + /* "dopt_pollublock_blockchain/blockchain.pyx":267 + * digest = malloc(dig_buff_len * sizeof(unsigned char)) + * ossl.EVP_DigestInit_ex(ctx, algo, NULL) + * ossl.EVP_DigestUpdate(ctx, data, data_size) # <<<<<<<<<<<<<< + * ossl.EVP_DigestFinal_ex(ctx, digest, &digest_len) + * +*/ + (void)(EVP_DigestUpdate(__pyx_v_ctx, __pyx_v_data, __pyx_v_data_size)); + + /* "dopt_pollublock_blockchain/blockchain.pyx":268 + * ossl.EVP_DigestInit_ex(ctx, algo, NULL) + * ossl.EVP_DigestUpdate(ctx, data, data_size) + * ossl.EVP_DigestFinal_ex(ctx, digest, &digest_len) # <<<<<<<<<<<<<< + * + * ossl.EVP_MD_CTX_free(ctx) +*/ + (void)(EVP_DigestFinal_ex(__pyx_v_ctx, __pyx_v_digest, (&__pyx_v_digest_len))); + + /* "dopt_pollublock_blockchain/blockchain.pyx":270 + * ossl.EVP_DigestFinal_ex(ctx, digest, &digest_len) + * + * ossl.EVP_MD_CTX_free(ctx) # <<<<<<<<<<<<<< + * + * return digest +*/ + EVP_MD_CTX_free(__pyx_v_ctx); + + /* "dopt_pollublock_blockchain/blockchain.pyx":272 + * ossl.EVP_MD_CTX_free(ctx) + * + * return digest # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = __pyx_v_digest; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":250 + * return buf + * + * cdef unsigned char* SHA256_digest(const void *data, size_t data_size, size_t *digest_size) nogil: # <<<<<<<<<<<<<< + * cdef ossl.EVP_MD_CTX *ctx = ossl.EVP_MD_CTX_new() + * if ctx is NULL: +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":275 + * + * + * cdef unsigned char* perform_hash_c(Block *block, size_t *digest_size) nogil: # <<<<<<<<<<<<<< + * cdef: + * unsigned char *serialize_res +*/ + +static unsigned char *__pyx_f_26dopt_pollublock_blockchain_10blockchain_perform_hash_c(::Block *__pyx_v_block, size_t *__pyx_v_digest_size) { + unsigned char *__pyx_v_serialize_res; + size_t __pyx_v_serialize_size; + unsigned char *__pyx_v_digest; + unsigned char *__pyx_r; + unsigned char *__pyx_t_1; + int __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyGILState_STATE __pyx_gilstate_save; + + /* "dopt_pollublock_blockchain/blockchain.pyx":281 + * unsigned char *digest + * + * serialize_res = bytes_serialize_c(block, &serialize_size) # <<<<<<<<<<<<<< + * if serialize_res is NULL: + * return NULL +*/ + __pyx_t_1 = __pyx_f_26dopt_pollublock_blockchain_10blockchain_bytes_serialize_c(__pyx_v_block, (&__pyx_v_serialize_size)); if (unlikely(__pyx_t_1 == ((void *)NULL) && __Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 281, __pyx_L1_error) + __pyx_v_serialize_res = __pyx_t_1; + + /* "dopt_pollublock_blockchain/blockchain.pyx":282 + * + * serialize_res = bytes_serialize_c(block, &serialize_size) + * if serialize_res is NULL: # <<<<<<<<<<<<<< + * return NULL + * digest = SHA256_digest(serialize_res, serialize_size, digest_size) +*/ + __pyx_t_2 = (__pyx_v_serialize_res == NULL); + if (__pyx_t_2) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":283 + * serialize_res = bytes_serialize_c(block, &serialize_size) + * if serialize_res is NULL: + * return NULL # <<<<<<<<<<<<<< + * digest = SHA256_digest(serialize_res, serialize_size, digest_size) + * free(serialize_res) +*/ + __pyx_r = NULL; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":282 + * + * serialize_res = bytes_serialize_c(block, &serialize_size) + * if serialize_res is NULL: # <<<<<<<<<<<<<< + * return NULL + * digest = SHA256_digest(serialize_res, serialize_size, digest_size) +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":284 + * if serialize_res is NULL: + * return NULL + * digest = SHA256_digest(serialize_res, serialize_size, digest_size) # <<<<<<<<<<<<<< + * free(serialize_res) + * if digest is NULL: +*/ + __pyx_t_1 = __pyx_f_26dopt_pollublock_blockchain_10blockchain_SHA256_digest(__pyx_v_serialize_res, __pyx_v_serialize_size, __pyx_v_digest_size); if (unlikely(__pyx_t_1 == ((void *)NULL) && __Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 284, __pyx_L1_error) + __pyx_v_digest = __pyx_t_1; + + /* "dopt_pollublock_blockchain/blockchain.pyx":285 + * return NULL + * digest = SHA256_digest(serialize_res, serialize_size, digest_size) + * free(serialize_res) # <<<<<<<<<<<<<< + * if digest is NULL: + * return NULL +*/ + free(__pyx_v_serialize_res); + + /* "dopt_pollublock_blockchain/blockchain.pyx":286 + * digest = SHA256_digest(serialize_res, serialize_size, digest_size) + * free(serialize_res) + * if digest is NULL: # <<<<<<<<<<<<<< + * return NULL + * +*/ + __pyx_t_2 = (__pyx_v_digest == NULL); + if (__pyx_t_2) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":287 + * free(serialize_res) + * if digest is NULL: + * return NULL # <<<<<<<<<<<<<< + * + * return digest +*/ + __pyx_r = NULL; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":286 + * digest = SHA256_digest(serialize_res, serialize_size, digest_size) + * free(serialize_res) + * if digest is NULL: # <<<<<<<<<<<<<< + * return NULL + * +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":289 + * return NULL + * + * return digest # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = __pyx_v_digest; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":275 + * + * + * cdef unsigned char* perform_hash_c(Block *block, size_t *digest_size) nogil: # <<<<<<<<<<<<<< + * cdef: + * unsigned char *serialize_res +*/ + + /* function exit code */ + __pyx_L1_error:; + __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.perform_hash_c", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_PyGILState_Release(__pyx_gilstate_save); + __pyx_L0:; + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":292 + * + * + * cdef int mine_block(Block *block, unsigned int difficulty, uint64_t *nonce_solution, unsigned int max_nonce=0xFFFFFFFF) nogil: # <<<<<<<<<<<<<< + * cdef: + * unsigned char *serial_buf +*/ + +static int __pyx_f_26dopt_pollublock_blockchain_10blockchain_mine_block(::Block *__pyx_v_block, unsigned int __pyx_v_difficulty, uint64_t *__pyx_v_nonce_solution, struct __pyx_opt_args_26dopt_pollublock_blockchain_10blockchain_mine_block *__pyx_optional_args) { + unsigned int __pyx_v_max_nonce = ((unsigned int)0xFFFFFFFF); + unsigned char *__pyx_v_serial_buf; + size_t __pyx_v_serialize_size; + unsigned char *__pyx_v_digest; + size_t __pyx_v_digest_size; + int __pyx_v_nonce_found; + int __pyx_v_nonce; + int __pyx_r; + unsigned char *__pyx_t_1; + unsigned int __pyx_t_2; + unsigned int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyGILState_STATE __pyx_gilstate_save; + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_max_nonce = __pyx_optional_args->max_nonce; + } + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":298 + * unsigned char *digest + * size_t digest_size + * bint nonce_found = False # <<<<<<<<<<<<<< + * int nonce + * +*/ + __pyx_v_nonce_found = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":301 + * int nonce + * + * serial_buf = bytes_serialize_c(block, &serialize_size) # <<<<<<<<<<<<<< + * + * with nogil: +*/ + __pyx_t_1 = __pyx_f_26dopt_pollublock_blockchain_10blockchain_bytes_serialize_c(__pyx_v_block, (&__pyx_v_serialize_size)); if (unlikely(__pyx_t_1 == ((void *)NULL) && __Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 301, __pyx_L1_error) + __pyx_v_serial_buf = __pyx_t_1; + + /* "dopt_pollublock_blockchain/blockchain.pyx":303 + * serial_buf = bytes_serialize_c(block, &serialize_size) + * + * with nogil: # <<<<<<<<<<<<<< + * for nonce in range(max_nonce): + * serialize_uint64(serial_buf + NONCE_OFFSET, nonce) +*/ + { + __Pyx_UnknownThreadState _save; + _save = __Pyx_SaveUnknownThread(); + __Pyx_FastGIL_Remember(); + /*try:*/ { + + /* "dopt_pollublock_blockchain/blockchain.pyx":304 + * + * with nogil: + * for nonce in range(max_nonce): # <<<<<<<<<<<<<< + * serialize_uint64(serial_buf + NONCE_OFFSET, nonce) + * digest = SHA256_digest(serial_buf, serialize_size, &digest_size) +*/ + __pyx_t_2 = __pyx_v_max_nonce; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_nonce = __pyx_t_4; + + /* "dopt_pollublock_blockchain/blockchain.pyx":305 + * with nogil: + * for nonce in range(max_nonce): + * serialize_uint64(serial_buf + NONCE_OFFSET, nonce) # <<<<<<<<<<<<<< + * digest = SHA256_digest(serial_buf, serialize_size, &digest_size) + * +*/ + __pyx_t_5 = __pyx_f_26dopt_pollublock_blockchain_10blockchain_serialize_uint64((__pyx_v_serial_buf + __pyx_v_26dopt_pollublock_blockchain_10blockchain_NONCE_OFFSET), ((uint64_t)__pyx_v_nonce)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 305, __pyx_L4_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":306 + * for nonce in range(max_nonce): + * serialize_uint64(serial_buf + NONCE_OFFSET, nonce) + * digest = SHA256_digest(serial_buf, serialize_size, &digest_size) # <<<<<<<<<<<<<< + * + * if has_leading_zero_bits(digest, difficulty): +*/ + __pyx_t_1 = __pyx_f_26dopt_pollublock_blockchain_10blockchain_SHA256_digest(__pyx_v_serial_buf, __pyx_v_serialize_size, (&__pyx_v_digest_size)); if (unlikely(__pyx_t_1 == ((void *)NULL) && __Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 306, __pyx_L4_error) + __pyx_v_digest = __pyx_t_1; + + /* "dopt_pollublock_blockchain/blockchain.pyx":308 + * digest = SHA256_digest(serial_buf, serialize_size, &digest_size) + * + * if has_leading_zero_bits(digest, difficulty): # <<<<<<<<<<<<<< + * nonce_found = True + * nonce_solution[0] = nonce +*/ + __pyx_t_6 = __pyx_f_26dopt_pollublock_blockchain_10blockchain_has_leading_zero_bits(__pyx_v_digest, __pyx_v_difficulty); if (unlikely(__pyx_t_6 == ((int)-1) && __Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 308, __pyx_L4_error) + if (__pyx_t_6) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":309 + * + * if has_leading_zero_bits(digest, difficulty): + * nonce_found = True # <<<<<<<<<<<<<< + * nonce_solution[0] = nonce + * break +*/ + __pyx_v_nonce_found = 1; + + /* "dopt_pollublock_blockchain/blockchain.pyx":310 + * if has_leading_zero_bits(digest, difficulty): + * nonce_found = True + * nonce_solution[0] = nonce # <<<<<<<<<<<<<< + * break + * +*/ + (__pyx_v_nonce_solution[0]) = __pyx_v_nonce; + + /* "dopt_pollublock_blockchain/blockchain.pyx":311 + * nonce_found = True + * nonce_solution[0] = nonce + * break # <<<<<<<<<<<<<< + * + * free(digest) +*/ + goto __pyx_L7_break; + + /* "dopt_pollublock_blockchain/blockchain.pyx":308 + * digest = SHA256_digest(serial_buf, serialize_size, &digest_size) + * + * if has_leading_zero_bits(digest, difficulty): # <<<<<<<<<<<<<< + * nonce_found = True + * nonce_solution[0] = nonce +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":313 + * break + * + * free(digest) # <<<<<<<<<<<<<< + * + * free(serial_buf) +*/ + free(__pyx_v_digest); + } + __pyx_L7_break:; + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":303 + * serial_buf = bytes_serialize_c(block, &serialize_size) + * + * with nogil: # <<<<<<<<<<<<<< + * for nonce in range(max_nonce): + * serialize_uint64(serial_buf + NONCE_OFFSET, nonce) +*/ + /*finally:*/ { + /*normal exit:*/{ + __Pyx_FastGIL_Forget(); + __Pyx_RestoreUnknownThread(_save); + goto __pyx_L5; + } + __pyx_L4_error: { + __Pyx_FastGIL_Forget(); + __Pyx_RestoreUnknownThread(_save); + goto __pyx_L1_error; + } + __pyx_L5:; + } + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":315 + * free(digest) + * + * free(serial_buf) # <<<<<<<<<<<<<< + * + * if not nonce_found: +*/ + free(__pyx_v_serial_buf); + + /* "dopt_pollublock_blockchain/blockchain.pyx":317 + * free(serial_buf) + * + * if not nonce_found: # <<<<<<<<<<<<<< + * return 1 + * +*/ + __pyx_t_6 = (!__pyx_v_nonce_found); + if (__pyx_t_6) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":318 + * + * if not nonce_found: + * return 1 # <<<<<<<<<<<<<< + * + * return 0 +*/ + __pyx_r = 1; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":317 + * free(serial_buf) + * + * if not nonce_found: # <<<<<<<<<<<<<< + * return 1 + * +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":320 + * return 1 + * + * return 0 # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = 0; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":292 + * + * + * cdef int mine_block(Block *block, unsigned int difficulty, uint64_t *nonce_solution, unsigned int max_nonce=0xFFFFFFFF) nogil: # <<<<<<<<<<<<<< + * cdef: + * unsigned char *serial_buf +*/ + + /* function exit code */ + __pyx_L1_error:; + __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.mine_block", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_PyGILState_Release(__pyx_gilstate_save); + __pyx_L0:; + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":334 + * readonly object _engine + * + * def __cinit__(self, *args, **kwargs): # <<<<<<<<<<<<<< + * self._difficulty = 26 + * self._index = 0 +*/ + +/* Python wrapper */ +static int __pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED PyObject *__pyx_v_args = 0; + CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return -1; + if (__pyx_kwds_len > 0) { + if (unlikely(__Pyx_CheckKeywordStrings("__cinit__", __pyx_kwds) == -1)) return -1; + } + __Pyx_INCREF(__pyx_args); + __pyx_v_args = __pyx_args; + __pyx_r = __pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain___cinit__(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *)__pyx_v_self), __pyx_v_args, __pyx_v_kwargs); + + /* function exit code */ + __Pyx_DECREF(__pyx_v_args); + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain___cinit__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs) { + int __pyx_r; + __Pyx_RefNannyDeclarations + std::unordered_map *__pyx_t_1; + std::vector<::Block *> *__pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + size_t __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* "dopt_pollublock_blockchain/blockchain.pyx":335 + * + * def __cinit__(self, *args, **kwargs): + * self._difficulty = 26 # <<<<<<<<<<<<<< + * self._index = 0 + * self._genesis_done = False +*/ + __pyx_v_self->_difficulty = 26; + + /* "dopt_pollublock_blockchain/blockchain.pyx":336 + * def __cinit__(self, *args, **kwargs): + * self._difficulty = 26 + * self._index = 0 # <<<<<<<<<<<<<< + * self._genesis_done = False + * self._loaded = False +*/ + __pyx_v_self->_index = ((uint64_t)0); + + /* "dopt_pollublock_blockchain/blockchain.pyx":337 + * self._difficulty = 26 + * self._index = 0 + * self._genesis_done = False # <<<<<<<<<<<<<< + * self._loaded = False + * self._chain_map = new unordered_map[uint64_t, Block*]() +*/ + __pyx_v_self->_genesis_done = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":338 + * self._index = 0 + * self._genesis_done = False + * self._loaded = False # <<<<<<<<<<<<<< + * self._chain_map = new unordered_map[uint64_t, Block*]() + * self._chain = new vector[Block*]() +*/ + __pyx_v_self->_loaded = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":339 + * self._genesis_done = False + * self._loaded = False + * self._chain_map = new unordered_map[uint64_t, Block*]() # <<<<<<<<<<<<<< + * self._chain = new vector[Block*]() + * if self._chain_map is NULL: +*/ + try { + __pyx_t_1 = new std::unordered_map (); + } catch(...) { + __Pyx_CppExn2PyErr(); + __PYX_ERR(0, 339, __pyx_L1_error) + } + __pyx_v_self->_chain_map = __pyx_t_1; + + /* "dopt_pollublock_blockchain/blockchain.pyx":340 + * self._loaded = False + * self._chain_map = new unordered_map[uint64_t, Block*]() + * self._chain = new vector[Block*]() # <<<<<<<<<<<<<< + * if self._chain_map is NULL: + * raise MemoryError("Could not allocate hasmap") +*/ + try { + __pyx_t_2 = new std::vector<::Block *> (); + } catch(...) { + __Pyx_CppExn2PyErr(); + __PYX_ERR(0, 340, __pyx_L1_error) + } + __pyx_v_self->_chain = __pyx_t_2; + + /* "dopt_pollublock_blockchain/blockchain.pyx":341 + * self._chain_map = new unordered_map[uint64_t, Block*]() + * self._chain = new vector[Block*]() + * if self._chain_map is NULL: # <<<<<<<<<<<<<< + * raise MemoryError("Could not allocate hasmap") + * if self._chain is NULL: +*/ + __pyx_t_3 = (__pyx_v_self->_chain_map == NULL); + if (unlikely(__pyx_t_3)) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":342 + * self._chain = new vector[Block*]() + * if self._chain_map is NULL: + * raise MemoryError("Could not allocate hasmap") # <<<<<<<<<<<<<< + * if self._chain is NULL: + * raise MemoryError("Could not allocate vector") +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_Could_not_allocate_hasmap}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_MemoryError)), __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, 342, __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, 342, __pyx_L1_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":341 + * self._chain_map = new unordered_map[uint64_t, Block*]() + * self._chain = new vector[Block*]() + * if self._chain_map is NULL: # <<<<<<<<<<<<<< + * raise MemoryError("Could not allocate hasmap") + * if self._chain is NULL: +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":343 + * if self._chain_map is NULL: + * raise MemoryError("Could not allocate hasmap") + * if self._chain is NULL: # <<<<<<<<<<<<<< + * raise MemoryError("Could not allocate vector") + * +*/ + __pyx_t_3 = (__pyx_v_self->_chain == NULL); + if (unlikely(__pyx_t_3)) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":344 + * raise MemoryError("Could not allocate hasmap") + * if self._chain is NULL: + * raise MemoryError("Could not allocate vector") # <<<<<<<<<<<<<< + * + * def __init__(self, db_path): +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_Could_not_allocate_vector}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_MemoryError)), __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, 344, __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, 344, __pyx_L1_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":343 + * if self._chain_map is NULL: + * raise MemoryError("Could not allocate hasmap") + * if self._chain is NULL: # <<<<<<<<<<<<<< + * raise MemoryError("Could not allocate vector") + * +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":334 + * readonly object _engine + * + * def __cinit__(self, *args, **kwargs): # <<<<<<<<<<<<<< + * self._difficulty = 26 + * self._index = 0 +*/ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.Blockchain.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":346 + * raise MemoryError("Could not allocate vector") + * + * def __init__(self, db_path): # <<<<<<<<<<<<<< + * self.db_path = Path(db_path).resolve() + * if not self.db_path.parent.exists(): +*/ + +/* Python wrapper */ +static int __pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_db_path = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_db_path,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 346, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 346, __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, 346, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, i); __PYX_ERR(0, 346, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 346, __pyx_L3_error) + } + __pyx_v_db_path = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 346, __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("dopt_pollublock_blockchain.blockchain.Blockchain.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_2__init__(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *)__pyx_v_self), __pyx_v_db_path); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_2__init__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self, PyObject *__pyx_v_db_path) { + int __pyx_r; + __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; + size_t __pyx_t_6; + int __pyx_t_7; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "dopt_pollublock_blockchain/blockchain.pyx":347 + * + * def __init__(self, db_path): + * self.db_path = Path(db_path).resolve() # <<<<<<<<<<<<<< + * if not self.db_path.parent.exists(): + * raise FileNotFoundError( +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_Path); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_db_path}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_t_2 = __pyx_t_3; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_resolve, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->db_path); + __Pyx_DECREF(__pyx_v_self->db_path); + __pyx_v_self->db_path = __pyx_t_1; + __pyx_t_1 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":348 + * def __init__(self, db_path): + * self.db_path = Path(db_path).resolve() + * if not self.db_path.parent.exists(): # <<<<<<<<<<<<<< + * raise FileNotFoundError( + * "The parent directory of the provided database path does not exist" +*/ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->db_path, __pyx_mstate_global->__pyx_n_u_parent); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 348, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_t_2; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_exists, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (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, 348, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 348, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_8 = (!__pyx_t_7); + if (unlikely(__pyx_t_8)) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":349 + * self.db_path = Path(db_path).resolve() + * if not self.db_path.parent.exists(): + * raise FileNotFoundError( # <<<<<<<<<<<<<< + * "The parent directory of the provided database path does not exist" + * ) +*/ + __pyx_t_2 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_mstate_global->__pyx_kp_u_The_parent_directory_of_the_prov}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_FileNotFoundError)), __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 349, __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, 349, __pyx_L1_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":348 + * def __init__(self, db_path): + * self.db_path = Path(db_path).resolve() + * if not self.db_path.parent.exists(): # <<<<<<<<<<<<<< + * raise FileNotFoundError( + * "The parent directory of the provided database path does not exist" +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":353 + * ) + * + * self._engine = sql.create_engine(f"sqlite:///{str(self.db_path)}") # <<<<<<<<<<<<<< + * db.metadata_blockchain.create_all(self._engine) + * +*/ + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_sql); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_create_engine); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Unicode(__pyx_v_self->db_path); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_sqlite, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_engine); + __Pyx_DECREF(__pyx_v_self->_engine); + __pyx_v_self->_engine = __pyx_t_1; + __pyx_t_1 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":354 + * + * self._engine = sql.create_engine(f"sqlite:///{str(self.db_path)}") + * db.metadata_blockchain.create_all(self._engine) # <<<<<<<<<<<<<< + * + * def __dealloc__(self): +*/ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_db); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 354, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_metadata_blockchain); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 354, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __pyx_t_2; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_self->_engine}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_create_all, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 354, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":346 + * raise MemoryError("Could not allocate vector") + * + * def __init__(self, db_path): # <<<<<<<<<<<<<< + * self.db_path = Path(db_path).resolve() + * if not self.db_path.parent.exists(): +*/ + + /* function exit code */ + __pyx_r = 0; + 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_AddTraceback("dopt_pollublock_blockchain.blockchain.Blockchain.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":356 + * db.metadata_blockchain.create_all(self._engine) + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * # ownership is typically not transferred from the Blockchain extension class + * cdef BcHashmap.iterator it = self._chain_map.begin() +*/ + +/* Python wrapper */ +static void __pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_5__dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_5__dealloc__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_4__dealloc__(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_4__dealloc__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self) { + std::unordered_map ::iterator __pyx_v_it; + int __pyx_t_1; + + /* "dopt_pollublock_blockchain/blockchain.pyx":358 + * def __dealloc__(self): + * # ownership is typically not transferred from the Blockchain extension class + * cdef BcHashmap.iterator it = self._chain_map.begin() # <<<<<<<<<<<<<< + * if self._chain_map is not NULL: + * while it != self._chain_map.end(): +*/ + __pyx_v_it = __pyx_v_self->_chain_map->begin(); + + /* "dopt_pollublock_blockchain/blockchain.pyx":359 + * # ownership is typically not transferred from the Blockchain extension class + * cdef BcHashmap.iterator it = self._chain_map.begin() + * if self._chain_map is not NULL: # <<<<<<<<<<<<<< + * while it != self._chain_map.end(): + * del dereference(it).second +*/ + __pyx_t_1 = (__pyx_v_self->_chain_map != NULL); + if (__pyx_t_1) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":360 + * cdef BcHashmap.iterator it = self._chain_map.begin() + * if self._chain_map is not NULL: + * while it != self._chain_map.end(): # <<<<<<<<<<<<<< + * del dereference(it).second + * postincrement(it) +*/ + while (1) { + __pyx_t_1 = (__pyx_v_it != __pyx_v_self->_chain_map->end()); + if (!__pyx_t_1) break; + + /* "dopt_pollublock_blockchain/blockchain.pyx":361 + * if self._chain_map is not NULL: + * while it != self._chain_map.end(): + * del dereference(it).second # <<<<<<<<<<<<<< + * postincrement(it) + * +*/ + delete (*__pyx_v_it).second; + + /* "dopt_pollublock_blockchain/blockchain.pyx":362 + * while it != self._chain_map.end(): + * del dereference(it).second + * postincrement(it) # <<<<<<<<<<<<<< + * + * del self._chain_map +*/ + (void)((__pyx_v_it++)); + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":364 + * postincrement(it) + * + * del self._chain_map # <<<<<<<<<<<<<< + * self._chain_map = NULL + * +*/ + delete __pyx_v_self->_chain_map; + + /* "dopt_pollublock_blockchain/blockchain.pyx":365 + * + * del self._chain_map + * self._chain_map = NULL # <<<<<<<<<<<<<< + * + * if self._chain is not NULL: +*/ + __pyx_v_self->_chain_map = NULL; + + /* "dopt_pollublock_blockchain/blockchain.pyx":359 + * # ownership is typically not transferred from the Blockchain extension class + * cdef BcHashmap.iterator it = self._chain_map.begin() + * if self._chain_map is not NULL: # <<<<<<<<<<<<<< + * while it != self._chain_map.end(): + * del dereference(it).second +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":367 + * self._chain_map = NULL + * + * if self._chain is not NULL: # <<<<<<<<<<<<<< + * del self._chain + * self._chain = NULL +*/ + __pyx_t_1 = (__pyx_v_self->_chain != NULL); + if (__pyx_t_1) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":368 + * + * if self._chain is not NULL: + * del self._chain # <<<<<<<<<<<<<< + * self._chain = NULL + * +*/ + delete __pyx_v_self->_chain; + + /* "dopt_pollublock_blockchain/blockchain.pyx":369 + * if self._chain is not NULL: + * del self._chain + * self._chain = NULL # <<<<<<<<<<<<<< + * + * cdef Block* get_block_c(self, uint64_t idx) nogil: +*/ + __pyx_v_self->_chain = NULL; + + /* "dopt_pollublock_blockchain/blockchain.pyx":367 + * self._chain_map = NULL + * + * if self._chain is not NULL: # <<<<<<<<<<<<<< + * del self._chain + * self._chain = NULL +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":356 + * db.metadata_blockchain.create_all(self._engine) + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * # ownership is typically not transferred from the Blockchain extension class + * cdef BcHashmap.iterator it = self._chain_map.begin() +*/ + + /* function exit code */ +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":371 + * self._chain = NULL + * + * cdef Block* get_block_c(self, uint64_t idx) nogil: # <<<<<<<<<<<<<< + * if idx > self._index: + * return NULL +*/ + +static ::Block *__pyx_f_26dopt_pollublock_blockchain_10blockchain_10Blockchain_get_block_c(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self, uint64_t __pyx_v_idx) { + ::Block *__pyx_r; + int __pyx_t_1; + + /* "dopt_pollublock_blockchain/blockchain.pyx":372 + * + * cdef Block* get_block_c(self, uint64_t idx) nogil: + * if idx > self._index: # <<<<<<<<<<<<<< + * return NULL + * return self._chain_map[0][idx] +*/ + __pyx_t_1 = (__pyx_v_idx > __pyx_v_self->_index); + if (__pyx_t_1) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":373 + * cdef Block* get_block_c(self, uint64_t idx) nogil: + * if idx > self._index: + * return NULL # <<<<<<<<<<<<<< + * return self._chain_map[0][idx] + * +*/ + __pyx_r = NULL; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":372 + * + * cdef Block* get_block_c(self, uint64_t idx) nogil: + * if idx > self._index: # <<<<<<<<<<<<<< + * return NULL + * return self._chain_map[0][idx] +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":374 + * if idx > self._index: + * return NULL + * return self._chain_map[0][idx] # <<<<<<<<<<<<<< + * + * cdef void add_block_from_loading(self, Block *block) nogil: +*/ + __pyx_r = ((__pyx_v_self->_chain_map[0])[__pyx_v_idx]); + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":371 + * self._chain = NULL + * + * cdef Block* get_block_c(self, uint64_t idx) nogil: # <<<<<<<<<<<<<< + * if idx > self._index: + * return NULL +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":376 + * return self._chain_map[0][idx] + * + * cdef void add_block_from_loading(self, Block *block) nogil: # <<<<<<<<<<<<<< + * self._chain[0].push_back(block) + * self._chain_map[0][block.index] = block +*/ + +static void __pyx_f_26dopt_pollublock_blockchain_10blockchain_10Blockchain_add_block_from_loading(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self, ::Block *__pyx_v_block) { + uint64_t __pyx_t_1; + int __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyGILState_STATE __pyx_gilstate_save; + + /* "dopt_pollublock_blockchain/blockchain.pyx":377 + * + * cdef void add_block_from_loading(self, Block *block) nogil: + * self._chain[0].push_back(block) # <<<<<<<<<<<<<< + * self._chain_map[0][block.index] = block + * self._index = block.index +*/ + try { + (__pyx_v_self->_chain[0]).push_back(__pyx_v_block); + } catch(...) { + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + __Pyx_CppExn2PyErr(); + __Pyx_PyGILState_Release(__pyx_gilstate_save); + __PYX_ERR(0, 377, __pyx_L1_error) + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":378 + * cdef void add_block_from_loading(self, Block *block) nogil: + * self._chain[0].push_back(block) + * self._chain_map[0][block.index] = block # <<<<<<<<<<<<<< + * self._index = block.index + * if not self._genesis_done: +*/ + ((__pyx_v_self->_chain_map[0])[__pyx_v_block->index]) = __pyx_v_block; + + /* "dopt_pollublock_blockchain/blockchain.pyx":379 + * self._chain[0].push_back(block) + * self._chain_map[0][block.index] = block + * self._index = block.index # <<<<<<<<<<<<<< + * if not self._genesis_done: + * self._genesis_done = True +*/ + __pyx_t_1 = __pyx_v_block->index; + __pyx_v_self->_index = __pyx_t_1; + + /* "dopt_pollublock_blockchain/blockchain.pyx":380 + * self._chain_map[0][block.index] = block + * self._index = block.index + * if not self._genesis_done: # <<<<<<<<<<<<<< + * self._genesis_done = True + * +*/ + __pyx_t_2 = (!__pyx_v_self->_genesis_done); + if (__pyx_t_2) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":381 + * self._index = block.index + * if not self._genesis_done: + * self._genesis_done = True # <<<<<<<<<<<<<< + * + * cdef int add_block(self, Block *block) nogil: +*/ + __pyx_v_self->_genesis_done = 1; + + /* "dopt_pollublock_blockchain/blockchain.pyx":380 + * self._chain_map[0][block.index] = block + * self._index = block.index + * if not self._genesis_done: # <<<<<<<<<<<<<< + * self._genesis_done = True + * +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":376 + * return self._chain_map[0][idx] + * + * cdef void add_block_from_loading(self, Block *block) nogil: # <<<<<<<<<<<<<< + * self._chain[0].push_back(block) + * self._chain_map[0][block.index] = block +*/ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.Blockchain.add_block_from_loading", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_PyGILState_Release(__pyx_gilstate_save); + __pyx_L0:; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":383 + * self._genesis_done = True + * + * cdef int add_block(self, Block *block) nogil: # <<<<<<<<<<<<<< + * cdef: + * uint64_t mined_nonce +*/ + +static int __pyx_f_26dopt_pollublock_blockchain_10blockchain_10Blockchain_add_block(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self, ::Block *__pyx_v_block) { + uint64_t __pyx_v_mined_nonce; + size_t __pyx_v_digest_size; + unsigned char *__pyx_v_sha256_digest; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + unsigned char *__pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + size_t __pyx_t_9; + std::string __pyx_t_10; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyGILState_STATE __pyx_gilstate_save; + __Pyx_RefNannySetupContext("add_block", 1); + + /* "dopt_pollublock_blockchain/blockchain.pyx":389 + * unsigned char *sha256_digest + * # mine block + * if mine_block(block, self._difficulty, &mined_nonce) != 0: # <<<<<<<<<<<<<< + * return 1 + * block.nonce = mined_nonce +*/ + __pyx_t_1 = __pyx_f_26dopt_pollublock_blockchain_10blockchain_mine_block(__pyx_v_block, __pyx_v_self->_difficulty, (&__pyx_v_mined_nonce), NULL); if (unlikely(__pyx_t_1 == ((int)-1) && __Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 389, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":390 + * # mine block + * if mine_block(block, self._difficulty, &mined_nonce) != 0: + * return 1 # <<<<<<<<<<<<<< + * block.nonce = mined_nonce + * # hash block, add hash to block, add block to blockchain hashmap +*/ + __pyx_r = 1; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":389 + * unsigned char *sha256_digest + * # mine block + * if mine_block(block, self._difficulty, &mined_nonce) != 0: # <<<<<<<<<<<<<< + * return 1 + * block.nonce = mined_nonce +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":391 + * if mine_block(block, self._difficulty, &mined_nonce) != 0: + * return 1 + * block.nonce = mined_nonce # <<<<<<<<<<<<<< + * # hash block, add hash to block, add block to blockchain hashmap + * sha256_digest = perform_hash_c(block, &digest_size) +*/ + __pyx_v_block->nonce = __pyx_v_mined_nonce; + + /* "dopt_pollublock_blockchain/blockchain.pyx":393 + * block.nonce = mined_nonce + * # hash block, add hash to block, add block to blockchain hashmap + * sha256_digest = perform_hash_c(block, &digest_size) # <<<<<<<<<<<<<< + * with gil: + * block.hash = bytes(sha256_digest[:digest_size]).hex().encode("UTF-8") +*/ + __pyx_t_3 = __pyx_f_26dopt_pollublock_blockchain_10blockchain_perform_hash_c(__pyx_v_block, (&__pyx_v_digest_size)); if (unlikely(__pyx_t_3 == ((void *)NULL) && __Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 393, __pyx_L1_error) + __pyx_v_sha256_digest = __pyx_t_3; + + /* "dopt_pollublock_blockchain/blockchain.pyx":394 + * # hash block, add hash to block, add block to blockchain hashmap + * sha256_digest = perform_hash_c(block, &digest_size) + * with gil: # <<<<<<<<<<<<<< + * block.hash = bytes(sha256_digest[:digest_size]).hex().encode("UTF-8") + * free(sha256_digest) +*/ + { + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + /*try:*/ { + + /* "dopt_pollublock_blockchain/blockchain.pyx":395 + * sha256_digest = perform_hash_c(block, &digest_size) + * with gil: + * block.hash = bytes(sha256_digest[:digest_size]).hex().encode("UTF-8") # <<<<<<<<<<<<<< + * free(sha256_digest) + * self._chain[0].push_back(block) +*/ + __pyx_t_7 = NULL; + __pyx_t_8 = __Pyx_PyBytes_FromStringAndSize(((char const *)__pyx_v_sha256_digest) + 0, __pyx_v_digest_size - 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 395, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_8}; + __pyx_t_6 = __Pyx_PyObject_FastCall((PyObject*)(&PyBytes_Type), __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 395, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_6); + } + __pyx_t_5 = __pyx_t_6; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_hex, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 395, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_6 = PyUnicode_AsUTF8String(((PyObject*)__pyx_t_4)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 395, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_10 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_t_6); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 395, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_v_block->hash = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_10); + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":394 + * # hash block, add hash to block, add block to blockchain hashmap + * sha256_digest = perform_hash_c(block, &digest_size) + * with gil: # <<<<<<<<<<<<<< + * block.hash = bytes(sha256_digest[:digest_size]).hex().encode("UTF-8") + * free(sha256_digest) +*/ + /*finally:*/ { + /*normal exit:*/{ + __Pyx_PyGILState_Release(__pyx_gilstate_save); + goto __pyx_L6; + } + __pyx_L5_error: { + __Pyx_PyGILState_Release(__pyx_gilstate_save); + goto __pyx_L1_error; + } + __pyx_L6:; + } + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":396 + * with gil: + * block.hash = bytes(sha256_digest[:digest_size]).hex().encode("UTF-8") + * free(sha256_digest) # <<<<<<<<<<<<<< + * self._chain[0].push_back(block) + * self._chain_map[0][block.index] = block +*/ + free(__pyx_v_sha256_digest); + + /* "dopt_pollublock_blockchain/blockchain.pyx":397 + * block.hash = bytes(sha256_digest[:digest_size]).hex().encode("UTF-8") + * free(sha256_digest) + * self._chain[0].push_back(block) # <<<<<<<<<<<<<< + * self._chain_map[0][block.index] = block + * +*/ + try { + (__pyx_v_self->_chain[0]).push_back(__pyx_v_block); + } catch(...) { + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + __Pyx_CppExn2PyErr(); + __Pyx_PyGILState_Release(__pyx_gilstate_save); + __PYX_ERR(0, 397, __pyx_L1_error) + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":398 + * free(sha256_digest) + * self._chain[0].push_back(block) + * self._chain_map[0][block.index] = block # <<<<<<<<<<<<<< + * + * if self._genesis_done: +*/ + ((__pyx_v_self->_chain_map[0])[__pyx_v_block->index]) = __pyx_v_block; + + /* "dopt_pollublock_blockchain/blockchain.pyx":400 + * self._chain_map[0][block.index] = block + * + * if self._genesis_done: # <<<<<<<<<<<<<< + * self._index += 1 + * +*/ + if (__pyx_v_self->_genesis_done) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":401 + * + * if self._genesis_done: + * self._index += 1 # <<<<<<<<<<<<<< + * + * return 0 +*/ + __pyx_v_self->_index = (__pyx_v_self->_index + 1); + + /* "dopt_pollublock_blockchain/blockchain.pyx":400 + * self._chain_map[0][block.index] = block + * + * if self._genesis_done: # <<<<<<<<<<<<<< + * self._index += 1 + * +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":403 + * self._index += 1 + * + * return 0 # <<<<<<<<<<<<<< + * + * cdef string hash_data(self, data): +*/ + __pyx_r = 0; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":383 + * self._genesis_done = True + * + * cdef int add_block(self, Block *block) nogil: # <<<<<<<<<<<<<< + * cdef: + * uint64_t mined_nonce +*/ + + /* function exit code */ + __pyx_L1_error:; + __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.Blockchain.add_block", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __Pyx_PyGILState_Release(__pyx_gilstate_save); + __pyx_L0:; + __Pyx_RefNannyFinishContextNogil() + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":405 + * return 0 + * + * cdef string hash_data(self, data): # <<<<<<<<<<<<<< + * cdef: + * string data_str +*/ + +static std::string __pyx_f_26dopt_pollublock_blockchain_10blockchain_10Blockchain_hash_data(CYTHON_UNUSED struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self, PyObject *__pyx_v_data) { + std::string __pyx_v_data_str; + unsigned char *__pyx_v_data_digest; + size_t __pyx_v_digest_size; + std::string __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + size_t __pyx_t_3; + std::string __pyx_t_4; + unsigned char *__pyx_t_5; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("hash_data", 0); + + /* "dopt_pollublock_blockchain/blockchain.pyx":410 + * unsigned char *data_digest + * size_t digest_size + * data_str = data.encode("UTF-8") # <<<<<<<<<<<<<< + * data_digest = SHA256_digest(data_str.c_str(), data_str.size(), &digest_size) + * if data_digest is NULL: +*/ + __pyx_t_2 = __pyx_v_data; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __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_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, 410, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_4 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 410, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_data_str = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_4); + + /* "dopt_pollublock_blockchain/blockchain.pyx":411 + * size_t digest_size + * data_str = data.encode("UTF-8") + * data_digest = SHA256_digest(data_str.c_str(), data_str.size(), &digest_size) # <<<<<<<<<<<<<< + * if data_digest is NULL: + * raise RuntimeError("Failed to hash data") +*/ + __pyx_t_5 = __pyx_f_26dopt_pollublock_blockchain_10blockchain_SHA256_digest(__pyx_v_data_str.c_str(), __pyx_v_data_str.size(), (&__pyx_v_digest_size)); if (unlikely(__pyx_t_5 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 411, __pyx_L1_error) + __pyx_v_data_digest = __pyx_t_5; + + /* "dopt_pollublock_blockchain/blockchain.pyx":412 + * data_str = data.encode("UTF-8") + * data_digest = SHA256_digest(data_str.c_str(), data_str.size(), &digest_size) + * if data_digest is NULL: # <<<<<<<<<<<<<< + * raise RuntimeError("Failed to hash data") + * data_str = bytes(data_digest[:digest_size]).hex().encode("UTF-8") +*/ + __pyx_t_6 = (__pyx_v_data_digest == NULL); + if (unlikely(__pyx_t_6)) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":413 + * data_digest = SHA256_digest(data_str.c_str(), data_str.size(), &digest_size) + * if data_digest is NULL: + * raise RuntimeError("Failed to hash data") # <<<<<<<<<<<<<< + * data_str = bytes(data_digest[:digest_size]).hex().encode("UTF-8") + * free(data_digest) +*/ + __pyx_t_2 = NULL; + __pyx_t_3 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_mstate_global->__pyx_kp_u_Failed_to_hash_data}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_RuntimeError)), __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 413, __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, 413, __pyx_L1_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":412 + * data_str = data.encode("UTF-8") + * data_digest = SHA256_digest(data_str.c_str(), data_str.size(), &digest_size) + * if data_digest is NULL: # <<<<<<<<<<<<<< + * raise RuntimeError("Failed to hash data") + * data_str = bytes(data_digest[:digest_size]).hex().encode("UTF-8") +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":414 + * if data_digest is NULL: + * raise RuntimeError("Failed to hash data") + * data_str = bytes(data_digest[:digest_size]).hex().encode("UTF-8") # <<<<<<<<<<<<<< + * free(data_digest) + * +*/ + __pyx_t_8 = NULL; + __pyx_t_9 = __Pyx_PyBytes_FromStringAndSize(((char const *)__pyx_v_data_digest) + 0, __pyx_v_digest_size - 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 414, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_3 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_9}; + __pyx_t_7 = __Pyx_PyObject_FastCall((PyObject*)(&PyBytes_Type), __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 414, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + } + __pyx_t_2 = __pyx_t_7; + __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_hex, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 414, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_7 = PyUnicode_AsUTF8String(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 414, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_4 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 414, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_v_data_str = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_4); + + /* "dopt_pollublock_blockchain/blockchain.pyx":415 + * raise RuntimeError("Failed to hash data") + * data_str = bytes(data_digest[:digest_size]).hex().encode("UTF-8") + * free(data_digest) # <<<<<<<<<<<<<< + * + * return data_str +*/ + free(__pyx_v_data_digest); + + /* "dopt_pollublock_blockchain/blockchain.pyx":417 + * free(data_digest) + * + * return data_str # <<<<<<<<<<<<<< + * + * cdef load_from_batch(self, batch): +*/ + __pyx_r = __pyx_v_data_str; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":405 + * return 0 + * + * cdef string hash_data(self, data): # <<<<<<<<<<<<<< + * cdef: + * string data_str +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.Blockchain.hash_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":419 + * return data_str + * + * cdef load_from_batch(self, batch): # <<<<<<<<<<<<<< + * cdef Block *block + * +*/ + +static PyObject *__pyx_f_26dopt_pollublock_blockchain_10blockchain_10Blockchain_load_from_batch(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self, PyObject *__pyx_v_batch) { + ::Block *__pyx_v_block; + PyObject *__pyx_v_entry = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *(*__pyx_t_3)(PyObject *); + PyObject *__pyx_t_4 = NULL; + uint64_t __pyx_t_5; + double __pyx_t_6; + uint64_t __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + size_t __pyx_t_10; + std::string __pyx_t_11; + std::string __pyx_t_12; + std::string __pyx_t_13; + ::Block *__pyx_t_14; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("load_from_batch", 0); + + /* "dopt_pollublock_blockchain/blockchain.pyx":422 + * cdef Block *block + * + * for entry in batch: # <<<<<<<<<<<<<< + * block = new Block( + * entry[0], +*/ + if (likely(PyList_CheckExact(__pyx_v_batch)) || PyTuple_CheckExact(__pyx_v_batch)) { + __pyx_t_1 = __pyx_v_batch; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + __pyx_t_3 = NULL; + } else { + __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_batch); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 422, __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, 422, __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, 422, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + __pyx_t_4 = __Pyx_PyList_GetItemRefFast(__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, 422, __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, 422, __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, 422, __pyx_L1_error) + PyErr_Clear(); + } + break; + } + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_entry, __pyx_t_4); + __pyx_t_4 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":424 + * for entry in batch: + * block = new Block( + * entry[0], # <<<<<<<<<<<<<< + * entry[1], + * entry[2], +*/ + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_entry, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 424, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyLong_As_uint64_t(__pyx_t_4); if (unlikely((__pyx_t_5 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 424, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":425 + * block = new Block( + * entry[0], + * entry[1], # <<<<<<<<<<<<<< + * entry[2], + * entry[5].encode("UTF-8"), +*/ + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_entry, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 425, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 425, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":426 + * entry[0], + * entry[1], + * entry[2], # <<<<<<<<<<<<<< + * entry[5].encode("UTF-8"), + * entry[3].encode("UTF-8"), +*/ + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_entry, 2, long, 1, __Pyx_PyLong_From_long, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 426, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_PyLong_As_uint64_t(__pyx_t_4); if (unlikely((__pyx_t_7 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 426, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":427 + * entry[1], + * entry[2], + * entry[5].encode("UTF-8"), # <<<<<<<<<<<<<< + * entry[3].encode("UTF-8"), + * entry[4].encode("UTF-8"), +*/ + __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_entry, 5, long, 1, __Pyx_PyLong_From_long, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_8 = __pyx_t_9; + __Pyx_INCREF(__pyx_t_8); + __pyx_t_10 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_mstate_global->__pyx_kp_u_UTF_8}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_encode, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_11 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_t_4); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 427, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":428 + * entry[2], + * entry[5].encode("UTF-8"), + * entry[3].encode("UTF-8"), # <<<<<<<<<<<<<< + * entry[4].encode("UTF-8"), + * ) +*/ + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_entry, 3, long, 1, __Pyx_PyLong_From_long, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 428, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __pyx_t_8; + __Pyx_INCREF(__pyx_t_9); + __pyx_t_10 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_mstate_global->__pyx_kp_u_UTF_8}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_encode, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (1*__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, 428, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_12 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_t_4); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 428, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":429 + * entry[5].encode("UTF-8"), + * entry[3].encode("UTF-8"), + * entry[4].encode("UTF-8"), # <<<<<<<<<<<<<< + * ) + * self.add_block_from_loading(block) +*/ + __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_entry, 4, long, 1, __Pyx_PyLong_From_long, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 429, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_8 = __pyx_t_9; + __Pyx_INCREF(__pyx_t_8); + __pyx_t_10 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_mstate_global->__pyx_kp_u_UTF_8}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_encode, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 429, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_13 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_t_4); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 429, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":423 + * + * for entry in batch: + * block = new Block( # <<<<<<<<<<<<<< + * entry[0], + * entry[1], +*/ + try { + __pyx_t_14 = new ::Block(__pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_t_11, __pyx_t_12, __pyx_t_13); + } catch(...) { + __Pyx_CppExn2PyErr(); + __PYX_ERR(0, 423, __pyx_L1_error) + } + __pyx_v_block = __pyx_t_14; + + /* "dopt_pollublock_blockchain/blockchain.pyx":431 + * entry[4].encode("UTF-8"), + * ) + * self.add_block_from_loading(block) # <<<<<<<<<<<<<< + * + * # // Python public API +*/ + ((struct __pyx_vtabstruct_26dopt_pollublock_blockchain_10blockchain_Blockchain *)__pyx_v_self->__pyx_vtab)->add_block_from_loading(__pyx_v_self, __pyx_v_block); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 431, __pyx_L1_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":422 + * cdef Block *block + * + * for entry in batch: # <<<<<<<<<<<<<< + * block = new Block( + * entry[0], +*/ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":419 + * return data_str + * + * cdef load_from_batch(self, batch): # <<<<<<<<<<<<<< + * cdef Block *block + * +*/ + + /* 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_4); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.Blockchain.load_from_batch", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_entry); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":434 + * + * # // Python public API + * def __len__(self): # <<<<<<<<<<<<<< + * return self._index + 1 + * +*/ + +/* Python wrapper */ +static Py_ssize_t __pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_7__len__(PyObject *__pyx_v_self); /*proto*/ +static Py_ssize_t __pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_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_26dopt_pollublock_blockchain_10blockchain_10Blockchain_6__len__(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static Py_ssize_t __pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_6__len__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self) { + Py_ssize_t __pyx_r; + + /* "dopt_pollublock_blockchain/blockchain.pyx":435 + * # // Python public API + * def __len__(self): + * return self._index + 1 # <<<<<<<<<<<<<< + * + * @property +*/ + __pyx_r = (__pyx_v_self->_index + 1); + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":434 + * + * # // Python public API + * def __len__(self): # <<<<<<<<<<<<<< + * return self._index + 1 + * +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":437 + * return self._index + 1 + * + * @property # <<<<<<<<<<<<<< + * def difficulty(self): + * return self._difficulty +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_10difficulty_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_10difficulty_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_26dopt_pollublock_blockchain_10blockchain_10Blockchain_10difficulty___get__(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_10difficulty___get__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__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); + + /* "dopt_pollublock_blockchain/blockchain.pyx":439 + * @property + * def difficulty(self): + * return self._difficulty # <<<<<<<<<<<<<< + * + * @difficulty.setter +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyLong_From_unsigned_int(__pyx_v_self->_difficulty); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 439, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":437 + * return self._index + 1 + * + * @property # <<<<<<<<<<<<<< + * def difficulty(self): + * return self._difficulty +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.Blockchain.difficulty.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":441 + * return self._difficulty + * + * @difficulty.setter # <<<<<<<<<<<<<< + * def difficulty(self, value): + * if not isinstance(value, int): +*/ + +/* Python wrapper */ +static int __pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_10difficulty_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_10difficulty_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_10difficulty_2__set__(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_10difficulty_2__set__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __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; + unsigned int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + + /* "dopt_pollublock_blockchain/blockchain.pyx":443 + * @difficulty.setter + * def difficulty(self, value): + * if not isinstance(value, int): # <<<<<<<<<<<<<< + * raise TypeError("Difficulty must be integer value") + * if value <= 0: +*/ + __pyx_t_1 = PyLong_Check(__pyx_v_value); + __pyx_t_2 = (!__pyx_t_1); + if (unlikely(__pyx_t_2)) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":444 + * def difficulty(self, value): + * if not isinstance(value, int): + * raise TypeError("Difficulty must be integer value") # <<<<<<<<<<<<<< + * if value <= 0: + * raise ValueError("Difficulty must be greater than 0") +*/ + __pyx_t_4 = NULL; + __pyx_t_5 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_Difficulty_must_be_integer_value}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_TypeError)), __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, 444, __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, 444, __pyx_L1_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":443 + * @difficulty.setter + * def difficulty(self, value): + * if not isinstance(value, int): # <<<<<<<<<<<<<< + * raise TypeError("Difficulty must be integer value") + * if value <= 0: +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":445 + * if not isinstance(value, int): + * raise TypeError("Difficulty must be integer value") + * if value <= 0: # <<<<<<<<<<<<<< + * raise ValueError("Difficulty must be greater than 0") + * self._difficulty = value +*/ + __pyx_t_3 = PyObject_RichCompare(__pyx_v_value, __pyx_mstate_global->__pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 445, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 445, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(__pyx_t_2)) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":446 + * raise TypeError("Difficulty must be integer value") + * if value <= 0: + * raise ValueError("Difficulty must be greater than 0") # <<<<<<<<<<<<<< + * self._difficulty = value + * +*/ + __pyx_t_4 = NULL; + __pyx_t_5 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_Difficulty_must_be_greater_than}; + __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, 446, __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, 446, __pyx_L1_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":445 + * if not isinstance(value, int): + * raise TypeError("Difficulty must be integer value") + * if value <= 0: # <<<<<<<<<<<<<< + * raise ValueError("Difficulty must be greater than 0") + * self._difficulty = value +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":447 + * if value <= 0: + * raise ValueError("Difficulty must be greater than 0") + * self._difficulty = value # <<<<<<<<<<<<<< + * + * @property +*/ + __pyx_t_6 = __Pyx_PyLong_As_unsigned_int(__pyx_v_value); if (unlikely((__pyx_t_6 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 447, __pyx_L1_error) + __pyx_v_self->_difficulty = __pyx_t_6; + + /* "dopt_pollublock_blockchain/blockchain.pyx":441 + * return self._difficulty + * + * @difficulty.setter # <<<<<<<<<<<<<< + * def difficulty(self, value): + * if not isinstance(value, int): +*/ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.Blockchain.difficulty.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":449 + * self._difficulty = value + * + * @property # <<<<<<<<<<<<<< + * def genesis_done(self): + * return self._genesis_done +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_12genesis_done_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_12genesis_done_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_26dopt_pollublock_blockchain_10blockchain_10Blockchain_12genesis_done___get__(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_12genesis_done___get__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__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); + + /* "dopt_pollublock_blockchain/blockchain.pyx":451 + * @property + * def genesis_done(self): + * return self._genesis_done # <<<<<<<<<<<<<< + * + * @property +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_genesis_done); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 451, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":449 + * self._difficulty = value + * + * @property # <<<<<<<<<<<<<< + * def genesis_done(self): + * return self._genesis_done +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.Blockchain.genesis_done.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":453 + * return self._genesis_done + * + * @property # <<<<<<<<<<<<<< + * def index(self): + * return self._index +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_5index_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_5index_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_26dopt_pollublock_blockchain_10blockchain_10Blockchain_5index___get__(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_5index___get__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__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); + + /* "dopt_pollublock_blockchain/blockchain.pyx":455 + * @property + * def index(self): + * return self._index # <<<<<<<<<<<<<< + * + * def _print_key_value_pair(self): +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyLong_From_uint64_t(__pyx_v_self->_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 455, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":453 + * return self._genesis_done + * + * @property # <<<<<<<<<<<<<< + * def index(self): + * return self._index +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.Blockchain.index.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":457 + * return self._index + * + * def _print_key_value_pair(self): # <<<<<<<<<<<<<< + * cdef BcHashmap.iterator it = self._chain_map.begin() + * cdef Block *block +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_9_print_key_value_pair(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_26dopt_pollublock_blockchain_10blockchain_10Blockchain_9_print_key_value_pair = {"_print_key_value_pair", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_9_print_key_value_pair, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_9_print_key_value_pair(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_print_key_value_pair (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("_print_key_value_pair", 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("_print_key_value_pair", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_8_print_key_value_pair(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_8_print_key_value_pair(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self) { + std::unordered_map ::iterator __pyx_v_it; + ::Block *__pyx_v_block; + struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__pyx_v_py_block = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + size_t __pyx_t_5; + ::Block *__pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_print_key_value_pair", 0); + + /* "dopt_pollublock_blockchain/blockchain.pyx":458 + * + * def _print_key_value_pair(self): + * cdef BcHashmap.iterator it = self._chain_map.begin() # <<<<<<<<<<<<<< + * cdef Block *block + * while it != self._chain_map.end(): +*/ + __pyx_v_it = __pyx_v_self->_chain_map->begin(); + + /* "dopt_pollublock_blockchain/blockchain.pyx":460 + * cdef BcHashmap.iterator it = self._chain_map.begin() + * cdef Block *block + * while it != self._chain_map.end(): # <<<<<<<<<<<<<< + * print(dereference(it).first) + * block = dereference(it).second +*/ + while (1) { + __pyx_t_1 = (__pyx_v_it != __pyx_v_self->_chain_map->end()); + if (!__pyx_t_1) break; + + /* "dopt_pollublock_blockchain/blockchain.pyx":461 + * cdef Block *block + * while it != self._chain_map.end(): + * print(dereference(it).first) # <<<<<<<<<<<<<< + * block = dereference(it).second + * py_block = PyBlock.from_ptr(block) +*/ + __pyx_t_3 = NULL; + __pyx_t_4 = __Pyx_PyLong_From_uint64_t((*__pyx_v_it).first); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 461, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_print, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 461, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":462 + * while it != self._chain_map.end(): + * print(dereference(it).first) + * block = dereference(it).second # <<<<<<<<<<<<<< + * py_block = PyBlock.from_ptr(block) + * print(py_block) +*/ + __pyx_t_6 = (*__pyx_v_it).second; + __pyx_v_block = __pyx_t_6; + + /* "dopt_pollublock_blockchain/blockchain.pyx":463 + * print(dereference(it).first) + * block = dereference(it).second + * py_block = PyBlock.from_ptr(block) # <<<<<<<<<<<<<< + * print(py_block) + * postincrement(it) +*/ + __pyx_t_2 = ((PyObject *)__pyx_vtabptr_26dopt_pollublock_blockchain_10blockchain_PyBlock->from_ptr(__pyx_v_block, NULL)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 463, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_py_block, ((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *)__pyx_t_2)); + __pyx_t_2 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":464 + * block = dereference(it).second + * py_block = PyBlock.from_ptr(block) + * print(py_block) # <<<<<<<<<<<<<< + * postincrement(it) + * +*/ + __pyx_t_4 = NULL; + __pyx_t_5 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, ((PyObject *)__pyx_v_py_block)}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_print, __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_2)) __PYX_ERR(0, 464, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":465 + * py_block = PyBlock.from_ptr(block) + * print(py_block) + * postincrement(it) # <<<<<<<<<<<<<< + * + * def print_blocks(self, max_num): +*/ + (void)((__pyx_v_it++)); + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":457 + * return self._index + * + * def _print_key_value_pair(self): # <<<<<<<<<<<<<< + * cdef BcHashmap.iterator it = self._chain_map.begin() + * cdef Block *block +*/ + + /* 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_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.Blockchain._print_key_value_pair", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_py_block); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":467 + * postincrement(it) + * + * def print_blocks(self, max_num): # <<<<<<<<<<<<<< + * cdef: + * Block *block +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_11print_blocks(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_26dopt_pollublock_blockchain_10blockchain_10Blockchain_11print_blocks = {"print_blocks", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_11print_blocks, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_11print_blocks(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_max_num = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("print_blocks (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_max_num,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, 467, __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, 467, __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, "print_blocks", 0) < (0)) __PYX_ERR(0, 467, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("print_blocks", 1, 1, 1, i); __PYX_ERR(0, 467, __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, 467, __pyx_L3_error) + } + __pyx_v_max_num = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("print_blocks", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 467, __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("dopt_pollublock_blockchain.blockchain.Blockchain.print_blocks", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_10print_blocks(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *)__pyx_v_self), __pyx_v_max_num); + + /* 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_26dopt_pollublock_blockchain_10blockchain_10Blockchain_10print_blocks(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self, PyObject *__pyx_v_max_num) { + ::Block *__pyx_v_block; + int __pyx_v_max_nummber; + int __pyx_v_idx; + int __pyx_v_num; + struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *__pyx_v_py_block = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + size_t __pyx_t_5; + std::vector<::Block *> ::size_type __pyx_t_6; + std::vector<::Block *> ::size_type __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("print_blocks", 0); + + /* "dopt_pollublock_blockchain/blockchain.pyx":470 + * cdef: + * Block *block + * int max_nummber = max_num # <<<<<<<<<<<<<< + * int idx, num = 0 + * +*/ + __pyx_t_1 = __Pyx_PyLong_As_int(__pyx_v_max_num); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 470, __pyx_L1_error) + __pyx_v_max_nummber = __pyx_t_1; + + /* "dopt_pollublock_blockchain/blockchain.pyx":471 + * Block *block + * int max_nummber = max_num + * int idx, num = 0 # <<<<<<<<<<<<<< + * + * if max_num <= 0: +*/ + __pyx_v_num = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":473 + * int idx, num = 0 + * + * if max_num <= 0: # <<<<<<<<<<<<<< + * raise ValueError("Maximum number must be greater than 0") + * +*/ + __pyx_t_2 = PyObject_RichCompare(__pyx_v_max_num, __pyx_mstate_global->__pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 473, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 473, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(__pyx_t_3)) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":474 + * + * if max_num <= 0: + * raise ValueError("Maximum number must be greater than 0") # <<<<<<<<<<<<<< + * + * for idx in range(self._chain[0].size()): +*/ + __pyx_t_4 = NULL; + __pyx_t_5 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_Maximum_number_must_be_greater_t}; + __pyx_t_2 = __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_2)) __PYX_ERR(0, 474, __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, 474, __pyx_L1_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":473 + * int idx, num = 0 + * + * if max_num <= 0: # <<<<<<<<<<<<<< + * raise ValueError("Maximum number must be greater than 0") + * +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":476 + * raise ValueError("Maximum number must be greater than 0") + * + * for idx in range(self._chain[0].size()): # <<<<<<<<<<<<<< + * block = self._chain[0][idx] + * py_block = PyBlock.from_ptr(block) +*/ + __pyx_t_6 = (__pyx_v_self->_chain[0]).size(); + __pyx_t_7 = __pyx_t_6; + for (__pyx_t_1 = 0; __pyx_t_1 < __pyx_t_7; __pyx_t_1+=1) { + __pyx_v_idx = __pyx_t_1; + + /* "dopt_pollublock_blockchain/blockchain.pyx":477 + * + * for idx in range(self._chain[0].size()): + * block = self._chain[0][idx] # <<<<<<<<<<<<<< + * py_block = PyBlock.from_ptr(block) + * print(py_block) +*/ + __pyx_v_block = ((__pyx_v_self->_chain[0])[__pyx_v_idx]); + + /* "dopt_pollublock_blockchain/blockchain.pyx":478 + * for idx in range(self._chain[0].size()): + * block = self._chain[0][idx] + * py_block = PyBlock.from_ptr(block) # <<<<<<<<<<<<<< + * print(py_block) + * num += 1 +*/ + __pyx_t_2 = ((PyObject *)__pyx_vtabptr_26dopt_pollublock_blockchain_10blockchain_PyBlock->from_ptr(__pyx_v_block, NULL)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 478, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_py_block, ((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *)__pyx_t_2)); + __pyx_t_2 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":479 + * block = self._chain[0][idx] + * py_block = PyBlock.from_ptr(block) + * print(py_block) # <<<<<<<<<<<<<< + * num += 1 + * if num == max_nummber: +*/ + __pyx_t_4 = NULL; + __pyx_t_5 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, ((PyObject *)__pyx_v_py_block)}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_print, __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_2)) __PYX_ERR(0, 479, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":480 + * py_block = PyBlock.from_ptr(block) + * print(py_block) + * num += 1 # <<<<<<<<<<<<<< + * if num == max_nummber: + * break +*/ + __pyx_v_num = (__pyx_v_num + 1); + + /* "dopt_pollublock_blockchain/blockchain.pyx":481 + * print(py_block) + * num += 1 + * if num == max_nummber: # <<<<<<<<<<<<<< + * break + * +*/ + __pyx_t_3 = (__pyx_v_num == __pyx_v_max_nummber); + if (__pyx_t_3) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":482 + * num += 1 + * if num == max_nummber: + * break # <<<<<<<<<<<<<< + * + * def get_block(self, idx): +*/ + goto __pyx_L5_break; + + /* "dopt_pollublock_blockchain/blockchain.pyx":481 + * print(py_block) + * num += 1 + * if num == max_nummber: # <<<<<<<<<<<<<< + * break + * +*/ + } + } + __pyx_L5_break:; + + /* "dopt_pollublock_blockchain/blockchain.pyx":467 + * postincrement(it) + * + * def print_blocks(self, max_num): # <<<<<<<<<<<<<< + * cdef: + * Block *block +*/ + + /* 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_4); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.Blockchain.print_blocks", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_py_block); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":484 + * break + * + * def get_block(self, idx): # <<<<<<<<<<<<<< + * if idx < 0 or idx > self._index: + * raise IndexError("Index value is out of bounds") +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_13get_block(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_26dopt_pollublock_blockchain_10blockchain_10Blockchain_13get_block = {"get_block", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_13get_block, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_13get_block(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_idx = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_block (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_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, 484, __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, 484, __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_block", 0) < (0)) __PYX_ERR(0, 484, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_block", 1, 1, 1, i); __PYX_ERR(0, 484, __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, 484, __pyx_L3_error) + } + __pyx_v_idx = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get_block", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 484, __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("dopt_pollublock_blockchain.blockchain.Blockchain.get_block", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_12get_block(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *)__pyx_v_self), __pyx_v_idx); + + /* 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_26dopt_pollublock_blockchain_10blockchain_10Blockchain_12get_block(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self, PyObject *__pyx_v_idx) { + ::Block *__pyx_v_block; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + size_t __pyx_t_5; + uint64_t __pyx_t_6; + ::Block *__pyx_t_7; + struct __pyx_opt_args_26dopt_pollublock_blockchain_10blockchain_7PyBlock_from_ptr __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_block", 0); + + /* "dopt_pollublock_blockchain/blockchain.pyx":485 + * + * def get_block(self, idx): + * if idx < 0 or idx > self._index: # <<<<<<<<<<<<<< + * raise IndexError("Index value is out of bounds") + * +*/ + __pyx_t_2 = PyObject_RichCompare(__pyx_v_idx, __pyx_mstate_global->__pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 485, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 485, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = __Pyx_PyLong_From_uint64_t(__pyx_v_self->_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 485, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_idx, __pyx_t_2, Py_GT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 485, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 485, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_1 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":486 + * def get_block(self, idx): + * if idx < 0 or idx > self._index: + * raise IndexError("Index value is out of bounds") # <<<<<<<<<<<<<< + * + * cdef Block *block = self.get_block_c(idx) +*/ + __pyx_t_2 = NULL; + __pyx_t_5 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_mstate_global->__pyx_kp_u_Index_value_is_out_of_bounds}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_IndexError)), __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_4)) __PYX_ERR(0, 486, __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, 486, __pyx_L1_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":485 + * + * def get_block(self, idx): + * if idx < 0 or idx > self._index: # <<<<<<<<<<<<<< + * raise IndexError("Index value is out of bounds") + * +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":488 + * raise IndexError("Index value is out of bounds") + * + * cdef Block *block = self.get_block_c(idx) # <<<<<<<<<<<<<< + * if block is NULL: + * raise IndexError("Provided index not found") +*/ + __pyx_t_6 = __Pyx_PyLong_As_uint64_t(__pyx_v_idx); if (unlikely((__pyx_t_6 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 488, __pyx_L1_error) + __pyx_t_7 = ((struct __pyx_vtabstruct_26dopt_pollublock_blockchain_10blockchain_Blockchain *)__pyx_v_self->__pyx_vtab)->get_block_c(__pyx_v_self, __pyx_t_6); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 488, __pyx_L1_error) + __pyx_v_block = __pyx_t_7; + + /* "dopt_pollublock_blockchain/blockchain.pyx":489 + * + * cdef Block *block = self.get_block_c(idx) + * if block is NULL: # <<<<<<<<<<<<<< + * raise IndexError("Provided index not found") + * return PyBlock.from_ptr(block, owner=False) +*/ + __pyx_t_1 = (__pyx_v_block == NULL); + if (unlikely(__pyx_t_1)) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":490 + * cdef Block *block = self.get_block_c(idx) + * if block is NULL: + * raise IndexError("Provided index not found") # <<<<<<<<<<<<<< + * return PyBlock.from_ptr(block, owner=False) + * +*/ + __pyx_t_2 = NULL; + __pyx_t_5 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_mstate_global->__pyx_kp_u_Provided_index_not_found}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_IndexError)), __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_4)) __PYX_ERR(0, 490, __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, 490, __pyx_L1_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":489 + * + * cdef Block *block = self.get_block_c(idx) + * if block is NULL: # <<<<<<<<<<<<<< + * raise IndexError("Provided index not found") + * return PyBlock.from_ptr(block, owner=False) +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":491 + * if block is NULL: + * raise IndexError("Provided index not found") + * return PyBlock.from_ptr(block, owner=False) # <<<<<<<<<<<<<< + * + * def create_genesis_block(self): +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_8.__pyx_n = 1; + __pyx_t_8.owner = 0; + __pyx_t_4 = ((PyObject *)__pyx_vtabptr_26dopt_pollublock_blockchain_10blockchain_PyBlock->from_ptr(__pyx_v_block, &__pyx_t_8)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 491, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":484 + * break + * + * def get_block(self, idx): # <<<<<<<<<<<<<< + * if idx < 0 or idx > self._index: + * raise IndexError("Index value is out of bounds") +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.Blockchain.get_block", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":493 + * return PyBlock.from_ptr(block, owner=False) + * + * def create_genesis_block(self): # <<<<<<<<<<<<<< + * if self._genesis_done: + * raise RuntimeError( +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_15create_genesis_block(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_26dopt_pollublock_blockchain_10blockchain_10Blockchain_15create_genesis_block = {"create_genesis_block", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_15create_genesis_block, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_15create_genesis_block(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("create_genesis_block (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("create_genesis_block", 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("create_genesis_block", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_14create_genesis_block(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_14create_genesis_block(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self) { + PyObject *__pyx_v_genesis_prev_hash = NULL; + std::string __pyx_v_data_str; + ::Block *__pyx_v_block; + int __pyx_v_res; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + size_t __pyx_t_3; + std::string __pyx_t_4; + uint64_t __pyx_t_5; + std::string __pyx_t_6; + ::Block *__pyx_t_7; + int __pyx_t_8; + int __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("create_genesis_block", 0); + + /* "dopt_pollublock_blockchain/blockchain.pyx":494 + * + * def create_genesis_block(self): + * if self._genesis_done: # <<<<<<<<<<<<<< + * raise RuntimeError( + * ("Blockchain already has a genesis block. " +*/ + if (unlikely(__pyx_v_self->_genesis_done)) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":495 + * def create_genesis_block(self): + * if self._genesis_done: + * raise RuntimeError( # <<<<<<<<<<<<<< + * ("Blockchain already has a genesis block. " + * "Either it was created or loaded.") +*/ + __pyx_t_2 = NULL; + __pyx_t_3 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_mstate_global->__pyx_kp_u_Blockchain_already_has_a_genesis}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_RuntimeError)), __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 495, __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, 495, __pyx_L1_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":494 + * + * def create_genesis_block(self): + * if self._genesis_done: # <<<<<<<<<<<<<< + * raise RuntimeError( + * ("Blockchain already has a genesis block. " +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":500 + * ) + * + * genesis_prev_hash = ("0" * 64).encode("UTF-8") # <<<<<<<<<<<<<< + * cdef string data_str = self.hash_data("Genesis Block") + * +*/ + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_b_00000000000000000000000000000000); + __pyx_v_genesis_prev_hash = __pyx_mstate_global->__pyx_kp_b_00000000000000000000000000000000; + + /* "dopt_pollublock_blockchain/blockchain.pyx":501 + * + * genesis_prev_hash = ("0" * 64).encode("UTF-8") + * cdef string data_str = self.hash_data("Genesis Block") # <<<<<<<<<<<<<< + * + * cdef Block *block = new Block( +*/ + __pyx_t_4 = ((struct __pyx_vtabstruct_26dopt_pollublock_blockchain_10blockchain_Blockchain *)__pyx_v_self->__pyx_vtab)->hash_data(__pyx_v_self, __pyx_mstate_global->__pyx_kp_u_Genesis_Block); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 501, __pyx_L1_error) + __pyx_v_data_str = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_4); + + /* "dopt_pollublock_blockchain/blockchain.pyx":505 + * cdef Block *block = new Block( + * self._index, + * current_timestamp_integer(), # <<<<<<<<<<<<<< + * 0, + * data_str, +*/ + __pyx_t_5 = __pyx_f_26dopt_pollublock_blockchain_10blockchain_current_timestamp_integer(); if (unlikely(__pyx_t_5 == ((uint64_t)-1LL) && PyErr_Occurred())) __PYX_ERR(0, 505, __pyx_L1_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":508 + * 0, + * data_str, + * genesis_prev_hash, # <<<<<<<<<<<<<< + * "".encode("UTF-8"), + * ) +*/ + __pyx_t_4 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_v_genesis_prev_hash); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 508, __pyx_L1_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":509 + * data_str, + * genesis_prev_hash, + * "".encode("UTF-8"), # <<<<<<<<<<<<<< + * ) + * cdef int res = self.add_block(block) +*/ + __pyx_t_6 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_mstate_global->__pyx_kp_b_); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 509, __pyx_L1_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":503 + * cdef string data_str = self.hash_data("Genesis Block") + * + * cdef Block *block = new Block( # <<<<<<<<<<<<<< + * self._index, + * current_timestamp_integer(), +*/ + try { + __pyx_t_7 = new ::Block(__pyx_v_self->_index, __pyx_t_5, 0, __pyx_v_data_str, __pyx_t_4, __pyx_t_6); + } catch(...) { + __Pyx_CppExn2PyErr(); + __PYX_ERR(0, 503, __pyx_L1_error) + } + __pyx_v_block = __pyx_t_7; + + /* "dopt_pollublock_blockchain/blockchain.pyx":511 + * "".encode("UTF-8"), + * ) + * cdef int res = self.add_block(block) # <<<<<<<<<<<<<< + * if res != 0: + * raise RuntimeError("Could not mine block. No nonce found") +*/ + __pyx_t_8 = ((struct __pyx_vtabstruct_26dopt_pollublock_blockchain_10blockchain_Blockchain *)__pyx_v_self->__pyx_vtab)->add_block(__pyx_v_self, __pyx_v_block); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 511, __pyx_L1_error) + __pyx_v_res = __pyx_t_8; + + /* "dopt_pollublock_blockchain/blockchain.pyx":512 + * ) + * cdef int res = self.add_block(block) + * if res != 0: # <<<<<<<<<<<<<< + * raise RuntimeError("Could not mine block. No nonce found") + * self._genesis_done = True +*/ + __pyx_t_9 = (__pyx_v_res != 0); + if (unlikely(__pyx_t_9)) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":513 + * cdef int res = self.add_block(block) + * if res != 0: + * raise RuntimeError("Could not mine block. No nonce found") # <<<<<<<<<<<<<< + * self._genesis_done = True + * +*/ + __pyx_t_2 = NULL; + __pyx_t_3 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_mstate_global->__pyx_kp_u_Could_not_mine_block_No_nonce_fo}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_RuntimeError)), __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 513, __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, 513, __pyx_L1_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":512 + * ) + * cdef int res = self.add_block(block) + * if res != 0: # <<<<<<<<<<<<<< + * raise RuntimeError("Could not mine block. No nonce found") + * self._genesis_done = True +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":514 + * if res != 0: + * raise RuntimeError("Could not mine block. No nonce found") + * self._genesis_done = True # <<<<<<<<<<<<<< + * + * def new_block(self, data): +*/ + __pyx_v_self->_genesis_done = 1; + + /* "dopt_pollublock_blockchain/blockchain.pyx":493 + * return PyBlock.from_ptr(block, owner=False) + * + * def create_genesis_block(self): # <<<<<<<<<<<<<< + * if self._genesis_done: + * raise RuntimeError( +*/ + + /* 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("dopt_pollublock_blockchain.blockchain.Blockchain.create_genesis_block", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_genesis_prev_hash); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":516 + * self._genesis_done = True + * + * def new_block(self, data): # <<<<<<<<<<<<<< + * cdef: + * Block *prev_block +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_17new_block(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_26dopt_pollublock_blockchain_10blockchain_10Blockchain_17new_block = {"new_block", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_17new_block, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_17new_block(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_data = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("new_block (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_data,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, 516, __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, 516, __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, "new_block", 0) < (0)) __PYX_ERR(0, 516, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("new_block", 1, 1, 1, i); __PYX_ERR(0, 516, __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, 516, __pyx_L3_error) + } + __pyx_v_data = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("new_block", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 516, __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("dopt_pollublock_blockchain.blockchain.Blockchain.new_block", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_16new_block(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *)__pyx_v_self), __pyx_v_data); + + /* 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_26dopt_pollublock_blockchain_10blockchain_10Blockchain_16new_block(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self, PyObject *__pyx_v_data) { + ::Block *__pyx_v_prev_block; + std::string __pyx_v_prev_hash; + uint64_t __pyx_v_new_idx; + std::string __pyx_v_data_str; + ::Block *__pyx_v_block; + int __pyx_v_res; + 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; + std::string __pyx_t_6; + ::Block *__pyx_t_7; + uint64_t __pyx_t_8; + int __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("new_block", 0); + + /* "dopt_pollublock_blockchain/blockchain.pyx":525 + * size_t digest_size + * + * if not self._genesis_done: # <<<<<<<<<<<<<< + * raise RuntimeError("Create a genesis block first.") + * if not isinstance(data, str): +*/ + __pyx_t_1 = (!__pyx_v_self->_genesis_done); + if (unlikely(__pyx_t_1)) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":526 + * + * if not self._genesis_done: + * raise RuntimeError("Create a genesis block first.") # <<<<<<<<<<<<<< + * if not isinstance(data, str): + * raise TypeError("Data must be a string") +*/ + __pyx_t_3 = NULL; + __pyx_t_4 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Create_a_genesis_block_first}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_RuntimeError)), __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, 526, __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, 526, __pyx_L1_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":525 + * size_t digest_size + * + * if not self._genesis_done: # <<<<<<<<<<<<<< + * raise RuntimeError("Create a genesis block first.") + * if not isinstance(data, str): +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":527 + * if not self._genesis_done: + * raise RuntimeError("Create a genesis block first.") + * if not isinstance(data, str): # <<<<<<<<<<<<<< + * raise TypeError("Data must be a string") + * +*/ + __pyx_t_1 = PyUnicode_Check(__pyx_v_data); + __pyx_t_5 = (!__pyx_t_1); + if (unlikely(__pyx_t_5)) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":528 + * raise RuntimeError("Create a genesis block first.") + * if not isinstance(data, str): + * raise TypeError("Data must be a string") # <<<<<<<<<<<<<< + * + * data_str = self.hash_data(data) +*/ + __pyx_t_3 = NULL; + __pyx_t_4 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Data_must_be_a_string}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_TypeError)), __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, 528, __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, 528, __pyx_L1_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":527 + * if not self._genesis_done: + * raise RuntimeError("Create a genesis block first.") + * if not isinstance(data, str): # <<<<<<<<<<<<<< + * raise TypeError("Data must be a string") + * +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":530 + * raise TypeError("Data must be a string") + * + * data_str = self.hash_data(data) # <<<<<<<<<<<<<< + * prev_block = self.get_block_c(self._index) + * prev_hash = prev_block.hash +*/ + __pyx_t_6 = ((struct __pyx_vtabstruct_26dopt_pollublock_blockchain_10blockchain_Blockchain *)__pyx_v_self->__pyx_vtab)->hash_data(__pyx_v_self, __pyx_v_data); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 530, __pyx_L1_error) + __pyx_v_data_str = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_6); + + /* "dopt_pollublock_blockchain/blockchain.pyx":531 + * + * data_str = self.hash_data(data) + * prev_block = self.get_block_c(self._index) # <<<<<<<<<<<<<< + * prev_hash = prev_block.hash + * new_idx = self._index + 1 +*/ + __pyx_t_7 = ((struct __pyx_vtabstruct_26dopt_pollublock_blockchain_10blockchain_Blockchain *)__pyx_v_self->__pyx_vtab)->get_block_c(__pyx_v_self, __pyx_v_self->_index); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 531, __pyx_L1_error) + __pyx_v_prev_block = __pyx_t_7; + + /* "dopt_pollublock_blockchain/blockchain.pyx":532 + * data_str = self.hash_data(data) + * prev_block = self.get_block_c(self._index) + * prev_hash = prev_block.hash # <<<<<<<<<<<<<< + * new_idx = self._index + 1 + * +*/ + __pyx_t_6 = __pyx_v_prev_block->hash; + __pyx_v_prev_hash = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_6); + + /* "dopt_pollublock_blockchain/blockchain.pyx":533 + * prev_block = self.get_block_c(self._index) + * prev_hash = prev_block.hash + * new_idx = self._index + 1 # <<<<<<<<<<<<<< + * + * cdef Block *block = new Block( +*/ + __pyx_v_new_idx = (__pyx_v_self->_index + 1); + + /* "dopt_pollublock_blockchain/blockchain.pyx":537 + * cdef Block *block = new Block( + * new_idx, + * current_timestamp_integer(), # <<<<<<<<<<<<<< + * 0, + * data_str, +*/ + __pyx_t_8 = __pyx_f_26dopt_pollublock_blockchain_10blockchain_current_timestamp_integer(); if (unlikely(__pyx_t_8 == ((uint64_t)-1LL) && PyErr_Occurred())) __PYX_ERR(0, 537, __pyx_L1_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":541 + * data_str, + * prev_hash, + * "".encode("UTF-8"), # <<<<<<<<<<<<<< + * ) + * cdef int res = self.add_block(block) +*/ + __pyx_t_6 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_mstate_global->__pyx_kp_b_); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 541, __pyx_L1_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":535 + * new_idx = self._index + 1 + * + * cdef Block *block = new Block( # <<<<<<<<<<<<<< + * new_idx, + * current_timestamp_integer(), +*/ + try { + __pyx_t_7 = new ::Block(__pyx_v_new_idx, __pyx_t_8, 0, __pyx_v_data_str, __pyx_v_prev_hash, __pyx_t_6); + } catch(...) { + __Pyx_CppExn2PyErr(); + __PYX_ERR(0, 535, __pyx_L1_error) + } + __pyx_v_block = __pyx_t_7; + + /* "dopt_pollublock_blockchain/blockchain.pyx":543 + * "".encode("UTF-8"), + * ) + * cdef int res = self.add_block(block) # <<<<<<<<<<<<<< + * if res != 0: + * raise RuntimeError("Could not mine block. No nonce found") +*/ + __pyx_t_9 = ((struct __pyx_vtabstruct_26dopt_pollublock_blockchain_10blockchain_Blockchain *)__pyx_v_self->__pyx_vtab)->add_block(__pyx_v_self, __pyx_v_block); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 543, __pyx_L1_error) + __pyx_v_res = __pyx_t_9; + + /* "dopt_pollublock_blockchain/blockchain.pyx":544 + * ) + * cdef int res = self.add_block(block) + * if res != 0: # <<<<<<<<<<<<<< + * raise RuntimeError("Could not mine block. No nonce found") + * +*/ + __pyx_t_5 = (__pyx_v_res != 0); + if (unlikely(__pyx_t_5)) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":545 + * cdef int res = self.add_block(block) + * if res != 0: + * raise RuntimeError("Could not mine block. No nonce found") # <<<<<<<<<<<<<< + * + * def validate(self): +*/ + __pyx_t_3 = NULL; + __pyx_t_4 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Could_not_mine_block_No_nonce_fo}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_RuntimeError)), __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, 545, __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, 545, __pyx_L1_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":544 + * ) + * cdef int res = self.add_block(block) + * if res != 0: # <<<<<<<<<<<<<< + * raise RuntimeError("Could not mine block. No nonce found") + * +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":516 + * self._genesis_done = True + * + * def new_block(self, data): # <<<<<<<<<<<<<< + * cdef: + * Block *prev_block +*/ + + /* 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_3); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.Blockchain.new_block", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":547 + * raise RuntimeError("Could not mine block. No nonce found") + * + * def validate(self): # <<<<<<<<<<<<<< + * cdef: + * Block *block +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_19validate(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_26dopt_pollublock_blockchain_10blockchain_10Blockchain_19validate = {"validate", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_19validate, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_19validate(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("validate (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("validate", 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("validate", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_18validate(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_18validate(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self) { + ::Block *__pyx_v_block; + ::Block *__pyx_v_prev_block; + int __pyx_v_idx; + unsigned char *__pyx_v_digest; + size_t __pyx_v_digest_size; + PyObject *__pyx_v_py_bytes = NULL; + PyObject *__pyx_v_py_bytes_rehashed = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + std::vector<::Block *> ::size_type __pyx_t_1; + std::vector<::Block *> ::size_type __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + size_t __pyx_t_7; + unsigned char *__pyx_t_8; + int __pyx_t_9; + PyObject *__pyx_t_10[3]; + PyObject *__pyx_t_11 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("validate", 0); + + /* "dopt_pollublock_blockchain/blockchain.pyx":550 + * cdef: + * Block *block + * Block *prev_block = NULL # <<<<<<<<<<<<<< + * int idx = 0 + * unsigned char *digest +*/ + __pyx_v_prev_block = NULL; + + /* "dopt_pollublock_blockchain/blockchain.pyx":551 + * Block *block + * Block *prev_block = NULL + * int idx = 0 # <<<<<<<<<<<<<< + * unsigned char *digest + * size_t digest_size +*/ + __pyx_v_idx = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":555 + * size_t digest_size + * + * for idx in range(self._chain[0].size()): # <<<<<<<<<<<<<< + * block = self._chain[0][idx] + * py_bytes = bytes.fromhex(block.hash.decode("UTF-8")) +*/ + __pyx_t_1 = (__pyx_v_self->_chain[0]).size(); + __pyx_t_2 = __pyx_t_1; + for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { + __pyx_v_idx = __pyx_t_3; + + /* "dopt_pollublock_blockchain/blockchain.pyx":556 + * + * for idx in range(self._chain[0].size()): + * block = self._chain[0][idx] # <<<<<<<<<<<<<< + * py_bytes = bytes.fromhex(block.hash.decode("UTF-8")) + * digest = perform_hash_c(block, &digest_size) +*/ + __pyx_v_block = ((__pyx_v_self->_chain[0])[__pyx_v_idx]); + + /* "dopt_pollublock_blockchain/blockchain.pyx":557 + * for idx in range(self._chain[0].size()): + * block = self._chain[0][idx] + * py_bytes = bytes.fromhex(block.hash.decode("UTF-8")) # <<<<<<<<<<<<<< + * digest = perform_hash_c(block, &digest_size) + * py_bytes_rehashed = bytes(digest[:digest_size]) +*/ + __pyx_t_5 = ((PyObject *)(&PyBytes_Type)); + __Pyx_INCREF(__pyx_t_5); + __pyx_t_6 = __Pyx_decode_cpp_string(__pyx_v_block->hash, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 557, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_fromhex, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 557, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XDECREF_SET(__pyx_v_py_bytes, __pyx_t_4); + __pyx_t_4 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":558 + * block = self._chain[0][idx] + * py_bytes = bytes.fromhex(block.hash.decode("UTF-8")) + * digest = perform_hash_c(block, &digest_size) # <<<<<<<<<<<<<< + * py_bytes_rehashed = bytes(digest[:digest_size]) + * free(digest) +*/ + __pyx_t_8 = __pyx_f_26dopt_pollublock_blockchain_10blockchain_perform_hash_c(__pyx_v_block, (&__pyx_v_digest_size)); if (unlikely(__pyx_t_8 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 558, __pyx_L1_error) + __pyx_v_digest = __pyx_t_8; + + /* "dopt_pollublock_blockchain/blockchain.pyx":559 + * py_bytes = bytes.fromhex(block.hash.decode("UTF-8")) + * digest = perform_hash_c(block, &digest_size) + * py_bytes_rehashed = bytes(digest[:digest_size]) # <<<<<<<<<<<<<< + * free(digest) + * if py_bytes != py_bytes_rehashed: +*/ + __pyx_t_6 = NULL; + __pyx_t_5 = __Pyx_PyBytes_FromStringAndSize(((char const *)__pyx_v_digest) + 0, __pyx_v_digest_size - 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 559, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)(&PyBytes_Type), __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_4)) __PYX_ERR(0, 559, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XDECREF_SET(__pyx_v_py_bytes_rehashed, ((PyObject*)__pyx_t_4)); + __pyx_t_4 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":560 + * digest = perform_hash_c(block, &digest_size) + * py_bytes_rehashed = bytes(digest[:digest_size]) + * free(digest) # <<<<<<<<<<<<<< + * if py_bytes != py_bytes_rehashed: + * print(f"Index {idx}: Hashes to not match. Abort.") +*/ + free(__pyx_v_digest); + + /* "dopt_pollublock_blockchain/blockchain.pyx":561 + * py_bytes_rehashed = bytes(digest[:digest_size]) + * free(digest) + * if py_bytes != py_bytes_rehashed: # <<<<<<<<<<<<<< + * print(f"Index {idx}: Hashes to not match. Abort.") + * return False +*/ + __pyx_t_9 = (__Pyx_PyBytes_Equals(__pyx_v_py_bytes, __pyx_v_py_bytes_rehashed, Py_NE)); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(0, 561, __pyx_L1_error) + if (__pyx_t_9) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":562 + * free(digest) + * if py_bytes != py_bytes_rehashed: + * print(f"Index {idx}: Hashes to not match. Abort.") # <<<<<<<<<<<<<< + * return False + * if prev_block is not NULL: +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = __Pyx_PyUnicode_From_int(__pyx_v_idx, 0, ' ', 'd'); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 562, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_10[0] = __pyx_mstate_global->__pyx_kp_u_Index; + __pyx_t_10[1] = __pyx_t_6; + __pyx_t_10[2] = __pyx_mstate_global->__pyx_kp_u_Hashes_to_not_match_Abort; + __pyx_t_11 = __Pyx_PyUnicode_Join(__pyx_t_10, 3, 6 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6) + 29, 127); + if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 562, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_7 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_11}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_print, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 562, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":563 + * if py_bytes != py_bytes_rehashed: + * print(f"Index {idx}: Hashes to not match. Abort.") + * return False # <<<<<<<<<<<<<< + * if prev_block is not NULL: + * if prev_block.hash != block.prev_hash: +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":561 + * py_bytes_rehashed = bytes(digest[:digest_size]) + * free(digest) + * if py_bytes != py_bytes_rehashed: # <<<<<<<<<<<<<< + * print(f"Index {idx}: Hashes to not match. Abort.") + * return False +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":564 + * print(f"Index {idx}: Hashes to not match. Abort.") + * return False + * if prev_block is not NULL: # <<<<<<<<<<<<<< + * if prev_block.hash != block.prev_hash: + * print( +*/ + __pyx_t_9 = (__pyx_v_prev_block != NULL); + if (__pyx_t_9) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":565 + * return False + * if prev_block is not NULL: + * if prev_block.hash != block.prev_hash: # <<<<<<<<<<<<<< + * print( + * (f"Index {idx}: Hash mismatch. Hash of previous block does not " +*/ + __pyx_t_9 = (__pyx_v_prev_block->hash != __pyx_v_block->prev_hash); + if (__pyx_t_9) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":566 + * if prev_block is not NULL: + * if prev_block.hash != block.prev_hash: + * print( # <<<<<<<<<<<<<< + * (f"Index {idx}: Hash mismatch. Hash of previous block does not " + * "match the saved one in the current block. Abort.") +*/ + __pyx_t_11 = NULL; + + /* "dopt_pollublock_blockchain/blockchain.pyx":567 + * if prev_block.hash != block.prev_hash: + * print( + * (f"Index {idx}: Hash mismatch. Hash of previous block does not " # <<<<<<<<<<<<<< + * "match the saved one in the current block. Abort.") + * ) +*/ + __pyx_t_5 = __Pyx_PyUnicode_From_int(__pyx_v_idx, 0, ' ', 'd'); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 567, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_10[0] = __pyx_mstate_global->__pyx_kp_u_Index; + __pyx_t_10[1] = __pyx_t_5; + __pyx_t_10[2] = __pyx_mstate_global->__pyx_kp_u_Hash_mismatch_Hash_of_previous; + __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_10, 3, 6 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + 97, 127); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 567, __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_11, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_print, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 566, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":570 + * "match the saved one in the current block. Abort.") + * ) + * return False # <<<<<<<<<<<<<< + * prev_block = block + * +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":565 + * return False + * if prev_block is not NULL: + * if prev_block.hash != block.prev_hash: # <<<<<<<<<<<<<< + * print( + * (f"Index {idx}: Hash mismatch. Hash of previous block does not " +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":564 + * print(f"Index {idx}: Hashes to not match. Abort.") + * return False + * if prev_block is not NULL: # <<<<<<<<<<<<<< + * if prev_block.hash != block.prev_hash: + * print( +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":571 + * ) + * return False + * prev_block = block # <<<<<<<<<<<<<< + * + * return True +*/ + __pyx_v_prev_block = __pyx_v_block; + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":573 + * prev_block = block + * + * return True # <<<<<<<<<<<<<< + * + * def get_saving_entries(self, max_idx): +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_True); + __pyx_r = Py_True; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":547 + * raise RuntimeError("Could not mine block. No nonce found") + * + * def validate(self): # <<<<<<<<<<<<<< + * cdef: + * Block *block +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.Blockchain.validate", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_py_bytes); + __Pyx_XDECREF(__pyx_v_py_bytes_rehashed); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":575 + * return True + * + * def get_saving_entries(self, max_idx): # <<<<<<<<<<<<<< + * entries = [] + * cdef: +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_21get_saving_entries(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_26dopt_pollublock_blockchain_10blockchain_10Blockchain_21get_saving_entries = {"get_saving_entries", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_21get_saving_entries, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_21get_saving_entries(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_max_idx = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_saving_entries (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_max_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, 575, __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, 575, __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_saving_entries", 0) < (0)) __PYX_ERR(0, 575, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_saving_entries", 1, 1, 1, i); __PYX_ERR(0, 575, __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, 575, __pyx_L3_error) + } + __pyx_v_max_idx = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get_saving_entries", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 575, __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("dopt_pollublock_blockchain.blockchain.Blockchain.get_saving_entries", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_20get_saving_entries(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *)__pyx_v_self), __pyx_v_max_idx); + + /* 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_26dopt_pollublock_blockchain_10blockchain_10Blockchain_20get_saving_entries(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self, PyObject *__pyx_v_max_idx) { + PyObject *__pyx_v_entries = NULL; + ::Block *__pyx_v_block; + int __pyx_v_idx; + int __pyx_v__max_idx; + PyObject *__pyx_v_contents = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + std::vector<::Block *> ::size_type __pyx_t_4; + std::vector<::Block *> ::size_type __pyx_t_5; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_saving_entries", 0); + + /* "dopt_pollublock_blockchain/blockchain.pyx":576 + * + * def get_saving_entries(self, max_idx): + * entries = [] # <<<<<<<<<<<<<< + * cdef: + * Block *block +*/ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 576, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_entries = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":579 + * cdef: + * Block *block + * int idx = 0 # <<<<<<<<<<<<<< + * int _max_idx + * +*/ + __pyx_v_idx = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":582 + * int _max_idx + * + * if max_idx is None: # <<<<<<<<<<<<<< + * _max_idx = -1 + * else: +*/ + __pyx_t_2 = (__pyx_v_max_idx == Py_None); + if (__pyx_t_2) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":583 + * + * if max_idx is None: + * _max_idx = -1 # <<<<<<<<<<<<<< + * else: + * _max_idx = max_idx +*/ + __pyx_v__max_idx = -1; + + /* "dopt_pollublock_blockchain/blockchain.pyx":582 + * int _max_idx + * + * if max_idx is None: # <<<<<<<<<<<<<< + * _max_idx = -1 + * else: +*/ + goto __pyx_L3; + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":585 + * _max_idx = -1 + * else: + * _max_idx = max_idx # <<<<<<<<<<<<<< + * + * for idx in range(self._chain[0].size()): +*/ + /*else*/ { + __pyx_t_3 = __Pyx_PyLong_As_int(__pyx_v_max_idx); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 585, __pyx_L1_error) + __pyx_v__max_idx = __pyx_t_3; + } + __pyx_L3:; + + /* "dopt_pollublock_blockchain/blockchain.pyx":587 + * _max_idx = max_idx + * + * for idx in range(self._chain[0].size()): # <<<<<<<<<<<<<< + * if idx <= _max_idx: + * continue +*/ + __pyx_t_4 = (__pyx_v_self->_chain[0]).size(); + __pyx_t_5 = __pyx_t_4; + for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_5; __pyx_t_3+=1) { + __pyx_v_idx = __pyx_t_3; + + /* "dopt_pollublock_blockchain/blockchain.pyx":588 + * + * for idx in range(self._chain[0].size()): + * if idx <= _max_idx: # <<<<<<<<<<<<<< + * continue + * block = self._chain[0][idx] +*/ + __pyx_t_2 = (__pyx_v_idx <= __pyx_v__max_idx); + if (__pyx_t_2) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":589 + * for idx in range(self._chain[0].size()): + * if idx <= _max_idx: + * continue # <<<<<<<<<<<<<< + * block = self._chain[0][idx] + * contents = {} +*/ + goto __pyx_L4_continue; + + /* "dopt_pollublock_blockchain/blockchain.pyx":588 + * + * for idx in range(self._chain[0].size()): + * if idx <= _max_idx: # <<<<<<<<<<<<<< + * continue + * block = self._chain[0][idx] +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":590 + * if idx <= _max_idx: + * continue + * block = self._chain[0][idx] # <<<<<<<<<<<<<< + * contents = {} + * contents["index"] = block.index +*/ + __pyx_v_block = ((__pyx_v_self->_chain[0])[__pyx_v_idx]); + + /* "dopt_pollublock_blockchain/blockchain.pyx":591 + * continue + * block = self._chain[0][idx] + * contents = {} # <<<<<<<<<<<<<< + * contents["index"] = block.index + * contents["timestamp"] = block.timestamp +*/ + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 591, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_contents, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":592 + * block = self._chain[0][idx] + * contents = {} + * contents["index"] = block.index # <<<<<<<<<<<<<< + * contents["timestamp"] = block.timestamp + * contents["nonce"] = block.nonce +*/ + __pyx_t_1 = __Pyx_PyLong_From_uint64_t(__pyx_v_block->index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 592, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_contents, __pyx_mstate_global->__pyx_n_u_index, __pyx_t_1) < 0))) __PYX_ERR(0, 592, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":593 + * contents = {} + * contents["index"] = block.index + * contents["timestamp"] = block.timestamp # <<<<<<<<<<<<<< + * contents["nonce"] = block.nonce + * contents["previous_hash"] = block.prev_hash.decode("UTF-8") +*/ + __pyx_t_1 = __Pyx_PyLong_From_uint64_t(__pyx_v_block->timestamp); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 593, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_contents, __pyx_mstate_global->__pyx_n_u_timestamp, __pyx_t_1) < 0))) __PYX_ERR(0, 593, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":594 + * contents["index"] = block.index + * contents["timestamp"] = block.timestamp + * contents["nonce"] = block.nonce # <<<<<<<<<<<<<< + * contents["previous_hash"] = block.prev_hash.decode("UTF-8") + * contents["hash"] = block.hash.decode("UTF-8") +*/ + __pyx_t_1 = __Pyx_PyLong_From_uint64_t(__pyx_v_block->nonce); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 594, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_contents, __pyx_mstate_global->__pyx_n_u_nonce, __pyx_t_1) < 0))) __PYX_ERR(0, 594, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":595 + * contents["timestamp"] = block.timestamp + * contents["nonce"] = block.nonce + * contents["previous_hash"] = block.prev_hash.decode("UTF-8") # <<<<<<<<<<<<<< + * contents["hash"] = block.hash.decode("UTF-8") + * contents["data"] = block.data.decode("UTF-8") +*/ + __pyx_t_1 = __Pyx_decode_cpp_string(__pyx_v_block->prev_hash, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 595, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_contents, __pyx_mstate_global->__pyx_n_u_previous_hash, __pyx_t_1) < 0))) __PYX_ERR(0, 595, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":596 + * contents["nonce"] = block.nonce + * contents["previous_hash"] = block.prev_hash.decode("UTF-8") + * contents["hash"] = block.hash.decode("UTF-8") # <<<<<<<<<<<<<< + * contents["data"] = block.data.decode("UTF-8") + * entries.append(contents) +*/ + __pyx_t_1 = __Pyx_decode_cpp_string(__pyx_v_block->hash, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 596, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_contents, __pyx_mstate_global->__pyx_n_u_hash, __pyx_t_1) < 0))) __PYX_ERR(0, 596, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":597 + * contents["previous_hash"] = block.prev_hash.decode("UTF-8") + * contents["hash"] = block.hash.decode("UTF-8") + * contents["data"] = block.data.decode("UTF-8") # <<<<<<<<<<<<<< + * entries.append(contents) + * +*/ + __pyx_t_1 = __Pyx_decode_cpp_string(__pyx_v_block->data, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 597, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_contents, __pyx_mstate_global->__pyx_n_u_data, __pyx_t_1) < 0))) __PYX_ERR(0, 597, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":598 + * contents["hash"] = block.hash.decode("UTF-8") + * contents["data"] = block.data.decode("UTF-8") + * entries.append(contents) # <<<<<<<<<<<<<< + * + * return entries +*/ + __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_entries, __pyx_v_contents); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 598, __pyx_L1_error) + __pyx_L4_continue:; + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":600 + * entries.append(contents) + * + * return entries # <<<<<<<<<<<<<< + * + * def save(self): +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_entries); + __pyx_r = __pyx_v_entries; + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":575 + * return True + * + * def get_saving_entries(self, max_idx): # <<<<<<<<<<<<<< + * entries = [] + * cdef: +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.Blockchain.get_saving_entries", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_entries); + __Pyx_XDECREF(__pyx_v_contents); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":602 + * return entries + * + * def save(self): # <<<<<<<<<<<<<< + * # get max index from db + * # only retrieve indices greater than max value +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_23save(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_26dopt_pollublock_blockchain_10blockchain_10Blockchain_23save = {"save", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_23save, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_23save(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("save (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("save", 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("save", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_22save(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_22save(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self) { + PyObject *__pyx_v_stmt = NULL; + PyObject *__pyx_v_conn = NULL; + PyObject *__pyx_v_result = NULL; + PyObject *__pyx_v_max_value = NULL; + PyObject *__pyx_v_entries = NULL; + PyObject *__pyx_v_con = 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; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + size_t __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + int __pyx_t_15; + int __pyx_t_16; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("save", 0); + + /* "dopt_pollublock_blockchain/blockchain.pyx":605 + * # get max index from db + * # only retrieve indices greater than max value + * stmt = sql.select(sql.func.max(db.blocks.c.index)) # <<<<<<<<<<<<<< + * with self._engine.connect() as conn: + * result = conn.execute(stmt) +*/ + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_sql); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 605, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_select); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 605, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_sql); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 605, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_func); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 605, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_5 = __pyx_t_7; + __Pyx_INCREF(__pyx_t_5); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_db); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 605, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_blocks); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 605, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_c); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 605, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_index); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 605, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_8}; + __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_max, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 605, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_t_9 = 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_9 = 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_9, (2-__pyx_t_9) | (__pyx_t_9*__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, 605, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_stmt = __pyx_t_1; + __pyx_t_1 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":606 + * # only retrieve indices greater than max value + * stmt = sql.select(sql.func.max(db.blocks.c.index)) + * with self._engine.connect() as conn: # <<<<<<<<<<<<<< + * result = conn.execute(stmt) + * max_value = result.scalar() +*/ + /*with:*/ { + __pyx_t_4 = __pyx_v_self->_engine; + __Pyx_INCREF(__pyx_t_4); + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_connect, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 606, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_10 = __Pyx_PyObject_LookupSpecial(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_exit); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 606, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_3 = NULL; + __pyx_t_2 = __Pyx_PyObject_LookupSpecial(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_enter); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 606, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_2, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_2, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (__pyx_t_9*__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_4)) __PYX_ERR(0, 606, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_2 = __pyx_t_4; + __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /*try:*/ { + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13); + __Pyx_XGOTREF(__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_12); + __Pyx_XGOTREF(__pyx_t_13); + /*try:*/ { + __pyx_v_conn = __pyx_t_2; + __pyx_t_2 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":607 + * stmt = sql.select(sql.func.max(db.blocks.c.index)) + * with self._engine.connect() as conn: + * result = conn.execute(stmt) # <<<<<<<<<<<<<< + * max_value = result.scalar() + * +*/ + __pyx_t_1 = __pyx_v_conn; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_v_stmt}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_execute, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 607, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_v_result = __pyx_t_2; + __pyx_t_2 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":608 + * with self._engine.connect() as conn: + * result = conn.execute(stmt) + * max_value = result.scalar() # <<<<<<<<<<<<<< + * + * entries = self.get_saving_entries(max_value) +*/ + __pyx_t_1 = __pyx_v_result; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_scalar, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 608, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_v_max_value = __pyx_t_2; + __pyx_t_2 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":606 + * # only retrieve indices greater than max value + * stmt = sql.select(sql.func.max(db.blocks.c.index)) + * with self._engine.connect() as conn: # <<<<<<<<<<<<<< + * result = conn.execute(stmt) + * max_value = result.scalar() +*/ + } + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + goto __pyx_L12_try_end; + __pyx_L7_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + /*except:*/ { + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.Blockchain.save", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_1, &__pyx_t_4) < 0) __PYX_ERR(0, 606, __pyx_L9_except_error) + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_4); + __pyx_t_3 = PyTuple_Pack(3, __pyx_t_2, __pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 606, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_3, NULL); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 606, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_14); + __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_t_14); + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + if (__pyx_t_15 < (0)) __PYX_ERR(0, 606, __pyx_L9_except_error) + __pyx_t_16 = (!__pyx_t_15); + if (unlikely(__pyx_t_16)) { + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ErrRestoreWithState(__pyx_t_2, __pyx_t_1, __pyx_t_4); + __pyx_t_2 = 0; __pyx_t_1 = 0; __pyx_t_4 = 0; + __PYX_ERR(0, 606, __pyx_L9_except_error) + } + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L8_exception_handled; + } + __pyx_L9_except_error:; + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13); + goto __pyx_L1_error; + __pyx_L8_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13); + __pyx_L12_try_end:; + } + } + /*finally:*/ { + /*normal exit:*/{ + if (__pyx_t_10) { + __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_mstate_global->__pyx_tuple[0], NULL); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 606, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } + goto __pyx_L6; + } + __pyx_L6:; + } + goto __pyx_L16; + __pyx_L3_error:; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + goto __pyx_L1_error; + __pyx_L16:; + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":610 + * max_value = result.scalar() + * + * entries = self.get_saving_entries(max_value) # <<<<<<<<<<<<<< + * if not entries: + * return +*/ + __pyx_t_1 = ((PyObject *)__pyx_v_self); + __Pyx_INCREF(__pyx_t_1); + if (unlikely(!__pyx_v_max_value)) { __Pyx_RaiseUnboundLocalError("max_value"); __PYX_ERR(0, 610, __pyx_L1_error) } + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_v_max_value}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_get_saving_entries, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 610, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_v_entries = __pyx_t_4; + __pyx_t_4 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":611 + * + * entries = self.get_saving_entries(max_value) + * if not entries: # <<<<<<<<<<<<<< + * return + * +*/ + __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_v_entries); if (unlikely((__pyx_t_16 < 0))) __PYX_ERR(0, 611, __pyx_L1_error) + __pyx_t_15 = (!__pyx_t_16); + if (__pyx_t_15) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":612 + * entries = self.get_saving_entries(max_value) + * if not entries: + * return # <<<<<<<<<<<<<< + * + * with self._engine.begin() as con: +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":611 + * + * entries = self.get_saving_entries(max_value) + * if not entries: # <<<<<<<<<<<<<< + * return + * +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":614 + * return + * + * with self._engine.begin() as con: # <<<<<<<<<<<<<< + * con.execute(sql.insert(db.blocks), entries) + * +*/ + /*with:*/ { + __pyx_t_1 = __pyx_v_self->_engine; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_begin, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_10 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_exit); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_2 = NULL; + __pyx_t_3 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_enter); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 614, __pyx_L18_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 614, __pyx_L18_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_3 = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + /*try:*/ { + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_13, &__pyx_t_12, &__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_13); + __Pyx_XGOTREF(__pyx_t_12); + __Pyx_XGOTREF(__pyx_t_11); + /*try:*/ { + __pyx_v_con = __pyx_t_3; + __pyx_t_3 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":615 + * + * with self._engine.begin() as con: + * con.execute(sql.insert(db.blocks), entries) # <<<<<<<<<<<<<< + * + * def close_db_connections(self): +*/ + __pyx_t_4 = __pyx_v_con; + __Pyx_INCREF(__pyx_t_4); + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_sql); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 615, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_insert); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 615, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_db); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 615, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_blocks); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 615, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_8); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_8, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_8, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 615, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_1, __pyx_v_entries}; + __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_execute, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 615, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":614 + * return + * + * with self._engine.begin() as con: # <<<<<<<<<<<<<< + * con.execute(sql.insert(db.blocks), entries) + * +*/ + } + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + goto __pyx_L27_try_end; + __pyx_L22_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + /*except:*/ { + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.Blockchain.save", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_1, &__pyx_t_4) < 0) __PYX_ERR(0, 614, __pyx_L24_except_error) + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_4); + __pyx_t_8 = PyTuple_Pack(3, __pyx_t_3, __pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 614, __pyx_L24_except_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_8, NULL); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 614, __pyx_L24_except_error) + __Pyx_GOTREF(__pyx_t_14); + __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_t_14); + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + if (__pyx_t_15 < (0)) __PYX_ERR(0, 614, __pyx_L24_except_error) + __pyx_t_16 = (!__pyx_t_15); + if (unlikely(__pyx_t_16)) { + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ErrRestoreWithState(__pyx_t_3, __pyx_t_1, __pyx_t_4); + __pyx_t_3 = 0; __pyx_t_1 = 0; __pyx_t_4 = 0; + __PYX_ERR(0, 614, __pyx_L24_except_error) + } + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L23_exception_handled; + } + __pyx_L24_except_error:; + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_ExceptionReset(__pyx_t_13, __pyx_t_12, __pyx_t_11); + goto __pyx_L1_error; + __pyx_L23_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_ExceptionReset(__pyx_t_13, __pyx_t_12, __pyx_t_11); + __pyx_L27_try_end:; + } + } + /*finally:*/ { + /*normal exit:*/{ + if (__pyx_t_10) { + __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_mstate_global->__pyx_tuple[0], NULL); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } + goto __pyx_L21; + } + __pyx_L21:; + } + goto __pyx_L31; + __pyx_L18_error:; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + goto __pyx_L1_error; + __pyx_L31:; + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":602 + * return entries + * + * def save(self): # <<<<<<<<<<<<<< + * # get max index from db + * # only retrieve indices greater than max value +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.Blockchain.save", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_stmt); + __Pyx_XDECREF(__pyx_v_conn); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_max_value); + __Pyx_XDECREF(__pyx_v_entries); + __Pyx_XDECREF(__pyx_v_con); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":617 + * con.execute(sql.insert(db.blocks), entries) + * + * def close_db_connections(self): # <<<<<<<<<<<<<< + * self._engine.dispose() + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_25close_db_connections(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_26dopt_pollublock_blockchain_10blockchain_10Blockchain_25close_db_connections = {"close_db_connections", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_25close_db_connections, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_25close_db_connections(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("close_db_connections (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("close_db_connections", 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("close_db_connections", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_24close_db_connections(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_24close_db_connections(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__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("close_db_connections", 0); + + /* "dopt_pollublock_blockchain/blockchain.pyx":618 + * + * def close_db_connections(self): + * self._engine.dispose() # <<<<<<<<<<<<<< + * + * def load(self, batch_size): +*/ + __pyx_t_2 = __pyx_v_self->_engine; + __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_dispose, __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, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":617 + * con.execute(sql.insert(db.blocks), entries) + * + * def close_db_connections(self): # <<<<<<<<<<<<<< + * self._engine.dispose() + * +*/ + + /* 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("dopt_pollublock_blockchain.blockchain.Blockchain.close_db_connections", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":620 + * self._engine.dispose() + * + * def load(self, batch_size): # <<<<<<<<<<<<<< + * if self._loaded: + * raise RuntimeError("Blockchain was already loaded") +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_27load(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_26dopt_pollublock_blockchain_10blockchain_10Blockchain_27load = {"load", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_27load, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_27load(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_batch_size = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("load (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_batch_size,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, 620, __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, 620, __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, "load", 0) < (0)) __PYX_ERR(0, 620, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("load", 1, 1, 1, i); __PYX_ERR(0, 620, __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, 620, __pyx_L3_error) + } + __pyx_v_batch_size = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("load", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 620, __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("dopt_pollublock_blockchain.blockchain.Blockchain.load", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_26load(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *)__pyx_v_self), __pyx_v_batch_size); + + /* 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_26dopt_pollublock_blockchain_10blockchain_10Blockchain_26load(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self, PyObject *__pyx_v_batch_size) { + PyObject *__pyx_v_con = NULL; + PyObject *__pyx_v_res = NULL; + PyObject *__pyx_v_batch = 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; + 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; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + PyObject *__pyx_t_15 = NULL; + int __pyx_t_16; + int __pyx_t_17; + Py_ssize_t __pyx_t_18; + PyObject *(*__pyx_t_19)(PyObject *); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("load", 0); + + /* "dopt_pollublock_blockchain/blockchain.pyx":621 + * + * def load(self, batch_size): + * if self._loaded: # <<<<<<<<<<<<<< + * raise RuntimeError("Blockchain was already loaded") + * +*/ + if (unlikely(__pyx_v_self->_loaded)) { + + /* "dopt_pollublock_blockchain/blockchain.pyx":622 + * def load(self, batch_size): + * if self._loaded: + * raise RuntimeError("Blockchain was already loaded") # <<<<<<<<<<<<<< + * + * with self._engine.connect() as con: +*/ + __pyx_t_2 = NULL; + __pyx_t_3 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_mstate_global->__pyx_kp_u_Blockchain_was_already_loaded}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_RuntimeError)), __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 622, __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, 622, __pyx_L1_error) + + /* "dopt_pollublock_blockchain/blockchain.pyx":621 + * + * def load(self, batch_size): + * if self._loaded: # <<<<<<<<<<<<<< + * raise RuntimeError("Blockchain was already loaded") + * +*/ + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":624 + * raise RuntimeError("Blockchain was already loaded") + * + * with self._engine.connect() as con: # <<<<<<<<<<<<<< + * res = con.execute(sql.select(db.blocks).order_by(db.blocks.c.index.asc())) + * +*/ + /*with:*/ { + __pyx_t_2 = __pyx_v_self->_engine; + __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_connect, __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, 624, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_4 = __Pyx_PyObject_LookupSpecial(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_exit); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 624, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = __Pyx_PyObject_LookupSpecial(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_enter); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 624, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = 1; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_3 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 624, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_t_6 = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /*try:*/ { + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_9); + /*try:*/ { + __pyx_v_con = __pyx_t_6; + __pyx_t_6 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":625 + * + * with self._engine.connect() as con: + * res = con.execute(sql.select(db.blocks).order_by(db.blocks.c.index.asc())) # <<<<<<<<<<<<<< + * + * for batch in res.partitions(batch_size): +*/ + __pyx_t_1 = __pyx_v_con; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_11 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_sql); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 625, __pyx_L8_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_select); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 625, __pyx_L8_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_db); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 625, __pyx_L8_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_blocks); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 625, __pyx_L8_error) + __Pyx_GOTREF(__pyx_t_14); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_3 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_13))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_13); + assert(__pyx_t_11); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_13); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_13, __pyx__function); + __pyx_t_3 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_11, __pyx_t_14}; + __pyx_t_10 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_13, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 625, __pyx_L8_error) + __Pyx_GOTREF(__pyx_t_10); + } + __pyx_t_5 = __pyx_t_10; + __Pyx_INCREF(__pyx_t_5); + __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_db); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 625, __pyx_L8_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_blocks); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 625, __pyx_L8_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_c); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 625, __pyx_L8_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_index); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 625, __pyx_L8_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_14 = __pyx_t_12; + __Pyx_INCREF(__pyx_t_14); + __pyx_t_3 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_14, NULL}; + __pyx_t_13 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_asc, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 625, __pyx_L8_error) + __Pyx_GOTREF(__pyx_t_13); + } + __pyx_t_3 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_13}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_order_by, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 625, __pyx_L8_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_t_3 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_2}; + __pyx_t_6 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_execute, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 625, __pyx_L8_error) + __Pyx_GOTREF(__pyx_t_6); + } + __pyx_v_res = __pyx_t_6; + __pyx_t_6 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":624 + * raise RuntimeError("Blockchain was already loaded") + * + * with self._engine.connect() as con: # <<<<<<<<<<<<<< + * res = con.execute(sql.select(db.blocks).order_by(db.blocks.c.index.asc())) + * +*/ + } + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L13_try_end; + __pyx_L8_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + /*except:*/ { + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.Blockchain.load", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_2, &__pyx_t_1) < 0) __PYX_ERR(0, 624, __pyx_L10_except_error) + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_1); + __pyx_t_10 = PyTuple_Pack(3, __pyx_t_6, __pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 624, __pyx_L10_except_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_10, NULL); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 624, __pyx_L10_except_error) + __Pyx_GOTREF(__pyx_t_15); + __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_15); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (__pyx_t_16 < (0)) __PYX_ERR(0, 624, __pyx_L10_except_error) + __pyx_t_17 = (!__pyx_t_16); + if (unlikely(__pyx_t_17)) { + __Pyx_GIVEREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_ErrRestoreWithState(__pyx_t_6, __pyx_t_2, __pyx_t_1); + __pyx_t_6 = 0; __pyx_t_2 = 0; __pyx_t_1 = 0; + __PYX_ERR(0, 624, __pyx_L10_except_error) + } + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L9_exception_handled; + } + __pyx_L10_except_error:; + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); + goto __pyx_L1_error; + __pyx_L9_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); + __pyx_L13_try_end:; + } + } + /*finally:*/ { + /*normal exit:*/{ + if (__pyx_t_4) { + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_mstate_global->__pyx_tuple[0], NULL); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 624, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + goto __pyx_L7; + } + __pyx_L7:; + } + goto __pyx_L17; + __pyx_L4_error:; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L1_error; + __pyx_L17:; + } + + /* "dopt_pollublock_blockchain/blockchain.pyx":627 + * res = con.execute(sql.select(db.blocks).order_by(db.blocks.c.index.asc())) + * + * for batch in res.partitions(batch_size): # <<<<<<<<<<<<<< + * self.load_from_batch(batch) + * +*/ + if (unlikely(!__pyx_v_res)) { __Pyx_RaiseUnboundLocalError("res"); __PYX_ERR(0, 627, __pyx_L1_error) } + __pyx_t_2 = __pyx_v_res; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_batch_size}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_partitions, __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, 627, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { + __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); + __pyx_t_18 = 0; + __pyx_t_19 = NULL; + } else { + __pyx_t_18 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 627, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_19 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 627, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + for (;;) { + if (likely(!__pyx_t_19)) { + 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, 627, __pyx_L1_error) + #endif + if (__pyx_t_18 >= __pyx_temp) break; + } + __pyx_t_1 = __Pyx_PyList_GetItemRefFast(__pyx_t_2, __pyx_t_18, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_18; + } 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, 627, __pyx_L1_error) + #endif + if (__pyx_t_18 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_18)); + #else + __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_18); + #endif + ++__pyx_t_18; + } + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 627, __pyx_L1_error) + } else { + __pyx_t_1 = __pyx_t_19(__pyx_t_2); + 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, 627, __pyx_L1_error) + PyErr_Clear(); + } + break; + } + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_batch, __pyx_t_1); + __pyx_t_1 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":628 + * + * for batch in res.partitions(batch_size): + * self.load_from_batch(batch) # <<<<<<<<<<<<<< + * + * self._loaded = True +*/ + __pyx_t_1 = ((struct __pyx_vtabstruct_26dopt_pollublock_blockchain_10blockchain_Blockchain *)__pyx_v_self->__pyx_vtab)->load_from_batch(__pyx_v_self, __pyx_v_batch); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 628, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":627 + * res = con.execute(sql.select(db.blocks).order_by(db.blocks.c.index.asc())) + * + * for batch in res.partitions(batch_size): # <<<<<<<<<<<<<< + * self.load_from_batch(batch) + * +*/ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":630 + * self.load_from_batch(batch) + * + * self._loaded = True # <<<<<<<<<<<<<< +*/ + __pyx_v_self->_loaded = 1; + + /* "dopt_pollublock_blockchain/blockchain.pyx":620 + * self._engine.dispose() + * + * def load(self, batch_size): # <<<<<<<<<<<<<< + * if self._loaded: + * raise RuntimeError("Blockchain was already loaded") +*/ + + /* 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_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_XDECREF(__pyx_t_14); + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.Blockchain.load", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_con); + __Pyx_XDECREF(__pyx_v_res); + __Pyx_XDECREF(__pyx_v_batch); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":331 + * bint _genesis_done + * bint _loaded + * readonly object db_path # <<<<<<<<<<<<<< + * readonly object _engine + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_7db_path_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_7db_path_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_26dopt_pollublock_blockchain_10blockchain_10Blockchain_7db_path___get__(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_7db_path___get__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->db_path); + __pyx_r = __pyx_v_self->db_path; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dopt_pollublock_blockchain/blockchain.pyx":332 + * bint _loaded + * readonly object db_path + * readonly object _engine # <<<<<<<<<<<<<< + * + * def __cinit__(self, *args, **kwargs): +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_7_engine_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_7_engine_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_26dopt_pollublock_blockchain_10blockchain_10Blockchain_7_engine___get__(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_7_engine___get__(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_engine); + __pyx_r = __pyx_v_self->_engine; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_29__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_26dopt_pollublock_blockchain_10blockchain_10Blockchain_29__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_29__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_29__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_28__reduce_cython__(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_28__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__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, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_TypeError))), __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.Blockchain.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_31__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_26dopt_pollublock_blockchain_10blockchain_10Blockchain_31__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_31__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_31__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 3, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__setstate_cython__", 0) < (0)) __PYX_ERR(1, 3, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 3, __pyx_L3_error) + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.Blockchain.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_26dopt_pollublock_blockchain_10blockchain_10Blockchain_30__setstate_cython__(((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *)__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_26dopt_pollublock_blockchain_10blockchain_10Blockchain_30__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *__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, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_TypeError))), __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("dopt_pollublock_blockchain.blockchain.Blockchain.__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_26dopt_pollublock_blockchain_10blockchain_PyBlock __pyx_vtable_26dopt_pollublock_blockchain_10blockchain_PyBlock; + +static PyObject *__pyx_tp_new_26dopt_pollublock_blockchain_10blockchain_PyBlock(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *p; + PyObject *o; + o = __Pyx_AllocateExtensionType(t, 0); + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *)o); + p->__pyx_vtab = __pyx_vtabptr_26dopt_pollublock_blockchain_10blockchain_PyBlock; + if (unlikely(__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_1__cinit__(o, a, k) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_26dopt_pollublock_blockchain_10blockchain_PyBlock(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_26dopt_pollublock_blockchain_10blockchain_PyBlock) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); + __pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_5__dealloc__(o); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); + PyErr_Restore(etype, eval, etb); + } + 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_getprop_26dopt_pollublock_blockchain_10blockchain_7PyBlock_index(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_5index_1__get__(o); +} + +static PyObject *__pyx_getprop_26dopt_pollublock_blockchain_10blockchain_7PyBlock_timestamp(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_9timestamp_1__get__(o); +} + +static PyObject *__pyx_getprop_26dopt_pollublock_blockchain_10blockchain_7PyBlock_data(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_4data_1__get__(o); +} + +static PyObject *__pyx_getprop_26dopt_pollublock_blockchain_10blockchain_7PyBlock_prev_hash(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_9prev_hash_1__get__(o); +} + +static PyObject *__pyx_getprop_26dopt_pollublock_blockchain_10blockchain_7PyBlock_nonce(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_5nonce_1__get__(o); +} + +static PyObject *__pyx_getprop_26dopt_pollublock_blockchain_10blockchain_7PyBlock_hash(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_4hash_1__get__(o); +} + +static PyMethodDef __pyx_methods_26dopt_pollublock_blockchain_10blockchain_PyBlock[] = { + {"serialize_dict", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_11serialize_dict, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"bytes_serialize", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_13bytes_serialize, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"perform_hash", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_15perform_hash, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_19__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_26dopt_pollublock_blockchain_10blockchain_PyBlock[] = { + {"index", __pyx_getprop_26dopt_pollublock_blockchain_10blockchain_7PyBlock_index, 0, 0, 0}, + {"timestamp", __pyx_getprop_26dopt_pollublock_blockchain_10blockchain_7PyBlock_timestamp, 0, 0, 0}, + {"data", __pyx_getprop_26dopt_pollublock_blockchain_10blockchain_7PyBlock_data, 0, 0, 0}, + {"prev_hash", __pyx_getprop_26dopt_pollublock_blockchain_10blockchain_7PyBlock_prev_hash, 0, 0, 0}, + {"nonce", __pyx_getprop_26dopt_pollublock_blockchain_10blockchain_7PyBlock_nonce, 0, 0, 0}, + {"hash", __pyx_getprop_26dopt_pollublock_blockchain_10blockchain_7PyBlock_hash, 0, 0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_26dopt_pollublock_blockchain_10blockchain_PyBlock_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_26dopt_pollublock_blockchain_10blockchain_PyBlock}, + {Py_tp_repr, (void *)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_7__repr__}, + {Py_tp_str, (void *)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_9__str__}, + {Py_tp_methods, (void *)__pyx_methods_26dopt_pollublock_blockchain_10blockchain_PyBlock}, + {Py_tp_getset, (void *)__pyx_getsets_26dopt_pollublock_blockchain_10blockchain_PyBlock}, + {Py_tp_init, (void *)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_3__init__}, + {Py_tp_new, (void *)__pyx_tp_new_26dopt_pollublock_blockchain_10blockchain_PyBlock}, + {0, 0}, +}; +static PyType_Spec __pyx_type_26dopt_pollublock_blockchain_10blockchain_PyBlock_spec = { + "dopt_pollublock_blockchain.blockchain.PyBlock", + sizeof(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_26dopt_pollublock_blockchain_10blockchain_PyBlock_slots, +}; +#else + +static PyTypeObject __pyx_type_26dopt_pollublock_blockchain_10blockchain_PyBlock = { + PyVarObject_HEAD_INIT(0, 0) + "dopt_pollublock_blockchain.blockchain.""PyBlock", /*tp_name*/ + sizeof(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_26dopt_pollublock_blockchain_10blockchain_PyBlock, /*tp_dealloc*/ + 0, /*tp_vectorcall_offset*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + __pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_7__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + __pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_9__str__, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_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_26dopt_pollublock_blockchain_10blockchain_PyBlock, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_26dopt_pollublock_blockchain_10blockchain_PyBlock, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_26dopt_pollublock_blockchain_10blockchain_7PyBlock_3__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_26dopt_pollublock_blockchain_10blockchain_PyBlock, /*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 + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif +static struct __pyx_vtabstruct_26dopt_pollublock_blockchain_10blockchain_Blockchain __pyx_vtable_26dopt_pollublock_blockchain_10blockchain_Blockchain; + +static PyObject *__pyx_tp_new_26dopt_pollublock_blockchain_10blockchain_Blockchain(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *p; + PyObject *o; + o = __Pyx_AllocateExtensionType(t, 0); + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *)o); + p->__pyx_vtab = __pyx_vtabptr_26dopt_pollublock_blockchain_10blockchain_Blockchain; + p->db_path = Py_None; Py_INCREF(Py_None); + p->_engine = Py_None; Py_INCREF(Py_None); + if (unlikely(__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_1__cinit__(o, a, k) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_26dopt_pollublock_blockchain_10blockchain_Blockchain(PyObject *o) { + struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *p = (struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *)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_26dopt_pollublock_blockchain_10blockchain_Blockchain) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); + __pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_5__dealloc__(o); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->db_path); + Py_CLEAR(p->_engine); + 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_26dopt_pollublock_blockchain_10blockchain_Blockchain(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *p = (struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->db_path) { + e = (*v)(p->db_path, a); if (e) return e; + } + if (p->_engine) { + e = (*v)(p->_engine, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_26dopt_pollublock_blockchain_10blockchain_Blockchain(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *p = (struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *)o; + tmp = ((PyObject*)p->db_path); + p->db_path = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_engine); + p->_engine = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_26dopt_pollublock_blockchain_10blockchain_10Blockchain_difficulty(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_10difficulty_1__get__(o); +} + +static int __pyx_setprop_26dopt_pollublock_blockchain_10blockchain_10Blockchain_difficulty(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_10difficulty_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_26dopt_pollublock_blockchain_10blockchain_10Blockchain_genesis_done(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_12genesis_done_1__get__(o); +} + +static PyObject *__pyx_getprop_26dopt_pollublock_blockchain_10blockchain_10Blockchain_index(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_5index_1__get__(o); +} + +static PyObject *__pyx_getprop_26dopt_pollublock_blockchain_10blockchain_10Blockchain_db_path(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_7db_path_1__get__(o); +} + +static PyObject *__pyx_getprop_26dopt_pollublock_blockchain_10blockchain_10Blockchain__engine(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_7_engine_1__get__(o); +} + +static PyMethodDef __pyx_methods_26dopt_pollublock_blockchain_10blockchain_Blockchain[] = { + {"_print_key_value_pair", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_9_print_key_value_pair, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"print_blocks", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_11print_blocks, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"get_block", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_13get_block, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"create_genesis_block", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_15create_genesis_block, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"new_block", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_17new_block, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"validate", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_19validate, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"get_saving_entries", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_21get_saving_entries, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"save", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_23save, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"close_db_connections", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_25close_db_connections, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"load", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_27load, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_29__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_31__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_26dopt_pollublock_blockchain_10blockchain_Blockchain[] = { + {"difficulty", __pyx_getprop_26dopt_pollublock_blockchain_10blockchain_10Blockchain_difficulty, __pyx_setprop_26dopt_pollublock_blockchain_10blockchain_10Blockchain_difficulty, 0, 0}, + {"genesis_done", __pyx_getprop_26dopt_pollublock_blockchain_10blockchain_10Blockchain_genesis_done, 0, 0, 0}, + {"index", __pyx_getprop_26dopt_pollublock_blockchain_10blockchain_10Blockchain_index, 0, 0, 0}, + {"db_path", __pyx_getprop_26dopt_pollublock_blockchain_10blockchain_10Blockchain_db_path, 0, 0, 0}, + {"_engine", __pyx_getprop_26dopt_pollublock_blockchain_10blockchain_10Blockchain__engine, 0, 0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_26dopt_pollublock_blockchain_10blockchain_Blockchain_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_26dopt_pollublock_blockchain_10blockchain_Blockchain}, + {Py_sq_length, (void *)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_7__len__}, + {Py_mp_length, (void *)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_7__len__}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_26dopt_pollublock_blockchain_10blockchain_Blockchain}, + {Py_tp_clear, (void *)__pyx_tp_clear_26dopt_pollublock_blockchain_10blockchain_Blockchain}, + {Py_tp_methods, (void *)__pyx_methods_26dopt_pollublock_blockchain_10blockchain_Blockchain}, + {Py_tp_getset, (void *)__pyx_getsets_26dopt_pollublock_blockchain_10blockchain_Blockchain}, + {Py_tp_init, (void *)__pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_3__init__}, + {Py_tp_new, (void *)__pyx_tp_new_26dopt_pollublock_blockchain_10blockchain_Blockchain}, + {0, 0}, +}; +static PyType_Spec __pyx_type_26dopt_pollublock_blockchain_10blockchain_Blockchain_spec = { + "dopt_pollublock_blockchain.blockchain.Blockchain", + sizeof(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_26dopt_pollublock_blockchain_10blockchain_Blockchain_slots, +}; +#else + +static PySequenceMethods __pyx_tp_as_sequence_Blockchain = { + __pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_7__len__, /*sq_length*/ + 0, /*sq_concat*/ + 0, /*sq_repeat*/ + 0, /*sq_item*/ + 0, /*sq_slice*/ + 0, /*sq_ass_item*/ + 0, /*sq_ass_slice*/ + 0, /*sq_contains*/ + 0, /*sq_inplace_concat*/ + 0, /*sq_inplace_repeat*/ +}; + +static PyMappingMethods __pyx_tp_as_mapping_Blockchain = { + __pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_7__len__, /*mp_length*/ + 0, /*mp_subscript*/ + 0, /*mp_ass_subscript*/ +}; + +static PyTypeObject __pyx_type_26dopt_pollublock_blockchain_10blockchain_Blockchain = { + PyVarObject_HEAD_INIT(0, 0) + "dopt_pollublock_blockchain.blockchain.""Blockchain", /*tp_name*/ + sizeof(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_26dopt_pollublock_blockchain_10blockchain_Blockchain, /*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_Blockchain, /*tp_as_sequence*/ + &__pyx_tp_as_mapping_Blockchain, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_26dopt_pollublock_blockchain_10blockchain_Blockchain, /*tp_traverse*/ + __pyx_tp_clear_26dopt_pollublock_blockchain_10blockchain_Blockchain, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_26dopt_pollublock_blockchain_10blockchain_Blockchain, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_26dopt_pollublock_blockchain_10blockchain_Blockchain, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_26dopt_pollublock_blockchain_10blockchain_10Blockchain_3__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_26dopt_pollublock_blockchain_10blockchain_Blockchain, /*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 + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; +/* #### Code section: initfunc_declarations ### */ +static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate); /*proto*/ +/* #### Code section: init_module ### */ + +static int __Pyx_modinit_global_init_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); + /*--- Global init code ---*/ + __Pyx_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_type_init_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); + /*--- Type init code ---*/ + __pyx_vtabptr_26dopt_pollublock_blockchain_10blockchain_PyBlock = &__pyx_vtable_26dopt_pollublock_blockchain_10blockchain_PyBlock; + __pyx_vtable_26dopt_pollublock_blockchain_10blockchain_PyBlock.from_ptr = (struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_PyBlock *(*)(::Block *, struct __pyx_opt_args_26dopt_pollublock_blockchain_10blockchain_7PyBlock_from_ptr *__pyx_optional_args))__pyx_f_26dopt_pollublock_blockchain_10blockchain_7PyBlock_from_ptr; + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_PyBlock = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_26dopt_pollublock_blockchain_10blockchain_PyBlock_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_PyBlock)) __PYX_ERR(0, 86, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_26dopt_pollublock_blockchain_10blockchain_PyBlock_spec, __pyx_mstate->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_PyBlock) < (0)) __PYX_ERR(0, 86, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_PyBlock = &__pyx_type_26dopt_pollublock_blockchain_10blockchain_PyBlock; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_PyBlock) < (0)) __PYX_ERR(0, 86, __pyx_L1_error) + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_PyBlock); + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_PyBlock->tp_dictoffset && __pyx_mstate->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_PyBlock->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_PyBlock->tp_getattro = PyObject_GenericGetAttr; + } + #endif + if (__Pyx_SetVtable(__pyx_mstate->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_PyBlock, __pyx_vtabptr_26dopt_pollublock_blockchain_10blockchain_PyBlock) < (0)) __PYX_ERR(0, 86, __pyx_L1_error) + if (__Pyx_MergeVtables(__pyx_mstate->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_PyBlock) < (0)) __PYX_ERR(0, 86, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_PyBlock, (PyObject *) __pyx_mstate->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_PyBlock) < (0)) __PYX_ERR(0, 86, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_PyBlock) < (0)) __PYX_ERR(0, 86, __pyx_L1_error) + __pyx_vtabptr_26dopt_pollublock_blockchain_10blockchain_Blockchain = &__pyx_vtable_26dopt_pollublock_blockchain_10blockchain_Blockchain; + __pyx_vtable_26dopt_pollublock_blockchain_10blockchain_Blockchain.get_block_c = (::Block *(*)(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *, uint64_t))__pyx_f_26dopt_pollublock_blockchain_10blockchain_10Blockchain_get_block_c; + __pyx_vtable_26dopt_pollublock_blockchain_10blockchain_Blockchain.add_block_from_loading = (void (*)(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *, ::Block *))__pyx_f_26dopt_pollublock_blockchain_10blockchain_10Blockchain_add_block_from_loading; + __pyx_vtable_26dopt_pollublock_blockchain_10blockchain_Blockchain.add_block = (int (*)(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *, ::Block *))__pyx_f_26dopt_pollublock_blockchain_10blockchain_10Blockchain_add_block; + __pyx_vtable_26dopt_pollublock_blockchain_10blockchain_Blockchain.hash_data = (std::string (*)(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *, PyObject *))__pyx_f_26dopt_pollublock_blockchain_10blockchain_10Blockchain_hash_data; + __pyx_vtable_26dopt_pollublock_blockchain_10blockchain_Blockchain.load_from_batch = (PyObject *(*)(struct __pyx_obj_26dopt_pollublock_blockchain_10blockchain_Blockchain *, PyObject *))__pyx_f_26dopt_pollublock_blockchain_10blockchain_10Blockchain_load_from_batch; + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_Blockchain = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_26dopt_pollublock_blockchain_10blockchain_Blockchain_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_Blockchain)) __PYX_ERR(0, 323, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_26dopt_pollublock_blockchain_10blockchain_Blockchain_spec, __pyx_mstate->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_Blockchain) < (0)) __PYX_ERR(0, 323, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_Blockchain = &__pyx_type_26dopt_pollublock_blockchain_10blockchain_Blockchain; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_Blockchain) < (0)) __PYX_ERR(0, 323, __pyx_L1_error) + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_Blockchain); + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_Blockchain->tp_dictoffset && __pyx_mstate->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_Blockchain->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_Blockchain->tp_getattro = PyObject_GenericGetAttr; + } + #endif + if (__Pyx_SetVtable(__pyx_mstate->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_Blockchain, __pyx_vtabptr_26dopt_pollublock_blockchain_10blockchain_Blockchain) < (0)) __PYX_ERR(0, 323, __pyx_L1_error) + if (__Pyx_MergeVtables(__pyx_mstate->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_Blockchain) < (0)) __PYX_ERR(0, 323, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_Blockchain, (PyObject *) __pyx_mstate->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_Blockchain) < (0)) __PYX_ERR(0, 323, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_Blockchain) < (0)) __PYX_ERR(0, 323, __pyx_L1_error) + __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_blockchain(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_blockchain}, + #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, + "blockchain", + 0, /* m_doc */ + #if CYTHON_USE_MODULE_STATE + sizeof(__pyx_mstatetype), /* m_size */ + #else + (CYTHON_PEP489_MULTI_PHASE_INIT) ? 0 : -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + #if CYTHON_USE_MODULE_STATE + __pyx_m_traverse, /* m_traverse */ + __pyx_m_clear, /* m_clear */ + NULL /* m_free */ + #else + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ + #endif + }; + #ifdef __cplusplus +} /* anonymous namespace */ +#endif + +/* PyModInitFuncType */ +#ifndef CYTHON_NO_PYINIT_EXPORT + #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#else + #ifdef __cplusplus + #define __Pyx_PyMODINIT_FUNC extern "C" PyObject * + #else + #define __Pyx_PyMODINIT_FUNC PyObject * + #endif +#endif + +__Pyx_PyMODINIT_FUNC PyInit_blockchain(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit_blockchain(void) +#if CYTHON_PEP489_MULTI_PHASE_INIT +{ + return PyModuleDef_Init(&__pyx_moduledef); +} +/* ModuleCreationPEP489 */ +#if CYTHON_COMPILING_IN_LIMITED_API && (__PYX_LIMITED_VERSION_HEX < 0x03090000\ + || ((defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS)) && __PYX_LIMITED_VERSION_HEX < 0x030A0000)) +static PY_INT64_T __Pyx_GetCurrentInterpreterId(void) { + { + PyObject *module = PyImport_ImportModule("_interpreters"); // 3.13+ I think + if (!module) { + PyErr_Clear(); // just try the 3.8-3.12 version + module = PyImport_ImportModule("_xxsubinterpreters"); + if (!module) goto bad; + } + PyObject *current = PyObject_CallMethod(module, "get_current", NULL); + Py_DECREF(module); + if (!current) goto bad; + if (PyTuple_Check(current)) { + PyObject *new_current = PySequence_GetItem(current, 0); + Py_DECREF(current); + current = new_current; + if (!new_current) goto bad; + } + long long as_c_int = PyLong_AsLongLong(current); + Py_DECREF(current); + return as_c_int; + } + bad: + PySys_WriteStderr("__Pyx_GetCurrentInterpreterId failed. Try setting the C define CYTHON_PEP489_MULTI_PHASE_INIT=0\n"); + return -1; +} +#endif +#if !CYTHON_USE_MODULE_STATE +static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { + static PY_INT64_T main_interpreter_id = -1; +#if CYTHON_COMPILING_IN_GRAAL && 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 < 0x03090000\ + || ((defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS)) && __PYX_LIMITED_VERSION_HEX < 0x030A0000)) + 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_blockchain(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_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 'blockchain' 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 "blockchain" 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) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); + } + #endif + +__Pyx_RefNannySetupContext("PyInit_blockchain", 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_dopt_pollublock_blockchain__blockchain) { + 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, "dopt_pollublock_blockchain.blockchain")) { + if (unlikely((PyDict_SetItemString(modules, "dopt_pollublock_blockchain.blockchain", __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); + if (unlikely((__Pyx_modinit_type_init_code(__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); + /*--- Execution code ---*/ + + /* "dopt_pollublock_blockchain/blockchain.pyx":7 + * from __future__ import annotations + * + * import datetime # <<<<<<<<<<<<<< + * from pathlib import Path + * +*/ + __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_datetime, 0, 0, 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); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_datetime, __pyx_t_2) < (0)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":8 + * + * import datetime + * from pathlib import Path # <<<<<<<<<<<<<< + * + * import dopt_basics.datetime +*/ + { + PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_Path}; + __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_pathlib, __pyx_imported_names, 1, 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_Path}; + __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, 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; + + /* "dopt_pollublock_blockchain/blockchain.pyx":10 + * from pathlib import Path + * + * import dopt_basics.datetime # <<<<<<<<<<<<<< + * import sqlalchemy as sql + * from dopt_pollublock_blockchain import db +*/ + __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_dopt_basics_datetime, 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_dopt_basics, __pyx_t_2) < (0)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":11 + * + * import dopt_basics.datetime + * import sqlalchemy as sql # <<<<<<<<<<<<<< + * from dopt_pollublock_blockchain import db + * +*/ + __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_sqlalchemy, 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_sql, __pyx_t_2) < (0)) __PYX_ERR(0, 11, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":12 + * import dopt_basics.datetime + * import sqlalchemy as sql + * from dopt_pollublock_blockchain import db # <<<<<<<<<<<<<< + * + * +*/ + { + PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_db}; + __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_dopt_pollublock_blockchain, __pyx_imported_names, 1, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __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_db}; + __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, 12, __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, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":145 + * return self.__repr__() + * + * def serialize_dict(self): # <<<<<<<<<<<<<< + * contents = {} + * +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_26dopt_pollublock_blockchain_10blockchain_7PyBlock_11serialize_dict, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PyBlock_serialize_dict, NULL, __pyx_mstate_global->__pyx_n_u_dopt_pollublock_blockchain_block, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 145, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_PyBlock, __pyx_mstate_global->__pyx_n_u_serialize_dict, __pyx_t_2) < (0)) __PYX_ERR(0, 145, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":182 + * return self.BlockC.hash.decode("UTF-8") + * + * def bytes_serialize(self): # <<<<<<<<<<<<<< + * cdef: + * unsigned char *serialize_res +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_26dopt_pollublock_blockchain_10blockchain_7PyBlock_13bytes_serialize, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PyBlock_bytes_serialize, NULL, __pyx_mstate_global->__pyx_n_u_dopt_pollublock_blockchain_block, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[1])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 182, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_PyBlock, __pyx_mstate_global->__pyx_n_u_bytes_serialize, __pyx_t_2) < (0)) __PYX_ERR(0, 182, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":193 + * + * + * def perform_hash(self): # <<<<<<<<<<<<<< + * cdef: + * unsigned char *digest +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_26dopt_pollublock_blockchain_10blockchain_7PyBlock_15perform_hash, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PyBlock_perform_hash, NULL, __pyx_mstate_global->__pyx_n_u_dopt_pollublock_blockchain_block, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[2])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_PyBlock, __pyx_mstate_global->__pyx_n_u_perform_hash, __pyx_t_2) < (0)) __PYX_ERR(0, 193, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_26dopt_pollublock_blockchain_10blockchain_7PyBlock_17__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PyBlock___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_dopt_pollublock_blockchain_block, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[3])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_2) < (0)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_26dopt_pollublock_blockchain_10blockchain_7PyBlock_19__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PyBlock___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_dopt_pollublock_blockchain_block, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[4])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_2) < (0)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":457 + * return self._index + * + * def _print_key_value_pair(self): # <<<<<<<<<<<<<< + * cdef BcHashmap.iterator it = self._chain_map.begin() + * cdef Block *block +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_26dopt_pollublock_blockchain_10blockchain_10Blockchain_9_print_key_value_pair, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Blockchain__print_key_value_pair, NULL, __pyx_mstate_global->__pyx_n_u_dopt_pollublock_blockchain_block, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[5])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 457, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_Blockchain, __pyx_mstate_global->__pyx_n_u_print_key_value_pair, __pyx_t_2) < (0)) __PYX_ERR(0, 457, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":467 + * postincrement(it) + * + * def print_blocks(self, max_num): # <<<<<<<<<<<<<< + * cdef: + * Block *block +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_26dopt_pollublock_blockchain_10blockchain_10Blockchain_11print_blocks, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Blockchain_print_blocks, NULL, __pyx_mstate_global->__pyx_n_u_dopt_pollublock_blockchain_block, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[6])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 467, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_Blockchain, __pyx_mstate_global->__pyx_n_u_print_blocks, __pyx_t_2) < (0)) __PYX_ERR(0, 467, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":484 + * break + * + * def get_block(self, idx): # <<<<<<<<<<<<<< + * if idx < 0 or idx > self._index: + * raise IndexError("Index value is out of bounds") +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_26dopt_pollublock_blockchain_10blockchain_10Blockchain_13get_block, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Blockchain_get_block, NULL, __pyx_mstate_global->__pyx_n_u_dopt_pollublock_blockchain_block, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[7])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 484, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_Blockchain, __pyx_mstate_global->__pyx_n_u_get_block, __pyx_t_2) < (0)) __PYX_ERR(0, 484, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":493 + * return PyBlock.from_ptr(block, owner=False) + * + * def create_genesis_block(self): # <<<<<<<<<<<<<< + * if self._genesis_done: + * raise RuntimeError( +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_26dopt_pollublock_blockchain_10blockchain_10Blockchain_15create_genesis_block, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Blockchain_create_genesis_block, NULL, __pyx_mstate_global->__pyx_n_u_dopt_pollublock_blockchain_block, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[8])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 493, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_Blockchain, __pyx_mstate_global->__pyx_n_u_create_genesis_block, __pyx_t_2) < (0)) __PYX_ERR(0, 493, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":516 + * self._genesis_done = True + * + * def new_block(self, data): # <<<<<<<<<<<<<< + * cdef: + * Block *prev_block +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_26dopt_pollublock_blockchain_10blockchain_10Blockchain_17new_block, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Blockchain_new_block, NULL, __pyx_mstate_global->__pyx_n_u_dopt_pollublock_blockchain_block, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[9])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 516, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_Blockchain, __pyx_mstate_global->__pyx_n_u_new_block, __pyx_t_2) < (0)) __PYX_ERR(0, 516, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":547 + * raise RuntimeError("Could not mine block. No nonce found") + * + * def validate(self): # <<<<<<<<<<<<<< + * cdef: + * Block *block +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_26dopt_pollublock_blockchain_10blockchain_10Blockchain_19validate, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Blockchain_validate, NULL, __pyx_mstate_global->__pyx_n_u_dopt_pollublock_blockchain_block, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[10])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 547, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_Blockchain, __pyx_mstate_global->__pyx_n_u_validate, __pyx_t_2) < (0)) __PYX_ERR(0, 547, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":575 + * return True + * + * def get_saving_entries(self, max_idx): # <<<<<<<<<<<<<< + * entries = [] + * cdef: +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_26dopt_pollublock_blockchain_10blockchain_10Blockchain_21get_saving_entries, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Blockchain_get_saving_entries, NULL, __pyx_mstate_global->__pyx_n_u_dopt_pollublock_blockchain_block, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[11])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 575, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_Blockchain, __pyx_mstate_global->__pyx_n_u_get_saving_entries, __pyx_t_2) < (0)) __PYX_ERR(0, 575, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":602 + * return entries + * + * def save(self): # <<<<<<<<<<<<<< + * # get max index from db + * # only retrieve indices greater than max value +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_26dopt_pollublock_blockchain_10blockchain_10Blockchain_23save, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Blockchain_save, NULL, __pyx_mstate_global->__pyx_n_u_dopt_pollublock_blockchain_block, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[12])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 602, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_Blockchain, __pyx_mstate_global->__pyx_n_u_save, __pyx_t_2) < (0)) __PYX_ERR(0, 602, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":617 + * con.execute(sql.insert(db.blocks), entries) + * + * def close_db_connections(self): # <<<<<<<<<<<<<< + * self._engine.dispose() + * +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_26dopt_pollublock_blockchain_10blockchain_10Blockchain_25close_db_connections, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Blockchain_close_db_connections, NULL, __pyx_mstate_global->__pyx_n_u_dopt_pollublock_blockchain_block, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[13])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 617, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_Blockchain, __pyx_mstate_global->__pyx_n_u_close_db_connections, __pyx_t_2) < (0)) __PYX_ERR(0, 617, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":620 + * self._engine.dispose() + * + * def load(self, batch_size): # <<<<<<<<<<<<<< + * if self._loaded: + * raise RuntimeError("Blockchain was already loaded") +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_26dopt_pollublock_blockchain_10blockchain_10Blockchain_27load, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Blockchain_load, NULL, __pyx_mstate_global->__pyx_n_u_dopt_pollublock_blockchain_block, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[14])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 620, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_26dopt_pollublock_blockchain_10blockchain_Blockchain, __pyx_mstate_global->__pyx_n_u_load, __pyx_t_2) < (0)) __PYX_ERR(0, 620, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_26dopt_pollublock_blockchain_10blockchain_10Blockchain_29__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Blockchain___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_dopt_pollublock_blockchain_block, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[15])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_2) < (0)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_26dopt_pollublock_blockchain_10blockchain_10Blockchain_31__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Blockchain___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_dopt_pollublock_blockchain_block, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[16])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_2) < (0)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "dopt_pollublock_blockchain/blockchain.pyx":1 + * # distutils: language = c++ # <<<<<<<<<<<<<< + * + * """placeholder module for compilation""" +*/ + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_test, __pyx_t_2) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + if (__pyx_m) { + if (__pyx_mstate->__pyx_d && stringtab_initialized) { + __Pyx_AddTraceback("init dopt_pollublock_blockchain.blockchain", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + #if !CYTHON_USE_MODULE_STATE + Py_CLEAR(__pyx_m); + #else + Py_DECREF(__pyx_m); + if (pystate_addmodule_run) { + PyObject *tp, *value, *tb; + PyErr_Fetch(&tp, &value, &tb); + PyState_RemoveModule(&__pyx_moduledef); + PyErr_Restore(tp, value, tb); + } + #endif + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init dopt_pollublock_blockchain.blockchain"); + } + __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) { + CYTHON_UNUSED_VAR(__pyx_mstate); + __pyx_builtin_print = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_print); if (!__pyx_builtin_print) __PYX_ERR(0, 461, __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 + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "dopt_pollublock_blockchain/blockchain.pyx":606 + * # only retrieve indices greater than max value + * stmt = sql.select(sql.func.max(db.blocks.c.index)) + * with self._engine.connect() as conn: # <<<<<<<<<<<<<< + * result = conn.execute(stmt) + * max_value = result.scalar() +*/ + __pyx_mstate_global->__pyx_tuple[0] = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_mstate_global->__pyx_tuple[0])) __PYX_ERR(0, 606, __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 CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + Py_SET_REFCNT(table[i], _Py_IMMORTAL_REFCNT_LOCAL); + #else + 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) { + CYTHON_UNUSED_VAR(__pyx_mstate); + { + const struct { const unsigned int length: 8; } index[] = {{72},{29},{25},{25},{36},{29},{9},{21},{33},{32},{19},{13},{9},{97},{29},{6},{28},{37},{13},{24},{18},{65},{5},{2},{1},{1},{7},{6},{2},{9},{50},{10},{10},{45},{14},{13},{10},{28},{30},{32},{31},{31},{20},{29},{15},{20},{23},{15},{19},{4},{7},{25},{27},{23},{20},{22},{20},{12},{3},{18},{5},{10},{5},{5},{6},{15},{1},{18},{20},{3},{4},{7},{8},{10},{13},{20},{15},{16},{4},{11},{8},{8},{2},{7},{6},{11},{7},{11},{20},{26},{37},{6},{9},{7},{7},{6},{8},{8},{7},{13},{4},{8},{17},{9},{18},{12},{4},{3},{3},{5},{6},{13},{2},{5},{4},{8},{3},{7},{8},{7},{11},{9},{19},{10},{8},{9},{7},{5},{3},{8},{6},{10},{7},{12},{3},{10},{9},{13},{5},{12},{21},{8},{8},{17},{11},{14},{12},{10},{17},{13},{8},{3},{7},{6},{4},{6},{6},{4},{14},{13},{14},{12},{10},{12},{19},{3},{10},{4},{8},{9},{8},{6},{0},{64},{75},{85},{115},{95},{70},{148},{11},{39},{71},{101},{187},{180},{112},{9}}; + #if (CYTHON_COMPRESS_STRINGS) == 2 /* compression: bz2 (1984 bytes) */ +const char* const cstring = "BZh91AY&SY\252\301U\317\000\001p\377\377\377\377\377\377\377\377\377\367\277\377\377\373\277\357\377\370@@@@@@@@@@@@@\000@\000`\007\177\030\365\"f\204\323T\251\031\014k\201\340h\221\002z\200\000\r\r\2500\233S\332\221\241\240\032\006A\240\000\000\000441\r\003M4\031&@&SD\301O%=G\246\200i4\310\000\000\000\000\000\000\000\r\006\2324\001\240\212\247\370\247\211(\000\000\000\000\000\014\206\200\000\000\000\000\000\000\000\000\006\231$\324\r\004\217j\236\230\232mS4M\000\032\000h\000\000\000\000\000\000\014 h\r\020i\211\211\211\200\230\t\200\000\000\000L\000\0010\000\t\200\000\000\000\232\004\211\021\252l\200j\023\365S\332\032\231O\321M\000\001\352=@\000\r\000\000\320\000\000\014\206\215\003\324\365,\301\237\0046\303\240\227L\017\335\177\035O\344\237RJjO\374\256\002\270#\221\205|\242\235t\205Q\311R\240\034\251\261\2641\2646\332hg\220\031\222\276\036p\210\206\360\323\275\374x\274\013\274\317'n\322\364\027\031@36\333\000\033K\225\242\242\2443\243\303n\027\277|\001\004\010\002\002\360b\365,\n\026n>\246<\005\306\246gF\306@\350\263\321\021\036\272k4\010@h\362\025\202A\0360q\001\222F\366\213=\002\243\237Qh<<#T\270P\304\321yH\301\020>\234\271\231@b\203\006\227Hl\035Cx\350\257\323\350h\346\320(Qt\001\004\276rZ\031\377h\276F;\250\254\340\207\356\202\024H\374\206\201\234Y\204DE2\"\257\3579\305\204(,\202\265\027iF\021\302+\032u\272\270\203_w8\030\240\340\272\310\255'sA\023\201\340\364\206-\032\0206\347\327Cy*m\"\033\307\247\341Y\247p\222\271\327T`I\004\316q\010\016X\234\0355\370\\\230\345\262\2575\306\265p\3008\201\005P*\253\210vp\003\230+\212\242\372j\037\247?\033\203\213\37577\205\260\300ZX\263\341\210\213\020\206$[\026\356\tVVR\367\203\016Y=\031\352\346\216f\255\2417\234\354w/\370\303L\234\361o\347Fp7\000\320>\356\216\2056\311\267n\351x\200\272\005\255g\251\360\203\304\034\237f\217\277\\\272\231(&\267\021\013\341\n\225n&X@8\t3\022v\371.\323\3077u\210\021F\006\234\270+\305\212\t\212\244\037WC6b\034\n\027O\252\322\007\261\331\2400\241@1K\207:\216\027u\355\271\221\326\034Y\346aA:N\244L*m\177J\201\302\316\216\3078 -\206\000`2\357oy\3310\252W\303q\010+\222X!I\022un\366\341h_P\234\271\221(\022I\244 \023\221Y\006\020\326\010\202\210\300\n>\2345\rVQ\205h\324Y\202\261\347\310*\335\370H]\365]O\351\365\304n\314\242!\226e\235XA-\227\222,\014\023`\226M\202g$\325\300\340\314xnL\223,d\242c\223S\t2\245\2102Ui-\031\352\342\3374fU,\203\224%`\202n\331\257KS\023I\006.\241\337\305.\367\306!8\007\00573\240\330P\271\301!\2240`h\211\314\342er\210\277\034\022I\255\343k`Z\364\250\353\366\213\312\212\013\353A3\021\023\301\2000v(H\021\335VkU\361d\245Bc'\0014W\227\210U-s$\026G\312\316\250\206\227_\016\202g\310\325@\021\0236\221bA\027\010N=VSHsm\334\205\027\326kkB\r)\356\343\3270\237\265\243i\241\246\301\241\262Q\002\"\022&\"'b T\032.P\354\225\250L\352\232\240\261Y\034\240\345\244,(C\255U\257](\023\250\222\233\000hcr0\363\360O\001Z\356)\027\314\343\255\214\211\303d\323U\013c[~jl\2544c;\253\241)\225:\310\006\342\003\220\005\220u2\216:C)$\035Y\354(x\347V\243]\240\241\220\202\001B\221\221\rZu\242\003hk\014'R{3!\033\330a 0\333\2306\313\271e\256\222c\231\3724e~\272F\225xV\221\013K\326sxS\267\207\223\277\276\340\347\001\311\034\347\027\006g\007\016\301Wg#\221f\301\003\r)\214\325\261\224\227\206&+\014\241N\315\222\0106\257\022\362\300U\313\256\301\n\3041`\230\032\301\357\265W\022F[\002U \242\353Q4\220\021AD#H\316n\357\335`d\217R\355\335\350e\017\202V\217\245Z\340g~""\024\3033n5P\214\366\251%\001S\274\264m1U\327\306\227=\206\2001\212\221q\004.\034\013\247\247\007\337\210m\240n\001\210q\027\223\\r\035\251\221%\235\267E\205D\320QX\240{X\236\026s\020\020\212\271QMP\003(\252(L\300fR3\004B\3670-!\242\3531Q!|*X`)\t,\204\034\210\323\305\0012\177\252\246q@a8\247\300\240G\313\361\003\362h\314\3545\004X$\320\307\355\022J!\3772\022\022\300L\222\212\365\350\234\214\211O\214lDy\021\356\240\345y\255\273pW\035\333\356\256{\327\267\266u(\306=\313\222\361\260\025\260k\267cm[\255\357=y\365\365M\356\334<\314U\373\3453\235q\325\254\264\032\245p\332\025\030Zd\311\0064@\320T\024\314\202\200\000P\201^T\227V4p<\002O\022\260\240\013(\230\013\000\230\t\356\21309\300D\204\014\372\252\203\201\\dbo\351\274\257\022\010\243\354\004\342bQ}\310\312 \"T\244\037\342\356H\247\n\022\025X*\271\340"; + PyObject *data = __Pyx_DecompressString(cstring, 1984, 2); + 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 /* compression: zlib (1867 bytes) */ +const char* const cstring = "x\332\245UIs\033\307\025\026\274H\000\004Z\004)\222r\304X\203X\212\255$\002M[\211\025V\226\202DjIbE\224)'Q*\351\032\3144\200)\017f\200\231\036\022P.:\342\330\307>\366q\2168\362\250\243\216<\342\310\237\240\237\340\3575\006\213E\250*\225\260\206\275\275\356\367\336\367\275\005w\375\320\371\336i\331^`\331~\304m\267o\265\354\330\262\255&\017x\354\305V\235.T\255=O\264xdy\302:\202\330\301M\301]+\214,?\264]\356V\357\316\364\320\205\211\256\261\364^\230\370\256\025\204\002\347\270\207\247d\244mw\026\010\016\271#\302h&h{\001\2378\3618\304Q\340p\253\021&\201{\3178\361\266\253V\303\213bQ-\026vma\357\024\314d\265\223XXu\272\033\213\310\013\232\273^\243\3419\211/\372SQ\323h\213,\321\262\003\353\213\005\027\274@\360&.\034\332~\302\357\333\236\017\374\"$ -\313\205\221\007\231\027\206\211b\341!\316a~\307\242\005P\000\256pZ\325\3616lX\235\210\037za2\361\332\ry<\306K\327\340\005\267b\373\220(\016\310\2649p\222(\342\201\230\260Q\253\207\221\250\216\r\340\261\010g\357'\302G\201\313{\326x4~[p0L\0049P'\016\343o\354\236\327N\332V\220\264\353\000\267\230\215b\341\t\274\265\306\220\236D\341\241\207\240\302+RK6M8\236\364\r\362\317\213\005c\017\330\017\340s\3076.\273^d\342\332'\313\204\2453\321B\324\325\355\230n\212\326\214\006\336\363b\361\354\340\376\255;\305\233\325?\272^l\327}\316\003\032\233\216\027\217Wn\020Z.o\330\210\223\305X\304\335\304\341\214Y.p\0326\202[\210\366\241g\373\220:^\340\t\306\212\005\223A\360.\356\372\236\340;[[[q\344l\271aG\260N\350\373\211a\227\325\247\371\2745[V;\375\336\357\306\031\024\207I\344\360?\024\013\302k\363X\330\355\316NaV\003\263Uu\352\227\323\027\2550`\354G\262\230\013<\026\213\245\035\030\022\354{\336g&v\254c{\321\234\334\361\303\2303\267\316\2340\010\300\256\027\006\361\274\330\204\220e\3051\0064'nr\261\360\014Y\007x\014A\213<>\257\217Jyn\033\360\2433\357\307\016\233\323\371\227\224\310s[\200\361\020u\376\004\001\317\222&\233\316\2225\023\234aj\"\252\367\005\217!\216\020g\357\005\237\034wx\324\010\2436\243\372\234\234M/1\327s\004\251\350\341\177\227""\326\217yO<\345\215\203G\337\354=\377\353\343=\366\354\340\236\035;v\334\017\034/\254:a\204\252A'\212\353T^f`1\024\325y\323\013\014\3401\352\267\234q\034\037\217\230\0270\021\331\016\257\333\340`A\324\260\244]v\202I\200\3768\013 :c\266\342\001\214\361Eq\315:\003\243dd\342\205\223\010\326\366\234\010\226\240\314\215\251\306\350\037\260\233HV\263D\032S\020\350\205[\207;T~\231\330\214\006\036\352\256\003%\2468P\244\236\023\317-\253\323\367\357\254\235wK\252\263%\007p\027u\013\000j\004c\343\307\325<\333\341\305lCYl\232GF-V\331/\306\\Ka\013\332\013~\036\360\331\276\323\342\355~,\332\270/\250,\3304\341&}\314p\025\177\361\177\376\275\254\275)\236+\024G\2455\371o\275\255w\323\302\260<\254\214J\227\006G\322Q\345\321r\371\264\264,/\310\236JtM\177\227~\231\376\353\370\372q\375\325\205W\335\3279\022\345d\3714\177i \344\366\313\332(\277*\267O\363txU\355\352\013\272;2\233k\372\003\375 \335\036\235\221\234\224\257\303dn,\370\211\272\255\272sKR\333%\245\027\007\267\007\335QiE\376J\331\243\362\312\233\374\271\302'\352\037\272\231\356\247\366(\177M\t\275C\313\323\374\246z\244\367G\344\324\250t\203VK\223\357\243AS\356K\\\331\220B\355\350}m\217\325\306\262\222)&\323\245\223\322O\325\376\333&\341\311RY^QW\364\2726g\237\312\277\253}\345\350\2154\227\256\244w\206\277=\256\035?=>zU\177}\376\265{\362\364\333\323|i\360H~\253.\202\320\032\3349Y\266tN\227\351\370\317r\212(\222+\362+\351\252\237\201\217\034""\251\375\205\252\251}\002\261\253Ki-\335\247k\277\221\253\2626\025\216\362\353\322S]\275\224\302\3117+\347\n%\350\001\363s\020H\363\013UV?\037\353\274\251\266U\355\024a\271-_\350\262\256\214\362k\362@m\202\0007\305\346\262\374\023(\315\257\310\353\262\245\352:7\245p\351\177!\220\220\225\006\017\345CU\203{y\223V\233'\233\267\020\034wx\363x\373\030HV\345\357\365{\272\222e\016\275\270\241\017\322\253\303\373\307\225\323\374G\003\007xwA\334mb\272,\313P\354\350\362\250tY\376E\277\257\001\364\023\345\351.2\306\010a\372c`\255\300\332\371sK\327\000\245tU!\001/\016\356\200Z{\216\324\322\340\201\374\265\312\251\313\352oH\343\247:Ik\244tW]\000\235\360g\221\352U\"\2262\233T-\033_Wd\205,mH\033\023\330\317\314\\Q(\205\r\331}\207\235\231\21636\361\210\316j\362\237\372C\342\233\226L\357\245\345\267OO\326>O?L\237\017\217\216\355\343\354\311s\224\344^\2721\314\r\313\013\016V\345\327\252Bd\230\"\"\257+\224\022\353p\035\221Y\372/\370\330\220\211z\010\351\263\364Fz4\264\207\335I\223@)\323u\213\234\323\215\364.\252p\034N\202\332W\357\253\355\321\362\032\262\245eRr\331`\2744\370\217\372\014\221\\^\225;\352;\375\225\346\350\007\227\021\275\321\307\025JL8\270\266\211\207\024\320\231\317\205e$\330g\010\361\247\352\231\276\256m\035\001\336{\350O\363\005I\031}\305$7\002q^55\342\215\214>Y\277\231\226)\311\263Z^\032W\361\272:$J/\rz\262\013W\277\006\326/\365\363\264\37327\372\2408\370\245\334\377\001f\260\232\305"; + PyObject *data = __Pyx_DecompressString(cstring, 1867, 1); + 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 (3739 bytes) */ +const char* const bytes = "Blockchain already has a genesis block. Either it was created or loaded.Blockchain was already loadedCould not allocate hasmapCould not allocate vectorCould not mine block. No nonce foundCreate a genesis block first.\n\tData:\t\tData must be a stringDifficulty must be greater than 0Difficulty must be integer valueFailed to hash dataGenesis Block\n\tHash:\t\t: Hash mismatch. Hash of previous block does not match the saved one in the current block. Abort.: Hashes to not match. Abort.Index Index value is out of boundsMaximum number must be greater than 0\n\tPrev Hash:\tProvided index not foundPyBlock(\n\tIndex:\t\tThe parent directory of the provided database path does not existUTF-8\n).?disableenablegcisenabledno default __reduce__ due to non-trivial __cinit__\n\tnonce:\t\tsqlite:///src/dopt_pollublock_blockchain/blockchain.pyx\n\ttimestamp:\tBlockchainBlockchain.__reduce_cython__Blockchain.__setstate_cython__Blockchain._print_key_value_pairBlockchain.close_db_connectionsBlockchain.create_genesis_blockBlockchain.get_blockBlockchain.get_saving_entriesBlockchain.loadBlockchain.new_blockBlockchain.print_blocksBlockchain.saveBlockchain.validatePathPyBlockPyBlock.__reduce_cython__PyBlock.__setstate_cython__PyBlock.bytes_serializePyBlock.perform_hashPyBlock.serialize_dict__Pyx_PyDict_NextRefTIMEZONE_UTCascasyncio.coroutinesbatchbatch_sizebeginblockblocksbytes_serializeccline_in_tracebackclose_db_connectionsconconnconnectcontentscreate_allcreate_enginecreate_genesis_blockcurrent_time_tzcut_microsecondsdatadata_digestdata_strdatetimedbdb_pathdigestdigest_sizedisposedopt_basicsdopt_basics.datetimedopt_pollublock_blockchaindopt_pollublock_blockchain.blockchainencode__enter__entriesexecuteexists__exit__from_ptrfromhexfromtimestampfunc__func__genesis_prev_hashget_blockget_saving_entries__getstate__hashhexidxindexinsert_is_coroutineititemsload__main__maxmax_idx_max_idxmax_nummax_nummbermax_valuemetadata_blockchain__module____name__new_blocknew_idxnoncenumorder_bypare""ntpartitionspathlibperform_hashpopprev_blockprev_hashprevious_hashprintprint_blocks_print_key_value_pairpy_blockpy_bytespy_bytes_rehashed__pyx_state__pyx_vtable____qualname____reduce____reduce_cython____reduce_ex____repr__resresolveresultsavescalarselectselfserialize_dictserialize_resserialize_size__set_name__setdefault__setstate____setstate_cython__sqlsqlalchemystmt__test__timestampvalidatevalues0000000000000000000000000000000000000000000000000000000000000000\200A\360\n\000\t\n\330\014\025\220^\2401\240D\250\t\260\021\260!\330\014\017\210w\220c\230\021\330\020\021\340\014\020\220\007\220x\230u\240A\240V\2502\250]\270$\270b\300\007\300q\310\001\340\014\020\220\001\220\021\340\010\017\210t\2201\200A\330\010\023\2201\340\010\020\220\001\220\033\230D\240\007\240q\330\010\020\220\001\220\037\240\004\240G\2501\330\010\020\220\001\220\033\230D\240\007\240q\330\010\020\220\001\320\021$\240D\250\001\330\010\020\220\001\220\032\2304\230q\330\010\020\220\001\220\032\2304\230q\340\010\017\210q\200A\330\010\013\2104\210q\330\014\022\220,\230a\330\021\022\360\010\000\t\036\230Y\240g\250Q\250a\330\010\037\230t\240:\250Q\250a\340\010\034\230I\240Q\330\014\020\220\001\330\014%\240Q\330\014\r\330\014\r\330\014\r\330\014\016\210g\220Q\220a\340\010\027\220t\230:\240Q\240a\330\010\013\2104\210s\220!\330\014\022\220,\230a\230q\330\010\014\320\014\035\230Q\200A\330\010\013\2104\210q\330\014\022\220,\230a\230q\340\r\021\220\030\230\030\240\026\240q\330\014\022\220#\220X\230Q\230c\240\027\250\001\250\022\2508\2609\270A\270R\270w\300b\310\006\310d\320RS\340\010\014\210I\220S\230\013\2401\240A\330\014\020\320\020 \240\001\240\021\340\010\014\210K\220q\200A\330\010\013\2104\210r\220\022\2203\220d\230\"\230D\240\001\330\014\022\220*\230A\230Q\340\010\034\230D\240\014\250A\250Q\330\010\013\2106\220\023\220A\330\014\022\220*\230A\230Q\330\010\026\220i\230q\240\r\250Q\200A\360\022\000\t\014\2104\210t\2201\330\014\022\220,\230a\230q\330\010\013\2104\210z\230\021\230&\240\001\330\014\022\220)\2301""\230A\340\010\023\2204\220z\240\021\240!\330\010\025\220T\230\034\240Q\240d\250!\330\010\024\220J\230a\330\010\022\220$\220h\230b\240\001\340\010\034\230I\240Q\330\014\r\330\014%\240Q\330\014\r\330\014\r\330\014\r\330\014\016\210g\220Q\220a\340\010\027\220t\230:\240Q\240a\330\010\013\2104\210s\220!\330\014\022\220,\230a\230q\200A\330\010\014\210H\220H\230A\200A\360\010\000\t\n\330\014\034\320\034-\250Q\250d\260)\2701\270A\330\014\023\220=\240\002\240!\340\014\020\220\001\220\021\200A\330\010%\240T\250\033\260F\270!\340\010\016\210c\220\023\220D\230\013\2404\240q\330\014\021\220\021\220,\230c\240\021\330\014\024\220L\240\003\2401\330\014\036\230i\240q\250\001\330\014\021\220\021\220!\330\014\031\230\021\230!\200A\360\006\000\r\037\230a\330\014\033\2301\340\010\013\2108\2203\220a\330\014\022\220*\230A\230Q\340\010\014\210G\2205\230\001\230\024\230W\240A\240R\240u\250A\330\014\024\220D\230\007\230q\240\002\240!\2401\330\014\036\230i\240q\250\001\330\014\021\220\021\220!\330\014\023\2201\330\014\017\210t\2203\220a\330\020\021\200A\330\010\022\220!\360\006\000\r\027\220a\360\006\000\t\014\2108\2203\220a\330\014\030\230\001\340\014\027\220q\340\010\014\210G\2205\230\001\230\024\230W\240A\240R\240u\250A\330\014\017\210t\2203\220a\330\020\021\330\014\024\220D\230\007\230q\240\002\240!\2401\330\014\027\220q\330\014\024\220A\220[\240\005\240Q\330\014\024\220A\220_\240E\250\021\330\014\024\220A\220[\240\005\240Q\330\014\024\220A\320\025(\250\005\250Z\260w\270a\270q\330\014\024\220A\220Z\230u\240E\250\027\260\001\260\021\330\014\024\220A\220Z\230u\240E\250\027\260\001\260\021\330\014\023\2207\230!\2301\340\010\017\210q\200A\360\006\000\r!\240\001\330\014\026\220a\360\010\000\t\r\210G\2205\230\001\230\024\230W\240A\240R\240u\250A\330\014\024\220D\230\007\230q\240\002\240!\2401\330\014\027\220u\230H\240A\240U\250%\250w\260a\260q\330\014\025\220^\2401\240G\2501\250A\330\014 \240\005\240Q\240f\250B\250a\330\014\020\220\001\220\021\330\014\017\210y\230\003\2301\330\020\025\220Q\220h""\230a\230q\330\020\027\220q\330\014\017\210{\230'\240\021\330\020\023\220:\230V\2403\240e\2501\330\024\031\230\021\330\031!\240\021\240!\360\006\000\025\034\2301\330\014\031\230\021\340\010\017\210q\200A\360\006\000\t\020\210s\220'\230\021\230#\230U\240$\240a\240r\250\027\260\002\260!\330\r\021\220\030\230\030\240\026\240q\330\014\025\220T\230\030\240\021\240!\330\014\030\230\006\230g\240Q\340\010\022\220$\320\026)\250\021\250!\330\010\013\2104\210q\330\014\r\340\r\021\220\030\230\026\230v\240Q\330\014\017\210x\220q\230\003\2307\240!\2402\240Z\250q\200\001\330\004\n\210+\220Q"; + PyObject *data = NULL; + CYTHON_UNUSED_VAR(__Pyx_DecompressString); + #endif + PyObject **stringtab = __pyx_mstate->__pyx_string_tab; + Py_ssize_t pos = 0; + for (int i = 0; i < 172; i++) { + Py_ssize_t bytes_length = index[i].length; + PyObject *string = PyUnicode_DecodeUTF8(bytes + pos, bytes_length, NULL); + if (likely(string) && i >= 36) 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 = 172; i < 188; i++) { + Py_ssize_t bytes_length = index[i].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 < 188; i++) { + if (unlikely(PyObject_Hash(stringtab[i]) == -1)) { + __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #if CYTHON_IMMORTAL_CONSTANTS + { + PyObject **table = stringtab + 172; + for (Py_ssize_t i=0; i<16; ++i) { + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + Py_SET_REFCNT(table[i], _Py_IMMORTAL_REFCNT_LOCAL); + #else + 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}; + for (int i = 0; i < 1; i++) { + numbertab[i] = PyLong_FromLong(cint_constants_1[i - 0]); + 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<1; ++i) { + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + Py_SET_REFCNT(table[i], _Py_IMMORTAL_REFCNT_LOCAL); + #else + Py_SET_REFCNT(table[i], _Py_IMMORTAL_INITIAL_REFCNT); + #endif + } + } + #endif + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: init_codeobjects ### */ +typedef struct { + unsigned int argcount : 2; + unsigned int num_posonly_args : 1; + unsigned int num_kwonly_args : 1; + unsigned int nlocals : 4; + unsigned int flags : 10; + unsigned int first_line : 10; +} __Pyx_PyCode_New_function_description; +/* NewCodeObj.proto */ +static PyObject* __Pyx_PyCode_New( + const __Pyx_PyCode_New_function_description descr, + PyObject * const *varnames, + PyObject *filename, + PyObject *funcname, + 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, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 145}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_contents}; + __pyx_mstate_global->__pyx_codeobj_tab[0] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_dopt_pollublock_blockchain_b, __pyx_mstate->__pyx_n_u_serialize_dict, __pyx_mstate->__pyx_kp_b_iso88591_A_1_D_q_G1_D_q_D_4q_4q_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[0])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 182}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_serialize_res, __pyx_mstate->__pyx_n_u_serialize_size}; + __pyx_mstate_global->__pyx_codeobj_tab[1] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_dopt_pollublock_blockchain_b, __pyx_mstate->__pyx_n_u_bytes_serialize, __pyx_mstate->__pyx_kp_b_iso88591_A_Qd_1A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[1])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 193}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_digest, __pyx_mstate->__pyx_n_u_digest_size}; + __pyx_mstate_global->__pyx_codeobj_tab[2] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_dopt_pollublock_blockchain_b, __pyx_mstate->__pyx_n_u_perform_hash, __pyx_mstate->__pyx_kp_b_iso88591_A_1D_wc_xuAV2_b_q_t1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[2])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[3] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __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[3])) 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[4] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __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[4])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 457}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_it, __pyx_mstate->__pyx_n_u_block, __pyx_mstate->__pyx_n_u_py_block}; + __pyx_mstate_global->__pyx_codeobj_tab[5] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_dopt_pollublock_blockchain_b, __pyx_mstate->__pyx_n_u_print_key_value_pair, __pyx_mstate->__pyx_kp_b_iso88591_A_T_F_c_D_4q_c_L_1_iq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[5])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 467}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_max_num, __pyx_mstate->__pyx_n_u_block, __pyx_mstate->__pyx_n_u_max_nummber, __pyx_mstate->__pyx_n_u_idx, __pyx_mstate->__pyx_n_u_num, __pyx_mstate->__pyx_n_u_py_block}; + __pyx_mstate_global->__pyx_codeobj_tab[6] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_dopt_pollublock_blockchain_b, __pyx_mstate->__pyx_n_u_print_blocks, __pyx_mstate->__pyx_kp_b_iso88591_A_a_1_83a_AQ_G5_WARuA_D_q_1_iq_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), 484}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_idx, __pyx_mstate->__pyx_n_u_block}; + __pyx_mstate_global->__pyx_codeobj_tab[7] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_dopt_pollublock_blockchain_b, __pyx_mstate->__pyx_n_u_get_block, __pyx_mstate->__pyx_kp_b_iso88591_A_4r_3d_D_AQ_D_AQ_6_A_AQ_iq_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[7])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 493}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_genesis_prev_hash, __pyx_mstate->__pyx_n_u_data_str, __pyx_mstate->__pyx_n_u_block, __pyx_mstate->__pyx_n_u_res}; + __pyx_mstate_global->__pyx_codeobj_tab[8] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_dopt_pollublock_blockchain_b, __pyx_mstate->__pyx_n_u_create_genesis_block, __pyx_mstate->__pyx_kp_b_iso88591_A_4q_a_YgQa_t_Qa_IQ_Q_gQa_t_Qa_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[8])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 516}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_data, __pyx_mstate->__pyx_n_u_prev_block, __pyx_mstate->__pyx_n_u_prev_hash, __pyx_mstate->__pyx_n_u_new_idx, __pyx_mstate->__pyx_n_u_data_str, __pyx_mstate->__pyx_n_u_data_digest, __pyx_mstate->__pyx_n_u_digest_size, __pyx_mstate->__pyx_n_u_block, __pyx_mstate->__pyx_n_u_res}; + __pyx_mstate_global->__pyx_codeobj_tab[9] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_dopt_pollublock_blockchain_b, __pyx_mstate->__pyx_n_u_new_block, __pyx_mstate->__pyx_kp_b_iso88591_A_4t1_aq_4z_1A_4z_T_Qd_Ja_hb_IQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[9])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 547}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_block, __pyx_mstate->__pyx_n_u_prev_block, __pyx_mstate->__pyx_n_u_idx, __pyx_mstate->__pyx_n_u_digest, __pyx_mstate->__pyx_n_u_digest_size, __pyx_mstate->__pyx_n_u_py_bytes, __pyx_mstate->__pyx_n_u_py_bytes_rehashed}; + __pyx_mstate_global->__pyx_codeobj_tab[10] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_dopt_pollublock_blockchain_b, __pyx_mstate->__pyx_n_u_validate, __pyx_mstate->__pyx_kp_b_iso88591_A_a_G5_WARuA_D_q_1_uHAU_waq_1G1A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[10])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 575}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_max_idx, __pyx_mstate->__pyx_n_u_entries, __pyx_mstate->__pyx_n_u_block, __pyx_mstate->__pyx_n_u_idx, __pyx_mstate->__pyx_n_u_max_idx_2, __pyx_mstate->__pyx_n_u_contents}; + __pyx_mstate_global->__pyx_codeobj_tab[11] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_dopt_pollublock_blockchain_b, __pyx_mstate->__pyx_n_u_get_saving_entries, __pyx_mstate->__pyx_kp_b_iso88591_A_a_83a_q_G5_WARuA_t3a_D_q_1_q_A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[11])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 602}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_stmt, __pyx_mstate->__pyx_n_u_conn, __pyx_mstate->__pyx_n_u_result, __pyx_mstate->__pyx_n_u_max_value, __pyx_mstate->__pyx_n_u_entries, __pyx_mstate->__pyx_n_u_con}; + __pyx_mstate_global->__pyx_codeobj_tab[12] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_dopt_pollublock_blockchain_b, __pyx_mstate->__pyx_n_u_save, __pyx_mstate->__pyx_kp_b_iso88591_A_s_U_ar_q_T_gQ_4q_vQ_xq_7_2Zq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[12])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 617}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[13] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_dopt_pollublock_blockchain_b, __pyx_mstate->__pyx_n_u_close_db_connections, __pyx_mstate->__pyx_kp_b_iso88591_A_HHA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[13])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 620}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_batch_size, __pyx_mstate->__pyx_n_u_con, __pyx_mstate->__pyx_n_u_res, __pyx_mstate->__pyx_n_u_batch}; + __pyx_mstate_global->__pyx_codeobj_tab[14] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_dopt_pollublock_blockchain_b, __pyx_mstate->__pyx_n_u_load, __pyx_mstate->__pyx_kp_b_iso88591_A_4q_aq_q_XQc_89ARwb_dRS_IS_1A_K, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[14])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[15] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __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[15])) 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[16] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __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[16])) goto bad; + } + Py_DECREF(tuple_dedup_map); + return 0; + bad: + Py_DECREF(tuple_dedup_map); + return -1; +} +/* #### Code section: init_globals ### */ + +static int __Pyx_InitGlobals(void) { + /* PythonCompatibility.init */ + if (likely(__Pyx_init_co_variables() == 0)); else + + if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + /* 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) + + /* CythonFunctionShared.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 + +/* PyErrExceptionMatches (used by PyObjectGetAttrStrNoError) */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); + for (i=0; i= 0x030C00A6 + PyObject *current_exception = tstate->current_exception; + if (unlikely(!current_exception)) return 0; + exc_type = (PyObject*) Py_TYPE(current_exception); + if (exc_type == err) return 1; +#else + exc_type = tstate->curexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; +#endif + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(exc_type); + #endif + if (unlikely(PyTuple_Check(err))) { + result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + } else { + result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err); + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(exc_type); + #endif + return result; +} +#endif + +/* PyErrFetchRestore (used by PyObjectGetAttrStrNoError) */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject *tmp_value; + assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value))); + if (value) { + #if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb)) + #endif + PyException_SetTraceback(value, tb); + } + tmp_value = tstate->current_exception; + tstate->current_exception = value; + Py_XDECREF(tmp_value); + Py_XDECREF(type); + Py_XDECREF(tb); +#else + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#endif +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject* exc_value; + exc_value = tstate->current_exception; + tstate->current_exception = 0; + *value = exc_value; + *type = NULL; + *tb = NULL; + if (exc_value) { + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + #if CYTHON_COMPILING_IN_CPYTHON + *tb = ((PyBaseExceptionObject*) exc_value)->traceback; + Py_XINCREF(*tb); + #else + *tb = PyException_GetTraceback(exc_value); + #endif + } +#else + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#endif +} +#endif + +/* PyObjectGetAttrStr (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; +} + +/* 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; + } + PyErr_Clear(); +#elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + if (unlikely(__Pyx_PyDict_GetItemRef(__pyx_mstate_global->__pyx_d, name, &result) == -1)) PyErr_Clear(); + __PYX_UPDATE_DICT_CACHE(__pyx_mstate_global->__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return result; + } +#else + result = _PyDict_GetItem_KnownHash(__pyx_mstate_global->__pyx_d, name, ((PyASCIIObject *) name)->hash); + __PYX_UPDATE_DICT_CACHE(__pyx_mstate_global->__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } + PyErr_Clear(); +#endif + return __Pyx_GetBuiltinName(name); +} + +/* PyObjectCall (used by PyObjectFastCall) */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = Py_TYPE(func)->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallMethO (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 PyObjectFastCallMethod) */ +#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API +static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject * const*args, size_t nargs, PyObject *kwargs) { + PyObject *argstuple; + PyObject *result = 0; + size_t i; + argstuple = PyTuple_New((Py_ssize_t)nargs); + if (unlikely(!argstuple)) return NULL; + for (i = 0; i < nargs; i++) { + Py_INCREF(args[i]); + if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) != (0)) goto bad; + } + result = __Pyx_PyObject_Call(func, argstuple, kwargs); + bad: + Py_DECREF(argstuple); + return result; +} +#endif +#if CYTHON_VECTORCALL && !CYTHON_COMPILING_IN_LIMITED_API + #if PY_VERSION_HEX < 0x03090000 + #define __Pyx_PyVectorcall_Function(callable) _PyVectorcall_Function(callable) + #elif CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE vectorcallfunc __Pyx_PyVectorcall_Function(PyObject *callable) { + PyTypeObject *tp = Py_TYPE(callable); + #if defined(__Pyx_CyFunction_USED) + if (__Pyx_CyFunction_CheckExact(callable)) { + return __Pyx_CyFunction_func_vectorcall(callable); + } + #endif + if (!PyType_HasFeature(tp, Py_TPFLAGS_HAVE_VECTORCALL)) { + return NULL; + } + assert(PyCallable_Check(callable)); + Py_ssize_t offset = tp->tp_vectorcall_offset; + assert(offset > 0); + vectorcallfunc ptr; + memcpy(&ptr, (char *) callable + offset, sizeof(ptr)); + return ptr; +} + #else + #define __Pyx_PyVectorcall_Function(callable) PyVectorcall_Function(callable) + #endif +#endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject *const *args, size_t _nargs, PyObject *kwargs) { + Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs); +#if CYTHON_COMPILING_IN_CPYTHON + if (nargs == 0 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS)) + return __Pyx_PyObject_CallMethO(func, NULL); + } + else if (nargs == 1 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O)) + return __Pyx_PyObject_CallMethO(func, args[0]); + } +#endif + if (kwargs == NULL) { + #if CYTHON_VECTORCALL + #if CYTHON_COMPILING_IN_LIMITED_API + return PyObject_Vectorcall(func, args, _nargs, NULL); + #else + vectorcallfunc f = __Pyx_PyVectorcall_Function(func); + if (f) { + return f(func, args, _nargs, NULL); + } + #endif + #endif + } + if (nargs == 0) { + return __Pyx_PyObject_Call(func, __pyx_mstate_global->__pyx_empty_tuple, kwargs); + } + #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API + return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs); + #else + return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs); + #endif +} + +/* PyObjectFastCallMethod */ +#if !CYTHON_VECTORCALL || PY_VERSION_HEX < 0x03090000 +static PyObject *__Pyx_PyObject_FastCallMethod(PyObject *name, PyObject *const *args, size_t nargsf) { + PyObject *result; + PyObject *attr = PyObject_GetAttr(args[0], name); + if (unlikely(!attr)) + return NULL; + result = __Pyx_PyObject_FastCall(attr, args+1, nargsf - 1); + Py_DECREF(attr); + return result; +} +#endif + +/* PyObjectVectorCallKwBuilder (used by PyObjectVectorCallMethodKwBuilder) */ +#if CYTHON_VECTORCALL +static int __Pyx_VectorcallBuilder_AddArg(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n) { + (void)__Pyx_PyObject_FastCallDict; + if (__Pyx_PyTuple_SET_ITEM(builder, n, key) != (0)) return -1; + Py_INCREF(key); + args[n] = value; + return 0; +} +CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n) { + (void)__Pyx_VectorcallBuilder_AddArgStr; + if (unlikely(!PyUnicode_Check(key))) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + return -1; + } + return __Pyx_VectorcallBuilder_AddArg(key, value, builder, args, n); +} +static int __Pyx_VectorcallBuilder_AddArgStr(const char *key, PyObject *value, PyObject *builder, PyObject **args, int n) { + PyObject *pyKey = PyUnicode_FromString(key); + if (!pyKey) return -1; + return __Pyx_VectorcallBuilder_AddArg(pyKey, value, builder, args, n); +} +#else // CYTHON_VECTORCALL +CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, CYTHON_UNUSED PyObject **args, CYTHON_UNUSED int n) { + if (unlikely(!PyUnicode_Check(key))) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + return -1; + } + return PyDict_SetItem(builder, key, value); +} +#endif + +/* PyObjectVectorCallMethodKwBuilder */ +#if !CYTHON_VECTORCALL || PY_VERSION_HEX < 0x03090000 +static PyObject *__Pyx_Object_VectorcallMethod_CallFromBuilder(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_Vectorcall_CallFromBuilder(obj, args+1, nargsf-1, kwnames); + Py_DECREF(obj); + return result; +} +#endif + +/* DivInt[long] */ +static CYTHON_INLINE long __Pyx_div_long(long a, long b, int b_is_constant) { + long q = a / b; + long r = a - q*b; + long adapt_python = (b_is_constant ? + ((r != 0) & ((r < 0) ^ (b < 0))) : + ((r != 0) & ((r ^ b) < 0)) + ); + return q - adapt_python; +} + +/* ModInt[long] */ +static CYTHON_INLINE long __Pyx_mod_long(long a, long b, int b_is_constant) { + long r = a % b; + long adapt_python = (b_is_constant ? + ((r != 0) & ((r < 0) ^ (b < 0))) : + ((r != 0) & ((r ^ b) < 0)) + ); + return r + adapt_python * b; +} + +/* TupleAndListFromArray (used by fastcall) */ +#if !CYTHON_COMPILING_IN_CPYTHON && CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject * +__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + Py_ssize_t i; + if (n <= 0) { + return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_tuple); + } + res = PyTuple_New(n); + if (unlikely(res == NULL)) return NULL; + for (i = 0; i < n; i++) { + if (unlikely(__Pyx_PyTuple_SET_ITEM(res, i, src[i]) < (0))) { + Py_DECREF(res); + return NULL; + } + Py_INCREF(src[i]); + } + return res; +} +#elif CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) { + PyObject *v; + Py_ssize_t i; + for (i = 0; i < length; i++) { + v = dest[i] = src[i]; + Py_INCREF(v); + } +} +static CYTHON_INLINE PyObject * +__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_tuple); + } + res = PyTuple_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n); + return res; +} +static CYTHON_INLINE PyObject * +__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + return PyList_New(0); + } + res = PyList_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n); + return res; +} +#endif + +/* BytesEquals (used by UnicodeEquals) */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL ||\ + !(CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS) + return PyObject_RichCompareBool(s1, s2, equals); +#else + if (s1 == s2) { + return (equals == Py_EQ); + } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { + const char *ps1, *ps2; + Py_ssize_t length = PyBytes_GET_SIZE(s1); + if (length != PyBytes_GET_SIZE(s2)) + return (equals == Py_NE); + ps1 = PyBytes_AS_STRING(s1); + ps2 = PyBytes_AS_STRING(s2); + if (ps1[0] != ps2[0]) { + return (equals == Py_NE); + } else if (length == 1) { + return (equals == Py_EQ); + } else { + int result; +#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000) + Py_hash_t hash1, hash2; + hash1 = ((PyBytesObject*)s1)->ob_shash; + hash2 = ((PyBytesObject*)s2)->ob_shash; + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + return (equals == Py_NE); + } +#endif + result = memcmp(ps1, ps2, (size_t)length); + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { + return (equals == Py_NE); + } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { + return (equals == Py_NE); + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +#endif +} + +/* UnicodeEquals (used by fastcall) */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL + return PyObject_RichCompareBool(s1, s2, equals); +#else + int s1_is_unicode, s2_is_unicode; + if (s1 == s2) { + goto return_eq; + } + s1_is_unicode = PyUnicode_CheckExact(s1); + s2_is_unicode = PyUnicode_CheckExact(s2); + if (s1_is_unicode & s2_is_unicode) { + Py_ssize_t length, length2; + int kind; + void *data1, *data2; + #if !CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) + return -1; + #endif + length = __Pyx_PyUnicode_GET_LENGTH(s1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(length < 0)) return -1; + #endif + length2 = __Pyx_PyUnicode_GET_LENGTH(s2); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(length2 < 0)) return -1; + #endif + if (length != length2) { + goto return_ne; + } +#if CYTHON_USE_UNICODE_INTERNALS + { + Py_hash_t hash1, hash2; + hash1 = ((PyASCIIObject*)s1)->hash; + hash2 = ((PyASCIIObject*)s2)->hash; + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + goto return_ne; + } + } +#endif + kind = __Pyx_PyUnicode_KIND(s1); + if (kind != __Pyx_PyUnicode_KIND(s2)) { + goto return_ne; + } + data1 = __Pyx_PyUnicode_DATA(s1); + data2 = __Pyx_PyUnicode_DATA(s2); + if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { + goto return_ne; + } else if (length == 1) { + goto return_eq; + } else { + int result = memcmp(data1, data2, (size_t)(length * kind)); + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & s2_is_unicode) { + goto return_ne; + } else if ((s2 == Py_None) & s1_is_unicode) { + goto return_ne; + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +return_eq: + return (equals == Py_EQ); +return_ne: + return (equals == Py_NE); +#endif +} + +/* fastcall */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) +{ + Py_ssize_t i, n = __Pyx_PyTuple_GET_SIZE(kwnames); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(n == -1)) return NULL; + #endif + for (i = 0; i < n; i++) + { + PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!namei)) return NULL; + #endif + if (s == namei) return kwvalues[i]; + } + for (i = 0; i < n; i++) + { + PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!namei)) return NULL; + #endif + int eq = __Pyx_PyUnicode_Equals(s, namei, Py_EQ); + if (unlikely(eq != 0)) { + if (unlikely(eq < 0)) return NULL; + return kwvalues[i]; + } + } + return NULL; +} +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API +CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { + Py_ssize_t i, nkwargs; + PyObject *dict; +#if !CYTHON_ASSUME_SAFE_SIZE + nkwargs = PyTuple_Size(kwnames); + if (unlikely(nkwargs < 0)) return NULL; +#else + nkwargs = PyTuple_GET_SIZE(kwnames); +#endif + dict = PyDict_New(); + if (unlikely(!dict)) + return NULL; + for (i=0; itype, *target->method_name); + if (unlikely(!method)) + return -1; + result = method; +#if CYTHON_COMPILING_IN_CPYTHON + if (likely(__Pyx_TypeCheck(method, &PyMethodDescr_Type))) + { + PyMethodDescrObject *descr = (PyMethodDescrObject*) method; + target->func = descr->d_method->ml_meth; + target->flag = descr->d_method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_STACKLESS); + } else +#endif +#if CYTHON_COMPILING_IN_PYPY +#else + if (PyCFunction_Check(method)) +#endif + { + PyObject *self; + int self_found; +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + self = PyObject_GetAttrString(method, "__self__"); + if (!self) { + PyErr_Clear(); + } +#else + self = PyCFunction_GET_SELF(method); +#endif + self_found = (self && self != Py_None); +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + Py_XDECREF(self); +#endif + if (self_found) { + PyObject *unbound_method = PyCFunction_New(&__Pyx_UnboundCMethod_Def, method); + if (unlikely(!unbound_method)) return -1; + Py_DECREF(method); + result = unbound_method; + } + } +#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + if (unlikely(target->method)) { + Py_DECREF(result); + } else +#endif + target->method = result; + return 0; +} + +/* 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); + while ( + #if CYTHON_AVOID_BORROWED_REFS + __Pyx_PyDict_NextRef(kwds, &pos, &key, NULL) + #else + 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_METH_FASTCALL && likely(PyTuple_Check(kwds))) + return __Pyx_ParseKeywordsTuple(kwds, kwvalues, argnames, kwds2, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs); + else if (kwds2) + return __Pyx_ParseKeywordDictToDict(kwds, argnames, kwds2, values, num_pos_args, function_name); + else + return __Pyx_ParseKeywordDict(kwds, argnames, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs); +} + +/* RaiseArgTupleInvalid */ +static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +/* KeywordStringCheck */ +static int __Pyx_CheckKeywordStrings( + const char* function_name, + PyObject *kw) +{ +#if CYTHON_COMPILING_IN_PYPY && !defined(PyArg_ValidateKeywordArguments) + CYTHON_UNUSED_VAR(function_name); + CYTHON_UNUSED_VAR(kw); + return 0; +#else + if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) { +#if PY_VERSION_HEX >= 0x03090000 + CYTHON_UNUSED_VAR(function_name); +#else + Py_ssize_t kwsize; + #if CYTHON_ASSUME_SAFE_SIZE + kwsize = PyTuple_GET_SIZE(kw); + #else + kwsize = PyTuple_Size(kw); + if (unlikely(kwsize < 0)) return -1; + #endif + for (Py_ssize_t pos = 0; pos < kwsize; pos++) { + PyObject* key = NULL; + #if CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kw, pos); + #else + key = PyTuple_GetItem(kw, pos); + if (unlikely(!key)) return -1; + #endif + if (unlikely(!PyUnicode_Check(key))) { + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + return -1; + } + } +#endif + } else { + if (unlikely(!PyArg_ValidateKeywordArguments(kw))) return -1; + } + return 0; +#endif +} + +/* JoinPyUnicode */ +static PyObject* __Pyx_PyUnicode_Join(PyObject** values, Py_ssize_t value_count, Py_ssize_t result_ulength, + Py_UCS4 max_char) { +#if CYTHON_USE_UNICODE_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + PyObject *result_uval; + int result_ukind, kind_shift; + Py_ssize_t i, char_pos; + void *result_udata; + if (max_char > 1114111) max_char = 1114111; + result_uval = PyUnicode_New(result_ulength, max_char); + if (unlikely(!result_uval)) return NULL; + result_ukind = (max_char <= 255) ? PyUnicode_1BYTE_KIND : (max_char <= 65535) ? PyUnicode_2BYTE_KIND : PyUnicode_4BYTE_KIND; + kind_shift = (result_ukind == PyUnicode_4BYTE_KIND) ? 2 : result_ukind - 1; + result_udata = PyUnicode_DATA(result_uval); + assert(kind_shift == 2 || kind_shift == 1 || kind_shift == 0); + if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - result_ulength < 0)) + goto overflow; + char_pos = 0; + for (i=0; i < value_count; i++) { + int ukind; + Py_ssize_t ulength; + void *udata; + PyObject *uval = values[i]; + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_PyUnicode_READY(uval) == (-1)) + goto bad; + #endif + ulength = __Pyx_PyUnicode_GET_LENGTH(uval); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(ulength < 0)) goto bad; + #endif + if (unlikely(!ulength)) + continue; + if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - ulength < char_pos)) + goto overflow; + ukind = __Pyx_PyUnicode_KIND(uval); + udata = __Pyx_PyUnicode_DATA(uval); + if (ukind == result_ukind) { + memcpy((char *)result_udata + (char_pos << kind_shift), udata, (size_t) (ulength << kind_shift)); + } else { + #if PY_VERSION_HEX >= 0x030d0000 + if (unlikely(PyUnicode_CopyCharacters(result_uval, char_pos, uval, 0, ulength) < 0)) goto bad; + #elif CYTHON_COMPILING_IN_CPYTHON || defined(_PyUnicode_FastCopyCharacters) + _PyUnicode_FastCopyCharacters(result_uval, char_pos, uval, 0, ulength); + #else + Py_ssize_t j; + for (j=0; j < ulength; j++) { + Py_UCS4 uchar = __Pyx_PyUnicode_READ(ukind, udata, j); + __Pyx_PyUnicode_WRITE(result_ukind, result_udata, char_pos+j, uchar); + } + #endif + } + char_pos += ulength; + } + return result_uval; +overflow: + PyErr_SetString(PyExc_OverflowError, "join() result is too long for a Python string"); +bad: + Py_DECREF(result_uval); + return NULL; +#else + Py_ssize_t i; + PyObject *result = NULL; + PyObject *value_tuple = PyTuple_New(value_count); + if (unlikely(!value_tuple)) return NULL; + CYTHON_UNUSED_VAR(max_char); + CYTHON_UNUSED_VAR(result_ulength); + for (i=0; i__pyx_empty_unicode, value_tuple); +bad: + Py_DECREF(value_tuple); + return result; +#endif +} + +/* RejectKeywords */ +static void __Pyx_RejectKeywords(const char* function_name, PyObject *kwds) { + PyObject *key = NULL; + if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds))) { + key = __Pyx_PySequence_ITEM(kwds, 0); + } else { +#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); + } +} + +/* decode_c_bytes (used by decode_cpp_string) */ +static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes( + const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { + if (unlikely((start < 0) | (stop < 0))) { + if (start < 0) { + start += length; + if (start < 0) + start = 0; + } + if (stop < 0) + stop += length; + } + if (stop > length) + stop = length; + if (unlikely(stop <= start)) + return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_unicode); + length = stop - start; + cstring += start; + if (decode_func) { + return decode_func(cstring, length, errors); + } else { + return PyUnicode_Decode(cstring, length, encoding, errors); + } +} + +/* 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 +} + +/* SwapException */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_value = exc_info->exc_value; + exc_info->exc_value = *value; + if (tmp_value == NULL || tmp_value == Py_None) { + Py_XDECREF(tmp_value); + tmp_value = NULL; + tmp_type = NULL; + tmp_tb = NULL; + } else { + tmp_type = (PyObject*) Py_TYPE(tmp_value); + Py_INCREF(tmp_type); + #if CYTHON_COMPILING_IN_CPYTHON + tmp_tb = ((PyBaseExceptionObject*) tmp_value)->traceback; + Py_XINCREF(tmp_tb); + #else + tmp_tb = PyException_GetTraceback(tmp_value); + #endif + } + #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 + +/* 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 + +/* 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; +} + +/* ErrOccurredWithGIL */ +static CYTHON_INLINE int __Pyx_ErrOccurredWithGIL(void) { + int err; + PyGILState_STATE _save = PyGILState_Ensure(); + err = !!PyErr_Occurred(); + PyGILState_Release(_save); + return err; +} + +/* ReleaseUnknownGil */ +static __Pyx_UnknownThreadState __Pyx_SaveUnknownThread(void) { +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 + if (__Pyx_get_runtime_version() >= 0x030d0000) { + PyThreadState *ts = PyThreadState_Swap(NULL); + __Pyx_UnknownThreadState out = { ts, PyGILState_UNLOCKED }; + return out; + } else { + PyGILState_STATE gil_state = PyGILState_Ensure(); + PyThreadState *ts = PyEval_SaveThread(); + __Pyx_UnknownThreadState out = { ts, gil_state }; + return out; + } +#elif __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + return PyThreadState_Swap(NULL); +#else + #if CYTHON_COMPILING_IN_PYPY || PY_VERSION_HEX < 0x030C0000 + if (PyGILState_Check()) + #else + if (_PyThreadState_UncheckedGet()) // UncheckedGet is a reliable check for the GIL from 3.12 upwards + #endif + { + return PyEval_SaveThread(); + } + return NULL; // Nothing to release - we don't have the GIL +#endif +} +static void __Pyx_RestoreUnknownThread(__Pyx_UnknownThreadState state) { +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 + if (!state.ts) return; + PyEval_RestoreThread(state.ts); + if (__Pyx_get_runtime_version() < 0x030d0000) { + PyGILState_Release(state.gil_state); + } +#else + if (state) { + PyEval_RestoreThread(state); + } +#endif +} +static CYTHON_INLINE int __Pyx_UnknownThreadStateDefinitelyHadGil(__Pyx_UnknownThreadState state) { + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 + return ((state.ts != NULL) && (__Pyx_get_runtime_version() >= 0x030d0000)); + #else + return state != NULL; + #endif +} +static CYTHON_INLINE int __Pyx_UnknownThreadStateMayHaveHadGil(__Pyx_UnknownThreadState state) { + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 + return state.ts != NULL; + #else + return state != NULL; + #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 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_ASSUME_SAFE_SIZE + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyList_GET_SIZE(o); + } + if ((CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS)) { + return __Pyx_PyList_GetItemRefFast(o, wrapped_i, unsafe_shared); + } else + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { + return __Pyx_NewRef(PyList_GET_ITEM(o, wrapped_i)); + } + return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(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_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyTuple_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { + return __Pyx_NewRef(PyTuple_GET_ITEM(o, wrapped_i)); + } + return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i)); +#else + (void)wraparound; + (void)boundscheck; + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, + int wraparound, int boundscheck, int unsafe_shared) { + CYTHON_MAYBE_UNUSED_VAR(unsafe_shared); +#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); + if ((CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS)) { + return __Pyx_PyList_GetItemRefFast(o, n, unsafe_shared); + } else if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { + return __Pyx_NewRef(PyList_GET_ITEM(o, n)); + } + } else + #if !CYTHON_AVOID_BORROWED_REFS + if (PyTuple_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { + return __Pyx_NewRef(PyTuple_GET_ITEM(o, n)); + } + } else + #endif +#endif +#if CYTHON_USE_TYPE_SLOTS && !CYTHON_COMPILING_IN_PYPY + { + PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping; + PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence; + if (!is_list && mm && mm->mp_subscript) { + PyObject *r, *key = PyLong_FromSsize_t(i); + if (unlikely(!key)) return NULL; + r = mm->mp_subscript(o, key); + Py_DECREF(key); + return r; + } + if (is_list || likely(sm && sm->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) { + Py_ssize_t l = sm->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return NULL; + PyErr_Clear(); + } + } + return sm->sq_item(o, i); + } + } +#else + if (is_list || !PyMapping_Check(o)) { + return PySequence_GetItem(o, i); + } +#endif + (void)wraparound; + (void)boundscheck; + return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i)); +} + +/* CIntToDigits (used by CIntToPyUnicode) */ +static const char DIGIT_PAIRS_10[2*10*10+1] = { + "00010203040506070809" + "10111213141516171819" + "20212223242526272829" + "30313233343536373839" + "40414243444546474849" + "50515253545556575859" + "60616263646566676869" + "70717273747576777879" + "80818283848586878889" + "90919293949596979899" +}; +static const char DIGIT_PAIRS_8[2*8*8+1] = { + "0001020304050607" + "1011121314151617" + "2021222324252627" + "3031323334353637" + "4041424344454647" + "5051525354555657" + "6061626364656667" + "7071727374757677" +}; +static const char DIGITS_HEX[2*16+1] = { + "0123456789abcdef" + "0123456789ABCDEF" +}; + +/* BuildPyUnicode (used by COrdinalToPyUnicode) */ +static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, const char* chars, int clength, + int prepend_sign, char padding_char) { + PyObject *uval; + Py_ssize_t uoffset = ulength - clength; +#if CYTHON_USE_UNICODE_INTERNALS + Py_ssize_t i; + void *udata; + uval = PyUnicode_New(ulength, 127); + if (unlikely(!uval)) return NULL; + udata = PyUnicode_DATA(uval); + if (uoffset > 0) { + i = 0; + if (prepend_sign) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, 0, '-'); + i++; + } + for (; i < uoffset; i++) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, i, padding_char); + } + } + for (i=0; i < clength; i++) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, uoffset+i, chars[i]); + } +#else + { + 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); +} + +/* 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 + +/* RaiseUnboundLocalError */ +static void __Pyx_RaiseUnboundLocalError(const char *varname) { + PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); +} + +/* 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); + } +} + +/* CallTypeTraverse */ +#if !CYTHON_USE_TYPE_SPECS || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x03090000) +#else +static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg) { + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x03090000 + if (__Pyx_get_runtime_version() < 0x03090000) return 0; + #endif + if (!always_call) { + PyTypeObject *base = __Pyx_PyObject_GetSlot(o, tp_base, PyTypeObject*); + unsigned long flags = PyType_GetFlags(base); + if (flags & Py_TPFLAGS_HEAPTYPE) { + return 0; + } + } + Py_VISIT((PyObject*)Py_TYPE(o)); + return 0; +} +#endif + +/* LimitedApiGetTypeDict (used by SetItemOnTypeDict) */ +#if CYTHON_COMPILING_IN_LIMITED_API +static Py_ssize_t __Pyx_GetTypeDictOffset(void) { + PyObject *tp_dictoffset_o; + Py_ssize_t tp_dictoffset; + tp_dictoffset_o = PyObject_GetAttrString((PyObject*)(&PyType_Type), "__dictoffset__"); + if (unlikely(!tp_dictoffset_o)) return -1; + tp_dictoffset = PyLong_AsSsize_t(tp_dictoffset_o); + Py_DECREF(tp_dictoffset_o); + if (unlikely(tp_dictoffset == 0)) { + PyErr_SetString( + PyExc_TypeError, + "'type' doesn't have a dictoffset"); + return -1; + } else if (unlikely(tp_dictoffset < 0)) { + PyErr_SetString( + PyExc_TypeError, + "'type' has an unexpected negative dictoffset. " + "Please report this as Cython bug"); + return -1; + } + return tp_dictoffset; +} +static PyObject *__Pyx_GetTypeDict(PyTypeObject *tp) { + static Py_ssize_t tp_dictoffset = 0; + if (unlikely(tp_dictoffset == 0)) { + tp_dictoffset = __Pyx_GetTypeDictOffset(); + if (unlikely(tp_dictoffset == -1 && PyErr_Occurred())) { + tp_dictoffset = 0; // try again next time? + return NULL; + } + } + return *(PyObject**)((char*)tp + tp_dictoffset); +} +#endif + +/* SetItemOnTypeDict (used by FixUpExtensionType) */ +static int __Pyx__SetItemOnTypeDict(PyTypeObject *tp, PyObject *k, PyObject *v) { + int result; + PyObject *tp_dict; +#if CYTHON_COMPILING_IN_LIMITED_API + tp_dict = __Pyx_GetTypeDict(tp); + if (unlikely(!tp_dict)) return -1; +#else + tp_dict = tp->tp_dict; +#endif + result = PyDict_SetItem(tp_dict, k, v); + if (likely(!result)) { + PyType_Modified(tp); + if (unlikely(PyObject_HasAttr(v, __pyx_mstate_global->__pyx_n_u_set_name))) { + PyObject *setNameResult = PyObject_CallMethodObjArgs(v, __pyx_mstate_global->__pyx_n_u_set_name, (PyObject *) tp, k, NULL); + if (!setNameResult) return -1; + Py_DECREF(setNameResult); + } + } + return result; +} + +/* FixUpExtensionType */ +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) { +#if __PYX_LIMITED_VERSION_HEX > 0x030900B1 + CYTHON_UNUSED_VAR(spec); + CYTHON_UNUSED_VAR(type); + CYTHON_UNUSED_VAR(__Pyx__SetItemOnTypeDict); +#else + const PyType_Slot *slot = spec->slots; + int changed = 0; +#if !CYTHON_COMPILING_IN_LIMITED_API + while (slot && slot->slot && slot->slot != Py_tp_members) + slot++; + if (slot && slot->slot == Py_tp_members) { +#if !CYTHON_COMPILING_IN_CPYTHON + const +#endif // !CYTHON_COMPILING_IN_CPYTHON) + PyMemberDef *memb = (PyMemberDef*) slot->pfunc; + while (memb && memb->name) { + if (memb->name[0] == '_' && memb->name[1] == '_') { + if (strcmp(memb->name, "__weaklistoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_weaklistoffset = memb->offset; + changed = 1; + } + else if (strcmp(memb->name, "__dictoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_dictoffset = memb->offset; + changed = 1; + } +#if CYTHON_METH_FASTCALL + else if (strcmp(memb->name, "__vectorcalloffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_vectorcall_offset = memb->offset; + changed = 1; + } +#endif // CYTHON_METH_FASTCALL +#if !CYTHON_COMPILING_IN_PYPY + else if (strcmp(memb->name, "__module__") == 0) { + PyObject *descr; + assert(memb->type == T_OBJECT); + assert(memb->flags == 0 || memb->flags == READONLY); + descr = PyDescr_NewMember(type, memb); + if (unlikely(!descr)) + return -1; + int set_item_result = PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr); + Py_DECREF(descr); + if (unlikely(set_item_result < 0)) { + return -1; + } + changed = 1; + } +#endif // !CYTHON_COMPILING_IN_PYPY + } + memb++; + } + } +#endif // !CYTHON_COMPILING_IN_LIMITED_API +#if !CYTHON_COMPILING_IN_PYPY + slot = spec->slots; + while (slot && slot->slot && slot->slot != Py_tp_getset) + slot++; + if (slot && slot->slot == Py_tp_getset) { + PyGetSetDef *getset = (PyGetSetDef*) slot->pfunc; + while (getset && getset->name) { + if (getset->name[0] == '_' && getset->name[1] == '_' && strcmp(getset->name, "__module__") == 0) { + PyObject *descr = PyDescr_NewGetSet(type, getset); + if (unlikely(!descr)) + return -1; + #if CYTHON_COMPILING_IN_LIMITED_API + PyObject *pyname = PyUnicode_FromString(getset->name); + if (unlikely(!pyname)) { + Py_DECREF(descr); + return -1; + } + int set_item_result = __Pyx_SetItemOnTypeDict(type, pyname, descr); + Py_DECREF(pyname); + #else + CYTHON_UNUSED_VAR(__Pyx__SetItemOnTypeDict); + int set_item_result = PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr); + #endif + Py_DECREF(descr); + if (unlikely(set_item_result < 0)) { + return -1; + } + changed = 1; + } + ++getset; + } + } +#else + CYTHON_UNUSED_VAR(__Pyx__SetItemOnTypeDict); +#endif // !CYTHON_COMPILING_IN_PYPY + if (changed) + PyType_Modified(type); +#endif // PY_VERSION_HEX > 0x030900B1 + return 0; +} + +/* PyObjectCallNoArg (used by PyObjectCallMethod0) */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { + PyObject *arg[2] = {NULL, NULL}; + return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} + +/* PyObjectGetMethod (used by PyObjectCallMethod0) */ +#if !(CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000))) +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { + PyObject *attr; +#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP + __Pyx_TypeName type_name; + PyTypeObject *tp = Py_TYPE(obj); + PyObject *descr; + descrgetfunc f = NULL; + PyObject **dictptr, *dict; + int meth_found = 0; + assert (*method == NULL); + if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) { + attr = __Pyx_PyObject_GetAttrStr(obj, name); + goto try_unpack; + } + if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) { + return 0; + } + descr = _PyType_Lookup(tp, name); + if (likely(descr != NULL)) { + Py_INCREF(descr); +#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR + if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)) +#else + #ifdef __Pyx_CyFunction_USED + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) + #else + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type))) + #endif +#endif + { + meth_found = 1; + } else { + f = Py_TYPE(descr)->tp_descr_get; + if (f != NULL && PyDescr_IsData(descr)) { + attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); + Py_DECREF(descr); + goto try_unpack; + } + } + } + dictptr = _PyObject_GetDictPtr(obj); + if (dictptr != NULL && (dict = *dictptr) != NULL) { + Py_INCREF(dict); + attr = __Pyx_PyDict_GetItemStr(dict, name); + if (attr != NULL) { + Py_INCREF(attr); + Py_DECREF(dict); + Py_XDECREF(descr); + goto try_unpack; + } + Py_DECREF(dict); + } + if (meth_found) { + *method = descr; + return 1; + } + if (f != NULL) { + attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); + Py_DECREF(descr); + goto try_unpack; + } + if (likely(descr != NULL)) { + *method = descr; + return 0; + } + type_name = __Pyx_PyType_GetFullyQualifiedName(tp); + PyErr_Format(PyExc_AttributeError, + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, name); + __Pyx_DECREF_TypeName(type_name); + return 0; +#else + attr = __Pyx_PyObject_GetAttrStr(obj, name); + goto try_unpack; +#endif +try_unpack: +#if CYTHON_UNPACK_METHODS + if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) { + PyObject *function = PyMethod_GET_FUNCTION(attr); + Py_INCREF(function); + Py_DECREF(attr); + *method = function; + return 1; + } +#endif + *method = attr; + return 0; +} +#endif + +/* PyObjectCallMethod0 (used by PyType_Ready) */ +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { +#if CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000)) + PyObject *args[1] = {obj}; + (void) __Pyx_PyObject_CallOneArg; + (void) __Pyx_PyObject_CallNoArg; + return PyObject_VectorcallMethod(method_name, args, 1 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); +#else + PyObject *method = NULL, *result = NULL; + int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); + if (likely(is_method)) { + result = __Pyx_PyObject_CallOneArg(method, obj); + Py_DECREF(method); + return result; + } + if (unlikely(!method)) goto bad; + result = __Pyx_PyObject_CallNoArg(method); + Py_DECREF(method); +bad: + return result; +#endif +} + +/* ValidateBasesTuple (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, Py_ssize_t dictoffset, PyObject *bases) { + Py_ssize_t i, n; +#if CYTHON_ASSUME_SAFE_SIZE + n = PyTuple_GET_SIZE(bases); +#else + n = PyTuple_Size(bases); + if (unlikely(n < 0)) return -1; +#endif + for (i = 1; i < n; i++) + { + PyTypeObject *b; +#if CYTHON_AVOID_BORROWED_REFS + PyObject *b0 = PySequence_GetItem(bases, i); + if (!b0) return -1; +#elif CYTHON_ASSUME_SAFE_MACROS + PyObject *b0 = PyTuple_GET_ITEM(bases, i); +#else + PyObject *b0 = PyTuple_GetItem(bases, i); + if (!b0) return -1; +#endif + b = (PyTypeObject*) b0; + if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) + { + __Pyx_TypeName b_name = __Pyx_PyType_GetFullyQualifiedName(b); + PyErr_Format(PyExc_TypeError, + "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name); + __Pyx_DECREF_TypeName(b_name); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } + if (dictoffset == 0) + { + Py_ssize_t b_dictoffset = 0; +#if CYTHON_USE_TYPE_SLOTS + b_dictoffset = b->tp_dictoffset; +#else + PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__"); + if (!py_b_dictoffset) goto dictoffset_return; + b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset); + Py_DECREF(py_b_dictoffset); + if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return; +#endif + if (b_dictoffset) { + { + __Pyx_TypeName b_name = __Pyx_PyType_GetFullyQualifiedName(b); + PyErr_Format(PyExc_TypeError, + "extension type '%.200s' has no __dict__ slot, " + "but base type '" __Pyx_FMT_TYPENAME "' has: " + "either add 'cdef dict __dict__' to the extension type " + "or add '__slots__ = [...]' to the base type", + type_name, b_name); + __Pyx_DECREF_TypeName(b_name); + } +#if !CYTHON_USE_TYPE_SLOTS + dictoffset_return: +#endif +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } + } +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + } + return 0; +} +#endif + +/* PyType_Ready */ +CYTHON_UNUSED static int __Pyx_PyType_HasMultipleInheritance(PyTypeObject *t) { + while (t) { + PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); + if (bases) { + return 1; + } + t = __Pyx_PyType_GetSlot(t, tp_base, PyTypeObject*); + } + return 0; +} +static int __Pyx_PyType_Ready(PyTypeObject *t) { +#if CYTHON_USE_TYPE_SPECS || !CYTHON_COMPILING_IN_CPYTHON || defined(PYSTON_MAJOR_VERSION) + (void)__Pyx_PyObject_CallMethod0; +#if CYTHON_USE_TYPE_SPECS + (void)__Pyx_validate_bases_tuple; +#endif + return PyType_Ready(t); +#else + int r; + if (!__Pyx_PyType_HasMultipleInheritance(t)) { + return PyType_Ready(t); + } + PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); + if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1)) + return -1; +#if !defined(PYSTON_MAJOR_VERSION) + { + int gc_was_enabled; + #if PY_VERSION_HEX >= 0x030A00b1 + gc_was_enabled = PyGC_Disable(); + (void)__Pyx_PyObject_CallMethod0; + #else + PyObject *ret, *py_status; + PyObject *gc = NULL; + #if (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) &&\ + !CYTHON_COMPILING_IN_GRAAL + gc = PyImport_GetModule(__pyx_mstate_global->__pyx_kp_u_gc); + #endif + if (unlikely(!gc)) gc = PyImport_Import(__pyx_mstate_global->__pyx_kp_u_gc); + if (unlikely(!gc)) return -1; + py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_isenabled); + if (unlikely(!py_status)) { + Py_DECREF(gc); + return -1; + } + gc_was_enabled = __Pyx_PyObject_IsTrue(py_status); + Py_DECREF(py_status); + if (gc_was_enabled > 0) { + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_disable); + if (unlikely(!ret)) { + Py_DECREF(gc); + return -1; + } + Py_DECREF(ret); + } else if (unlikely(gc_was_enabled == -1)) { + Py_DECREF(gc); + return -1; + } + #endif + t->tp_flags |= Py_TPFLAGS_HEAPTYPE; +#if PY_VERSION_HEX >= 0x030A0000 + t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE; +#endif +#else + (void)__Pyx_PyObject_CallMethod0; +#endif + r = PyType_Ready(t); +#if !defined(PYSTON_MAJOR_VERSION) + t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE; + #if PY_VERSION_HEX >= 0x030A00b1 + if (gc_was_enabled) + PyGC_Enable(); + #else + if (gc_was_enabled) { + PyObject *tp, *v, *tb; + PyErr_Fetch(&tp, &v, &tb); + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_enable); + if (likely(ret || r == -1)) { + Py_XDECREF(ret); + PyErr_Restore(tp, v, tb); + } else { + Py_XDECREF(tp); + Py_XDECREF(v); + Py_XDECREF(tb); + r = -1; + } + } + Py_DECREF(gc); + #endif + } +#endif + return r; +#endif +} + +/* 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 0; +bad: + Py_XDECREF(ob); + return -1; +} + +/* GetVTable (used by MergeVTables) */ +static void* __Pyx_GetVtable(PyTypeObject *type) { + void* ptr; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *ob = PyObject_GetAttr((PyObject *)type, __pyx_mstate_global->__pyx_n_u_pyx_vtable); +#else + PyObject *ob = PyObject_GetItem(type->tp_dict, __pyx_mstate_global->__pyx_n_u_pyx_vtable); +#endif + if (!ob) + goto bad; + ptr = PyCapsule_GetPointer(ob, 0); + if (!ptr && !PyErr_Occurred()) + PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type"); + Py_DECREF(ob); + return ptr; +bad: + Py_XDECREF(ob); + return NULL; +} + +/* MergeVTables */ +static int __Pyx_MergeVtables(PyTypeObject *type) { + int i=0; + Py_ssize_t size; + void** base_vtables; + __Pyx_TypeName tp_base_name = NULL; + __Pyx_TypeName base_name = NULL; + void* unknown = (void*)-1; + PyObject* bases = __Pyx_PyType_GetSlot(type, tp_bases, PyObject*); + int base_depth = 0; + { + PyTypeObject* base = __Pyx_PyType_GetSlot(type, tp_base, PyTypeObject*); + while (base) { + base_depth += 1; + base = __Pyx_PyType_GetSlot(base, tp_base, PyTypeObject*); + } + } + base_vtables = (void**) PyMem_Malloc(sizeof(void*) * (size_t)(base_depth + 1)); + base_vtables[0] = unknown; +#if CYTHON_COMPILING_IN_LIMITED_API + size = PyTuple_Size(bases); + if (size < 0) goto other_failure; +#else + size = PyTuple_GET_SIZE(bases); +#endif + for (i = 1; i < size; i++) { + PyObject *basei; + void* base_vtable; +#if CYTHON_AVOID_BORROWED_REFS + basei = PySequence_GetItem(bases, i); + if (unlikely(!basei)) goto other_failure; +#elif !CYTHON_ASSUME_SAFE_MACROS + basei = PyTuple_GetItem(bases, i); + if (unlikely(!basei)) goto other_failure; +#else + basei = PyTuple_GET_ITEM(bases, i); +#endif + base_vtable = __Pyx_GetVtable((PyTypeObject*)basei); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(basei); +#endif + if (base_vtable != NULL) { + int j; + PyTypeObject* base = __Pyx_PyType_GetSlot(type, tp_base, PyTypeObject*); + for (j = 0; j < base_depth; j++) { + if (base_vtables[j] == unknown) { + base_vtables[j] = __Pyx_GetVtable(base); + base_vtables[j + 1] = unknown; + } + if (base_vtables[j] == base_vtable) { + break; + } else if (base_vtables[j] == NULL) { + goto bad; + } + base = __Pyx_PyType_GetSlot(base, tp_base, PyTypeObject*); + } + } + } + PyErr_Clear(); + PyMem_Free(base_vtables); + return 0; +bad: + { + PyTypeObject* basei = NULL; + PyTypeObject* tp_base = __Pyx_PyType_GetSlot(type, tp_base, PyTypeObject*); + tp_base_name = __Pyx_PyType_GetFullyQualifiedName(tp_base); +#if CYTHON_AVOID_BORROWED_REFS + basei = (PyTypeObject*)PySequence_GetItem(bases, i); + if (unlikely(!basei)) goto really_bad; +#elif !CYTHON_ASSUME_SAFE_MACROS + basei = (PyTypeObject*)PyTuple_GetItem(bases, i); + if (unlikely(!basei)) goto really_bad; +#else + basei = (PyTypeObject*)PyTuple_GET_ITEM(bases, i); +#endif + base_name = __Pyx_PyType_GetFullyQualifiedName(basei); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(basei); +#endif + } + PyErr_Format(PyExc_TypeError, + "multiple bases have vtable conflict: '" __Pyx_FMT_TYPENAME "' and '" __Pyx_FMT_TYPENAME "'", tp_base_name, base_name); +#if CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS +really_bad: // bad has failed! +#endif + __Pyx_DECREF_TypeName(tp_base_name); + __Pyx_DECREF_TypeName(base_name); +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS +other_failure: +#endif + PyMem_Free(base_vtables); + return -1; +} + +/* 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_GetTypeDict(tp); + if (unlikely(!tp_dict)) return -1; +#else + tp_dict = tp->tp_dict; +#endif + result = PyDict_DelItem(tp_dict, k); + if (likely(!result)) PyType_Modified(tp); + return result; +} + +/* SetupReduce */ +static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { + int ret; + PyObject *name_attr; + name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_mstate_global->__pyx_n_u_name); + if (likely(name_attr)) { + ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); + } else { + ret = -1; + } + if (unlikely(ret < 0)) { + PyErr_Clear(); + ret = 0; + } + Py_XDECREF(name_attr); + return ret; +} +static int __Pyx_setup_reduce(PyObject* type_obj) { + int ret = 0; + PyObject *object_reduce = NULL; + PyObject *object_getstate = NULL; + PyObject *object_reduce_ex = NULL; + PyObject *reduce = NULL; + PyObject *reduce_ex = NULL; + PyObject *reduce_cython = NULL; + PyObject *setstate = NULL; + PyObject *setstate_cython = NULL; + PyObject *getstate = NULL; +#if CYTHON_USE_PYTYPE_LOOKUP + getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_getstate); +#else + getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_getstate); + if (!getstate && PyErr_Occurred()) { + goto __PYX_BAD; + } +#endif + if (getstate) { +#if CYTHON_USE_PYTYPE_LOOKUP + object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_getstate); +#else + object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_getstate); + if (!object_getstate && PyErr_Occurred()) { + goto __PYX_BAD; + } +#endif + if (object_getstate != getstate) { + goto __PYX_GOOD; + } + } +#if CYTHON_USE_PYTYPE_LOOKUP + object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; +#else + object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; +#endif + reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_mstate_global->__pyx_n_u_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; + if (reduce_ex == object_reduce_ex) { +#if CYTHON_USE_PYTYPE_LOOKUP + object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_reduce); if (!object_reduce) goto __PYX_BAD; +#else + object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_reduce); if (!object_reduce) goto __PYX_BAD; +#endif + reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_mstate_global->__pyx_n_u_reduce); if (unlikely(!reduce)) goto __PYX_BAD; + if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_mstate_global->__pyx_n_u_reduce_cython)) { + reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_reduce_cython); + if (likely(reduce_cython)) { + ret = __Pyx_SetItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = __Pyx_DelItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + } else if (reduce == object_reduce || PyErr_Occurred()) { + goto __PYX_BAD; + } + setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_setstate); + if (!setstate) PyErr_Clear(); + if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_mstate_global->__pyx_n_u_setstate_cython)) { + setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_setstate_cython); + if (likely(setstate_cython)) { + ret = __Pyx_SetItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = __Pyx_DelItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + } else if (!setstate || PyErr_Occurred()) { + goto __PYX_BAD; + } + } + PyType_Modified((PyTypeObject*)type_obj); + } + } + goto __PYX_GOOD; +__PYX_BAD: + if (!PyErr_Occurred()) { + __Pyx_TypeName type_obj_name = + __Pyx_PyType_GetFullyQualifiedName((PyTypeObject*)type_obj); + PyErr_Format(PyExc_RuntimeError, + "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name); + __Pyx_DECREF_TypeName(type_obj_name); + } + ret = -1; +__PYX_GOOD: +#if !CYTHON_USE_PYTYPE_LOOKUP + Py_XDECREF(object_reduce); + Py_XDECREF(object_reduce_ex); + Py_XDECREF(object_getstate); + Py_XDECREF(getstate); +#endif + Py_XDECREF(reduce); + Py_XDECREF(reduce_ex); + Py_XDECREF(reduce_cython); + Py_XDECREF(setstate); + Py_XDECREF(setstate_cython); + return ret; +} + +/* HasAttr (used by ImportImpl) */ +#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 + +/* 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; + } + empty_dict = PyDict_New(); + if (unlikely(!empty_dict)) + goto bad; + if (imported_names) { +#if CYTHON_COMPILING_IN_CPYTHON + from_list = __Pyx_PyList_FromArray(imported_names, len_imported_names); + if (unlikely(!from_list)) + goto bad; +#else + from_list = PyList_New(len_imported_names); + if (unlikely(!from_list)) goto bad; + for (Py_ssize_t i=0; i__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__3); + 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 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); +#elif PY_VERSION_HEX >= 0x030d0000 + PyDict_SetDefaultRef(d, key, default_value, &value); +#else + value = PyDict_SetDefault(d, key, default_value); + if (unlikely(!value)) return NULL; + Py_INCREF(value); +#endif + return value; +} + +/* AddModuleRef (used by FetchSharedCythonModule) */ +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + 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) { + 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 + #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) +#else + 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); +} + +/* 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); +#if __PYX_LIMITED_VERSION_HEX >= 0x03090000 + Py_SET_TYPE(result, metaclass); +#else + result->ob_type = metaclass; +#endif + Py_DECREF(old_tp); + } + return result; +} +#else +#define __Pyx_PyType_FromMetaclass(me, mo, s, b) PyType_FromMetaclass(me, mo, s, b) +#endif +static int __Pyx_VerifyCachedType(PyObject *cached_type, + const char *name, + Py_ssize_t expected_basicsize) { + Py_ssize_t basicsize; + if (!PyType_Check(cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", name); + return -1; + } + if (expected_basicsize == 0) { + return 0; // size is inherited, nothing useful to check + } +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_basicsize; + py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); + if (unlikely(!py_basicsize)) return -1; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = NULL; + if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) return -1; +#else + basicsize = ((PyTypeObject*) cached_type)->tp_basicsize; +#endif + if (basicsize != expected_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + name); + return -1; + } + return 0; +} +static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *abi_module = NULL, *cached_type = NULL, *abi_module_dict, *new_cached_type, *py_object_name; + int get_item_ref_result; + const char* object_name = strrchr(spec->name, '.'); + object_name = object_name ? object_name+1 : spec->name; + py_object_name = PyUnicode_FromString(object_name); + if (!py_object_name) return NULL; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) goto done; + abi_module_dict = PyModule_GetDict(abi_module); + if (!abi_module_dict) goto done; + get_item_ref_result = __Pyx_PyDict_GetItemRef(abi_module_dict, py_object_name, &cached_type); + if (get_item_ref_result == 1) { + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + spec->basicsize) < 0) { + goto bad; + } + goto done; + } else if (unlikely(get_item_ref_result == -1)) { + goto bad; + } + cached_type = __Pyx_PyType_FromMetaclass( + metaclass, + CYTHON_USE_MODULE_STATE ? module : abi_module, + spec, bases); + if (unlikely(!cached_type)) goto bad; + if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad; + new_cached_type = __Pyx_PyDict_SetDefault(abi_module_dict, py_object_name, cached_type); + 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; +} + +/* 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_METH_FASTCALL && 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) */ +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunctionNoMethod(PyObject *func, void (*cfunc)(void)) { + if (__Pyx_CyFunction_Check(func)) { + return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc; + } else if (PyCFunction_Check(func)) { + return PyCFunction_GetFunction(func) == (PyCFunction) cfunc; + } + return 0; +} +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) { + if ((PyObject*)Py_TYPE(func) == __pyx_mstate_global->__Pyx_CachedMethodType) { + int result; + PyObject *newFunc = PyObject_GetAttr(func, __pyx_mstate_global->__pyx_n_u_func_2); + if (unlikely(!newFunc)) { + PyErr_Clear(); // It's only an optimization, so don't throw an error + return 0; + } + result = __Pyx__IsSameCyOrCFunctionNoMethod(newFunc, cfunc); + Py_DECREF(newFunc); + return result; + } + return __Pyx__IsSameCyOrCFunctionNoMethod(func, cfunc); +} +#else +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) { + if (PyMethod_Check(func)) { + func = PyMethod_GET_FUNCTION(func); + } + return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +} +#endif +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) { +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + __Pyx_Py_XDECREF_SET( + __Pyx_CyFunction_GetClassObj(f), + ((classobj) ? __Pyx_NewRef(classobj) : NULL)); +#else + __Pyx_Py_XDECREF_SET( + ((PyCMethodObject *) (f))->mm_class, + (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL)); +#endif +} +static PyObject * +__Pyx_CyFunction_get_doc_locked(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_doc == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_doc = PyObject_GetAttrString(op->func, "__doc__"); + if (unlikely(!op->func_doc)) return NULL; +#else + if (((PyCFunctionObject*)op)->m_ml->ml_doc) { + op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); + if (unlikely(op->func_doc == NULL)) + return NULL; + } else { + Py_INCREF(Py_None); + return Py_None; + } +#endif + } + Py_INCREF(op->func_doc); + return op->func_doc; +} +static PyObject * +__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) { + PyObject *result; + CYTHON_UNUSED_VAR(closure); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_doc_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (value == NULL) { + value = Py_None; + } + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_doc, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_name_locked(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_name == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_name = PyObject_GetAttrString(op->func, "__name__"); +#else + op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); +#endif + if (unlikely(op->func_name == NULL)) + return NULL; + } + Py_INCREF(op->func_name); + return op->func_name; +} +static PyObject * +__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) +{ + PyObject *result = NULL; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_name_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_name, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + PyObject *result; + __Pyx_BEGIN_CRITICAL_SECTION(op); + Py_INCREF(op->func_qualname); + result = op->func_qualname; + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_qualname, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +#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(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + Py_INCREF(op->func_globals); + return op->func_globals; +} +static PyObject * +__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(op); + CYTHON_UNUSED_VAR(context); + Py_INCREF(Py_None); + return Py_None; +} +static PyObject * +__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context) +{ + PyObject* result = (op->func_code) ? op->func_code : Py_None; + CYTHON_UNUSED_VAR(context); + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { + int result = 0; + PyObject *res = op->defaults_getter((PyObject *) op); + if (unlikely(!res)) + return -1; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + op->defaults_tuple = PyTuple_GET_ITEM(res, 0); + Py_INCREF(op->defaults_tuple); + op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); + Py_INCREF(op->defaults_kwdict); + #else + op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0); + if (unlikely(!op->defaults_tuple)) result = -1; + else { + op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1); + if (unlikely(!op->defaults_kwdict)) result = -1; + } + #endif + Py_DECREF(res); + return result; +} +static int +__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyTuple_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__defaults__ must be set to a tuple object"); + return -1; + } + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->defaults_tuple, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_defaults_locked(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_tuple; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_tuple; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = NULL; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_defaults_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__kwdefaults__ must be set to a dict object"); + return -1; + } + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults_locked(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_kwdict; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_kwdict; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_kwdefaults_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value || value == Py_None) { + value = NULL; + } else if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__annotations__ must be set to a dict object"); + return -1; + } + Py_XINCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_annotations, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_annotations_locked(__pyx_CyFunctionObject *op) { + PyObject* result = op->func_annotations; + if (unlikely(!result)) { + result = PyDict_New(); + if (unlikely(!result)) return NULL; + op->func_annotations = result; + } + Py_INCREF(result); + return result; +} +static PyObject * +__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { + PyObject *result; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_annotations_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static PyObject * +__Pyx_CyFunction_get_is_coroutine_value(__pyx_CyFunctionObject *op) { + int is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; + if (is_coroutine) { + PyObject *is_coroutine_value, *module, *fromlist, *marker = __pyx_mstate_global->__pyx_n_u_is_coroutine; + fromlist = PyList_New(1); + if (unlikely(!fromlist)) return NULL; + Py_INCREF(marker); +#if CYTHON_ASSUME_SAFE_MACROS + PyList_SET_ITEM(fromlist, 0, marker); +#else + if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) { + Py_DECREF(marker); + Py_DECREF(fromlist); + return NULL; + } +#endif + module = PyImport_ImportModuleLevelObject(__pyx_mstate_global->__pyx_n_u_asyncio_coroutines, NULL, NULL, fromlist, 0); + Py_DECREF(fromlist); + if (unlikely(!module)) goto ignore; + is_coroutine_value = __Pyx_PyObject_GetAttrStr(module, marker); + Py_DECREF(module); + if (likely(is_coroutine_value)) { + return is_coroutine_value; + } +ignore: + PyErr_Clear(); + } + return __Pyx_PyBool_FromLong(is_coroutine); +} +static PyObject * +__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { + PyObject *result; + CYTHON_UNUSED_VAR(context); + if (op->func_is_coroutine) { + return __Pyx_NewRef(op->func_is_coroutine); + } + result = __Pyx_CyFunction_get_is_coroutine_value(op); + if (unlikely(!result)) + return NULL; + __Pyx_BEGIN_CRITICAL_SECTION(op); + if (op->func_is_coroutine) { + Py_DECREF(result); + result = __Pyx_NewRef(op->func_is_coroutine); + } else { + op->func_is_coroutine = __Pyx_NewRef(result); + } + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static void __Pyx_CyFunction_raise_argument_count_error(__pyx_CyFunctionObject *func, const char* message, Py_ssize_t size) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_name = __Pyx_CyFunction_get_name(func, NULL); + if (!py_name) return; + PyErr_Format(PyExc_TypeError, + "%.200S() %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(__pyx_CyFunctionObject *func, const char* message) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_name = __Pyx_CyFunction_get_name(func, NULL); + if (!py_name) return; + PyErr_Format(PyExc_TypeError, + "%.200S() %s", + py_name, message); + Py_DECREF(py_name); +#else + const char* name = ((PyCFunctionObject*)func)->m_ml->ml_name; + PyErr_Format(PyExc_TypeError, + "%.200s() %s", + name, message); +#endif +} +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject * +__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_GetAttrString(op->func, "__module__"); +} +static int +__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_SetAttrString(op->func, "__module__", value); +} +#endif +static PyGetSetDef __pyx_CyFunction_getsets[] = { + {"func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {"__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {"func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {"__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {"__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, +#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}, + {"_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0}, +#if CYTHON_COMPILING_IN_LIMITED_API + {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0}, +#endif + {0, 0, 0, 0, 0} +}; +static PyMemberDef __pyx_CyFunction_members[] = { +#if !CYTHON_COMPILING_IN_LIMITED_API + {"__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, +#endif +#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API + {"__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, +#endif +#if CYTHON_METH_FASTCALL +#if CYTHON_COMPILING_IN_LIMITED_API + {"__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, +#else + {"__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + {"__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, +#else + {"__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, +#endif +#endif + {0, 0, 0, 0, 0} +}; +static PyObject * +__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args) +{ + PyObject *result = NULL; + CYTHON_UNUSED_VAR(args); + __Pyx_BEGIN_CRITICAL_SECTION(m); + Py_INCREF(m->func_qualname); + result = m->func_qualname; + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} +}; +#if CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) +#else +#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist) +#endif +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { +#if !CYTHON_COMPILING_IN_LIMITED_API + PyCFunctionObject *cf = (PyCFunctionObject*) op; +#endif + if (unlikely(op == NULL)) + return NULL; +#if CYTHON_COMPILING_IN_LIMITED_API + op->func = PyCFunction_NewEx(ml, (PyObject*)op, module); + if (unlikely(!op->func)) return NULL; +#endif + op->flags = flags; + __Pyx_CyFunction_weakreflist(op) = NULL; +#if !CYTHON_COMPILING_IN_LIMITED_API + cf->m_ml = ml; + cf->m_self = (PyObject *) op; +#endif + Py_XINCREF(closure); + op->func_closure = closure; +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_XINCREF(module); + cf->m_module = module; +#endif +#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 PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + op->func_classobj = NULL; +#else + ((PyCMethodObject*)op)->mm_class = NULL; +#endif + op->func_globals = globals; + Py_INCREF(op->func_globals); + Py_XINCREF(code); + op->func_code = code; + op->defaults = NULL; + op->defaults_tuple = NULL; + op->defaults_kwdict = NULL; + op->defaults_getter = NULL; + op->func_annotations = NULL; + op->func_is_coroutine = NULL; +#if CYTHON_METH_FASTCALL + switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) { + case METH_NOARGS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS; + break; + case METH_O: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O; + break; + case METH_METHOD | METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD; + break; + case METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS; + break; + case METH_VARARGS | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = NULL; + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + Py_DECREF(op); + return NULL; + } +#endif + return (PyObject *) op; +} +static int +__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) +{ + Py_CLEAR(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_CLEAR(m->func); +#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 +#if PY_VERSION_HEX < 0x030900B1 + Py_CLEAR(__Pyx_CyFunction_GetClassObj(m)); +#else + { + PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class; + ((PyCMethodObject *) (m))->mm_class = NULL; + Py_XDECREF(cls); + } +#endif +#endif + Py_CLEAR(m->defaults_tuple); + Py_CLEAR(m->defaults_kwdict); + Py_CLEAR(m->func_annotations); + Py_CLEAR(m->func_is_coroutine); + Py_CLEAR(m->defaults); + return 0; +} +static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + if (__Pyx_CyFunction_weakreflist(m) != NULL) + PyObject_ClearWeakRefs((PyObject *) m); + __Pyx_CyFunction_clear(m); + __Pyx_PyHeapTypeObject_GC_Del(m); +} +static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + PyObject_GC_UnTrack(m); + __Pyx__CyFunction_dealloc(m); +} +static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) +{ + { + int e = __Pyx_call_type_traverse((PyObject*)m, 1, visit, arg); + if (e) return e; + } + Py_VISIT(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(m->func); +#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); +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(__Pyx_CyFunction_GetClassObj(m)); +#endif + Py_VISIT(m->defaults_tuple); + Py_VISIT(m->defaults_kwdict); + Py_VISIT(m->func_is_coroutine); + Py_VISIT(m->defaults); + return 0; +} +static PyObject* +__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) +{ + PyObject *repr; + __Pyx_BEGIN_CRITICAL_SECTION(op); + repr = PyUnicode_FromFormat("", + op->func_qualname, (void *)op); + __Pyx_END_CRITICAL_SECTION(); + return repr; +} +static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *f = ((__pyx_CyFunctionObject*)func)->func; + PyCFunction meth; + int flags; + meth = PyCFunction_GetFunction(f); + if (unlikely(!meth)) return NULL; + flags = PyCFunction_GetFlags(f); + if (unlikely(flags < 0)) return NULL; +#else + PyCFunctionObject* f = (PyCFunctionObject*)func; + PyCFunction meth = f->m_ml->ml_meth; + int flags = f->m_ml->ml_flags; +#endif + Py_ssize_t size; + switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { + case METH_VARARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) + return (*meth)(self, arg); + break; + case METH_VARARGS | METH_KEYWORDS: + return (*(PyCFunctionWithKeywords)(void(*)(void))meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_SIZE + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 0)) + return (*meth)(self, NULL); + __Pyx_CyFunction_raise_argument_count_error( + (__pyx_CyFunctionObject*)func, + "takes no arguments", size); + return NULL; + } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_SIZE + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 1)) { + PyObject *result, *arg0; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + arg0 = PyTuple_GET_ITEM(arg, 0); + #else + arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL; + #endif + result = (*meth)(self, arg0); + #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) + Py_DECREF(arg0); + #endif + return result; + } + __Pyx_CyFunction_raise_argument_count_error( + (__pyx_CyFunctionObject*)func, + "takes exactly one argument", size); + return NULL; + } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + return NULL; + } + __Pyx_CyFunction_raise_type_error( + (__pyx_CyFunctionObject*)func, "takes no keyword arguments"); + return NULL; +} +static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *self, *result; +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)func)->m_self; +#endif + result = __Pyx_CyFunction_CallMethod(func, self, arg, kw); + return result; +} +static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { + PyObject *result; + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; +#if CYTHON_METH_FASTCALL && CYTHON_VECTORCALL + __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_METH_FASTCALL && CYTHON_VECTORCALL +static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames) +{ + int ret = 0; + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + if (unlikely(nargs < 1)) { + __Pyx_CyFunction_raise_type_error( + cyfunc, "needs an argument"); + return -1; + } + ret = 1; + } + if (unlikely(kwnames) && unlikely(__Pyx_PyTuple_GET_SIZE(kwnames))) { + __Pyx_CyFunction_raise_type_error( + cyfunc, "takes no keyword arguments"); + return -1; + } + return ret; +} +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif + break; + default: + return NULL; + } + if (unlikely(nargs != 0)) { + __Pyx_CyFunction_raise_argument_count_error( + cyfunc, "takes no arguments", nargs); + return NULL; + } + return meth(self, NULL); +} +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif + break; + default: + return NULL; + } + if (unlikely(nargs != 1)) { + __Pyx_CyFunction_raise_argument_count_error( + cyfunc, "takes exactly one argument", nargs); + return NULL; + } + return meth(self, args[0]); +} +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif + break; + default: + return NULL; + } + return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))meth)(self, args, nargs, kwnames); +} +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc); + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif + break; + default: + return NULL; + } + #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", + sizeof(__pyx_CyFunctionObject), + 0, +#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR + Py_TPFLAGS_METHOD_DESCRIPTOR | +#endif +#if CYTHON_METH_FASTCALL +#if defined(Py_TPFLAGS_HAVE_VECTORCALL) + Py_TPFLAGS_HAVE_VECTORCALL | +#elif defined(_Py_TPFLAGS_HAVE_VECTORCALL) + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif +#endif // CYTHON_METH_FASTCALL +#if PY_VERSION_HEX >= 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; +} +static CYTHON_INLINE PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func, PyTypeObject *defaults_type) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults = PyObject_CallObject((PyObject*)defaults_type, NULL); // _PyObject_New(defaults_type); + if (unlikely(!m->defaults)) + return NULL; + return m->defaults; +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_tuple = tuple; + Py_INCREF(tuple); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_kwdict = dict; + Py_INCREF(dict); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->func_annotations = dict; + Py_INCREF(dict); +} + +/* CythonFunction */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + PyObject *op = __Pyx_CyFunction_Init( + PyObject_GC_New(__pyx_CyFunctionObject, __pyx_mstate_global->__pyx_CyFunctionType), + ml, flags, qualname, closure, module, globals, code + ); + if (likely(op)) { + PyObject_GC_Track(op); + } + return op; +} + +/* 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; + } + PyErr_Clear(); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL; + PyObject *replace = NULL, *getframe = NULL, *frame = NULL; + PyObject *exc_type, *exc_value, *exc_traceback; + int success = 0; + if (c_line) { + c_line = __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); + } + PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); + code_object = __pyx_find_code_object(c_line ? -c_line : py_line); + if (!code_object) { + code_object = Py_CompileString("_getframe()", filename, Py_eval_input); + if (unlikely(!code_object)) goto bad; + py_py_line = PyLong_FromLong(py_line); + if (unlikely(!py_py_line)) goto bad; + 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: + PyErr_Restore(exc_type, exc_value, exc_traceback); + Py_XDECREF(code_object); + Py_XDECREF(py_py_line); + Py_XDECREF(py_funcname); + Py_XDECREF(dict); + Py_XDECREF(replace); + if (success) { + PyTraceBack_Here( + (struct _frame*)frame); + } + Py_XDECREF(frame); +} +#else +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = NULL; + PyObject *py_funcname = NULL; + if (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;\ + } + +/* CIntToPy */ +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_uint64_t(uint64_t value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const uint64_t neg_one = (uint64_t) -1, const_zero = (uint64_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(uint64_t) < sizeof(long)) { + return PyLong_FromLong((long) value); + } else if (sizeof(uint64_t) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#if !CYTHON_COMPILING_IN_PYPY + } else if (sizeof(uint64_t) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(uint64_t) <= sizeof(long)) { + return PyLong_FromLong((long) value); + } else if (sizeof(uint64_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(uint64_t), + little, !is_unsigned); +#else + int one = 1; int little = (int)*(unsigned char *)&one; + PyObject *from_bytes, *result = NULL, *kwds = NULL; + PyObject *py_bytes = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(uint64_t)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + { + PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str }; + if (!is_unsigned) { + kwds = __Pyx_MakeVectorcallBuilderKwds(1); + if (!kwds) goto limited_bad; + if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad; + } + result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); + } + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif + } +} + +/* CIntFromPy */ +static CYTHON_INLINE uint64_t __Pyx_PyLong_As_uint64_t(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const uint64_t neg_one = (uint64_t) -1, const_zero = (uint64_t) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (unlikely(!PyLong_Check(x))) { + uint64_t val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (uint64_t) -1; + val = __Pyx_PyLong_As_uint64_t(tmp); + Py_DECREF(tmp); + return val; + } + 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(uint64_t, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(uint64_t) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(uint64_t) >= 2 * PyLong_SHIFT)) { + return (uint64_t) (((((uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])); + } + } + break; + case 3: + if ((8 * sizeof(uint64_t) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(uint64_t) >= 3 * PyLong_SHIFT)) { + return (uint64_t) (((((((uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])); + } + } + break; + case 4: + if ((8 * sizeof(uint64_t) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(uint64_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(uint64_t) >= 4 * PyLong_SHIFT)) { + return (uint64_t) (((((((((uint64_t)digits[3]) << PyLong_SHIFT) | (uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])); + } + } + break; + } + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (uint64_t) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if ((sizeof(uint64_t) <= sizeof(unsigned long))) { + __PYX_VERIFY_RETURN_INT_EXC(uint64_t, unsigned long, PyLong_AsUnsignedLong(x)) + } else if ((sizeof(uint64_t) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(uint64_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(uint64_t, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(uint64_t) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(uint64_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(uint64_t) - 1 > 2 * PyLong_SHIFT)) { + return (uint64_t) (((uint64_t)-1)*(((((uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0]))); + } + } + break; + case 2: + if ((8 * sizeof(uint64_t) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(uint64_t) - 1 > 2 * PyLong_SHIFT)) { + return (uint64_t) ((((((uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0]))); + } + } + break; + case -3: + if ((8 * sizeof(uint64_t) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(uint64_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(uint64_t) - 1 > 3 * PyLong_SHIFT)) { + return (uint64_t) (((uint64_t)-1)*(((((((uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0]))); + } + } + break; + case 3: + if ((8 * sizeof(uint64_t) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(uint64_t) - 1 > 3 * PyLong_SHIFT)) { + return (uint64_t) ((((((((uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0]))); + } + } + break; + case -4: + if ((8 * sizeof(uint64_t) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(uint64_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(uint64_t) - 1 > 4 * PyLong_SHIFT)) { + return (uint64_t) (((uint64_t)-1)*(((((((((uint64_t)digits[3]) << PyLong_SHIFT) | (uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0]))); + } + } + break; + case 4: + if ((8 * sizeof(uint64_t) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(uint64_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(uint64_t) - 1 > 4 * PyLong_SHIFT)) { + return (uint64_t) ((((((((((uint64_t)digits[3]) << PyLong_SHIFT) | (uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0]))); + } + } + break; + } + } +#endif + if ((sizeof(uint64_t) <= sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(uint64_t, long, PyLong_AsLong(x)) + } else if ((sizeof(uint64_t) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(uint64_t, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { + uint64_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); +#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 (uint64_t) -1; + assert(PyLong_CheckExact(v)); + } + { + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { + Py_DECREF(v); + return (uint64_t) -1; + } + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (uint64_t) -1; + } else { + stepval = v; + } + v = NULL; + val = (uint64_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(uint64_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 |= ((uint64_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(uint64_t) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((uint64_t) idigit) << bits; + } + if (!is_unsigned) { + if (unlikely(val & (((uint64_t) 1) << (sizeof(uint64_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 (uint64_t) -1; + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to uint64_t"); + return (uint64_t) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to uint64_t"); + return (uint64_t) -1; +} + +/* 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 *from_bytes, *result = NULL, *kwds = NULL; + PyObject *py_bytes = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + { + PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str }; + if (!is_unsigned) { + kwds = __Pyx_MakeVectorcallBuilderKwds(1); + if (!kwds) goto limited_bad; + if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad; + } + result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); + } + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif + } +} + +/* CIntFromPy */ +static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (unlikely(!PyLong_Check(x))) { + int val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (int) -1; + val = __Pyx_PyLong_As_int(tmp); + Py_DECREF(tmp); + return val; + } + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if ((sizeof(int) <= sizeof(unsigned long))) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) + } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(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 { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } + } +#endif + if ((sizeof(int) <= sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) + } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { + int val; + int ret = -1; +#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } +#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (int) -1; + assert(PyLong_CheckExact(v)); + } + { + 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); + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (int) -1; + } else { + stepval = v; + } + v = NULL; + val = (int) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((int) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((int) idigit) << bits; + } + if (!is_unsigned) { + if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif + if (unlikely(ret)) + return (int) -1; + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +/* CIntToPy */ +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_unsigned_int(unsigned int value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const unsigned int neg_one = (unsigned int) -1, const_zero = (unsigned 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(unsigned int) < sizeof(long)) { + return PyLong_FromLong((long) value); + } else if (sizeof(unsigned int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#if !CYTHON_COMPILING_IN_PYPY + } else if (sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(unsigned int) <= sizeof(long)) { + return PyLong_FromLong((long) value); + } else if (sizeof(unsigned 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(unsigned int), + little, !is_unsigned); +#else + int one = 1; int little = (int)*(unsigned char *)&one; + PyObject *from_bytes, *result = NULL, *kwds = NULL; + PyObject *py_bytes = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(unsigned int)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + { + PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str }; + if (!is_unsigned) { + kwds = __Pyx_MakeVectorcallBuilderKwds(1); + if (!kwds) goto limited_bad; + if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad; + } + result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); + } + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif + } +} + +/* 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 *from_bytes, *result = NULL, *kwds = NULL; + PyObject *py_bytes = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + { + PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str }; + if (!is_unsigned) { + kwds = __Pyx_MakeVectorcallBuilderKwds(1); + if (!kwds) goto limited_bad; + if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad; + } + result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); + } + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif + } +} + +/* CIntFromPy */ +static CYTHON_INLINE unsigned int __Pyx_PyLong_As_unsigned_int(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const unsigned int neg_one = (unsigned int) -1, const_zero = (unsigned int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (unlikely(!PyLong_Check(x))) { + unsigned int val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (unsigned int) -1; + val = __Pyx_PyLong_As_unsigned_int(tmp); + Py_DECREF(tmp); + return val; + } + 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(unsigned int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(unsigned int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) >= 2 * PyLong_SHIFT)) { + return (unsigned int) (((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); + } + } + break; + case 3: + if ((8 * sizeof(unsigned int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) >= 3 * PyLong_SHIFT)) { + return (unsigned int) (((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); + } + } + break; + case 4: + if ((8 * sizeof(unsigned int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned 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(unsigned int) >= 4 * PyLong_SHIFT)) { + return (unsigned int) (((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); + } + } + break; + } + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (unsigned int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if ((sizeof(unsigned int) <= sizeof(unsigned long))) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned long, PyLong_AsUnsignedLong(x)) + } else if ((sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(unsigned int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(unsigned int) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT)) { + return (unsigned int) (((unsigned int)-1)*(((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } + break; + case 2: + if ((8 * sizeof(unsigned int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT)) { + return (unsigned int) ((((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } + break; + case -3: + if ((8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT)) { + return (unsigned int) (((unsigned int)-1)*(((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } + break; + case 3: + if ((8 * sizeof(unsigned int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT)) { + return (unsigned int) ((((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } + break; + case -4: + if ((8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT)) { + return (unsigned int) (((unsigned int)-1)*(((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } + break; + case 4: + if ((8 * sizeof(unsigned int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned 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(unsigned int) - 1 > 4 * PyLong_SHIFT)) { + return (unsigned int) ((((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } + break; + } + } +#endif + if ((sizeof(unsigned int) <= sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned int, long, PyLong_AsLong(x)) + } else if ((sizeof(unsigned int) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned int, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { + unsigned int val; + int ret = -1; +#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } +#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (unsigned int) -1; + assert(PyLong_CheckExact(v)); + } + { + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { + Py_DECREF(v); + return (unsigned int) -1; + } + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (unsigned int) -1; + } else { + stepval = v; + } + v = NULL; + val = (unsigned 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(unsigned 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 |= ((unsigned 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(unsigned int) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((unsigned int) idigit) << bits; + } + if (!is_unsigned) { + if (unlikely(val & (((unsigned int) 1) << (sizeof(unsigned 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 (unsigned int) -1; + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to unsigned int"); + return (unsigned int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to unsigned int"); + return (unsigned int) -1; +} + +/* FormatTypeName */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 +static __Pyx_TypeName +__Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp) +{ + PyObject *module = NULL, *name = NULL, *result = NULL; + #if __PYX_LIMITED_VERSION_HEX < 0x030b0000 + name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_mstate_global->__pyx_n_u_qualname); + #else + name = PyType_GetQualName(tp); + #endif + if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) goto bad; + module = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_mstate_global->__pyx_n_u_module); + if (unlikely(module == NULL) || unlikely(!PyUnicode_Check(module))) goto bad; + if (PyUnicode_CompareWithASCIIString(module, "builtins") == 0) { + result = name; + name = NULL; + goto done; + } + result = PyUnicode_FromFormat("%U.%U", module, name); + if (unlikely(result == NULL)) goto bad; + done: + Py_XDECREF(name); + Py_XDECREF(module); + return result; + bad: + PyErr_Clear(); + if (name) { + result = name; + name = NULL; + } else { + result = __Pyx_NewRef(__pyx_mstate_global->__pyx_kp_u__4); + } + goto done; +} +#endif + +/* CIntFromPy */ +static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (unlikely(!PyLong_Check(x))) { + long val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (long) -1; + val = __Pyx_PyLong_As_long(tmp); + Py_DECREF(tmp); + return val; + } + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if ((sizeof(long) <= sizeof(unsigned long))) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) + } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(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 { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } + } +#endif + if ((sizeof(long) <= sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) + } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { + long val; + int ret = -1; +#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } +#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (long) -1; + assert(PyLong_CheckExact(v)); + } + { + 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); + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (long) -1; + } else { + stepval = v; + } + v = NULL; + val = (long) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((long) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((long) idigit) << bits; + } + if (!is_unsigned) { + if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif + if (unlikely(ret)) + return (long) -1; + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +/* FastTypeChecks */ +#if CYTHON_COMPILING_IN_CPYTHON +static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { + while (a) { + a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*); + if (a == b) + return 1; + } + return b == &PyBaseObject_Type; +} +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (a == b) return 1; + mro = a->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(a, b); +} +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (cls == a || cls == b) return 1; + mro = cls->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + PyObject *base = PyTuple_GET_ITEM(mro, i); + if (base == (PyObject *)a || base == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b); +} +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>= 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 +} + +/* 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; + PyObject *type, *value, *traceback; + PyErr_Fetch(&type, &value, &traceback); + #if __PYX_LIMITED_VERSION_HEX >= 0x030b0000 + minor_version = 11; + #else + if (!(version_info = PySys_GetObject("version_info"))) goto end; + if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; + minor_version = PyLong_AsLong(py_minor_version); + Py_DECREF(py_minor_version); + if (minor_version == -1 && PyErr_Occurred()) goto end; + #endif + if (!(types_module = PyImport_ImportModule("types"))) goto end; + if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; + if (minor_version <= 7) { + (void)p; + result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOOO", a, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else if (minor_version <= 10) { + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOOO", a,p, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else { + 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 (type) { + PyErr_Restore(type, value, traceback); + } + return result; + } +#elif PY_VERSION_HEX >= 0x030B0000 + static PyCodeObject* __Pyx__PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyCodeObject *result; + result = + #if PY_VERSION_HEX >= 0x030C0000 + PyUnstable_Code_NewWithPosOnlyArgs + #else + PyCode_NewWithPosOnlyArgs + #endif + (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, __pyx_mstate_global->__pyx_empty_bytes); + #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 */ +static PyObject *__Pyx_DecompressString(const char *s, Py_ssize_t length, int algo) { + PyObject *module, *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)) return NULL; + 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; +} + +#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 (PyLong_Check(result)) { + if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME "). " + "The ability to return an instance of a strict subclass of int is deprecated, " + "and may be removed in a future version of Python.", + result_type_name)) { + __Pyx_DECREF_TypeName(result_type_name); + Py_DECREF(result); + return NULL; + } + __Pyx_DECREF_TypeName(result_type_name); + return result; + } + PyErr_Format(PyExc_TypeError, + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ")", + result_type_name); + __Pyx_DECREF_TypeName(result_type_name); + Py_DECREF(result); + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_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_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(__Pyx_PyLong_IsCompact(b))) { + return __Pyx_PyLong_CompactValue(b); + } else { + const digit* digits = __Pyx_PyLong_Digits(b); + const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b); + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = 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(__Pyx_PyInterpreterState_Get()); + if (interpreter_id == -1) return NULL; +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData* data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data); + { + __pyx_atomic_incr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); + if (likely(data)) { + __Pyx_ModuleStateLookupData* new_data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_acquire(&__Pyx_ModuleStateLookup_data); + if (likely(data == new_data)) { + goto read_finished; + } + } + __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); + __Pyx_ModuleStateLookup_Lock(); + __pyx_atomic_incr_relaxed(&__Pyx_ModuleStateLookup_read_counter); + data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data); + __Pyx_ModuleStateLookup_Unlock(); + } + read_finished:; +#else + __Pyx_ModuleStateLookupData* data = __Pyx_ModuleStateLookup_data; +#endif + __Pyx_InterpreterIdAndModule* found = NULL; + if (unlikely(!data)) goto end; + if (data->interpreter_id_as_index) { + if (interpreter_id < data->count) { + found = data->table+interpreter_id; + } + } else { + found = __Pyx_State_FindModuleStateLookupTableLowerBound( + data->table, data->count, interpreter_id); + } + end: + { + PyObject *result=NULL; + if (found && found->id == interpreter_id) { + result = found->module; + } +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); +#endif + return result; + } +} +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +static void __Pyx_ModuleStateLookup_wait_until_no_readers(void) { + while (__pyx_atomic_load(&__Pyx_ModuleStateLookup_read_counter) != 0); +} +#else +#define __Pyx_ModuleStateLookup_wait_until_no_readers() +#endif +static int __Pyx_State_AddModuleInterpIdAsIndex(__Pyx_ModuleStateLookupData **old_data, PyObject* module, int64_t interpreter_id) { + Py_ssize_t to_allocate = (*old_data)->allocated; + while (to_allocate <= interpreter_id) { + if (to_allocate == 0) to_allocate = 1; + else to_allocate *= 2; + } + __Pyx_ModuleStateLookupData *new_data = *old_data; + if (to_allocate != (*old_data)->allocated) { + new_data = (__Pyx_ModuleStateLookupData *)realloc( + *old_data, + sizeof(__Pyx_ModuleStateLookupData)+(to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule)); + if (!new_data) { + PyErr_NoMemory(); + return -1; + } + for (Py_ssize_t i = new_data->allocated; i < to_allocate; ++i) { + new_data->table[i].id = i; + new_data->table[i].module = NULL; + } + new_data->allocated = to_allocate; + } + new_data->table[interpreter_id].module = module; + if (new_data->count < interpreter_id+1) { + new_data->count = interpreter_id+1; + } + *old_data = new_data; + return 0; +} +static void __Pyx_State_ConvertFromInterpIdAsIndex(__Pyx_ModuleStateLookupData *data) { + __Pyx_InterpreterIdAndModule *read = data->table; + __Pyx_InterpreterIdAndModule *write = data->table; + __Pyx_InterpreterIdAndModule *end = read + data->count; + for (; readmodule) { + write->id = read->id; + write->module = read->module; + ++write; + } + } + data->count = write - data->table; + for (; writeid = 0; + write->module = NULL; + } + data->interpreter_id_as_index = 0; +} +static int __Pyx_State_AddModule(PyObject* module, CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get()); + if (interpreter_id == -1) return -1; + int result = 0; + __Pyx_ModuleStateLookup_Lock(); +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData *old_data = (__Pyx_ModuleStateLookupData *) + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0); +#else + __Pyx_ModuleStateLookupData *old_data = __Pyx_ModuleStateLookup_data; +#endif + __Pyx_ModuleStateLookupData *new_data = old_data; + if (!new_data) { + new_data = (__Pyx_ModuleStateLookupData *)calloc(1, sizeof(__Pyx_ModuleStateLookupData)); + if (!new_data) { + result = -1; + PyErr_NoMemory(); + goto end; + } + new_data->allocated = 1; + new_data->interpreter_id_as_index = 1; + } + __Pyx_ModuleStateLookup_wait_until_no_readers(); + if (new_data->interpreter_id_as_index) { + if (interpreter_id < __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE) { + result = __Pyx_State_AddModuleInterpIdAsIndex(&new_data, module, interpreter_id); + goto end; + } + __Pyx_State_ConvertFromInterpIdAsIndex(new_data); + } + { + Py_ssize_t insert_at = 0; + { + __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound( + new_data->table, new_data->count, interpreter_id); + assert(lower_bound); + insert_at = lower_bound - new_data->table; + if (unlikely(insert_at < new_data->count && lower_bound->id == interpreter_id)) { + lower_bound->module = module; + goto end; // already in table, nothing more to do + } + } + if (new_data->count+1 >= new_data->allocated) { + Py_ssize_t to_allocate = (new_data->count+1)*2; + new_data = + (__Pyx_ModuleStateLookupData*)realloc( + new_data, + sizeof(__Pyx_ModuleStateLookupData) + + (to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule)); + if (!new_data) { + result = -1; + new_data = old_data; + PyErr_NoMemory(); + goto end; + } + new_data->allocated = to_allocate; + } + ++new_data->count; + int64_t last_id = interpreter_id; + PyObject *last_module = module; + for (Py_ssize_t i=insert_at; icount; ++i) { + int64_t current_id = new_data->table[i].id; + new_data->table[i].id = last_id; + last_id = current_id; + PyObject *current_module = new_data->table[i].module; + new_data->table[i].module = last_module; + last_module = current_module; + } + } + end: +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, new_data); +#else + __Pyx_ModuleStateLookup_data = new_data; +#endif + __Pyx_ModuleStateLookup_Unlock(); + return result; +} +static int __Pyx_State_RemoveModule(CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get()); + if (interpreter_id == -1) return -1; + __Pyx_ModuleStateLookup_Lock(); +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData *data = (__Pyx_ModuleStateLookupData *) + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0); +#else + __Pyx_ModuleStateLookupData *data = __Pyx_ModuleStateLookup_data; +#endif + if (data->interpreter_id_as_index) { + if (interpreter_id < data->count) { + data->table[interpreter_id].module = NULL; + } + goto done; + } + { + __Pyx_ModuleStateLookup_wait_until_no_readers(); + __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound( + data->table, data->count, interpreter_id); + if (!lower_bound) goto done; + if (lower_bound->id != interpreter_id) goto done; + __Pyx_InterpreterIdAndModule *end = data->table+data->count; + for (;lower_boundid = (lower_bound+1)->id; + lower_bound->module = (lower_bound+1)->module; + } + } + --data->count; + if (data->count == 0) { + free(data); + data = NULL; + } + done: +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, data); +#else + __Pyx_ModuleStateLookup_data = data; +#endif + __Pyx_ModuleStateLookup_Unlock(); + return 0; +} +#endif + +/* #### Code section: utility_code_pragmas_end ### */ +#ifdef _MSC_VER +#pragma warning( pop ) +#endif + + + +/* #### Code section: end ### */ +#endif /* Py_PYTHON_H */ diff --git a/src/polluck_blockchain/placeholder_native.pyx b/src/dopt_pollublock_blockchain/blockchain.pyx similarity index 62% rename from src/polluck_blockchain/placeholder_native.pyx rename to src/dopt_pollublock_blockchain/blockchain.pyx index f333105..a3631e2 100644 --- a/src/polluck_blockchain/placeholder_native.pyx +++ b/src/dopt_pollublock_blockchain/blockchain.pyx @@ -5,40 +5,39 @@ from __future__ import annotations import datetime -import hashlib -import struct -import time +from pathlib import Path -import cython import dopt_basics.datetime +import sqlalchemy as sql +from dopt_pollublock_blockchain import db -# from cython.cimports.cpython.ref import Py_INCREF, PyObject -from polluck_blockchain.block cimport Block + +from dopt_pollublock_blockchain.block cimport Block from libcpp.unordered_map cimport unordered_map +from libcpp.vector cimport vector from libcpp.string cimport string from libc.stdint cimport uint64_t from libc.stdlib cimport malloc, free from libc.string cimport memcpy from cython.operator import postincrement, dereference -cimport polluck_blockchain.openssl_evp as ossl -# from cython.parallel cimport prange +cimport dopt_pollublock_blockchain.openssl_evp as ossl ctypedef unsigned long ULong ctypedef unordered_map[uint64_t, Block*] BcHashmap cdef const size_t NONCE_OFFSET = 16 + cdef timestamp_to_datetime(uint64_t ts): return datetime.datetime.fromtimestamp(float(ts), dopt_basics.datetime.TIMEZONE_UTC) + cdef uint64_t current_timestamp_integer(): cdef uint64_t ts dt = dopt_basics.datetime.current_time_tz(cut_microseconds=True) ts = int(dt.timestamp()) return ts -# cdef float_to_bytes(double num): -# return struct.pack(">d", num) cdef int serialize_uint32(unsigned char* out, unsigned int v) except -1 nogil: out[0] = (v >> 24) & 0xFF @@ -46,6 +45,7 @@ cdef int serialize_uint32(unsigned char* out, unsigned int v) except -1 nogil: out[2] = (v >> 8) & 0xFF out[3] = v & 0xFF + cdef int serialize_uint64(unsigned char* out, unsigned long long v) except -1 nogil: out[0] = (v >> 56) & 0xFF out[1] = (v >> 48) & 0xFF @@ -71,6 +71,7 @@ cdef inline bint has_leading_zero_bits(const unsigned char *digest, int num_bits return True + cdef inline bint has_leading_zero_bytes(const unsigned char *digest, int num_bytes) nogil: cdef int i, full_bytes = num_bytes // 8 cdef int rem_bits = num_bytes % 8 @@ -98,13 +99,13 @@ cdef class PyBlock: if not from_ptr: self.BlockC = new Block( index, - int(datetime.datetime(2025, 12, 1, 12, 0, 0).timestamp()), + current_timestamp_integer(), nonce, data.encode("UTF-8"), previous_hash.encode("UTF-8"), "".encode("UTF-8"), ) - if self.BlockC == NULL: + if self.BlockC is NULL: raise MemoryError() self.ptr_owner = True @@ -133,11 +134,26 @@ cdef class PyBlock: return py_block def __repr__(self): - return f"PyBlock({self.index, self.timestamp, self.nonce, self.data})" + return ( + f"PyBlock(\n\tIndex:\t\t{self.index}\n\ttimestamp:\t{self.timestamp}\n\tnonce:\t\t{self.nonce}\n\t" + f"Prev Hash:\t{self.prev_hash}\n\tHash:\t\t{self.hash}\n\tData:\t\t{self.data}\n)" + ) def __str__(self): return self.__repr__() + def serialize_dict(self): + contents = {} + + contents["index"] = self.BlockC.index + contents["timestamp"] = self.BlockC.timestamp + contents["nonce"] = self.BlockC.nonce + contents["previous_hash"] = self.prev_hash + contents["hash"] = self.hash + contents["data"] = self.data + + return contents + # Python public API @property def index(self): @@ -181,7 +197,7 @@ cdef class PyBlock: try: digest = perform_hash_c(self.BlockC, &digest_size) - if digest == NULL: + if digest is NULL: raise MemoryError() # TODO out: hash assignment in blockchain self.BlockC.hash = bytes(digest[:digest_size]).hex().encode("UTF-8") @@ -205,7 +221,7 @@ cdef unsigned char* bytes_serialize_c(Block *block, size_t *size) nogil: ) buf = malloc(size[0] * sizeof(unsigned char)) - if buf == NULL: + if buf is NULL: return NULL serialize_uint64(buf + pos, block.index) @@ -233,10 +249,10 @@ cdef unsigned char* bytes_serialize_c(Block *block, size_t *size) nogil: cdef unsigned char* SHA256_digest(const void *data, size_t data_size, size_t *digest_size) nogil: cdef ossl.EVP_MD_CTX *ctx = ossl.EVP_MD_CTX_new() - if ctx == NULL: + if ctx is NULL: return NULL cdef const ossl.EVP_MD *algo = ossl.EVP_sha256() - if algo == NULL: + if algo is NULL: return NULL cdef: @@ -263,11 +279,11 @@ cdef unsigned char* perform_hash_c(Block *block, size_t *digest_size) nogil: unsigned char *digest serialize_res = bytes_serialize_c(block, &serialize_size) - if serialize_res == NULL: + if serialize_res is NULL: return NULL digest = SHA256_digest(serialize_res, serialize_size, digest_size) free(serialize_res) - if digest == NULL: + if digest is NULL: return NULL return digest @@ -305,34 +321,116 @@ cdef int mine_block(Block *block, unsigned int difficulty, uint64_t *nonce_solut cdef class Blockchain: - cdef unsigned int _difficulty - cdef uint64_t _index - cdef BcHashmap *_chain - cdef bint _genesis_done + cdef: + unsigned int _difficulty + uint64_t _index + BcHashmap *_chain_map + vector[Block*] *_chain + bint _genesis_done + bint _loaded + readonly object db_path + readonly object _engine - def __cinit__(self): + def __cinit__(self, *args, **kwargs): self._difficulty = 26 self._index = 0 - self._genesis_done = 0 - self._chain = new unordered_map[uint64_t, Block*]() - if self._chain is NULL: + self._genesis_done = False + self._loaded = False + self._chain_map = new unordered_map[uint64_t, Block*]() + self._chain = new vector[Block*]() + if self._chain_map is NULL: raise MemoryError("Could not allocate hasmap") + if self._chain is NULL: + raise MemoryError("Could not allocate vector") - def __init__(self, *args, **kwargs): - # self.db_path = db_path - pass + def __init__(self, db_path): + self.db_path = Path(db_path).resolve() + if not self.db_path.parent.exists(): + raise FileNotFoundError( + "The parent directory of the provided database path does not exist" + ) + + self._engine = sql.create_engine(f"sqlite:///{str(self.db_path)}") + db.metadata_blockchain.create_all(self._engine) def __dealloc__(self): # ownership is typically not transferred from the Blockchain extension class - cdef BcHashmap.iterator it = self._chain.begin() - if self._chain is not NULL: - while it != self._chain.end(): + cdef BcHashmap.iterator it = self._chain_map.begin() + if self._chain_map is not NULL: + while it != self._chain_map.end(): del dereference(it).second postincrement(it) + del self._chain_map + self._chain_map = NULL + + if self._chain is not NULL: del self._chain self._chain = NULL + cdef Block* get_block_c(self, uint64_t idx) nogil: + if idx > self._index: + return NULL + return self._chain_map[0][idx] + + cdef void add_block_from_loading(self, Block *block) nogil: + self._chain[0].push_back(block) + self._chain_map[0][block.index] = block + self._index = block.index + if not self._genesis_done: + self._genesis_done = True + + cdef int add_block(self, Block *block) nogil: + cdef: + uint64_t mined_nonce + size_t digest_size + unsigned char *sha256_digest + # mine block + if mine_block(block, self._difficulty, &mined_nonce) != 0: + return 1 + block.nonce = mined_nonce + # hash block, add hash to block, add block to blockchain hashmap + sha256_digest = perform_hash_c(block, &digest_size) + with gil: + block.hash = bytes(sha256_digest[:digest_size]).hex().encode("UTF-8") + free(sha256_digest) + self._chain[0].push_back(block) + self._chain_map[0][block.index] = block + + if self._genesis_done: + self._index += 1 + + return 0 + + cdef string hash_data(self, data): + cdef: + string data_str + unsigned char *data_digest + size_t digest_size + data_str = data.encode("UTF-8") + data_digest = SHA256_digest(data_str.c_str(), data_str.size(), &digest_size) + if data_digest is NULL: + raise RuntimeError("Failed to hash data") + data_str = bytes(data_digest[:digest_size]).hex().encode("UTF-8") + free(data_digest) + + return data_str + + cdef load_from_batch(self, batch): + cdef Block *block + + for entry in batch: + block = new Block( + entry[0], + entry[1], + entry[2], + entry[5].encode("UTF-8"), + entry[3].encode("UTF-8"), + entry[4].encode("UTF-8"), + ) + self.add_block_from_loading(block) + + # // Python public API def __len__(self): return self._index + 1 @@ -356,73 +454,55 @@ cdef class Blockchain: def index(self): return self._index - def print_key_value_pair(self): - cdef BcHashmap.iterator it = self._chain.begin() + def _print_key_value_pair(self): + cdef BcHashmap.iterator it = self._chain_map.begin() cdef Block *block - while it != self._chain.end(): + while it != self._chain_map.end(): print(dereference(it).first) block = dereference(it).second py_block = PyBlock.from_ptr(block) print(py_block) postincrement(it) - cdef Block* get_block_c(self, uint64_t idx) nogil: - if idx > self._index: - return NULL - return self._chain[0][idx] - - cdef int add_block(self, Block *block) nogil: + def print_blocks(self, max_num): cdef: - uint64_t mined_nonce - size_t digest_size - unsigned char *sha256_digest - # mine block - if mine_block(block, self._difficulty, &mined_nonce) != 0: - return 1 - block.nonce = mined_nonce - # hash block, add hash to block, add block to blockchain hashmap - sha256_digest = perform_hash_c(block, &digest_size) - with gil: - block.hash = bytes(sha256_digest[:digest_size]).hex().encode("UTF-8") - free(sha256_digest) - self._chain[0][block.index] = block + Block *block + int max_nummber = max_num + int idx, num = 0 - if self._genesis_done: - self._index += 1 + if max_num <= 0: + raise ValueError("Maximum number must be greater than 0") + + for idx in range(self._chain[0].size()): + block = self._chain[0][idx] + py_block = PyBlock.from_ptr(block) + print(py_block) + num += 1 + if num == max_nummber: + break - return 0 - - # // Python public API def get_block(self, idx): if idx < 0 or idx > self._index: raise IndexError("Index value is out of bounds") cdef Block *block = self.get_block_c(idx) - if block == NULL: + if block is NULL: raise IndexError("Provided index not found") return PyBlock.from_ptr(block, owner=False) - cdef string hash_data(self, data): - cdef: - string data_str - unsigned char *data_digest - size_t digest_size - data_str = data.encode("UTF-8") - data_digest = SHA256_digest(data_str.c_str(), data_str.size(), &digest_size) - if data_digest == NULL: - raise RuntimeError("Failed to hash data") - data_str = bytes(data_digest[:digest_size]).hex().encode("UTF-8") - free(data_digest) - - return data_str - def create_genesis_block(self): + if self._genesis_done: + raise RuntimeError( + ("Blockchain already has a genesis block. " + "Either it was created or loaded.") + ) + genesis_prev_hash = ("0" * 64).encode("UTF-8") cdef string data_str = self.hash_data("Genesis Block") cdef Block *block = new Block( self._index, - int(datetime.datetime(2025, 12, 1, 12, 0, 0).timestamp()), + current_timestamp_integer(), 0, data_str, genesis_prev_hash, @@ -449,12 +529,12 @@ cdef class Blockchain: data_str = self.hash_data(data) prev_block = self.get_block_c(self._index) - prev_hash = prev_block.prev_hash + prev_hash = prev_block.hash new_idx = self._index + 1 cdef Block *block = new Block( new_idx, - int(datetime.datetime(2025, 12, 1, 12, 0, 0).timestamp()), + current_timestamp_integer(), 0, data_str, prev_hash, @@ -464,3 +544,87 @@ cdef class Blockchain: if res != 0: raise RuntimeError("Could not mine block. No nonce found") + def validate(self): + cdef: + Block *block + Block *prev_block = NULL + int idx = 0 + unsigned char *digest + size_t digest_size + + for idx in range(self._chain[0].size()): + block = self._chain[0][idx] + py_bytes = bytes.fromhex(block.hash.decode("UTF-8")) + digest = perform_hash_c(block, &digest_size) + py_bytes_rehashed = bytes(digest[:digest_size]) + free(digest) + if py_bytes != py_bytes_rehashed: + print(f"Index {idx}: Hashes to not match. Abort.") + return False + if prev_block is not NULL: + if prev_block.hash != block.prev_hash: + print( + (f"Index {idx}: Hash mismatch. Hash of previous block does not " + "match the saved one in the current block. Abort.") + ) + return False + prev_block = block + + return True + + def get_saving_entries(self, max_idx): + entries = [] + cdef: + Block *block + int idx = 0 + int _max_idx + + if max_idx is None: + _max_idx = -1 + else: + _max_idx = max_idx + + for idx in range(self._chain[0].size()): + if idx <= _max_idx: + continue + block = self._chain[0][idx] + contents = {} + contents["index"] = block.index + contents["timestamp"] = block.timestamp + contents["nonce"] = block.nonce + contents["previous_hash"] = block.prev_hash.decode("UTF-8") + contents["hash"] = block.hash.decode("UTF-8") + contents["data"] = block.data.decode("UTF-8") + entries.append(contents) + + return entries + + def save(self): + # get max index from db + # only retrieve indices greater than max value + stmt = sql.select(sql.func.max(db.blocks.c.index)) + with self._engine.connect() as conn: + result = conn.execute(stmt) + max_value = result.scalar() + + entries = self.get_saving_entries(max_value) + if not entries: + return + + with self._engine.begin() as con: + con.execute(sql.insert(db.blocks), entries) + + def close_db_connections(self): + self._engine.dispose() + + def load(self, batch_size): + if self._loaded: + raise RuntimeError("Blockchain was already loaded") + + with self._engine.connect() as con: + res = con.execute(sql.select(db.blocks).order_by(db.blocks.c.index.asc())) + + for batch in res.partitions(batch_size): + self.load_from_batch(batch) + + self._loaded = True diff --git a/src/dopt_pollublock_blockchain/db.py b/src/dopt_pollublock_blockchain/db.py new file mode 100644 index 0000000..6f23d1c --- /dev/null +++ b/src/dopt_pollublock_blockchain/db.py @@ -0,0 +1,16 @@ +from __future__ import annotations + +import sqlalchemy as sql + +metadata_blockchain: sql.MetaData = sql.MetaData() + +blocks = sql.Table( + "blocks", + metadata_blockchain, + sql.Column("index", sql.BigInteger, primary_key=True), + sql.Column("timestamp", sql.BigInteger, nullable=False), + sql.Column("nonce", sql.BigInteger, nullable=False), + sql.Column("previous_hash", sql.String(64), nullable=False), + sql.Column("hash", sql.String(64), nullable=False), + sql.Column("data", sql.String(64), nullable=False), +) diff --git a/src/polluck_blockchain/openssl_evp.pxd b/src/dopt_pollublock_blockchain/openssl_evp.pxd similarity index 100% rename from src/polluck_blockchain/openssl_evp.pxd rename to src/dopt_pollublock_blockchain/openssl_evp.pxd diff --git a/src/polluck_blockchain/placeholder.c b/src/dopt_pollublock_blockchain/placeholder.c similarity index 100% rename from src/polluck_blockchain/placeholder.c rename to src/dopt_pollublock_blockchain/placeholder.c diff --git a/src/polluck_blockchain/placeholder.py b/src/dopt_pollublock_blockchain/placeholder.py similarity index 100% rename from src/polluck_blockchain/placeholder.py rename to src/dopt_pollublock_blockchain/placeholder.py diff --git a/src/polluck_blockchain/placeholder_native.cpp b/src/dopt_pollublock_blockchain/placeholder_native.cpp similarity index 72% rename from src/polluck_blockchain/placeholder_native.cpp rename to src/dopt_pollublock_blockchain/placeholder_native.cpp index da77328..5d9dfd8 100644 --- a/src/polluck_blockchain/placeholder_native.cpp +++ b/src/dopt_pollublock_blockchain/placeholder_native.cpp @@ -1180,6 +1180,7 @@ static int __Pyx_init_co_variables(void) { #endif #include +#include #include #include "openssl/evp.h" #ifdef _OPENMP @@ -1585,7 +1586,7 @@ static const char* const __pyx_f[] = { /* #### Code section: numeric_typedefs ### */ -/* "polluck_blockchain/placeholder_native.pyx":27 +/* "polluck_blockchain/placeholder_native.pyx":26 * * * ctypedef unsigned long ULong # <<<<<<<<<<<<<< @@ -1602,7 +1603,7 @@ struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain; struct __pyx_opt_args_18polluck_blockchain_18placeholder_native_7PyBlock_from_ptr; struct __pyx_opt_args_18polluck_blockchain_18placeholder_native_mine_block; -/* "polluck_blockchain/placeholder_native.pyx":28 +/* "polluck_blockchain/placeholder_native.pyx":27 * * ctypedef unsigned long ULong * ctypedef unordered_map[uint64_t, Block*] BcHashmap # <<<<<<<<<<<<<< @@ -1611,7 +1612,7 @@ struct __pyx_opt_args_18polluck_blockchain_18placeholder_native_mine_block; */ typedef std::unordered_map __pyx_t_18polluck_blockchain_18placeholder_native_BcHashmap; -/* "polluck_blockchain/placeholder_native.pyx":121 +/* "polluck_blockchain/placeholder_native.pyx":122 * * @staticmethod * cdef PyBlock from_ptr(Block *block, bint owner=False): # <<<<<<<<<<<<<< @@ -1623,7 +1624,7 @@ struct __pyx_opt_args_18polluck_blockchain_18placeholder_native_7PyBlock_from_pt int owner; }; -/* "polluck_blockchain/placeholder_native.pyx":276 +/* "polluck_blockchain/placeholder_native.pyx":292 * * * cdef int mine_block(Block *block, unsigned int difficulty, uint64_t *nonce_solution, unsigned int max_nonce=0xFFFFFFFF) nogil: # <<<<<<<<<<<<<< @@ -1635,7 +1636,7 @@ struct __pyx_opt_args_18polluck_blockchain_18placeholder_native_mine_block { unsigned int max_nonce; }; -/* "polluck_blockchain/placeholder_native.pyx":85 +/* "polluck_blockchain/placeholder_native.pyx":86 * * * cdef class PyBlock: # <<<<<<<<<<<<<< @@ -1650,25 +1651,28 @@ struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock { }; -/* "polluck_blockchain/placeholder_native.pyx":307 +/* "polluck_blockchain/placeholder_native.pyx":323 * * * cdef class Blockchain: # <<<<<<<<<<<<<< - * cdef unsigned int _difficulty - * cdef uint64_t _index + * cdef: + * unsigned int _difficulty */ struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain { PyObject_HEAD struct __pyx_vtabstruct_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_vtab; unsigned int _difficulty; uint64_t _index; - __pyx_t_18polluck_blockchain_18placeholder_native_BcHashmap *_chain; + __pyx_t_18polluck_blockchain_18placeholder_native_BcHashmap *_chain_map; + std::vector<::Block *> *_chain; int _genesis_done; + PyObject *db_path; + PyObject *_engine; }; -/* "polluck_blockchain/placeholder_native.pyx":85 +/* "polluck_blockchain/placeholder_native.pyx":86 * * * cdef class PyBlock: # <<<<<<<<<<<<<< @@ -1682,18 +1686,20 @@ struct __pyx_vtabstruct_18polluck_blockchain_18placeholder_native_PyBlock { static struct __pyx_vtabstruct_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_vtabptr_18polluck_blockchain_18placeholder_native_PyBlock; -/* "polluck_blockchain/placeholder_native.pyx":307 +/* "polluck_blockchain/placeholder_native.pyx":323 * * * cdef class Blockchain: # <<<<<<<<<<<<<< - * cdef unsigned int _difficulty - * cdef uint64_t _index + * cdef: + * unsigned int _difficulty */ struct __pyx_vtabstruct_18polluck_blockchain_18placeholder_native_Blockchain { ::Block *(*get_block_c)(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *, uint64_t); + void (*add_block_from_loading)(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *, ::Block *); int (*add_block)(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *, ::Block *); std::string (*hash_data)(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *, PyObject *); + PyObject *(*load_from_batch)(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *, PyObject *); }; static struct __pyx_vtabstruct_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_vtabptr_18polluck_blockchain_18placeholder_native_Blockchain; /* #### Code section: utility_code_proto ### */ @@ -2138,6 +2144,9 @@ static CYTHON_INLINE int __Pyx_CheckKeywordStrings(const char* function_name, Py static PyObject* __Pyx_PyUnicode_Join(PyObject** values, Py_ssize_t value_count, Py_ssize_t result_ulength, Py_UCS4 max_char); +/* RejectKeywords.export */ +static void __Pyx_RejectKeywords(const char* function_name, PyObject *kwds); + /* IncludeCppStringH.proto (used by decode_cpp_string) */ #include @@ -2170,9 +2179,6 @@ static CYTHON_INLINE PyObject* __Pyx_decode_cpp_string( cppstring.data(), (Py_ssize_t) cppstring.size(), start, stop, encoding, errors, decode_func); } -/* RejectKeywords.export */ -static void __Pyx_RejectKeywords(const char* function_name, PyObject *kwds); - /* GetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) @@ -2239,18 +2245,113 @@ static CYTHON_INLINE int __Pyx_UnknownThreadStateMayHaveHadGil(__Pyx_UnknownThre /* PyMemoryError_Check.proto */ #define __Pyx_PyExc_MemoryError_Check(obj) __Pyx_TypeCheck(obj, PyExc_MemoryError) +/* PyFileNotFoundError_Check.proto */ +#define __Pyx_PyExc_FileNotFoundError_Check(obj) __Pyx_TypeCheck(obj, PyExc_FileNotFoundError) + +/* PyObject_Unicode.proto */ +#define __Pyx_PyObject_Unicode(obj)\ + (likely(PyUnicode_CheckExact(obj)) ? __Pyx_NewRef(obj) : PyObject_Str(obj)) + +/* PyRuntimeError_Check.proto */ +#define __Pyx_PyExc_RuntimeError_Check(obj) __Pyx_TypeCheck(obj, PyExc_RuntimeError) + +/* GetItemInt.proto */ +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil, unsafe_shared)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck, unsafe_shared) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ + __Pyx_GetItemInt_Generic(o, to_py_func(i)))) +#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil, 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, is_list, 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 is_list, int wraparound, int boundscheck, int unsafe_shared); + /* PyValueError_Check.proto */ #define __Pyx_PyExc_ValueError_Check(obj) __Pyx_TypeCheck(obj, PyExc_ValueError) /* PyIndexError_Check.proto */ #define __Pyx_PyExc_IndexError_Check(obj) __Pyx_TypeCheck(obj, PyExc_IndexError) -/* PyRuntimeError_Check.proto */ -#define __Pyx_PyExc_RuntimeError_Check(obj) __Pyx_TypeCheck(obj, PyExc_RuntimeError) +/* 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); + +/* ListAppend.proto */ +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS +static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { + PyListObject* L = (PyListObject*) list; + Py_ssize_t len = Py_SIZE(list); + if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { + Py_INCREF(x); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 + L->ob_item[len] = x; + #else + PyList_SET_ITEM(list, len, x); + #endif + __Pyx_SET_SIZE(list, len + 1); + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_PyList_Append(L,x) PyList_Append(L,x) +#endif + +/* 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 + +/* RaiseUnboundLocalError.proto */ +static void __Pyx_RaiseUnboundLocalError(const char *varname); /* AllocateExtensionType.proto */ static PyObject *__Pyx_AllocateExtensionType(PyTypeObject *t, int is_final); +/* CallTypeTraverse.proto */ +#if !CYTHON_USE_TYPE_SPECS || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x03090000) +#define __Pyx_call_type_traverse(o, always_call, visit, arg) 0 +#else +static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg); +#endif + /* LimitedApiGetTypeDict.proto (used by SetItemOnTypeDict) */ #if CYTHON_COMPILING_IN_LIMITED_API static PyObject *__Pyx_GetTypeDict(PyTypeObject *tp); @@ -2311,6 +2412,9 @@ static PyObject *__Pyx__Import(PyObject *name, PyObject *const *imported_names, /* 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.proto */ +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); @@ -2332,13 +2436,6 @@ static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyOb static int __pyx_CommonTypesMetaclass_init(PyObject *module); #define __Pyx_CommonTypesMetaclass_USED -/* CallTypeTraverse.proto (used by CythonFunctionShared) */ -#if !CYTHON_USE_TYPE_SPECS || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x03090000) -#define __Pyx_call_type_traverse(o, always_call, visit, arg) 0 -#else -static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg); -#endif - /* PyMethodNew.proto (used by CythonFunctionShared) */ static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ); @@ -2477,11 +2574,6 @@ static void __pyx_insert_code_object(int code_line, __Pyx_CachedCodeObjectType* 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 - /* CppExceptionConversion.proto */ #ifndef __Pyx_CppExn2PyErr #include @@ -2539,6 +2631,9 @@ static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_unsigned_int(unsigned int value); +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value); + /* CIntFromPy.proto */ static CYTHON_INLINE unsigned int __Pyx_PyLong_As_unsigned_int(PyObject *); @@ -2559,9 +2654,6 @@ typedef const char *__Pyx_TypeName; #define __Pyx_DECREF_TypeName(obj) #endif -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value); - /* CIntFromPy.proto */ static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *); @@ -2653,10 +2745,10 @@ static int __Pyx_State_RemoveModule(void*); static struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_f_18polluck_blockchain_18placeholder_native_7PyBlock_from_ptr(::Block *__pyx_v_block, struct __pyx_opt_args_18polluck_blockchain_18placeholder_native_7PyBlock_from_ptr *__pyx_optional_args); /* proto*/ static ::Block *__pyx_f_18polluck_blockchain_18placeholder_native_10Blockchain_get_block_c(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, uint64_t __pyx_v_idx); /* proto*/ +static void __pyx_f_18polluck_blockchain_18placeholder_native_10Blockchain_add_block_from_loading(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, ::Block *__pyx_v_block); /* proto*/ static int __pyx_f_18polluck_blockchain_18placeholder_native_10Blockchain_add_block(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, ::Block *__pyx_v_block); /* proto*/ static std::string __pyx_f_18polluck_blockchain_18placeholder_native_10Blockchain_hash_data(CYTHON_UNUSED struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, PyObject *__pyx_v_data); /* proto*/ - -/* Module declarations from "cython" */ +static PyObject *__pyx_f_18polluck_blockchain_18placeholder_native_10Blockchain_load_from_batch(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, PyObject *__pyx_v_batch); /* proto*/ /* Module declarations from "libc.string" */ @@ -2674,6 +2766,8 @@ static std::string __pyx_f_18polluck_blockchain_18placeholder_native_10Blockchai /* Module declarations from "libcpp.unordered_map" */ +/* Module declarations from "libcpp.vector" */ + /* Module declarations from "libc.stdlib" */ /* Module declarations from "polluck_blockchain.openssl_evp" */ @@ -2681,6 +2775,7 @@ static std::string __pyx_f_18polluck_blockchain_18placeholder_native_10Blockchai /* Module declarations from "polluck_blockchain.placeholder_native" */ static size_t const __pyx_v_18polluck_blockchain_18placeholder_native_NONCE_OFFSET = ((size_t)16); static PyObject *__pyx_f_18polluck_blockchain_18placeholder_native_timestamp_to_datetime(uint64_t); /*proto*/ +static uint64_t __pyx_f_18polluck_blockchain_18placeholder_native_current_timestamp_integer(void); /*proto*/ static int __pyx_f_18polluck_blockchain_18placeholder_native_serialize_uint64(unsigned char *, unsigned PY_LONG_LONG); /*proto*/ static CYTHON_INLINE int __pyx_f_18polluck_blockchain_18placeholder_native_has_leading_zero_bits(unsigned char const *, int); /*proto*/ static unsigned char *__pyx_f_18polluck_blockchain_18placeholder_native_bytes_serialize_c(::Block *, size_t *); /*proto*/ @@ -2708,30 +2803,39 @@ static int __pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_2__init__ static void __pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_4__dealloc__(struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_6__repr__(struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_8__str__(struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_10serialize_dict(struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_5index___get__(struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_9timestamp___get__(struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_4data___get__(struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_9prev_hash___get__(struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_5nonce___get__(struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_4hash___get__(struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_10bytes_serialize(struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_12perform_hash(struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_14__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_16__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ -static int __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain___cinit__(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self); /* proto */ -static int __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_2__init__(CYTHON_UNUSED struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_12bytes_serialize(struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_14perform_hash(struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_16__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_18__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain___cinit__(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */ +static int __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_2__init__(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, PyObject *__pyx_v_db_path); /* proto */ static void __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_4__dealloc__(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self); /* proto */ static Py_ssize_t __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_6__len__(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_10difficulty___get__(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self); /* proto */ static int __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_10difficulty_2__set__(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_12genesis_done___get__(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_5index___get__(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_8print_key_value_pair(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_10get_block(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, PyObject *__pyx_v_idx); /* proto */ -static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_12create_genesis_block(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_14new_block(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, PyObject *__pyx_v_data); /* proto */ -static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_16__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_18__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_8_print_key_value_pair(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_10print_blocks(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, PyObject *__pyx_v_max_num); /* proto */ +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_12get_block(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, PyObject *__pyx_v_idx); /* proto */ +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_14create_genesis_block(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_16new_block(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, PyObject *__pyx_v_data); /* proto */ +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_18validate(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_20get_saving_entries(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, PyObject *__pyx_v_max_idx); /* proto */ +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_22save(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_24close_db_connections(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_26load(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, PyObject *__pyx_v_batch_size); /* proto */ +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_7db_path___get__(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_7_engine___get__(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_28__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_30__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_tp_new_18polluck_blockchain_18placeholder_native_PyBlock(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_18polluck_blockchain_18placeholder_native_Blockchain(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ /* #### Code section: late_includes ### */ @@ -2762,9 +2866,9 @@ typedef struct { __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_pop; __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_values; PyObject *__pyx_tuple[1]; - PyObject *__pyx_codeobj_tab[10]; - PyObject *__pyx_string_tab[109]; - PyObject *__pyx_number_tab[4]; + PyObject *__pyx_codeobj_tab[17]; + PyObject *__pyx_string_tab[186]; + PyObject *__pyx_number_tab[1]; /* #### Code section: module_state_contents ### */ /* CommonTypesMetaclass.module_state_decls */ PyTypeObject *__pyx_CommonTypesMetaclassType; @@ -2806,118 +2910,192 @@ static __pyx_mstatetype * const __pyx_mstate_global = &__pyx_mstate_global_stati #endif /* #### Code section: constant_name_defines ### */ #define __pyx_kp_u_Could_not_allocate_hasmap __pyx_string_tab[0] -#define __pyx_kp_u_Could_not_mine_block_No_nonce_fo __pyx_string_tab[1] -#define __pyx_kp_u_Create_a_genesis_block_first __pyx_string_tab[2] -#define __pyx_kp_u_Data_must_be_a_string __pyx_string_tab[3] -#define __pyx_kp_u_Difficulty_must_be_greater_than __pyx_string_tab[4] -#define __pyx_kp_u_Difficulty_must_be_integer_value __pyx_string_tab[5] -#define __pyx_kp_u_Failed_to_hash_data __pyx_string_tab[6] -#define __pyx_kp_u_Genesis_Block __pyx_string_tab[7] -#define __pyx_kp_u_Index_value_is_out_of_bounds __pyx_string_tab[8] -#define __pyx_kp_u_Provided_index_not_found __pyx_string_tab[9] -#define __pyx_kp_u_PyBlock __pyx_string_tab[10] -#define __pyx_kp_u_UTF_8 __pyx_string_tab[11] -#define __pyx_kp_u__2 __pyx_string_tab[12] -#define __pyx_kp_u__3 __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_no_default___reduce___due_to_non __pyx_string_tab[18] -#define __pyx_kp_u_src_polluck_blockchain_placehold __pyx_string_tab[19] -#define __pyx_kp_u_stringsource __pyx_string_tab[20] -#define __pyx_n_u_Blockchain __pyx_string_tab[21] -#define __pyx_n_u_Blockchain___reduce_cython __pyx_string_tab[22] -#define __pyx_n_u_Blockchain___setstate_cython __pyx_string_tab[23] -#define __pyx_n_u_Blockchain_create_genesis_block __pyx_string_tab[24] -#define __pyx_n_u_Blockchain_get_block __pyx_string_tab[25] -#define __pyx_n_u_Blockchain_new_block __pyx_string_tab[26] -#define __pyx_n_u_Blockchain_print_key_value_pair __pyx_string_tab[27] -#define __pyx_n_u_PyBlock_2 __pyx_string_tab[28] -#define __pyx_n_u_PyBlock___reduce_cython __pyx_string_tab[29] -#define __pyx_n_u_PyBlock___setstate_cython __pyx_string_tab[30] -#define __pyx_n_u_PyBlock_bytes_serialize __pyx_string_tab[31] -#define __pyx_n_u_PyBlock_perform_hash __pyx_string_tab[32] -#define __pyx_n_u_Pyx_PyDict_NextRef __pyx_string_tab[33] -#define __pyx_n_u_TIMEZONE_UTC __pyx_string_tab[34] -#define __pyx_n_u_asyncio_coroutines __pyx_string_tab[35] -#define __pyx_n_u_block __pyx_string_tab[36] -#define __pyx_n_u_bytes_serialize __pyx_string_tab[37] -#define __pyx_n_u_cline_in_traceback __pyx_string_tab[38] -#define __pyx_n_u_create_genesis_block __pyx_string_tab[39] -#define __pyx_n_u_current_time_tz __pyx_string_tab[40] -#define __pyx_n_u_cut_microseconds __pyx_string_tab[41] -#define __pyx_n_u_data __pyx_string_tab[42] -#define __pyx_n_u_data_digest __pyx_string_tab[43] -#define __pyx_n_u_data_str __pyx_string_tab[44] -#define __pyx_n_u_datetime __pyx_string_tab[45] -#define __pyx_n_u_digest __pyx_string_tab[46] -#define __pyx_n_u_digest_size __pyx_string_tab[47] -#define __pyx_n_u_dopt_basics __pyx_string_tab[48] -#define __pyx_n_u_dopt_basics_datetime __pyx_string_tab[49] -#define __pyx_n_u_encode __pyx_string_tab[50] -#define __pyx_n_u_from_ptr __pyx_string_tab[51] -#define __pyx_n_u_fromtimestamp __pyx_string_tab[52] -#define __pyx_n_u_func __pyx_string_tab[53] -#define __pyx_n_u_genesis_prev_hash __pyx_string_tab[54] -#define __pyx_n_u_get_block __pyx_string_tab[55] -#define __pyx_n_u_getstate __pyx_string_tab[56] -#define __pyx_n_u_hash __pyx_string_tab[57] -#define __pyx_n_u_hashlib __pyx_string_tab[58] -#define __pyx_n_u_hex __pyx_string_tab[59] -#define __pyx_n_u_idx __pyx_string_tab[60] -#define __pyx_n_u_index __pyx_string_tab[61] -#define __pyx_n_u_is_coroutine __pyx_string_tab[62] -#define __pyx_n_u_it __pyx_string_tab[63] -#define __pyx_n_u_items __pyx_string_tab[64] -#define __pyx_n_u_main __pyx_string_tab[65] -#define __pyx_n_u_module __pyx_string_tab[66] -#define __pyx_n_u_name __pyx_string_tab[67] -#define __pyx_n_u_new_block __pyx_string_tab[68] -#define __pyx_n_u_new_idx __pyx_string_tab[69] -#define __pyx_n_u_nonce __pyx_string_tab[70] -#define __pyx_n_u_perform_hash __pyx_string_tab[71] -#define __pyx_n_u_polluck_blockchain_placeholder_n __pyx_string_tab[72] -#define __pyx_n_u_pop __pyx_string_tab[73] -#define __pyx_n_u_prev_block __pyx_string_tab[74] -#define __pyx_n_u_prev_hash __pyx_string_tab[75] -#define __pyx_n_u_previous_hash __pyx_string_tab[76] -#define __pyx_n_u_print __pyx_string_tab[77] -#define __pyx_n_u_print_key_value_pair __pyx_string_tab[78] -#define __pyx_n_u_py_block __pyx_string_tab[79] -#define __pyx_n_u_pyx_state __pyx_string_tab[80] -#define __pyx_n_u_pyx_vtable __pyx_string_tab[81] -#define __pyx_n_u_qualname __pyx_string_tab[82] -#define __pyx_n_u_reduce __pyx_string_tab[83] -#define __pyx_n_u_reduce_cython __pyx_string_tab[84] -#define __pyx_n_u_reduce_ex __pyx_string_tab[85] -#define __pyx_n_u_repr __pyx_string_tab[86] -#define __pyx_n_u_res __pyx_string_tab[87] -#define __pyx_n_u_self __pyx_string_tab[88] -#define __pyx_n_u_serialize_res __pyx_string_tab[89] -#define __pyx_n_u_serialize_size __pyx_string_tab[90] -#define __pyx_n_u_set_name __pyx_string_tab[91] -#define __pyx_n_u_setdefault __pyx_string_tab[92] -#define __pyx_n_u_setstate __pyx_string_tab[93] -#define __pyx_n_u_setstate_cython __pyx_string_tab[94] -#define __pyx_n_u_struct __pyx_string_tab[95] -#define __pyx_n_u_test __pyx_string_tab[96] -#define __pyx_n_u_time __pyx_string_tab[97] -#define __pyx_n_u_timestamp __pyx_string_tab[98] -#define __pyx_n_u_values __pyx_string_tab[99] -#define __pyx_kp_b_ __pyx_string_tab[100] -#define __pyx_kp_b_00000000000000000000000000000000 __pyx_string_tab[101] -#define __pyx_kp_b_iso88591_A_1D_wc_xuAV2_b_q_t1 __pyx_string_tab[102] -#define __pyx_kp_b_iso88591_A_4r_3d_D_AQ_D_AQ_6_A_AQ_iq_Q __pyx_string_tab[103] -#define __pyx_kp_b_iso88591_A_4t1_aq_4z_1A_4z_T_Qd_Ja_hb_IQ __pyx_string_tab[104] -#define __pyx_kp_b_iso88591_A_Qd_1A __pyx_string_tab[105] -#define __pyx_kp_b_iso88591_A_T_a_c_D_t1_c_L_1_iq __pyx_string_tab[106] -#define __pyx_kp_b_iso88591_A_YgQa_t_Qa_IQ_q_Ct3b_gQa_t_Qa_4 __pyx_string_tab[107] -#define __pyx_kp_b_iso88591_Q __pyx_string_tab[108] +#define __pyx_kp_u_Could_not_allocate_vector __pyx_string_tab[1] +#define __pyx_kp_u_Could_not_mine_block_No_nonce_fo __pyx_string_tab[2] +#define __pyx_kp_u_Create_a_genesis_block_first __pyx_string_tab[3] +#define __pyx_kp_u_Data __pyx_string_tab[4] +#define __pyx_kp_u_Data_must_be_a_string __pyx_string_tab[5] +#define __pyx_kp_u_Difficulty_must_be_greater_than __pyx_string_tab[6] +#define __pyx_kp_u_Difficulty_must_be_integer_value __pyx_string_tab[7] +#define __pyx_kp_u_Failed_to_hash_data __pyx_string_tab[8] +#define __pyx_kp_u_Genesis_Block __pyx_string_tab[9] +#define __pyx_kp_u_Hash __pyx_string_tab[10] +#define __pyx_kp_u_Hash_mismatch_Hash_of_previous __pyx_string_tab[11] +#define __pyx_kp_u_Hashes_to_not_match_Abort __pyx_string_tab[12] +#define __pyx_kp_u_Index __pyx_string_tab[13] +#define __pyx_kp_u_Index_value_is_out_of_bounds __pyx_string_tab[14] +#define __pyx_kp_u_Maximum_number_must_be_greater_t __pyx_string_tab[15] +#define __pyx_kp_u_Prev_Hash __pyx_string_tab[16] +#define __pyx_kp_u_Provided_index_not_found __pyx_string_tab[17] +#define __pyx_kp_u_PyBlock_Index __pyx_string_tab[18] +#define __pyx_kp_u_The_parent_directory_of_the_prov __pyx_string_tab[19] +#define __pyx_kp_u_UTF_8 __pyx_string_tab[20] +#define __pyx_kp_u__2 __pyx_string_tab[21] +#define __pyx_kp_u__3 __pyx_string_tab[22] +#define __pyx_kp_u__4 __pyx_string_tab[23] +#define __pyx_kp_u_disable __pyx_string_tab[24] +#define __pyx_kp_u_enable __pyx_string_tab[25] +#define __pyx_kp_u_gc __pyx_string_tab[26] +#define __pyx_kp_u_isenabled __pyx_string_tab[27] +#define __pyx_kp_u_no_default___reduce___due_to_non __pyx_string_tab[28] +#define __pyx_kp_u_nonce_2 __pyx_string_tab[29] +#define __pyx_kp_u_sqlite __pyx_string_tab[30] +#define __pyx_kp_u_src_polluck_blockchain_placehold __pyx_string_tab[31] +#define __pyx_kp_u_stringsource __pyx_string_tab[32] +#define __pyx_kp_u_timestamp_2 __pyx_string_tab[33] +#define __pyx_n_u_Blockchain __pyx_string_tab[34] +#define __pyx_n_u_Blockchain___reduce_cython __pyx_string_tab[35] +#define __pyx_n_u_Blockchain___setstate_cython __pyx_string_tab[36] +#define __pyx_n_u_Blockchain__print_key_value_pair __pyx_string_tab[37] +#define __pyx_n_u_Blockchain_close_db_connections __pyx_string_tab[38] +#define __pyx_n_u_Blockchain_create_genesis_block __pyx_string_tab[39] +#define __pyx_n_u_Blockchain_get_block __pyx_string_tab[40] +#define __pyx_n_u_Blockchain_get_saving_entries __pyx_string_tab[41] +#define __pyx_n_u_Blockchain_load __pyx_string_tab[42] +#define __pyx_n_u_Blockchain_new_block __pyx_string_tab[43] +#define __pyx_n_u_Blockchain_print_blocks __pyx_string_tab[44] +#define __pyx_n_u_Blockchain_save __pyx_string_tab[45] +#define __pyx_n_u_Blockchain_validate __pyx_string_tab[46] +#define __pyx_n_u_Path __pyx_string_tab[47] +#define __pyx_n_u_PyBlock __pyx_string_tab[48] +#define __pyx_n_u_PyBlock___reduce_cython __pyx_string_tab[49] +#define __pyx_n_u_PyBlock___setstate_cython __pyx_string_tab[50] +#define __pyx_n_u_PyBlock_bytes_serialize __pyx_string_tab[51] +#define __pyx_n_u_PyBlock_perform_hash __pyx_string_tab[52] +#define __pyx_n_u_PyBlock_serialize_dict __pyx_string_tab[53] +#define __pyx_n_u_Pyx_PyDict_NextRef __pyx_string_tab[54] +#define __pyx_n_u_TIMEZONE_UTC __pyx_string_tab[55] +#define __pyx_n_u_asc __pyx_string_tab[56] +#define __pyx_n_u_asyncio_coroutines __pyx_string_tab[57] +#define __pyx_n_u_batch __pyx_string_tab[58] +#define __pyx_n_u_batch_size __pyx_string_tab[59] +#define __pyx_n_u_begin __pyx_string_tab[60] +#define __pyx_n_u_block __pyx_string_tab[61] +#define __pyx_n_u_blocks __pyx_string_tab[62] +#define __pyx_n_u_bytes_serialize __pyx_string_tab[63] +#define __pyx_n_u_c __pyx_string_tab[64] +#define __pyx_n_u_cline_in_traceback __pyx_string_tab[65] +#define __pyx_n_u_close_db_connections __pyx_string_tab[66] +#define __pyx_n_u_con __pyx_string_tab[67] +#define __pyx_n_u_conn __pyx_string_tab[68] +#define __pyx_n_u_connect __pyx_string_tab[69] +#define __pyx_n_u_contents __pyx_string_tab[70] +#define __pyx_n_u_create_all __pyx_string_tab[71] +#define __pyx_n_u_create_engine __pyx_string_tab[72] +#define __pyx_n_u_create_genesis_block __pyx_string_tab[73] +#define __pyx_n_u_current_time_tz __pyx_string_tab[74] +#define __pyx_n_u_cut_microseconds __pyx_string_tab[75] +#define __pyx_n_u_data __pyx_string_tab[76] +#define __pyx_n_u_data_digest __pyx_string_tab[77] +#define __pyx_n_u_data_str __pyx_string_tab[78] +#define __pyx_n_u_datetime __pyx_string_tab[79] +#define __pyx_n_u_db __pyx_string_tab[80] +#define __pyx_n_u_db_path __pyx_string_tab[81] +#define __pyx_n_u_digest __pyx_string_tab[82] +#define __pyx_n_u_digest_size __pyx_string_tab[83] +#define __pyx_n_u_dispose __pyx_string_tab[84] +#define __pyx_n_u_dopt_basics __pyx_string_tab[85] +#define __pyx_n_u_dopt_basics_datetime __pyx_string_tab[86] +#define __pyx_n_u_encode __pyx_string_tab[87] +#define __pyx_n_u_enter __pyx_string_tab[88] +#define __pyx_n_u_entries __pyx_string_tab[89] +#define __pyx_n_u_execute __pyx_string_tab[90] +#define __pyx_n_u_exists __pyx_string_tab[91] +#define __pyx_n_u_exit __pyx_string_tab[92] +#define __pyx_n_u_from_ptr __pyx_string_tab[93] +#define __pyx_n_u_fromhex __pyx_string_tab[94] +#define __pyx_n_u_fromtimestamp __pyx_string_tab[95] +#define __pyx_n_u_func __pyx_string_tab[96] +#define __pyx_n_u_func_2 __pyx_string_tab[97] +#define __pyx_n_u_genesis_prev_hash __pyx_string_tab[98] +#define __pyx_n_u_get_block __pyx_string_tab[99] +#define __pyx_n_u_get_saving_entries __pyx_string_tab[100] +#define __pyx_n_u_getstate __pyx_string_tab[101] +#define __pyx_n_u_hash __pyx_string_tab[102] +#define __pyx_n_u_hex __pyx_string_tab[103] +#define __pyx_n_u_idx __pyx_string_tab[104] +#define __pyx_n_u_index __pyx_string_tab[105] +#define __pyx_n_u_insert __pyx_string_tab[106] +#define __pyx_n_u_is_coroutine __pyx_string_tab[107] +#define __pyx_n_u_it __pyx_string_tab[108] +#define __pyx_n_u_items __pyx_string_tab[109] +#define __pyx_n_u_load __pyx_string_tab[110] +#define __pyx_n_u_main __pyx_string_tab[111] +#define __pyx_n_u_max __pyx_string_tab[112] +#define __pyx_n_u_max_idx __pyx_string_tab[113] +#define __pyx_n_u_max_idx_2 __pyx_string_tab[114] +#define __pyx_n_u_max_num __pyx_string_tab[115] +#define __pyx_n_u_max_nummber __pyx_string_tab[116] +#define __pyx_n_u_max_value __pyx_string_tab[117] +#define __pyx_n_u_metadata_blockchain __pyx_string_tab[118] +#define __pyx_n_u_module __pyx_string_tab[119] +#define __pyx_n_u_name __pyx_string_tab[120] +#define __pyx_n_u_new_block __pyx_string_tab[121] +#define __pyx_n_u_new_idx __pyx_string_tab[122] +#define __pyx_n_u_nonce __pyx_string_tab[123] +#define __pyx_n_u_num __pyx_string_tab[124] +#define __pyx_n_u_order_by __pyx_string_tab[125] +#define __pyx_n_u_parent __pyx_string_tab[126] +#define __pyx_n_u_partitions __pyx_string_tab[127] +#define __pyx_n_u_pathlib __pyx_string_tab[128] +#define __pyx_n_u_perform_hash __pyx_string_tab[129] +#define __pyx_n_u_polluck_blockchain __pyx_string_tab[130] +#define __pyx_n_u_polluck_blockchain_placeholder_n __pyx_string_tab[131] +#define __pyx_n_u_pop __pyx_string_tab[132] +#define __pyx_n_u_prev_block __pyx_string_tab[133] +#define __pyx_n_u_prev_hash __pyx_string_tab[134] +#define __pyx_n_u_previous_hash __pyx_string_tab[135] +#define __pyx_n_u_print __pyx_string_tab[136] +#define __pyx_n_u_print_blocks __pyx_string_tab[137] +#define __pyx_n_u_print_key_value_pair __pyx_string_tab[138] +#define __pyx_n_u_py_block __pyx_string_tab[139] +#define __pyx_n_u_py_bytes __pyx_string_tab[140] +#define __pyx_n_u_py_bytes_rehashed __pyx_string_tab[141] +#define __pyx_n_u_pyx_state __pyx_string_tab[142] +#define __pyx_n_u_pyx_vtable __pyx_string_tab[143] +#define __pyx_n_u_qualname __pyx_string_tab[144] +#define __pyx_n_u_reduce __pyx_string_tab[145] +#define __pyx_n_u_reduce_cython __pyx_string_tab[146] +#define __pyx_n_u_reduce_ex __pyx_string_tab[147] +#define __pyx_n_u_repr __pyx_string_tab[148] +#define __pyx_n_u_res __pyx_string_tab[149] +#define __pyx_n_u_resolve __pyx_string_tab[150] +#define __pyx_n_u_result __pyx_string_tab[151] +#define __pyx_n_u_save __pyx_string_tab[152] +#define __pyx_n_u_scalar __pyx_string_tab[153] +#define __pyx_n_u_select __pyx_string_tab[154] +#define __pyx_n_u_self __pyx_string_tab[155] +#define __pyx_n_u_serialize_dict __pyx_string_tab[156] +#define __pyx_n_u_serialize_res __pyx_string_tab[157] +#define __pyx_n_u_serialize_size __pyx_string_tab[158] +#define __pyx_n_u_set_name __pyx_string_tab[159] +#define __pyx_n_u_setdefault __pyx_string_tab[160] +#define __pyx_n_u_setstate __pyx_string_tab[161] +#define __pyx_n_u_setstate_cython __pyx_string_tab[162] +#define __pyx_n_u_sql __pyx_string_tab[163] +#define __pyx_n_u_sqlalchemy __pyx_string_tab[164] +#define __pyx_n_u_stmt __pyx_string_tab[165] +#define __pyx_n_u_test __pyx_string_tab[166] +#define __pyx_n_u_timestamp __pyx_string_tab[167] +#define __pyx_n_u_validate __pyx_string_tab[168] +#define __pyx_n_u_values __pyx_string_tab[169] +#define __pyx_kp_b_ __pyx_string_tab[170] +#define __pyx_kp_b_00000000000000000000000000000000 __pyx_string_tab[171] +#define __pyx_kp_b_iso88591_A_1D_wc_xuAV2_b_q_t1 __pyx_string_tab[172] +#define __pyx_kp_b_iso88591_A_1_D_q_G1_D_q_D_4q_4q_q __pyx_string_tab[173] +#define __pyx_kp_b_iso88591_A_4q_YgQa_t_Qa_IQ_Q_gQa_t_Qa_4s __pyx_string_tab[174] +#define __pyx_kp_b_iso88591_A_4r_3d_D_AQ_D_AQ_6_A_AQ_iq_Q __pyx_string_tab[175] +#define __pyx_kp_b_iso88591_A_4t1_aq_4z_1A_4z_T_Qd_Ja_hb_IQ __pyx_string_tab[176] +#define __pyx_kp_b_iso88591_A_HHA __pyx_string_tab[177] +#define __pyx_kp_b_iso88591_A_Qd_1A __pyx_string_tab[178] +#define __pyx_kp_b_iso88591_A_T_F_c_D_4q_c_L_1_iq __pyx_string_tab[179] +#define __pyx_kp_b_iso88591_A_a_1_83a_AQ_G5_WARuA_D_q_1_iq_1 __pyx_string_tab[180] +#define __pyx_kp_b_iso88591_A_a_83a_q_G5_WARuA_t3a_D_q_1_q_A __pyx_string_tab[181] +#define __pyx_kp_b_iso88591_A_a_G5_WARuA_D_q_1_uHAU_waq_1G1A __pyx_string_tab[182] +#define __pyx_kp_b_iso88591_A_q_XQc_89ARwb_dRS_IS_1A __pyx_string_tab[183] +#define __pyx_kp_b_iso88591_A_s_U_ar_q_T_gQ_4q_vQ_xq_7_2Zq __pyx_string_tab[184] +#define __pyx_kp_b_iso88591_Q __pyx_string_tab[185] #define __pyx_int_0 __pyx_number_tab[0] -#define __pyx_int_1 __pyx_number_tab[1] -#define __pyx_int_12 __pyx_number_tab[2] -#define __pyx_int_2025 __pyx_number_tab[3] /* #### Code section: module_state_clear ### */ #if CYTHON_USE_MODULE_STATE static CYTHON_SMALL_CODE int __pyx_m_clear(PyObject *m) { @@ -2937,9 +3115,9 @@ static CYTHON_SMALL_CODE int __pyx_m_clear(PyObject *m) { Py_CLEAR(clear_module_state->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain); Py_CLEAR(clear_module_state->__pyx_type_18polluck_blockchain_18placeholder_native_Blockchain); for (int i=0; i<1; ++i) { Py_CLEAR(clear_module_state->__pyx_tuple[i]); } - for (int i=0; i<10; ++i) { Py_CLEAR(clear_module_state->__pyx_codeobj_tab[i]); } - for (int i=0; i<109; ++i) { Py_CLEAR(clear_module_state->__pyx_string_tab[i]); } - for (int i=0; i<4; ++i) { Py_CLEAR(clear_module_state->__pyx_number_tab[i]); } + for (int i=0; i<17; ++i) { Py_CLEAR(clear_module_state->__pyx_codeobj_tab[i]); } + for (int i=0; i<186; ++i) { Py_CLEAR(clear_module_state->__pyx_string_tab[i]); } + for (int i=0; i<1; ++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); @@ -2967,9 +3145,9 @@ static CYTHON_SMALL_CODE int __pyx_m_traverse(PyObject *m, visitproc visit, void Py_VISIT(traverse_module_state->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain); Py_VISIT(traverse_module_state->__pyx_type_18polluck_blockchain_18placeholder_native_Blockchain); for (int i=0; i<1; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_tuple[i]); } - for (int i=0; i<10; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_codeobj_tab[i]); } - for (int i=0; i<109; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_string_tab[i]); } - for (int i=0; i<4; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_number_tab[i]); } + for (int i=0; i<17; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_codeobj_tab[i]); } + for (int i=0; i<186; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_string_tab[i]); } + for (int i=0; i<1; ++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); @@ -3365,7 +3543,7 @@ static CYTHON_INLINE PyObject *__pyx_convert_PyByteArray_string_to_py_6libcpp_6s } /* "polluck_blockchain/placeholder_native.pyx":31 - * cdef const size_t NONCE_OFFSET = 16 + * * * cdef timestamp_to_datetime(uint64_t ts): # <<<<<<<<<<<<<< * return datetime.datetime.fromtimestamp(float(ts), dopt_basics.datetime.TIMEZONE_UTC) @@ -3392,7 +3570,7 @@ static PyObject *__pyx_f_18polluck_blockchain_18placeholder_native_timestamp_to_ * cdef timestamp_to_datetime(uint64_t ts): * return datetime.datetime.fromtimestamp(float(ts), dopt_basics.datetime.TIMEZONE_UTC) # <<<<<<<<<<<<<< * - * cdef uint64_t current_timestamp_integer(): + * */ __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 32, __pyx_L1_error) @@ -3428,7 +3606,7 @@ static PyObject *__pyx_f_18polluck_blockchain_18placeholder_native_timestamp_to_ goto __pyx_L0; /* "polluck_blockchain/placeholder_native.pyx":31 - * cdef const size_t NONCE_OFFSET = 16 + * * * cdef timestamp_to_datetime(uint64_t ts): # <<<<<<<<<<<<<< * return datetime.datetime.fromtimestamp(float(ts), dopt_basics.datetime.TIMEZONE_UTC) @@ -3451,8 +3629,8 @@ static PyObject *__pyx_f_18polluck_blockchain_18placeholder_native_timestamp_to_ return __pyx_r; } -/* "polluck_blockchain/placeholder_native.pyx":34 - * return datetime.datetime.fromtimestamp(float(ts), dopt_basics.datetime.TIMEZONE_UTC) +/* "polluck_blockchain/placeholder_native.pyx":35 + * * * cdef uint64_t current_timestamp_integer(): # <<<<<<<<<<<<<< * cdef uint64_t ts @@ -3475,16 +3653,16 @@ static uint64_t __pyx_f_18polluck_blockchain_18placeholder_native_current_timest int __pyx_clineno = 0; __Pyx_RefNannySetupContext("current_timestamp_integer", 0); - /* "polluck_blockchain/placeholder_native.pyx":36 + /* "polluck_blockchain/placeholder_native.pyx":37 * cdef uint64_t current_timestamp_integer(): * cdef uint64_t ts * dt = dopt_basics.datetime.current_time_tz(cut_microseconds=True) # <<<<<<<<<<<<<< * ts = int(dt.timestamp()) * return ts */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_dopt_basics); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 36, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_dopt_basics); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 37, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 36, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 37, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_2 = __pyx_t_4; @@ -3492,20 +3670,20 @@ static uint64_t __pyx_f_18polluck_blockchain_18placeholder_native_current_timest __pyx_t_5 = 0; { PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_2, NULL}; - __pyx_t_3 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 36, __pyx_L1_error) + __pyx_t_3 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 37, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_cut_microseconds, Py_True, __pyx_t_3, __pyx_callargs+1, 0) < (0)) __PYX_ERR(0, 36, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_cut_microseconds, Py_True, __pyx_t_3, __pyx_callargs+1, 0) < (0)) __PYX_ERR(0, 37, __pyx_L1_error) __pyx_t_1 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_current_time_tz, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_3); __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, 36, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 37, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } __pyx_v_dt = __pyx_t_1; __pyx_t_1 = 0; - /* "polluck_blockchain/placeholder_native.pyx":37 + /* "polluck_blockchain/placeholder_native.pyx":38 * cdef uint64_t ts * dt = dopt_basics.datetime.current_time_tz(cut_microseconds=True) * ts = int(dt.timestamp()) # <<<<<<<<<<<<<< @@ -3519,28 +3697,28 @@ static uint64_t __pyx_f_18polluck_blockchain_18placeholder_native_current_timest PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_timestamp, __pyx_callargs+__pyx_t_5, (1-__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, 37, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 38, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } - __pyx_t_4 = __Pyx_PyNumber_Int(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 37, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyNumber_Int(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 38, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __Pyx_PyLong_As_uint64_t(__pyx_t_4); if (unlikely((__pyx_t_6 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 37, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyLong_As_uint64_t(__pyx_t_4); if (unlikely((__pyx_t_6 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 38, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_ts = ((uint64_t)__pyx_t_6); - /* "polluck_blockchain/placeholder_native.pyx":38 + /* "polluck_blockchain/placeholder_native.pyx":39 * dt = dopt_basics.datetime.current_time_tz(cut_microseconds=True) * ts = int(dt.timestamp()) * return ts # <<<<<<<<<<<<<< * - * # cdef float_to_bytes(double num): + * */ __pyx_r = __pyx_v_ts; goto __pyx_L0; - /* "polluck_blockchain/placeholder_native.pyx":34 - * return datetime.datetime.fromtimestamp(float(ts), dopt_basics.datetime.TIMEZONE_UTC) + /* "polluck_blockchain/placeholder_native.pyx":35 + * * * cdef uint64_t current_timestamp_integer(): # <<<<<<<<<<<<<< * cdef uint64_t ts @@ -3561,8 +3739,8 @@ static uint64_t __pyx_f_18polluck_blockchain_18placeholder_native_current_timest return __pyx_r; } -/* "polluck_blockchain/placeholder_native.pyx":43 - * # return struct.pack(">d", num) +/* "polluck_blockchain/placeholder_native.pyx":42 + * * * cdef int serialize_uint32(unsigned char* out, unsigned int v) except -1 nogil: # <<<<<<<<<<<<<< * out[0] = (v >> 24) & 0xFF @@ -3572,7 +3750,7 @@ static uint64_t __pyx_f_18polluck_blockchain_18placeholder_native_current_timest static int __pyx_f_18polluck_blockchain_18placeholder_native_serialize_uint32(unsigned char *__pyx_v_out, unsigned int __pyx_v_v) { int __pyx_r; - /* "polluck_blockchain/placeholder_native.pyx":44 + /* "polluck_blockchain/placeholder_native.pyx":43 * * cdef int serialize_uint32(unsigned char* out, unsigned int v) except -1 nogil: * out[0] = (v >> 24) & 0xFF # <<<<<<<<<<<<<< @@ -3581,7 +3759,7 @@ static int __pyx_f_18polluck_blockchain_18placeholder_native_serialize_uint32(un */ (__pyx_v_out[0]) = ((__pyx_v_v >> 24) & 0xFF); - /* "polluck_blockchain/placeholder_native.pyx":45 + /* "polluck_blockchain/placeholder_native.pyx":44 * cdef int serialize_uint32(unsigned char* out, unsigned int v) except -1 nogil: * out[0] = (v >> 24) & 0xFF * out[1] = (v >> 16) & 0xFF # <<<<<<<<<<<<<< @@ -3590,7 +3768,7 @@ static int __pyx_f_18polluck_blockchain_18placeholder_native_serialize_uint32(un */ (__pyx_v_out[1]) = ((__pyx_v_v >> 16) & 0xFF); - /* "polluck_blockchain/placeholder_native.pyx":46 + /* "polluck_blockchain/placeholder_native.pyx":45 * out[0] = (v >> 24) & 0xFF * out[1] = (v >> 16) & 0xFF * out[2] = (v >> 8) & 0xFF # <<<<<<<<<<<<<< @@ -3599,17 +3777,17 @@ static int __pyx_f_18polluck_blockchain_18placeholder_native_serialize_uint32(un */ (__pyx_v_out[2]) = ((__pyx_v_v >> 8) & 0xFF); - /* "polluck_blockchain/placeholder_native.pyx":47 + /* "polluck_blockchain/placeholder_native.pyx":46 * out[1] = (v >> 16) & 0xFF * out[2] = (v >> 8) & 0xFF * out[3] = v & 0xFF # <<<<<<<<<<<<<< * - * cdef int serialize_uint64(unsigned char* out, unsigned long long v) except -1 nogil: + * */ (__pyx_v_out[3]) = (__pyx_v_v & 0xFF); - /* "polluck_blockchain/placeholder_native.pyx":43 - * # return struct.pack(">d", num) + /* "polluck_blockchain/placeholder_native.pyx":42 + * * * cdef int serialize_uint32(unsigned char* out, unsigned int v) except -1 nogil: # <<<<<<<<<<<<<< * out[0] = (v >> 24) & 0xFF @@ -3622,7 +3800,7 @@ static int __pyx_f_18polluck_blockchain_18placeholder_native_serialize_uint32(un } /* "polluck_blockchain/placeholder_native.pyx":49 - * out[3] = v & 0xFF + * * * cdef int serialize_uint64(unsigned char* out, unsigned long long v) except -1 nogil: # <<<<<<<<<<<<<< * out[0] = (v >> 56) & 0xFF @@ -3705,7 +3883,7 @@ static int __pyx_f_18polluck_blockchain_18placeholder_native_serialize_uint64(un (__pyx_v_out[7]) = (__pyx_v_v & 0xFF); /* "polluck_blockchain/placeholder_native.pyx":49 - * out[3] = v & 0xFF + * * * cdef int serialize_uint64(unsigned char* out, unsigned long long v) except -1 nogil: # <<<<<<<<<<<<<< * out[0] = (v >> 56) & 0xFF @@ -3848,7 +4026,7 @@ static CYTHON_INLINE int __pyx_f_18polluck_blockchain_18placeholder_native_has_l * * return True # <<<<<<<<<<<<<< * - * cdef inline bint has_leading_zero_bytes(const unsigned char *digest, int num_bytes) nogil: + * */ __pyx_r = 1; goto __pyx_L0; @@ -3866,8 +4044,8 @@ static CYTHON_INLINE int __pyx_f_18polluck_blockchain_18placeholder_native_has_l return __pyx_r; } -/* "polluck_blockchain/placeholder_native.pyx":74 - * return True +/* "polluck_blockchain/placeholder_native.pyx":75 + * * * cdef inline bint has_leading_zero_bytes(const unsigned char *digest, int num_bytes) nogil: # <<<<<<<<<<<<<< * cdef int i, full_bytes = num_bytes // 8 @@ -3884,7 +4062,7 @@ static CYTHON_INLINE int __pyx_f_18polluck_blockchain_18placeholder_native_has_l int __pyx_t_3; int __pyx_t_4; - /* "polluck_blockchain/placeholder_native.pyx":75 + /* "polluck_blockchain/placeholder_native.pyx":76 * * cdef inline bint has_leading_zero_bytes(const unsigned char *digest, int num_bytes) nogil: * cdef int i, full_bytes = num_bytes // 8 # <<<<<<<<<<<<<< @@ -3893,7 +4071,7 @@ static CYTHON_INLINE int __pyx_f_18polluck_blockchain_18placeholder_native_has_l */ __pyx_v_full_bytes = __Pyx_div_long(__pyx_v_num_bytes, 8, 1); - /* "polluck_blockchain/placeholder_native.pyx":76 + /* "polluck_blockchain/placeholder_native.pyx":77 * cdef inline bint has_leading_zero_bytes(const unsigned char *digest, int num_bytes) nogil: * cdef int i, full_bytes = num_bytes // 8 * cdef int rem_bits = num_bytes % 8 # <<<<<<<<<<<<<< @@ -3902,7 +4080,7 @@ static CYTHON_INLINE int __pyx_f_18polluck_blockchain_18placeholder_native_has_l */ __pyx_v_rem_bits = __Pyx_mod_long(__pyx_v_num_bytes, 8, 1); - /* "polluck_blockchain/placeholder_native.pyx":78 + /* "polluck_blockchain/placeholder_native.pyx":79 * cdef int rem_bits = num_bytes % 8 * * for i in range(num_bytes): # <<<<<<<<<<<<<< @@ -3914,7 +4092,7 @@ static CYTHON_INLINE int __pyx_f_18polluck_blockchain_18placeholder_native_has_l for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { __pyx_v_i = __pyx_t_3; - /* "polluck_blockchain/placeholder_native.pyx":79 + /* "polluck_blockchain/placeholder_native.pyx":80 * * for i in range(num_bytes): * if digest[i] != 0: # <<<<<<<<<<<<<< @@ -3924,7 +4102,7 @@ static CYTHON_INLINE int __pyx_f_18polluck_blockchain_18placeholder_native_has_l __pyx_t_4 = ((__pyx_v_digest[__pyx_v_i]) != 0); if (__pyx_t_4) { - /* "polluck_blockchain/placeholder_native.pyx":80 + /* "polluck_blockchain/placeholder_native.pyx":81 * for i in range(num_bytes): * if digest[i] != 0: * return False # <<<<<<<<<<<<<< @@ -3934,7 +4112,7 @@ static CYTHON_INLINE int __pyx_f_18polluck_blockchain_18placeholder_native_has_l __pyx_r = 0; goto __pyx_L0; - /* "polluck_blockchain/placeholder_native.pyx":79 + /* "polluck_blockchain/placeholder_native.pyx":80 * * for i in range(num_bytes): * if digest[i] != 0: # <<<<<<<<<<<<<< @@ -3944,7 +4122,7 @@ static CYTHON_INLINE int __pyx_f_18polluck_blockchain_18placeholder_native_has_l } } - /* "polluck_blockchain/placeholder_native.pyx":82 + /* "polluck_blockchain/placeholder_native.pyx":83 * return False * * return True # <<<<<<<<<<<<<< @@ -3954,8 +4132,8 @@ static CYTHON_INLINE int __pyx_f_18polluck_blockchain_18placeholder_native_has_l __pyx_r = 1; goto __pyx_L0; - /* "polluck_blockchain/placeholder_native.pyx":74 - * return True + /* "polluck_blockchain/placeholder_native.pyx":75 + * * * cdef inline bint has_leading_zero_bytes(const unsigned char *digest, int num_bytes) nogil: # <<<<<<<<<<<<<< * cdef int i, full_bytes = num_bytes // 8 @@ -3967,7 +4145,7 @@ static CYTHON_INLINE int __pyx_f_18polluck_blockchain_18placeholder_native_has_l return __pyx_r; } -/* "polluck_blockchain/placeholder_native.pyx":90 +/* "polluck_blockchain/placeholder_native.pyx":91 * bint ptr_owner * * def __cinit__(self, # <<<<<<<<<<<<<< @@ -4001,36 +4179,36 @@ static int __pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_1__cinit_ { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_index,&__pyx_mstate_global->__pyx_n_u_nonce,&__pyx_mstate_global->__pyx_n_u_data,&__pyx_mstate_global->__pyx_n_u_previous_hash,&__pyx_mstate_global->__pyx_n_u_from_ptr,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 90, __pyx_L3_error) + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 91, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 5: values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4); - if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 90, __pyx_L3_error) + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 91, __pyx_L3_error) CYTHON_FALLTHROUGH; case 4: values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3); - if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 90, __pyx_L3_error) + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 91, __pyx_L3_error) CYTHON_FALLTHROUGH; case 3: values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2); - if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 90, __pyx_L3_error) + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 91, __pyx_L3_error) CYTHON_FALLTHROUGH; case 2: values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); - if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 90, __pyx_L3_error) + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 91, __pyx_L3_error) CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); - if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 90, __pyx_L3_error) + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 91, __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, "__cinit__", 0) < (0)) __PYX_ERR(0, 90, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__cinit__", 0) < (0)) __PYX_ERR(0, 91, __pyx_L3_error) - /* "polluck_blockchain/placeholder_native.pyx":95 + /* "polluck_blockchain/placeholder_native.pyx":96 * data, * previous_hash, * from_ptr=False, # <<<<<<<<<<<<<< @@ -4039,23 +4217,23 @@ static int __pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_1__cinit_ */ if (!values[4]) values[4] = __Pyx_NewRef(((PyObject *)Py_False)); for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { - if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 4, 5, i); __PYX_ERR(0, 90, __pyx_L3_error) } + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 4, 5, i); __PYX_ERR(0, 91, __pyx_L3_error) } } } else { switch (__pyx_nargs) { case 5: values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4); - if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 90, __pyx_L3_error) + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 91, __pyx_L3_error) CYTHON_FALLTHROUGH; case 4: values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3); - if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 90, __pyx_L3_error) + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 91, __pyx_L3_error) values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2); - if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 90, __pyx_L3_error) + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 91, __pyx_L3_error) values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); - if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 90, __pyx_L3_error) + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 91, __pyx_L3_error) values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); - if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 90, __pyx_L3_error) + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 91, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -4069,7 +4247,7 @@ static int __pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_1__cinit_ } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 4, 5, __pyx_nargs); __PYX_ERR(0, 90, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 4, 5, __pyx_nargs); __PYX_ERR(0, 91, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -4082,7 +4260,7 @@ static int __pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_1__cinit_ __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock___cinit__(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *)__pyx_v_self), __pyx_v_index, __pyx_v_nonce, __pyx_v_data, __pyx_v_previous_hash, __pyx_v_from_ptr); - /* "polluck_blockchain/placeholder_native.pyx":90 + /* "polluck_blockchain/placeholder_native.pyx":91 * bint ptr_owner * * def __cinit__(self, # <<<<<<<<<<<<<< @@ -4104,23 +4282,21 @@ static int __pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock___cinit__ int __pyx_t_1; int __pyx_t_2; uint64_t __pyx_t_3; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; + uint64_t __pyx_t_4; + uint64_t __pyx_t_5; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; size_t __pyx_t_8; - double __pyx_t_9; - uint64_t __pyx_t_10; + std::string __pyx_t_9; + std::string __pyx_t_10; std::string __pyx_t_11; - std::string __pyx_t_12; - std::string __pyx_t_13; - ::Block *__pyx_t_14; + ::Block *__pyx_t_12; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__cinit__", 0); - /* "polluck_blockchain/placeholder_native.pyx":97 + /* "polluck_blockchain/placeholder_native.pyx":98 * from_ptr=False, * ): * self.ptr_owner = False # <<<<<<<<<<<<<< @@ -4129,160 +4305,137 @@ static int __pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock___cinit__ */ __pyx_v_self->ptr_owner = 0; - /* "polluck_blockchain/placeholder_native.pyx":98 + /* "polluck_blockchain/placeholder_native.pyx":99 * ): * self.ptr_owner = False * if not from_ptr: # <<<<<<<<<<<<<< * self.BlockC = new Block( * index, */ - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_from_ptr); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 98, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_from_ptr); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 99, __pyx_L1_error) __pyx_t_2 = (!__pyx_t_1); if (__pyx_t_2) { - /* "polluck_blockchain/placeholder_native.pyx":100 + /* "polluck_blockchain/placeholder_native.pyx":101 * if not from_ptr: * self.BlockC = new Block( * index, # <<<<<<<<<<<<<< - * int(datetime.datetime(2025, 12, 1, 12, 0, 0).timestamp()), + * current_timestamp_integer(), * nonce, */ - __pyx_t_3 = __Pyx_PyLong_As_uint64_t(__pyx_v_index); if (unlikely((__pyx_t_3 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 100, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyLong_As_uint64_t(__pyx_v_index); if (unlikely((__pyx_t_3 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 101, __pyx_L1_error) - /* "polluck_blockchain/placeholder_native.pyx":101 + /* "polluck_blockchain/placeholder_native.pyx":102 * self.BlockC = new Block( * index, - * int(datetime.datetime(2025, 12, 1, 12, 0, 0).timestamp()), # <<<<<<<<<<<<<< + * current_timestamp_integer(), # <<<<<<<<<<<<<< * nonce, * data.encode("UTF-8"), */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 101, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 101, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_mstate_global->__pyx_tuple[0], NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 101, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_5 = __pyx_t_6; - __Pyx_INCREF(__pyx_t_5); - __pyx_t_8 = 0; - { - PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; - __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_timestamp, __pyx_callargs+__pyx_t_8, (1-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 101, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - } - __pyx_t_6 = __Pyx_PyNumber_Int(__pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 101, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_9 = __Pyx_PyFloat_AsDouble(__pyx_t_6); if (unlikely((__pyx_t_9 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 101, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_4 = __pyx_f_18polluck_blockchain_18placeholder_native_current_timestamp_integer(); if (unlikely(__pyx_t_4 == ((uint64_t)-1LL) && PyErr_Occurred())) __PYX_ERR(0, 102, __pyx_L1_error) - /* "polluck_blockchain/placeholder_native.pyx":102 + /* "polluck_blockchain/placeholder_native.pyx":103 * index, - * int(datetime.datetime(2025, 12, 1, 12, 0, 0).timestamp()), + * current_timestamp_integer(), * nonce, # <<<<<<<<<<<<<< * data.encode("UTF-8"), * previous_hash.encode("UTF-8"), */ - __pyx_t_10 = __Pyx_PyLong_As_uint64_t(__pyx_v_nonce); if (unlikely((__pyx_t_10 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 102, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyLong_As_uint64_t(__pyx_v_nonce); if (unlikely((__pyx_t_5 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 103, __pyx_L1_error) - /* "polluck_blockchain/placeholder_native.pyx":103 - * int(datetime.datetime(2025, 12, 1, 12, 0, 0).timestamp()), + /* "polluck_blockchain/placeholder_native.pyx":104 + * current_timestamp_integer(), * nonce, * data.encode("UTF-8"), # <<<<<<<<<<<<<< * previous_hash.encode("UTF-8"), * "".encode("UTF-8"), */ - __pyx_t_4 = __pyx_v_data; - __Pyx_INCREF(__pyx_t_4); + __pyx_t_7 = __pyx_v_data; + __Pyx_INCREF(__pyx_t_7); __pyx_t_8 = 0; { - PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_UTF_8}; + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_mstate_global->__pyx_kp_u_UTF_8}; __pyx_t_6 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_encode, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 103, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 104, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); } - __pyx_t_11 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_t_6); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 103, __pyx_L1_error) + __pyx_t_9 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_t_6); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 104, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "polluck_blockchain/placeholder_native.pyx":104 + /* "polluck_blockchain/placeholder_native.pyx":105 * nonce, * data.encode("UTF-8"), * previous_hash.encode("UTF-8"), # <<<<<<<<<<<<<< * "".encode("UTF-8"), * ) */ - __pyx_t_4 = __pyx_v_previous_hash; - __Pyx_INCREF(__pyx_t_4); + __pyx_t_7 = __pyx_v_previous_hash; + __Pyx_INCREF(__pyx_t_7); __pyx_t_8 = 0; { - PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_UTF_8}; + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_mstate_global->__pyx_kp_u_UTF_8}; __pyx_t_6 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_encode, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 104, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 105, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); } - __pyx_t_12 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_t_6); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 104, __pyx_L1_error) + __pyx_t_10 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_t_6); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 105, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "polluck_blockchain/placeholder_native.pyx":105 + /* "polluck_blockchain/placeholder_native.pyx":106 * data.encode("UTF-8"), * previous_hash.encode("UTF-8"), * "".encode("UTF-8"), # <<<<<<<<<<<<<< * ) - * if self.BlockC == NULL: + * if self.BlockC is NULL: */ - __pyx_t_13 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_mstate_global->__pyx_kp_b_); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 105, __pyx_L1_error) + __pyx_t_11 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_mstate_global->__pyx_kp_b_); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 106, __pyx_L1_error) - /* "polluck_blockchain/placeholder_native.pyx":99 + /* "polluck_blockchain/placeholder_native.pyx":100 * self.ptr_owner = False * if not from_ptr: * self.BlockC = new Block( # <<<<<<<<<<<<<< * index, - * int(datetime.datetime(2025, 12, 1, 12, 0, 0).timestamp()), + * current_timestamp_integer(), */ try { - __pyx_t_14 = new ::Block(__pyx_t_3, __pyx_t_9, __pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_t_13); + __pyx_t_12 = new ::Block(__pyx_t_3, __pyx_t_4, __pyx_t_5, __pyx_t_9, __pyx_t_10, __pyx_t_11); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(0, 99, __pyx_L1_error) + __PYX_ERR(0, 100, __pyx_L1_error) } - __pyx_v_self->BlockC = __pyx_t_14; + __pyx_v_self->BlockC = __pyx_t_12; - /* "polluck_blockchain/placeholder_native.pyx":107 + /* "polluck_blockchain/placeholder_native.pyx":108 * "".encode("UTF-8"), * ) - * if self.BlockC == NULL: # <<<<<<<<<<<<<< + * if self.BlockC is NULL: # <<<<<<<<<<<<<< * raise MemoryError() * */ __pyx_t_2 = (__pyx_v_self->BlockC == NULL); if (unlikely(__pyx_t_2)) { - /* "polluck_blockchain/placeholder_native.pyx":108 + /* "polluck_blockchain/placeholder_native.pyx":109 * ) - * if self.BlockC == NULL: + * if self.BlockC is NULL: * raise MemoryError() # <<<<<<<<<<<<<< * * self.ptr_owner = True */ - PyErr_NoMemory(); __PYX_ERR(0, 108, __pyx_L1_error) + PyErr_NoMemory(); __PYX_ERR(0, 109, __pyx_L1_error) - /* "polluck_blockchain/placeholder_native.pyx":107 + /* "polluck_blockchain/placeholder_native.pyx":108 * "".encode("UTF-8"), * ) - * if self.BlockC == NULL: # <<<<<<<<<<<<<< + * if self.BlockC is NULL: # <<<<<<<<<<<<<< * raise MemoryError() * */ } - /* "polluck_blockchain/placeholder_native.pyx":110 + /* "polluck_blockchain/placeholder_native.pyx":111 * raise MemoryError() * * self.ptr_owner = True # <<<<<<<<<<<<<< @@ -4291,7 +4444,7 @@ static int __pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock___cinit__ */ __pyx_v_self->ptr_owner = 1; - /* "polluck_blockchain/placeholder_native.pyx":98 + /* "polluck_blockchain/placeholder_native.pyx":99 * ): * self.ptr_owner = False * if not from_ptr: # <<<<<<<<<<<<<< @@ -4300,7 +4453,7 @@ static int __pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock___cinit__ */ } - /* "polluck_blockchain/placeholder_native.pyx":90 + /* "polluck_blockchain/placeholder_native.pyx":91 * bint ptr_owner * * def __cinit__(self, # <<<<<<<<<<<<<< @@ -4312,8 +4465,6 @@ static int __pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock___cinit__ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("polluck_blockchain.placeholder_native.PyBlock.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); @@ -4323,7 +4474,7 @@ static int __pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock___cinit__ return __pyx_r; } -/* "polluck_blockchain/placeholder_native.pyx":112 +/* "polluck_blockchain/placeholder_native.pyx":113 * self.ptr_owner = True * * def __init__(self, *args, **kwargs): # <<<<<<<<<<<<<< @@ -4371,7 +4522,7 @@ static int __pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_2__init__ return __pyx_r; } -/* "polluck_blockchain/placeholder_native.pyx":115 +/* "polluck_blockchain/placeholder_native.pyx":116 * pass * * def __dealloc__(self): # <<<<<<<<<<<<<< @@ -4396,7 +4547,7 @@ static void __pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_4__deall int __pyx_t_1; int __pyx_t_2; - /* "polluck_blockchain/placeholder_native.pyx":116 + /* "polluck_blockchain/placeholder_native.pyx":117 * * def __dealloc__(self): * if self.BlockC is not NULL and self.ptr_owner is True: # <<<<<<<<<<<<<< @@ -4414,7 +4565,7 @@ static void __pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_4__deall __pyx_L4_bool_binop_done:; if (__pyx_t_1) { - /* "polluck_blockchain/placeholder_native.pyx":117 + /* "polluck_blockchain/placeholder_native.pyx":118 * def __dealloc__(self): * if self.BlockC is not NULL and self.ptr_owner is True: * del self.BlockC # <<<<<<<<<<<<<< @@ -4423,7 +4574,7 @@ static void __pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_4__deall */ delete __pyx_v_self->BlockC; - /* "polluck_blockchain/placeholder_native.pyx":118 + /* "polluck_blockchain/placeholder_native.pyx":119 * if self.BlockC is not NULL and self.ptr_owner is True: * del self.BlockC * self.BlockC = NULL # <<<<<<<<<<<<<< @@ -4432,7 +4583,7 @@ static void __pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_4__deall */ __pyx_v_self->BlockC = NULL; - /* "polluck_blockchain/placeholder_native.pyx":116 + /* "polluck_blockchain/placeholder_native.pyx":117 * * def __dealloc__(self): * if self.BlockC is not NULL and self.ptr_owner is True: # <<<<<<<<<<<<<< @@ -4441,7 +4592,7 @@ static void __pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_4__deall */ } - /* "polluck_blockchain/placeholder_native.pyx":115 + /* "polluck_blockchain/placeholder_native.pyx":116 * pass * * def __dealloc__(self): # <<<<<<<<<<<<<< @@ -4452,7 +4603,7 @@ static void __pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_4__deall /* function exit code */ } -/* "polluck_blockchain/placeholder_native.pyx":120 +/* "polluck_blockchain/placeholder_native.pyx":121 * self.BlockC = NULL * * @staticmethod # <<<<<<<<<<<<<< @@ -4462,7 +4613,7 @@ static void __pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_4__deall static struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_f_18polluck_blockchain_18placeholder_native_7PyBlock_from_ptr(::Block *__pyx_v_block, struct __pyx_opt_args_18polluck_blockchain_18placeholder_native_7PyBlock_from_ptr *__pyx_optional_args) { - /* "polluck_blockchain/placeholder_native.pyx":121 + /* "polluck_blockchain/placeholder_native.pyx":122 * * @staticmethod * cdef PyBlock from_ptr(Block *block, bint owner=False): # <<<<<<<<<<<<<< @@ -4488,77 +4639,77 @@ static struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx } } - /* "polluck_blockchain/placeholder_native.pyx":124 + /* "polluck_blockchain/placeholder_native.pyx":125 * cdef PyBlock py_block = PyBlock.__new__( * PyBlock, * block.index, # <<<<<<<<<<<<<< * block.nonce, * block.data, */ - __pyx_t_1 = __Pyx_PyLong_From_uint64_t(__pyx_v_block->index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 124, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_uint64_t(__pyx_v_block->index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 125, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - /* "polluck_blockchain/placeholder_native.pyx":125 + /* "polluck_blockchain/placeholder_native.pyx":126 * PyBlock, * block.index, * block.nonce, # <<<<<<<<<<<<<< * block.data, * block.prev_hash, */ - __pyx_t_2 = __Pyx_PyLong_From_uint64_t(__pyx_v_block->nonce); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 125, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyLong_From_uint64_t(__pyx_v_block->nonce); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 126, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "polluck_blockchain/placeholder_native.pyx":126 + /* "polluck_blockchain/placeholder_native.pyx":127 * block.index, * block.nonce, * block.data, # <<<<<<<<<<<<<< * block.prev_hash, * True, */ - __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_6libcpp_6string_std__in_string(__pyx_v_block->data); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 126, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_6libcpp_6string_std__in_string(__pyx_v_block->data); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 127, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - /* "polluck_blockchain/placeholder_native.pyx":127 + /* "polluck_blockchain/placeholder_native.pyx":128 * block.nonce, * block.data, * block.prev_hash, # <<<<<<<<<<<<<< * True, * ) */ - __pyx_t_4 = __pyx_convert_PyBytes_string_to_py_6libcpp_6string_std__in_string(__pyx_v_block->prev_hash); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 127, __pyx_L1_error) + __pyx_t_4 = __pyx_convert_PyBytes_string_to_py_6libcpp_6string_std__in_string(__pyx_v_block->prev_hash); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 128, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - /* "polluck_blockchain/placeholder_native.pyx":122 + /* "polluck_blockchain/placeholder_native.pyx":123 * @staticmethod * cdef PyBlock from_ptr(Block *block, bint owner=False): * cdef PyBlock py_block = PyBlock.__new__( # <<<<<<<<<<<<<< * PyBlock, * block.index, */ - __pyx_t_5 = PyTuple_New(5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 122, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 122, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 123, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 122, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 123, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3) != (0)) __PYX_ERR(0, 122, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3) != (0)) __PYX_ERR(0, 123, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4) != (0)) __PYX_ERR(0, 122, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4) != (0)) __PYX_ERR(0, 123, __pyx_L1_error); __Pyx_INCREF(Py_True); __Pyx_GIVEREF(Py_True); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 4, Py_True) != (0)) __PYX_ERR(0, 122, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 4, Py_True) != (0)) __PYX_ERR(0, 123, __pyx_L1_error); __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_3 = 0; __pyx_t_4 = 0; - __pyx_t_4 = ((PyObject *)__pyx_tp_new_18polluck_blockchain_18placeholder_native_PyBlock(((PyTypeObject *)__pyx_mstate_global->__pyx_ptype_18polluck_blockchain_18placeholder_native_PyBlock), __pyx_t_5, NULL)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 122, __pyx_L1_error) + __pyx_t_4 = ((PyObject *)__pyx_tp_new_18polluck_blockchain_18placeholder_native_PyBlock(((PyTypeObject *)__pyx_mstate_global->__pyx_ptype_18polluck_blockchain_18placeholder_native_PyBlock), __pyx_t_5, NULL)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF((PyObject *)__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_py_block = ((struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *)__pyx_t_4); __pyx_t_4 = 0; - /* "polluck_blockchain/placeholder_native.pyx":130 + /* "polluck_blockchain/placeholder_native.pyx":131 * True, * ) * py_block.BlockC = block # <<<<<<<<<<<<<< @@ -4567,7 +4718,7 @@ static struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx */ __pyx_v_py_block->BlockC = __pyx_v_block; - /* "polluck_blockchain/placeholder_native.pyx":131 + /* "polluck_blockchain/placeholder_native.pyx":132 * ) * py_block.BlockC = block * py_block.ptr_owner = owner # <<<<<<<<<<<<<< @@ -4576,7 +4727,7 @@ static struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx */ __pyx_v_py_block->ptr_owner = __pyx_v_owner; - /* "polluck_blockchain/placeholder_native.pyx":133 + /* "polluck_blockchain/placeholder_native.pyx":134 * py_block.ptr_owner = owner * * return py_block # <<<<<<<<<<<<<< @@ -4588,7 +4739,7 @@ static struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx __pyx_r = __pyx_v_py_block; goto __pyx_L0; - /* "polluck_blockchain/placeholder_native.pyx":120 + /* "polluck_blockchain/placeholder_native.pyx":121 * self.BlockC = NULL * * @staticmethod # <<<<<<<<<<<<<< @@ -4612,12 +4763,12 @@ static struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx return __pyx_r; } -/* "polluck_blockchain/placeholder_native.pyx":135 +/* "polluck_blockchain/placeholder_native.pyx":136 * return py_block * * def __repr__(self): # <<<<<<<<<<<<<< - * return f"PyBlock({self.index, self.timestamp, self.nonce, self.data})" - * + * return ( + * f"PyBlock(\n\tIndex:\t\t{self.index}\n\ttimestamp:\t{self.timestamp}\n\tnonce:\t\t{self.nonce}\n\t" */ /* Python wrapper */ @@ -4643,62 +4794,108 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_6__ PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6[3]; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8[13]; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__repr__", 0); - /* "polluck_blockchain/placeholder_native.pyx":136 + /* "polluck_blockchain/placeholder_native.pyx":137 * * def __repr__(self): - * return f"PyBlock({self.index, self.timestamp, self.nonce, self.data})" # <<<<<<<<<<<<<< - * - * def __str__(self): + * return ( # <<<<<<<<<<<<<< + * f"PyBlock(\n\tIndex:\t\t{self.index}\n\ttimestamp:\t{self.timestamp}\n\tnonce:\t\t{self.nonce}\n\t" + * f"Prev Hash:\t{self.prev_hash}\n\tHash:\t\t{self.hash}\n\tData:\t\t{self.data}\n)" */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 136, __pyx_L1_error) + + /* "polluck_blockchain/placeholder_native.pyx":138 + * def __repr__(self): + * return ( + * f"PyBlock(\n\tIndex:\t\t{self.index}\n\ttimestamp:\t{self.timestamp}\n\tnonce:\t\t{self.nonce}\n\t" # <<<<<<<<<<<<<< + * f"Prev Hash:\t{self.prev_hash}\n\tHash:\t\t{self.hash}\n\tData:\t\t{self.data}\n)" + * ) +*/ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 138, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_timestamp); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_1, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 138, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_nonce); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_timestamp); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_t_1, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 138, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_data); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_nonce); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_t_1, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 138, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 136, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 136, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 136, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3) != (0)) __PYX_ERR(0, 136, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4) != (0)) __PYX_ERR(0, 136, __pyx_L1_error); - __pyx_t_1 = 0; - __pyx_t_2 = 0; - __pyx_t_3 = 0; - __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_t_5, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 136, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_6[0] = __pyx_mstate_global->__pyx_kp_u_PyBlock; - __pyx_t_6[1] = __pyx_t_4; - __pyx_t_6[2] = __pyx_mstate_global->__pyx_kp_u__2; - __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_6, 3, 8 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4)); - if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":139 + * return ( + * f"PyBlock(\n\tIndex:\t\t{self.index}\n\ttimestamp:\t{self.timestamp}\n\tnonce:\t\t{self.nonce}\n\t" + * f"Prev Hash:\t{self.prev_hash}\n\tHash:\t\t{self.hash}\n\tData:\t\t{self.data}\n)" # <<<<<<<<<<<<<< + * ) + * +*/ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_prev_hash); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_FormatSimple(__pyx_t_1, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 139, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_hash); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_1, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_1, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_8[0] = __pyx_mstate_global->__pyx_kp_u_PyBlock_Index; + __pyx_t_8[1] = __pyx_t_2; + __pyx_t_8[2] = __pyx_mstate_global->__pyx_kp_u_timestamp_2; + __pyx_t_8[3] = __pyx_t_3; + __pyx_t_8[4] = __pyx_mstate_global->__pyx_kp_u_nonce_2; + __pyx_t_8[5] = __pyx_t_4; + __pyx_t_8[6] = __pyx_mstate_global->__pyx_kp_u_Prev_Hash; + __pyx_t_8[7] = __pyx_t_5; + __pyx_t_8[8] = __pyx_mstate_global->__pyx_kp_u_Hash; + __pyx_t_8[9] = __pyx_t_6; + __pyx_t_8[10] = __pyx_mstate_global->__pyx_kp_u_Data; + __pyx_t_8[11] = __pyx_t_7; + __pyx_t_8[12] = __pyx_mstate_global->__pyx_kp_u__2; + + /* "polluck_blockchain/placeholder_native.pyx":138 + * def __repr__(self): + * return ( + * f"PyBlock(\n\tIndex:\t\t{self.index}\n\ttimestamp:\t{self.timestamp}\n\tnonce:\t\t{self.nonce}\n\t" # <<<<<<<<<<<<<< + * f"Prev Hash:\t{self.prev_hash}\n\tHash:\t\t{self.hash}\n\tData:\t\t{self.data}\n)" + * ) +*/ + __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_8, 13, 18 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2) + 13 * 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + 10 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + 9 * 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7) + 2, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7)); + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; goto __pyx_L0; - /* "polluck_blockchain/placeholder_native.pyx":135 + /* "polluck_blockchain/placeholder_native.pyx":136 * return py_block * * def __repr__(self): # <<<<<<<<<<<<<< - * return f"PyBlock({self.index, self.timestamp, self.nonce, self.data})" - * + * return ( + * f"PyBlock(\n\tIndex:\t\t{self.index}\n\ttimestamp:\t{self.timestamp}\n\tnonce:\t\t{self.nonce}\n\t" */ /* function exit code */ @@ -4708,6 +4905,8 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_6__ __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("polluck_blockchain.placeholder_native.PyBlock.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -4716,8 +4915,8 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_6__ return __pyx_r; } -/* "polluck_blockchain/placeholder_native.pyx":138 - * return f"PyBlock({self.index, self.timestamp, self.nonce, self.data})" +/* "polluck_blockchain/placeholder_native.pyx":142 + * ) * * def __str__(self): # <<<<<<<<<<<<<< * return self.__repr__() @@ -4750,12 +4949,12 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_8__ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__str__", 0); - /* "polluck_blockchain/placeholder_native.pyx":139 + /* "polluck_blockchain/placeholder_native.pyx":143 * * def __str__(self): * return self.__repr__() # <<<<<<<<<<<<<< * - * # Python public API + * def serialize_dict(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = ((PyObject *)__pyx_v_self); @@ -4765,15 +4964,15 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_8__ PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_repr, __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, 139, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 143, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "polluck_blockchain/placeholder_native.pyx":138 - * return f"PyBlock({self.index, self.timestamp, self.nonce, self.data})" + /* "polluck_blockchain/placeholder_native.pyx":142 + * ) * * def __str__(self): # <<<<<<<<<<<<<< * return self.__repr__() @@ -4792,7 +4991,183 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_8__ return __pyx_r; } -/* "polluck_blockchain/placeholder_native.pyx":142 +/* "polluck_blockchain/placeholder_native.pyx":145 + * return self.__repr__() + * + * def serialize_dict(self): # <<<<<<<<<<<<<< + * contents = {} + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_11serialize_dict(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_18polluck_blockchain_18placeholder_native_7PyBlock_11serialize_dict = {"serialize_dict", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_11serialize_dict, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_11serialize_dict(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("serialize_dict (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("serialize_dict", 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("serialize_dict", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_10serialize_dict(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_10serialize_dict(struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_v_self) { + PyObject *__pyx_v_contents = NULL; + 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("serialize_dict", 0); + + /* "polluck_blockchain/placeholder_native.pyx":146 + * + * def serialize_dict(self): + * contents = {} # <<<<<<<<<<<<<< + * + * contents["index"] = self.BlockC.index +*/ + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_contents = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":148 + * contents = {} + * + * contents["index"] = self.BlockC.index # <<<<<<<<<<<<<< + * contents["timestamp"] = self.BlockC.timestamp + * contents["nonce"] = self.BlockC.nonce +*/ + __pyx_t_1 = __Pyx_PyLong_From_uint64_t(__pyx_v_self->BlockC->index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_contents, __pyx_mstate_global->__pyx_n_u_index, __pyx_t_1) < 0))) __PYX_ERR(0, 148, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":149 + * + * contents["index"] = self.BlockC.index + * contents["timestamp"] = self.BlockC.timestamp # <<<<<<<<<<<<<< + * contents["nonce"] = self.BlockC.nonce + * contents["previous_hash"] = self.prev_hash +*/ + __pyx_t_1 = __Pyx_PyLong_From_uint64_t(__pyx_v_self->BlockC->timestamp); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_contents, __pyx_mstate_global->__pyx_n_u_timestamp, __pyx_t_1) < 0))) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":150 + * contents["index"] = self.BlockC.index + * contents["timestamp"] = self.BlockC.timestamp + * contents["nonce"] = self.BlockC.nonce # <<<<<<<<<<<<<< + * contents["previous_hash"] = self.prev_hash + * contents["hash"] = self.hash +*/ + __pyx_t_1 = __Pyx_PyLong_From_uint64_t(__pyx_v_self->BlockC->nonce); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_contents, __pyx_mstate_global->__pyx_n_u_nonce, __pyx_t_1) < 0))) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":151 + * contents["timestamp"] = self.BlockC.timestamp + * contents["nonce"] = self.BlockC.nonce + * contents["previous_hash"] = self.prev_hash # <<<<<<<<<<<<<< + * contents["hash"] = self.hash + * contents["data"] = self.data +*/ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_prev_hash); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_contents, __pyx_mstate_global->__pyx_n_u_previous_hash, __pyx_t_1) < 0))) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":152 + * contents["nonce"] = self.BlockC.nonce + * contents["previous_hash"] = self.prev_hash + * contents["hash"] = self.hash # <<<<<<<<<<<<<< + * contents["data"] = self.data + * +*/ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_hash); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_contents, __pyx_mstate_global->__pyx_n_u_hash, __pyx_t_1) < 0))) __PYX_ERR(0, 152, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":153 + * contents["previous_hash"] = self.prev_hash + * contents["hash"] = self.hash + * contents["data"] = self.data # <<<<<<<<<<<<<< + * + * return contents +*/ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_contents, __pyx_mstate_global->__pyx_n_u_data, __pyx_t_1) < 0))) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":155 + * contents["data"] = self.data + * + * return contents # <<<<<<<<<<<<<< + * + * # Python public API +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_contents); + __pyx_r = __pyx_v_contents; + goto __pyx_L0; + + /* "polluck_blockchain/placeholder_native.pyx":145 + * return self.__repr__() + * + * def serialize_dict(self): # <<<<<<<<<<<<<< + * contents = {} + * +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("polluck_blockchain.placeholder_native.PyBlock.serialize_dict", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_contents); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "polluck_blockchain/placeholder_native.pyx":158 * * # Python public API * @property # <<<<<<<<<<<<<< @@ -4824,7 +5199,7 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_5in int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); - /* "polluck_blockchain/placeholder_native.pyx":144 + /* "polluck_blockchain/placeholder_native.pyx":160 * @property * def index(self): * return self.BlockC.index # <<<<<<<<<<<<<< @@ -4832,13 +5207,13 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_5in * @property */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyLong_From_uint64_t(__pyx_v_self->BlockC->index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 144, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_uint64_t(__pyx_v_self->BlockC->index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "polluck_blockchain/placeholder_native.pyx":142 + /* "polluck_blockchain/placeholder_native.pyx":158 * * # Python public API * @property # <<<<<<<<<<<<<< @@ -4857,7 +5232,7 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_5in return __pyx_r; } -/* "polluck_blockchain/placeholder_native.pyx":146 +/* "polluck_blockchain/placeholder_native.pyx":162 * return self.BlockC.index * * @property # <<<<<<<<<<<<<< @@ -4889,7 +5264,7 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_9ti int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); - /* "polluck_blockchain/placeholder_native.pyx":148 + /* "polluck_blockchain/placeholder_native.pyx":164 * @property * def timestamp(self): * return timestamp_to_datetime(self.BlockC.timestamp) # <<<<<<<<<<<<<< @@ -4897,13 +5272,13 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_9ti * @property */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_f_18polluck_blockchain_18placeholder_native_timestamp_to_datetime(__pyx_v_self->BlockC->timestamp); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 148, __pyx_L1_error) + __pyx_t_1 = __pyx_f_18polluck_blockchain_18placeholder_native_timestamp_to_datetime(__pyx_v_self->BlockC->timestamp); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 164, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "polluck_blockchain/placeholder_native.pyx":146 + /* "polluck_blockchain/placeholder_native.pyx":162 * return self.BlockC.index * * @property # <<<<<<<<<<<<<< @@ -4922,7 +5297,7 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_9ti return __pyx_r; } -/* "polluck_blockchain/placeholder_native.pyx":150 +/* "polluck_blockchain/placeholder_native.pyx":166 * return timestamp_to_datetime(self.BlockC.timestamp) * * @property # <<<<<<<<<<<<<< @@ -4954,7 +5329,7 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_4da int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); - /* "polluck_blockchain/placeholder_native.pyx":152 + /* "polluck_blockchain/placeholder_native.pyx":168 * @property * def data(self): * return self.BlockC.data.decode("UTF-8") # <<<<<<<<<<<<<< @@ -4962,13 +5337,13 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_4da * @property */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_decode_cpp_string(__pyx_v_self->BlockC->data, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 152, __pyx_L1_error) + __pyx_t_1 = __Pyx_decode_cpp_string(__pyx_v_self->BlockC->data, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 168, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "polluck_blockchain/placeholder_native.pyx":150 + /* "polluck_blockchain/placeholder_native.pyx":166 * return timestamp_to_datetime(self.BlockC.timestamp) * * @property # <<<<<<<<<<<<<< @@ -4987,7 +5362,7 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_4da return __pyx_r; } -/* "polluck_blockchain/placeholder_native.pyx":154 +/* "polluck_blockchain/placeholder_native.pyx":170 * return self.BlockC.data.decode("UTF-8") * * @property # <<<<<<<<<<<<<< @@ -5019,7 +5394,7 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_9pr int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); - /* "polluck_blockchain/placeholder_native.pyx":156 + /* "polluck_blockchain/placeholder_native.pyx":172 * @property * def prev_hash(self): * return self.BlockC.prev_hash.decode("UTF-8") # <<<<<<<<<<<<<< @@ -5027,13 +5402,13 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_9pr * @property */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_decode_cpp_string(__pyx_v_self->BlockC->prev_hash, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 156, __pyx_L1_error) + __pyx_t_1 = __Pyx_decode_cpp_string(__pyx_v_self->BlockC->prev_hash, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 172, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "polluck_blockchain/placeholder_native.pyx":154 + /* "polluck_blockchain/placeholder_native.pyx":170 * return self.BlockC.data.decode("UTF-8") * * @property # <<<<<<<<<<<<<< @@ -5052,7 +5427,7 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_9pr return __pyx_r; } -/* "polluck_blockchain/placeholder_native.pyx":158 +/* "polluck_blockchain/placeholder_native.pyx":174 * return self.BlockC.prev_hash.decode("UTF-8") * * @property # <<<<<<<<<<<<<< @@ -5084,7 +5459,7 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_5no int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); - /* "polluck_blockchain/placeholder_native.pyx":160 + /* "polluck_blockchain/placeholder_native.pyx":176 * @property * def nonce(self): * return self.BlockC.nonce # <<<<<<<<<<<<<< @@ -5092,13 +5467,13 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_5no * @property */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyLong_From_uint64_t(__pyx_v_self->BlockC->nonce); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_uint64_t(__pyx_v_self->BlockC->nonce); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 176, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "polluck_blockchain/placeholder_native.pyx":158 + /* "polluck_blockchain/placeholder_native.pyx":174 * return self.BlockC.prev_hash.decode("UTF-8") * * @property # <<<<<<<<<<<<<< @@ -5117,7 +5492,7 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_5no return __pyx_r; } -/* "polluck_blockchain/placeholder_native.pyx":162 +/* "polluck_blockchain/placeholder_native.pyx":178 * return self.BlockC.nonce * * @property # <<<<<<<<<<<<<< @@ -5149,7 +5524,7 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_4ha int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); - /* "polluck_blockchain/placeholder_native.pyx":164 + /* "polluck_blockchain/placeholder_native.pyx":180 * @property * def hash(self): * return self.BlockC.hash.decode("UTF-8") # <<<<<<<<<<<<<< @@ -5157,13 +5532,13 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_4ha * def bytes_serialize(self): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_decode_cpp_string(__pyx_v_self->BlockC->hash, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 164, __pyx_L1_error) + __pyx_t_1 = __Pyx_decode_cpp_string(__pyx_v_self->BlockC->hash, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 180, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "polluck_blockchain/placeholder_native.pyx":162 + /* "polluck_blockchain/placeholder_native.pyx":178 * return self.BlockC.nonce * * @property # <<<<<<<<<<<<<< @@ -5182,7 +5557,7 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_4ha return __pyx_r; } -/* "polluck_blockchain/placeholder_native.pyx":166 +/* "polluck_blockchain/placeholder_native.pyx":182 * return self.BlockC.hash.decode("UTF-8") * * def bytes_serialize(self): # <<<<<<<<<<<<<< @@ -5191,15 +5566,15 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_4ha */ /* Python wrapper */ -static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_11bytes_serialize(PyObject *__pyx_v_self, +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_13bytes_serialize(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyMethodDef __pyx_mdef_18polluck_blockchain_18placeholder_native_7PyBlock_11bytes_serialize = {"bytes_serialize", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_11bytes_serialize, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_11bytes_serialize(PyObject *__pyx_v_self, +static PyMethodDef __pyx_mdef_18polluck_blockchain_18placeholder_native_7PyBlock_13bytes_serialize = {"bytes_serialize", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_13bytes_serialize, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_13bytes_serialize(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -5225,14 +5600,14 @@ PyObject *__pyx_args, PyObject *__pyx_kwds 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("bytes_serialize", __pyx_kwds); return NULL;} - __pyx_r = __pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_10bytes_serialize(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *)__pyx_v_self)); + __pyx_r = __pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_12bytes_serialize(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_10bytes_serialize(struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_v_self) { +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_12bytes_serialize(struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_v_self) { unsigned char *__pyx_v_serialize_res; size_t __pyx_v_serialize_size; PyObject *__pyx_r = NULL; @@ -5253,7 +5628,7 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_10b int __pyx_clineno = 0; __Pyx_RefNannySetupContext("bytes_serialize", 0); - /* "polluck_blockchain/placeholder_native.pyx":170 + /* "polluck_blockchain/placeholder_native.pyx":186 * unsigned char *serialize_res * size_t serialize_size * try: # <<<<<<<<<<<<<< @@ -5262,17 +5637,17 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_10b */ /*try:*/ { - /* "polluck_blockchain/placeholder_native.pyx":171 + /* "polluck_blockchain/placeholder_native.pyx":187 * size_t serialize_size * try: * serialize_res = bytes_serialize_c(self.BlockC, &serialize_size) # <<<<<<<<<<<<<< * return serialize_res[:serialize_size] * finally: */ - __pyx_t_1 = __pyx_f_18polluck_blockchain_18placeholder_native_bytes_serialize_c(__pyx_v_self->BlockC, (&__pyx_v_serialize_size)); if (unlikely(__pyx_t_1 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 171, __pyx_L4_error) + __pyx_t_1 = __pyx_f_18polluck_blockchain_18placeholder_native_bytes_serialize_c(__pyx_v_self->BlockC, (&__pyx_v_serialize_size)); if (unlikely(__pyx_t_1 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 187, __pyx_L4_error) __pyx_v_serialize_res = __pyx_t_1; - /* "polluck_blockchain/placeholder_native.pyx":172 + /* "polluck_blockchain/placeholder_native.pyx":188 * try: * serialize_res = bytes_serialize_c(self.BlockC, &serialize_size) * return serialize_res[:serialize_size] # <<<<<<<<<<<<<< @@ -5280,14 +5655,14 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_10b * free(serialize_res) */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyBytes_FromStringAndSize(((char const *)__pyx_v_serialize_res) + 0, __pyx_v_serialize_size - 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 172, __pyx_L4_error) + __pyx_t_2 = __Pyx_PyBytes_FromStringAndSize(((char const *)__pyx_v_serialize_res) + 0, __pyx_v_serialize_size - 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 188, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L3_return; } - /* "polluck_blockchain/placeholder_native.pyx":174 + /* "polluck_blockchain/placeholder_native.pyx":190 * return serialize_res[:serialize_size] * finally: * free(serialize_res) # <<<<<<<<<<<<<< @@ -5335,7 +5710,7 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_10b } } - /* "polluck_blockchain/placeholder_native.pyx":166 + /* "polluck_blockchain/placeholder_native.pyx":182 * return self.BlockC.hash.decode("UTF-8") * * def bytes_serialize(self): # <<<<<<<<<<<<<< @@ -5354,7 +5729,7 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_10b return __pyx_r; } -/* "polluck_blockchain/placeholder_native.pyx":177 +/* "polluck_blockchain/placeholder_native.pyx":193 * * * def perform_hash(self): # <<<<<<<<<<<<<< @@ -5363,15 +5738,15 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_10b */ /* Python wrapper */ -static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_13perform_hash(PyObject *__pyx_v_self, +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_15perform_hash(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyMethodDef __pyx_mdef_18polluck_blockchain_18placeholder_native_7PyBlock_13perform_hash = {"perform_hash", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_13perform_hash, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_13perform_hash(PyObject *__pyx_v_self, +static PyMethodDef __pyx_mdef_18polluck_blockchain_18placeholder_native_7PyBlock_15perform_hash = {"perform_hash", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_15perform_hash, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_15perform_hash(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -5397,14 +5772,14 @@ PyObject *__pyx_args, PyObject *__pyx_kwds 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("perform_hash", __pyx_kwds); return NULL;} - __pyx_r = __pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_12perform_hash(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *)__pyx_v_self)); + __pyx_r = __pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_14perform_hash(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_12perform_hash(struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_v_self) { +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_14perform_hash(struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_v_self) { unsigned char *__pyx_v_digest; size_t __pyx_v_digest_size; PyObject *__pyx_r = NULL; @@ -5432,54 +5807,54 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_12p int __pyx_clineno = 0; __Pyx_RefNannySetupContext("perform_hash", 0); - /* "polluck_blockchain/placeholder_native.pyx":182 + /* "polluck_blockchain/placeholder_native.pyx":198 * size_t digest_size * * try: # <<<<<<<<<<<<<< * digest = perform_hash_c(self.BlockC, &digest_size) - * if digest == NULL: + * if digest is NULL: */ /*try:*/ { - /* "polluck_blockchain/placeholder_native.pyx":183 + /* "polluck_blockchain/placeholder_native.pyx":199 * * try: * digest = perform_hash_c(self.BlockC, &digest_size) # <<<<<<<<<<<<<< - * if digest == NULL: + * if digest is NULL: * raise MemoryError() */ - __pyx_t_1 = __pyx_f_18polluck_blockchain_18placeholder_native_perform_hash_c(__pyx_v_self->BlockC, (&__pyx_v_digest_size)); if (unlikely(__pyx_t_1 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 183, __pyx_L4_error) + __pyx_t_1 = __pyx_f_18polluck_blockchain_18placeholder_native_perform_hash_c(__pyx_v_self->BlockC, (&__pyx_v_digest_size)); if (unlikely(__pyx_t_1 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 199, __pyx_L4_error) __pyx_v_digest = __pyx_t_1; - /* "polluck_blockchain/placeholder_native.pyx":184 + /* "polluck_blockchain/placeholder_native.pyx":200 * try: * digest = perform_hash_c(self.BlockC, &digest_size) - * if digest == NULL: # <<<<<<<<<<<<<< + * if digest is NULL: # <<<<<<<<<<<<<< * raise MemoryError() * # TODO out: hash assignment in blockchain */ __pyx_t_2 = (__pyx_v_digest == NULL); if (unlikely(__pyx_t_2)) { - /* "polluck_blockchain/placeholder_native.pyx":185 + /* "polluck_blockchain/placeholder_native.pyx":201 * digest = perform_hash_c(self.BlockC, &digest_size) - * if digest == NULL: + * if digest is NULL: * raise MemoryError() # <<<<<<<<<<<<<< * # TODO out: hash assignment in blockchain * self.BlockC.hash = bytes(digest[:digest_size]).hex().encode("UTF-8") */ - PyErr_NoMemory(); __PYX_ERR(0, 185, __pyx_L4_error) + PyErr_NoMemory(); __PYX_ERR(0, 201, __pyx_L4_error) - /* "polluck_blockchain/placeholder_native.pyx":184 + /* "polluck_blockchain/placeholder_native.pyx":200 * try: * digest = perform_hash_c(self.BlockC, &digest_size) - * if digest == NULL: # <<<<<<<<<<<<<< + * if digest is NULL: # <<<<<<<<<<<<<< * raise MemoryError() * # TODO out: hash assignment in blockchain */ } - /* "polluck_blockchain/placeholder_native.pyx":187 + /* "polluck_blockchain/placeholder_native.pyx":203 * raise MemoryError() * # TODO out: hash assignment in blockchain * self.BlockC.hash = bytes(digest[:digest_size]).hex().encode("UTF-8") # <<<<<<<<<<<<<< @@ -5487,7 +5862,7 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_12p * free(digest) */ __pyx_t_6 = NULL; - __pyx_t_7 = __Pyx_PyBytes_FromStringAndSize(((char const *)__pyx_v_digest) + 0, __pyx_v_digest_size - 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 187, __pyx_L4_error) + __pyx_t_7 = __Pyx_PyBytes_FromStringAndSize(((char const *)__pyx_v_digest) + 0, __pyx_v_digest_size - 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 203, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = 1; { @@ -5495,7 +5870,7 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_12p __pyx_t_5 = __Pyx_PyObject_FastCall((PyObject*)(&PyBytes_Type), __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 187, __pyx_L4_error) + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 203, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_5); } __pyx_t_4 = __pyx_t_5; @@ -5506,18 +5881,18 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_12p __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_hex, __pyx_callargs+__pyx_t_8, (1-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 187, __pyx_L4_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 203, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_3); } - __pyx_t_5 = PyUnicode_AsUTF8String(((PyObject*)__pyx_t_3)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 187, __pyx_L4_error) + __pyx_t_5 = PyUnicode_AsUTF8String(((PyObject*)__pyx_t_3)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 203, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_9 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_t_5); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 187, __pyx_L4_error) + __pyx_t_9 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_t_5); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 203, __pyx_L4_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_self->BlockC->hash = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_9); } - /* "polluck_blockchain/placeholder_native.pyx":189 + /* "polluck_blockchain/placeholder_native.pyx":205 * self.BlockC.hash = bytes(digest[:digest_size]).hex().encode("UTF-8") * finally: * free(digest) # <<<<<<<<<<<<<< @@ -5566,7 +5941,7 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_12p __pyx_L5:; } - /* "polluck_blockchain/placeholder_native.pyx":191 + /* "polluck_blockchain/placeholder_native.pyx":207 * free(digest) * # TODO rework * return self.hash # <<<<<<<<<<<<<< @@ -5574,13 +5949,13 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_12p * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_hash); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 191, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_hash); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 207, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; - /* "polluck_blockchain/placeholder_native.pyx":177 + /* "polluck_blockchain/placeholder_native.pyx":193 * * * def perform_hash(self): # <<<<<<<<<<<<<< @@ -5610,15 +5985,15 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_12p */ /* Python wrapper */ -static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_15__reduce_cython__(PyObject *__pyx_v_self, +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_17__reduce_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyMethodDef __pyx_mdef_18polluck_blockchain_18placeholder_native_7PyBlock_15__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_15__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_15__reduce_cython__(PyObject *__pyx_v_self, +static PyMethodDef __pyx_mdef_18polluck_blockchain_18placeholder_native_7PyBlock_17__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_17__reduce_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -5644,14 +6019,14 @@ PyObject *__pyx_args, PyObject *__pyx_kwds 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_18polluck_blockchain_18placeholder_native_7PyBlock_14__reduce_cython__(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *)__pyx_v_self)); + __pyx_r = __pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_16__reduce_cython__(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_14__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_v_self) { +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_16__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; @@ -5691,15 +6066,15 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_14_ */ /* Python wrapper */ -static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_17__setstate_cython__(PyObject *__pyx_v_self, +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_19__setstate_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyMethodDef __pyx_mdef_18polluck_blockchain_18placeholder_native_7PyBlock_17__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_17__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_17__setstate_cython__(PyObject *__pyx_v_self, +static PyMethodDef __pyx_mdef_18polluck_blockchain_18placeholder_native_7PyBlock_19__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_19__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_19__setstate_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -5765,7 +6140,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_16__setstate_cython__(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *)__pyx_v_self), __pyx_v___pyx_state); + __pyx_r = __pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_18__setstate_cython__(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *)__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) { @@ -5775,7 +6150,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds return __pyx_r; } -static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_16__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_18__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; @@ -5807,7 +6182,7 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_7PyBlock_16_ return __pyx_r; } -/* "polluck_blockchain/placeholder_native.pyx":194 +/* "polluck_blockchain/placeholder_native.pyx":210 * * * cdef unsigned char* bytes_serialize_c(Block *block, size_t *size) nogil: # <<<<<<<<<<<<<< @@ -5826,7 +6201,7 @@ static unsigned char *__pyx_f_18polluck_blockchain_18placeholder_native_bytes_se int __pyx_clineno = 0; PyGILState_STATE __pyx_gilstate_save; - /* "polluck_blockchain/placeholder_native.pyx":198 + /* "polluck_blockchain/placeholder_native.pyx":214 * size_t total_len * unsigned char* buf * size_t pos = 0 # <<<<<<<<<<<<<< @@ -5835,7 +6210,7 @@ static unsigned char *__pyx_f_18polluck_blockchain_18placeholder_native_bytes_se */ __pyx_v_pos = 0; - /* "polluck_blockchain/placeholder_native.pyx":201 + /* "polluck_blockchain/placeholder_native.pyx":217 * * # index (8), timestamp (8), nonce (8), data, prev_hash * size[0] = ( # <<<<<<<<<<<<<< @@ -5844,28 +6219,28 @@ static unsigned char *__pyx_f_18polluck_blockchain_18placeholder_native_bytes_se */ (__pyx_v_size[0]) = ((((size_t)0x18) + __pyx_v_block->data.size()) + __pyx_v_block->prev_hash.size()); - /* "polluck_blockchain/placeholder_native.pyx":206 + /* "polluck_blockchain/placeholder_native.pyx":222 * block.prev_hash.size() * ) * buf = malloc(size[0] * sizeof(unsigned char)) # <<<<<<<<<<<<<< * - * if buf == NULL: + * if buf is NULL: */ __pyx_v_buf = ((unsigned char *)malloc(((__pyx_v_size[0]) * (sizeof(unsigned char))))); - /* "polluck_blockchain/placeholder_native.pyx":208 + /* "polluck_blockchain/placeholder_native.pyx":224 * buf = malloc(size[0] * sizeof(unsigned char)) * - * if buf == NULL: # <<<<<<<<<<<<<< + * if buf is NULL: # <<<<<<<<<<<<<< * return NULL * */ __pyx_t_1 = (__pyx_v_buf == NULL); if (__pyx_t_1) { - /* "polluck_blockchain/placeholder_native.pyx":209 + /* "polluck_blockchain/placeholder_native.pyx":225 * - * if buf == NULL: + * if buf is NULL: * return NULL # <<<<<<<<<<<<<< * * serialize_uint64(buf + pos, block.index) @@ -5873,25 +6248,25 @@ static unsigned char *__pyx_f_18polluck_blockchain_18placeholder_native_bytes_se __pyx_r = NULL; goto __pyx_L0; - /* "polluck_blockchain/placeholder_native.pyx":208 + /* "polluck_blockchain/placeholder_native.pyx":224 * buf = malloc(size[0] * sizeof(unsigned char)) * - * if buf == NULL: # <<<<<<<<<<<<<< + * if buf is NULL: # <<<<<<<<<<<<<< * return NULL * */ } - /* "polluck_blockchain/placeholder_native.pyx":211 + /* "polluck_blockchain/placeholder_native.pyx":227 * return NULL * * serialize_uint64(buf + pos, block.index) # <<<<<<<<<<<<<< * pos += 8 * serialize_uint64(buf + pos, block.timestamp) */ - __pyx_t_2 = __pyx_f_18polluck_blockchain_18placeholder_native_serialize_uint64((__pyx_v_buf + __pyx_v_pos), __pyx_v_block->index); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 211, __pyx_L1_error) + __pyx_t_2 = __pyx_f_18polluck_blockchain_18placeholder_native_serialize_uint64((__pyx_v_buf + __pyx_v_pos), __pyx_v_block->index); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 227, __pyx_L1_error) - /* "polluck_blockchain/placeholder_native.pyx":212 + /* "polluck_blockchain/placeholder_native.pyx":228 * * serialize_uint64(buf + pos, block.index) * pos += 8 # <<<<<<<<<<<<<< @@ -5900,16 +6275,16 @@ static unsigned char *__pyx_f_18polluck_blockchain_18placeholder_native_bytes_se */ __pyx_v_pos = (__pyx_v_pos + 8); - /* "polluck_blockchain/placeholder_native.pyx":213 + /* "polluck_blockchain/placeholder_native.pyx":229 * serialize_uint64(buf + pos, block.index) * pos += 8 * serialize_uint64(buf + pos, block.timestamp) # <<<<<<<<<<<<<< * pos += 8 * serialize_uint64(buf + pos, block.nonce) */ - __pyx_t_2 = __pyx_f_18polluck_blockchain_18placeholder_native_serialize_uint64((__pyx_v_buf + __pyx_v_pos), __pyx_v_block->timestamp); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 213, __pyx_L1_error) + __pyx_t_2 = __pyx_f_18polluck_blockchain_18placeholder_native_serialize_uint64((__pyx_v_buf + __pyx_v_pos), __pyx_v_block->timestamp); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 229, __pyx_L1_error) - /* "polluck_blockchain/placeholder_native.pyx":214 + /* "polluck_blockchain/placeholder_native.pyx":230 * pos += 8 * serialize_uint64(buf + pos, block.timestamp) * pos += 8 # <<<<<<<<<<<<<< @@ -5918,16 +6293,16 @@ static unsigned char *__pyx_f_18polluck_blockchain_18placeholder_native_bytes_se */ __pyx_v_pos = (__pyx_v_pos + 8); - /* "polluck_blockchain/placeholder_native.pyx":215 + /* "polluck_blockchain/placeholder_native.pyx":231 * serialize_uint64(buf + pos, block.timestamp) * pos += 8 * serialize_uint64(buf + pos, block.nonce) # <<<<<<<<<<<<<< * pos += 8 * # Copy data */ - __pyx_t_2 = __pyx_f_18polluck_blockchain_18placeholder_native_serialize_uint64((__pyx_v_buf + __pyx_v_pos), __pyx_v_block->nonce); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 215, __pyx_L1_error) + __pyx_t_2 = __pyx_f_18polluck_blockchain_18placeholder_native_serialize_uint64((__pyx_v_buf + __pyx_v_pos), __pyx_v_block->nonce); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 231, __pyx_L1_error) - /* "polluck_blockchain/placeholder_native.pyx":216 + /* "polluck_blockchain/placeholder_native.pyx":232 * pos += 8 * serialize_uint64(buf + pos, block.nonce) * pos += 8 # <<<<<<<<<<<<<< @@ -5936,7 +6311,7 @@ static unsigned char *__pyx_f_18polluck_blockchain_18placeholder_native_bytes_se */ __pyx_v_pos = (__pyx_v_pos + 8); - /* "polluck_blockchain/placeholder_native.pyx":218 + /* "polluck_blockchain/placeholder_native.pyx":234 * pos += 8 * # Copy data * memcpy( # <<<<<<<<<<<<<< @@ -5945,7 +6320,7 @@ static unsigned char *__pyx_f_18polluck_blockchain_18placeholder_native_bytes_se */ (void)(memcpy((__pyx_v_buf + __pyx_v_pos), __pyx_v_block->data.c_str(), __pyx_v_block->data.size())); - /* "polluck_blockchain/placeholder_native.pyx":223 + /* "polluck_blockchain/placeholder_native.pyx":239 * block.data.size(), * ) * pos += block.data.size() # <<<<<<<<<<<<<< @@ -5954,7 +6329,7 @@ static unsigned char *__pyx_f_18polluck_blockchain_18placeholder_native_bytes_se */ __pyx_v_pos = (__pyx_v_pos + __pyx_v_block->data.size()); - /* "polluck_blockchain/placeholder_native.pyx":225 + /* "polluck_blockchain/placeholder_native.pyx":241 * pos += block.data.size() * # Copy prev_hash * memcpy( # <<<<<<<<<<<<<< @@ -5963,7 +6338,7 @@ static unsigned char *__pyx_f_18polluck_blockchain_18placeholder_native_bytes_se */ (void)(memcpy((__pyx_v_buf + __pyx_v_pos), __pyx_v_block->prev_hash.c_str(), __pyx_v_block->prev_hash.size())); - /* "polluck_blockchain/placeholder_native.pyx":230 + /* "polluck_blockchain/placeholder_native.pyx":246 * block.prev_hash.size(), * ) * pos += block.prev_hash.size() # <<<<<<<<<<<<<< @@ -5972,7 +6347,7 @@ static unsigned char *__pyx_f_18polluck_blockchain_18placeholder_native_bytes_se */ __pyx_v_pos = (__pyx_v_pos + __pyx_v_block->prev_hash.size()); - /* "polluck_blockchain/placeholder_native.pyx":232 + /* "polluck_blockchain/placeholder_native.pyx":248 * pos += block.prev_hash.size() * * return buf # <<<<<<<<<<<<<< @@ -5982,7 +6357,7 @@ static unsigned char *__pyx_f_18polluck_blockchain_18placeholder_native_bytes_se __pyx_r = __pyx_v_buf; goto __pyx_L0; - /* "polluck_blockchain/placeholder_native.pyx":194 + /* "polluck_blockchain/placeholder_native.pyx":210 * * * cdef unsigned char* bytes_serialize_c(Block *block, size_t *size) nogil: # <<<<<<<<<<<<<< @@ -6000,12 +6375,12 @@ static unsigned char *__pyx_f_18polluck_blockchain_18placeholder_native_bytes_se return __pyx_r; } -/* "polluck_blockchain/placeholder_native.pyx":234 +/* "polluck_blockchain/placeholder_native.pyx":250 * return buf * * cdef unsigned char* SHA256_digest(const void *data, size_t data_size, size_t *digest_size) nogil: # <<<<<<<<<<<<<< * cdef ossl.EVP_MD_CTX *ctx = ossl.EVP_MD_CTX_new() - * if ctx == NULL: + * if ctx is NULL: */ static unsigned char *__pyx_f_18polluck_blockchain_18placeholder_native_SHA256_digest(void const *__pyx_v_data, size_t __pyx_v_data_size, size_t *__pyx_v_digest_size) { @@ -6017,66 +6392,66 @@ static unsigned char *__pyx_f_18polluck_blockchain_18placeholder_native_SHA256_d unsigned char *__pyx_r; int __pyx_t_1; - /* "polluck_blockchain/placeholder_native.pyx":235 + /* "polluck_blockchain/placeholder_native.pyx":251 * * cdef unsigned char* SHA256_digest(const void *data, size_t data_size, size_t *digest_size) nogil: * cdef ossl.EVP_MD_CTX *ctx = ossl.EVP_MD_CTX_new() # <<<<<<<<<<<<<< - * if ctx == NULL: + * if ctx is NULL: * return NULL */ __pyx_v_ctx = EVP_MD_CTX_new(); - /* "polluck_blockchain/placeholder_native.pyx":236 + /* "polluck_blockchain/placeholder_native.pyx":252 * cdef unsigned char* SHA256_digest(const void *data, size_t data_size, size_t *digest_size) nogil: * cdef ossl.EVP_MD_CTX *ctx = ossl.EVP_MD_CTX_new() - * if ctx == NULL: # <<<<<<<<<<<<<< + * if ctx is NULL: # <<<<<<<<<<<<<< * return NULL * cdef const ossl.EVP_MD *algo = ossl.EVP_sha256() */ __pyx_t_1 = (__pyx_v_ctx == NULL); if (__pyx_t_1) { - /* "polluck_blockchain/placeholder_native.pyx":237 + /* "polluck_blockchain/placeholder_native.pyx":253 * cdef ossl.EVP_MD_CTX *ctx = ossl.EVP_MD_CTX_new() - * if ctx == NULL: + * if ctx is NULL: * return NULL # <<<<<<<<<<<<<< * cdef const ossl.EVP_MD *algo = ossl.EVP_sha256() - * if algo == NULL: + * if algo is NULL: */ __pyx_r = NULL; goto __pyx_L0; - /* "polluck_blockchain/placeholder_native.pyx":236 + /* "polluck_blockchain/placeholder_native.pyx":252 * cdef unsigned char* SHA256_digest(const void *data, size_t data_size, size_t *digest_size) nogil: * cdef ossl.EVP_MD_CTX *ctx = ossl.EVP_MD_CTX_new() - * if ctx == NULL: # <<<<<<<<<<<<<< + * if ctx is NULL: # <<<<<<<<<<<<<< * return NULL * cdef const ossl.EVP_MD *algo = ossl.EVP_sha256() */ } - /* "polluck_blockchain/placeholder_native.pyx":238 - * if ctx == NULL: + /* "polluck_blockchain/placeholder_native.pyx":254 + * if ctx is NULL: * return NULL * cdef const ossl.EVP_MD *algo = ossl.EVP_sha256() # <<<<<<<<<<<<<< - * if algo == NULL: + * if algo is NULL: * return NULL */ __pyx_v_algo = EVP_sha256(); - /* "polluck_blockchain/placeholder_native.pyx":239 + /* "polluck_blockchain/placeholder_native.pyx":255 * return NULL * cdef const ossl.EVP_MD *algo = ossl.EVP_sha256() - * if algo == NULL: # <<<<<<<<<<<<<< + * if algo is NULL: # <<<<<<<<<<<<<< * return NULL * */ __pyx_t_1 = (__pyx_v_algo == NULL); if (__pyx_t_1) { - /* "polluck_blockchain/placeholder_native.pyx":240 + /* "polluck_blockchain/placeholder_native.pyx":256 * cdef const ossl.EVP_MD *algo = ossl.EVP_sha256() - * if algo == NULL: + * if algo is NULL: * return NULL # <<<<<<<<<<<<<< * * cdef: @@ -6084,16 +6459,16 @@ static unsigned char *__pyx_f_18polluck_blockchain_18placeholder_native_SHA256_d __pyx_r = NULL; goto __pyx_L0; - /* "polluck_blockchain/placeholder_native.pyx":239 + /* "polluck_blockchain/placeholder_native.pyx":255 * return NULL * cdef const ossl.EVP_MD *algo = ossl.EVP_sha256() - * if algo == NULL: # <<<<<<<<<<<<<< + * if algo is NULL: # <<<<<<<<<<<<<< * return NULL * */ } - /* "polluck_blockchain/placeholder_native.pyx":247 + /* "polluck_blockchain/placeholder_native.pyx":263 * unsigned int digest_len * * dig_buff_len = ossl.EVP_MD_size(algo) # <<<<<<<<<<<<<< @@ -6102,7 +6477,7 @@ static unsigned char *__pyx_f_18polluck_blockchain_18placeholder_native_SHA256_d */ __pyx_v_dig_buff_len = ((size_t)EVP_MD_size(__pyx_v_algo)); - /* "polluck_blockchain/placeholder_native.pyx":248 + /* "polluck_blockchain/placeholder_native.pyx":264 * * dig_buff_len = ossl.EVP_MD_size(algo) * digest_size[0] = dig_buff_len # <<<<<<<<<<<<<< @@ -6111,7 +6486,7 @@ static unsigned char *__pyx_f_18polluck_blockchain_18placeholder_native_SHA256_d */ (__pyx_v_digest_size[0]) = __pyx_v_dig_buff_len; - /* "polluck_blockchain/placeholder_native.pyx":249 + /* "polluck_blockchain/placeholder_native.pyx":265 * dig_buff_len = ossl.EVP_MD_size(algo) * digest_size[0] = dig_buff_len * digest = malloc(dig_buff_len * sizeof(unsigned char)) # <<<<<<<<<<<<<< @@ -6120,7 +6495,7 @@ static unsigned char *__pyx_f_18polluck_blockchain_18placeholder_native_SHA256_d */ __pyx_v_digest = ((unsigned char *)malloc((__pyx_v_dig_buff_len * (sizeof(unsigned char))))); - /* "polluck_blockchain/placeholder_native.pyx":250 + /* "polluck_blockchain/placeholder_native.pyx":266 * digest_size[0] = dig_buff_len * digest = malloc(dig_buff_len * sizeof(unsigned char)) * ossl.EVP_DigestInit_ex(ctx, algo, NULL) # <<<<<<<<<<<<<< @@ -6129,7 +6504,7 @@ static unsigned char *__pyx_f_18polluck_blockchain_18placeholder_native_SHA256_d */ (void)(EVP_DigestInit_ex(__pyx_v_ctx, __pyx_v_algo, NULL)); - /* "polluck_blockchain/placeholder_native.pyx":251 + /* "polluck_blockchain/placeholder_native.pyx":267 * digest = malloc(dig_buff_len * sizeof(unsigned char)) * ossl.EVP_DigestInit_ex(ctx, algo, NULL) * ossl.EVP_DigestUpdate(ctx, data, data_size) # <<<<<<<<<<<<<< @@ -6138,7 +6513,7 @@ static unsigned char *__pyx_f_18polluck_blockchain_18placeholder_native_SHA256_d */ (void)(EVP_DigestUpdate(__pyx_v_ctx, __pyx_v_data, __pyx_v_data_size)); - /* "polluck_blockchain/placeholder_native.pyx":252 + /* "polluck_blockchain/placeholder_native.pyx":268 * ossl.EVP_DigestInit_ex(ctx, algo, NULL) * ossl.EVP_DigestUpdate(ctx, data, data_size) * ossl.EVP_DigestFinal_ex(ctx, digest, &digest_len) # <<<<<<<<<<<<<< @@ -6147,7 +6522,7 @@ static unsigned char *__pyx_f_18polluck_blockchain_18placeholder_native_SHA256_d */ (void)(EVP_DigestFinal_ex(__pyx_v_ctx, __pyx_v_digest, (&__pyx_v_digest_len))); - /* "polluck_blockchain/placeholder_native.pyx":254 + /* "polluck_blockchain/placeholder_native.pyx":270 * ossl.EVP_DigestFinal_ex(ctx, digest, &digest_len) * * ossl.EVP_MD_CTX_free(ctx) # <<<<<<<<<<<<<< @@ -6156,7 +6531,7 @@ static unsigned char *__pyx_f_18polluck_blockchain_18placeholder_native_SHA256_d */ EVP_MD_CTX_free(__pyx_v_ctx); - /* "polluck_blockchain/placeholder_native.pyx":256 + /* "polluck_blockchain/placeholder_native.pyx":272 * ossl.EVP_MD_CTX_free(ctx) * * return digest # <<<<<<<<<<<<<< @@ -6166,12 +6541,12 @@ static unsigned char *__pyx_f_18polluck_blockchain_18placeholder_native_SHA256_d __pyx_r = __pyx_v_digest; goto __pyx_L0; - /* "polluck_blockchain/placeholder_native.pyx":234 + /* "polluck_blockchain/placeholder_native.pyx":250 * return buf * * cdef unsigned char* SHA256_digest(const void *data, size_t data_size, size_t *digest_size) nogil: # <<<<<<<<<<<<<< * cdef ossl.EVP_MD_CTX *ctx = ossl.EVP_MD_CTX_new() - * if ctx == NULL: + * if ctx is NULL: */ /* function exit code */ @@ -6179,7 +6554,7 @@ static unsigned char *__pyx_f_18polluck_blockchain_18placeholder_native_SHA256_d return __pyx_r; } -/* "polluck_blockchain/placeholder_native.pyx":259 +/* "polluck_blockchain/placeholder_native.pyx":275 * * * cdef unsigned char* perform_hash_c(Block *block, size_t *digest_size) nogil: # <<<<<<<<<<<<<< @@ -6199,29 +6574,29 @@ static unsigned char *__pyx_f_18polluck_blockchain_18placeholder_native_perform_ int __pyx_clineno = 0; PyGILState_STATE __pyx_gilstate_save; - /* "polluck_blockchain/placeholder_native.pyx":265 + /* "polluck_blockchain/placeholder_native.pyx":281 * unsigned char *digest * * serialize_res = bytes_serialize_c(block, &serialize_size) # <<<<<<<<<<<<<< - * if serialize_res == NULL: + * if serialize_res is NULL: * return NULL */ - __pyx_t_1 = __pyx_f_18polluck_blockchain_18placeholder_native_bytes_serialize_c(__pyx_v_block, (&__pyx_v_serialize_size)); if (unlikely(__pyx_t_1 == ((void *)NULL) && __Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 265, __pyx_L1_error) + __pyx_t_1 = __pyx_f_18polluck_blockchain_18placeholder_native_bytes_serialize_c(__pyx_v_block, (&__pyx_v_serialize_size)); if (unlikely(__pyx_t_1 == ((void *)NULL) && __Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 281, __pyx_L1_error) __pyx_v_serialize_res = __pyx_t_1; - /* "polluck_blockchain/placeholder_native.pyx":266 + /* "polluck_blockchain/placeholder_native.pyx":282 * * serialize_res = bytes_serialize_c(block, &serialize_size) - * if serialize_res == NULL: # <<<<<<<<<<<<<< + * if serialize_res is NULL: # <<<<<<<<<<<<<< * return NULL * digest = SHA256_digest(serialize_res, serialize_size, digest_size) */ __pyx_t_2 = (__pyx_v_serialize_res == NULL); if (__pyx_t_2) { - /* "polluck_blockchain/placeholder_native.pyx":267 + /* "polluck_blockchain/placeholder_native.pyx":283 * serialize_res = bytes_serialize_c(block, &serialize_size) - * if serialize_res == NULL: + * if serialize_res is NULL: * return NULL # <<<<<<<<<<<<<< * digest = SHA256_digest(serialize_res, serialize_size, digest_size) * free(serialize_res) @@ -6229,47 +6604,47 @@ static unsigned char *__pyx_f_18polluck_blockchain_18placeholder_native_perform_ __pyx_r = NULL; goto __pyx_L0; - /* "polluck_blockchain/placeholder_native.pyx":266 + /* "polluck_blockchain/placeholder_native.pyx":282 * * serialize_res = bytes_serialize_c(block, &serialize_size) - * if serialize_res == NULL: # <<<<<<<<<<<<<< + * if serialize_res is NULL: # <<<<<<<<<<<<<< * return NULL * digest = SHA256_digest(serialize_res, serialize_size, digest_size) */ } - /* "polluck_blockchain/placeholder_native.pyx":268 - * if serialize_res == NULL: + /* "polluck_blockchain/placeholder_native.pyx":284 + * if serialize_res is NULL: * return NULL * digest = SHA256_digest(serialize_res, serialize_size, digest_size) # <<<<<<<<<<<<<< * free(serialize_res) - * if digest == NULL: + * if digest is NULL: */ - __pyx_t_1 = __pyx_f_18polluck_blockchain_18placeholder_native_SHA256_digest(__pyx_v_serialize_res, __pyx_v_serialize_size, __pyx_v_digest_size); if (unlikely(__pyx_t_1 == ((void *)NULL) && __Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 268, __pyx_L1_error) + __pyx_t_1 = __pyx_f_18polluck_blockchain_18placeholder_native_SHA256_digest(__pyx_v_serialize_res, __pyx_v_serialize_size, __pyx_v_digest_size); if (unlikely(__pyx_t_1 == ((void *)NULL) && __Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 284, __pyx_L1_error) __pyx_v_digest = __pyx_t_1; - /* "polluck_blockchain/placeholder_native.pyx":269 + /* "polluck_blockchain/placeholder_native.pyx":285 * return NULL * digest = SHA256_digest(serialize_res, serialize_size, digest_size) * free(serialize_res) # <<<<<<<<<<<<<< - * if digest == NULL: + * if digest is NULL: * return NULL */ free(__pyx_v_serialize_res); - /* "polluck_blockchain/placeholder_native.pyx":270 + /* "polluck_blockchain/placeholder_native.pyx":286 * digest = SHA256_digest(serialize_res, serialize_size, digest_size) * free(serialize_res) - * if digest == NULL: # <<<<<<<<<<<<<< + * if digest is NULL: # <<<<<<<<<<<<<< * return NULL * */ __pyx_t_2 = (__pyx_v_digest == NULL); if (__pyx_t_2) { - /* "polluck_blockchain/placeholder_native.pyx":271 + /* "polluck_blockchain/placeholder_native.pyx":287 * free(serialize_res) - * if digest == NULL: + * if digest is NULL: * return NULL # <<<<<<<<<<<<<< * * return digest @@ -6277,16 +6652,16 @@ static unsigned char *__pyx_f_18polluck_blockchain_18placeholder_native_perform_ __pyx_r = NULL; goto __pyx_L0; - /* "polluck_blockchain/placeholder_native.pyx":270 + /* "polluck_blockchain/placeholder_native.pyx":286 * digest = SHA256_digest(serialize_res, serialize_size, digest_size) * free(serialize_res) - * if digest == NULL: # <<<<<<<<<<<<<< + * if digest is NULL: # <<<<<<<<<<<<<< * return NULL * */ } - /* "polluck_blockchain/placeholder_native.pyx":273 + /* "polluck_blockchain/placeholder_native.pyx":289 * return NULL * * return digest # <<<<<<<<<<<<<< @@ -6296,7 +6671,7 @@ static unsigned char *__pyx_f_18polluck_blockchain_18placeholder_native_perform_ __pyx_r = __pyx_v_digest; goto __pyx_L0; - /* "polluck_blockchain/placeholder_native.pyx":259 + /* "polluck_blockchain/placeholder_native.pyx":275 * * * cdef unsigned char* perform_hash_c(Block *block, size_t *digest_size) nogil: # <<<<<<<<<<<<<< @@ -6314,7 +6689,7 @@ static unsigned char *__pyx_f_18polluck_blockchain_18placeholder_native_perform_ return __pyx_r; } -/* "polluck_blockchain/placeholder_native.pyx":276 +/* "polluck_blockchain/placeholder_native.pyx":292 * * * cdef int mine_block(Block *block, unsigned int difficulty, uint64_t *nonce_solution, unsigned int max_nonce=0xFFFFFFFF) nogil: # <<<<<<<<<<<<<< @@ -6347,7 +6722,7 @@ static int __pyx_f_18polluck_blockchain_18placeholder_native_mine_block(::Block } } - /* "polluck_blockchain/placeholder_native.pyx":282 + /* "polluck_blockchain/placeholder_native.pyx":298 * unsigned char *digest * size_t digest_size * bint nonce_found = False # <<<<<<<<<<<<<< @@ -6356,17 +6731,17 @@ static int __pyx_f_18polluck_blockchain_18placeholder_native_mine_block(::Block */ __pyx_v_nonce_found = 0; - /* "polluck_blockchain/placeholder_native.pyx":285 + /* "polluck_blockchain/placeholder_native.pyx":301 * int nonce * * serial_buf = bytes_serialize_c(block, &serialize_size) # <<<<<<<<<<<<<< * * with nogil: */ - __pyx_t_1 = __pyx_f_18polluck_blockchain_18placeholder_native_bytes_serialize_c(__pyx_v_block, (&__pyx_v_serialize_size)); if (unlikely(__pyx_t_1 == ((void *)NULL) && __Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 285, __pyx_L1_error) + __pyx_t_1 = __pyx_f_18polluck_blockchain_18placeholder_native_bytes_serialize_c(__pyx_v_block, (&__pyx_v_serialize_size)); if (unlikely(__pyx_t_1 == ((void *)NULL) && __Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 301, __pyx_L1_error) __pyx_v_serial_buf = __pyx_t_1; - /* "polluck_blockchain/placeholder_native.pyx":287 + /* "polluck_blockchain/placeholder_native.pyx":303 * serial_buf = bytes_serialize_c(block, &serialize_size) * * with nogil: # <<<<<<<<<<<<<< @@ -6379,7 +6754,7 @@ static int __pyx_f_18polluck_blockchain_18placeholder_native_mine_block(::Block __Pyx_FastGIL_Remember(); /*try:*/ { - /* "polluck_blockchain/placeholder_native.pyx":288 + /* "polluck_blockchain/placeholder_native.pyx":304 * * with nogil: * for nonce in range(max_nonce): # <<<<<<<<<<<<<< @@ -6391,36 +6766,36 @@ static int __pyx_f_18polluck_blockchain_18placeholder_native_mine_block(::Block for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_nonce = __pyx_t_4; - /* "polluck_blockchain/placeholder_native.pyx":289 + /* "polluck_blockchain/placeholder_native.pyx":305 * with nogil: * for nonce in range(max_nonce): * serialize_uint64(serial_buf + NONCE_OFFSET, nonce) # <<<<<<<<<<<<<< * digest = SHA256_digest(serial_buf, serialize_size, &digest_size) * */ - __pyx_t_5 = __pyx_f_18polluck_blockchain_18placeholder_native_serialize_uint64((__pyx_v_serial_buf + __pyx_v_18polluck_blockchain_18placeholder_native_NONCE_OFFSET), ((uint64_t)__pyx_v_nonce)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 289, __pyx_L4_error) + __pyx_t_5 = __pyx_f_18polluck_blockchain_18placeholder_native_serialize_uint64((__pyx_v_serial_buf + __pyx_v_18polluck_blockchain_18placeholder_native_NONCE_OFFSET), ((uint64_t)__pyx_v_nonce)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 305, __pyx_L4_error) - /* "polluck_blockchain/placeholder_native.pyx":290 + /* "polluck_blockchain/placeholder_native.pyx":306 * for nonce in range(max_nonce): * serialize_uint64(serial_buf + NONCE_OFFSET, nonce) * digest = SHA256_digest(serial_buf, serialize_size, &digest_size) # <<<<<<<<<<<<<< * * if has_leading_zero_bits(digest, difficulty): */ - __pyx_t_1 = __pyx_f_18polluck_blockchain_18placeholder_native_SHA256_digest(__pyx_v_serial_buf, __pyx_v_serialize_size, (&__pyx_v_digest_size)); if (unlikely(__pyx_t_1 == ((void *)NULL) && __Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 290, __pyx_L4_error) + __pyx_t_1 = __pyx_f_18polluck_blockchain_18placeholder_native_SHA256_digest(__pyx_v_serial_buf, __pyx_v_serialize_size, (&__pyx_v_digest_size)); if (unlikely(__pyx_t_1 == ((void *)NULL) && __Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 306, __pyx_L4_error) __pyx_v_digest = __pyx_t_1; - /* "polluck_blockchain/placeholder_native.pyx":292 + /* "polluck_blockchain/placeholder_native.pyx":308 * digest = SHA256_digest(serial_buf, serialize_size, &digest_size) * * if has_leading_zero_bits(digest, difficulty): # <<<<<<<<<<<<<< * nonce_found = True * nonce_solution[0] = nonce */ - __pyx_t_6 = __pyx_f_18polluck_blockchain_18placeholder_native_has_leading_zero_bits(__pyx_v_digest, __pyx_v_difficulty); if (unlikely(__pyx_t_6 == ((int)-1) && __Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 292, __pyx_L4_error) + __pyx_t_6 = __pyx_f_18polluck_blockchain_18placeholder_native_has_leading_zero_bits(__pyx_v_digest, __pyx_v_difficulty); if (unlikely(__pyx_t_6 == ((int)-1) && __Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 308, __pyx_L4_error) if (__pyx_t_6) { - /* "polluck_blockchain/placeholder_native.pyx":293 + /* "polluck_blockchain/placeholder_native.pyx":309 * * if has_leading_zero_bits(digest, difficulty): * nonce_found = True # <<<<<<<<<<<<<< @@ -6429,7 +6804,7 @@ static int __pyx_f_18polluck_blockchain_18placeholder_native_mine_block(::Block */ __pyx_v_nonce_found = 1; - /* "polluck_blockchain/placeholder_native.pyx":294 + /* "polluck_blockchain/placeholder_native.pyx":310 * if has_leading_zero_bits(digest, difficulty): * nonce_found = True * nonce_solution[0] = nonce # <<<<<<<<<<<<<< @@ -6438,7 +6813,7 @@ static int __pyx_f_18polluck_blockchain_18placeholder_native_mine_block(::Block */ (__pyx_v_nonce_solution[0]) = __pyx_v_nonce; - /* "polluck_blockchain/placeholder_native.pyx":295 + /* "polluck_blockchain/placeholder_native.pyx":311 * nonce_found = True * nonce_solution[0] = nonce * break # <<<<<<<<<<<<<< @@ -6447,7 +6822,7 @@ static int __pyx_f_18polluck_blockchain_18placeholder_native_mine_block(::Block */ goto __pyx_L7_break; - /* "polluck_blockchain/placeholder_native.pyx":292 + /* "polluck_blockchain/placeholder_native.pyx":308 * digest = SHA256_digest(serial_buf, serialize_size, &digest_size) * * if has_leading_zero_bits(digest, difficulty): # <<<<<<<<<<<<<< @@ -6456,7 +6831,7 @@ static int __pyx_f_18polluck_blockchain_18placeholder_native_mine_block(::Block */ } - /* "polluck_blockchain/placeholder_native.pyx":297 + /* "polluck_blockchain/placeholder_native.pyx":313 * break * * free(digest) # <<<<<<<<<<<<<< @@ -6468,7 +6843,7 @@ static int __pyx_f_18polluck_blockchain_18placeholder_native_mine_block(::Block __pyx_L7_break:; } - /* "polluck_blockchain/placeholder_native.pyx":287 + /* "polluck_blockchain/placeholder_native.pyx":303 * serial_buf = bytes_serialize_c(block, &serialize_size) * * with nogil: # <<<<<<<<<<<<<< @@ -6490,7 +6865,7 @@ static int __pyx_f_18polluck_blockchain_18placeholder_native_mine_block(::Block } } - /* "polluck_blockchain/placeholder_native.pyx":299 + /* "polluck_blockchain/placeholder_native.pyx":315 * free(digest) * * free(serial_buf) # <<<<<<<<<<<<<< @@ -6499,7 +6874,7 @@ static int __pyx_f_18polluck_blockchain_18placeholder_native_mine_block(::Block */ free(__pyx_v_serial_buf); - /* "polluck_blockchain/placeholder_native.pyx":301 + /* "polluck_blockchain/placeholder_native.pyx":317 * free(serial_buf) * * if not nonce_found: # <<<<<<<<<<<<<< @@ -6509,7 +6884,7 @@ static int __pyx_f_18polluck_blockchain_18placeholder_native_mine_block(::Block __pyx_t_6 = (!__pyx_v_nonce_found); if (__pyx_t_6) { - /* "polluck_blockchain/placeholder_native.pyx":302 + /* "polluck_blockchain/placeholder_native.pyx":318 * * if not nonce_found: * return 1 # <<<<<<<<<<<<<< @@ -6519,7 +6894,7 @@ static int __pyx_f_18polluck_blockchain_18placeholder_native_mine_block(::Block __pyx_r = 1; goto __pyx_L0; - /* "polluck_blockchain/placeholder_native.pyx":301 + /* "polluck_blockchain/placeholder_native.pyx":317 * free(serial_buf) * * if not nonce_found: # <<<<<<<<<<<<<< @@ -6528,7 +6903,7 @@ static int __pyx_f_18polluck_blockchain_18placeholder_native_mine_block(::Block */ } - /* "polluck_blockchain/placeholder_native.pyx":304 + /* "polluck_blockchain/placeholder_native.pyx":320 * return 1 * * return 0 # <<<<<<<<<<<<<< @@ -6538,7 +6913,7 @@ static int __pyx_f_18polluck_blockchain_18placeholder_native_mine_block(::Block __pyx_r = 0; goto __pyx_L0; - /* "polluck_blockchain/placeholder_native.pyx":276 + /* "polluck_blockchain/placeholder_native.pyx":292 * * * cdef int mine_block(Block *block, unsigned int difficulty, uint64_t *nonce_solution, unsigned int max_nonce=0xFFFFFFFF) nogil: # <<<<<<<<<<<<<< @@ -6556,10 +6931,10 @@ static int __pyx_f_18polluck_blockchain_18placeholder_native_mine_block(::Block return __pyx_r; } -/* "polluck_blockchain/placeholder_native.pyx":313 - * cdef bint _genesis_done +/* "polluck_blockchain/placeholder_native.pyx":333 + * readonly object _engine * - * def __cinit__(self): # <<<<<<<<<<<<<< + * def __cinit__(self, *args, **kwargs): # <<<<<<<<<<<<<< * self._difficulty = 26 * self._index = 0 */ @@ -6567,6 +6942,8 @@ static int __pyx_f_18polluck_blockchain_18placeholder_native_mine_block(::Block /* Python wrapper */ static int __pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED PyObject *__pyx_v_args = 0; + CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0; CYTHON_UNUSED Py_ssize_t __pyx_nargs; CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_r; @@ -6578,115 +6955,175 @@ static int __pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_1__ci __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; #endif __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1; } - const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; if (unlikely(__pyx_kwds_len < 0)) return -1; - if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__cinit__", __pyx_kwds); return -1;} - __pyx_r = __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain___cinit__(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self)); + if (__pyx_kwds_len > 0) { + if (unlikely(__Pyx_CheckKeywordStrings("__cinit__", __pyx_kwds) == -1)) return -1; + } + __Pyx_INCREF(__pyx_args); + __pyx_v_args = __pyx_args; + __pyx_r = __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain___cinit__(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self), __pyx_v_args, __pyx_v_kwargs); /* function exit code */ + __Pyx_DECREF(__pyx_v_args); + __Pyx_XDECREF(__pyx_v_kwargs); __Pyx_RefNannyFinishContext(); return __pyx_r; } -static int __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain___cinit__(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self) { +static int __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain___cinit__(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs) { int __pyx_r; __Pyx_RefNannyDeclarations std::unordered_map *__pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; + std::vector<::Block *> *__pyx_t_2; + int __pyx_t_3; PyObject *__pyx_t_4 = NULL; - size_t __pyx_t_5; + PyObject *__pyx_t_5 = NULL; + size_t __pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__cinit__", 0); - /* "polluck_blockchain/placeholder_native.pyx":314 + /* "polluck_blockchain/placeholder_native.pyx":334 * - * def __cinit__(self): + * def __cinit__(self, *args, **kwargs): * self._difficulty = 26 # <<<<<<<<<<<<<< * self._index = 0 * self._genesis_done = 0 */ __pyx_v_self->_difficulty = 26; - /* "polluck_blockchain/placeholder_native.pyx":315 - * def __cinit__(self): + /* "polluck_blockchain/placeholder_native.pyx":335 + * def __cinit__(self, *args, **kwargs): * self._difficulty = 26 * self._index = 0 # <<<<<<<<<<<<<< * self._genesis_done = 0 - * self._chain = new unordered_map[uint64_t, Block*]() + * self._chain_map = new unordered_map[uint64_t, Block*]() */ __pyx_v_self->_index = ((uint64_t)0); - /* "polluck_blockchain/placeholder_native.pyx":316 + /* "polluck_blockchain/placeholder_native.pyx":336 * self._difficulty = 26 * self._index = 0 * self._genesis_done = 0 # <<<<<<<<<<<<<< - * self._chain = new unordered_map[uint64_t, Block*]() - * if self._chain is NULL: + * self._chain_map = new unordered_map[uint64_t, Block*]() + * self._chain = new vector[Block*]() */ __pyx_v_self->_genesis_done = 0; - /* "polluck_blockchain/placeholder_native.pyx":317 + /* "polluck_blockchain/placeholder_native.pyx":337 * self._index = 0 * self._genesis_done = 0 - * self._chain = new unordered_map[uint64_t, Block*]() # <<<<<<<<<<<<<< - * if self._chain is NULL: - * raise MemoryError("Could not allocate hasmap") + * self._chain_map = new unordered_map[uint64_t, Block*]() # <<<<<<<<<<<<<< + * self._chain = new vector[Block*]() + * if self._chain_map is NULL: */ try { __pyx_t_1 = new std::unordered_map (); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(0, 317, __pyx_L1_error) + __PYX_ERR(0, 337, __pyx_L1_error) } - __pyx_v_self->_chain = __pyx_t_1; + __pyx_v_self->_chain_map = __pyx_t_1; - /* "polluck_blockchain/placeholder_native.pyx":318 + /* "polluck_blockchain/placeholder_native.pyx":338 * self._genesis_done = 0 - * self._chain = new unordered_map[uint64_t, Block*]() - * if self._chain is NULL: # <<<<<<<<<<<<<< + * self._chain_map = new unordered_map[uint64_t, Block*]() + * self._chain = new vector[Block*]() # <<<<<<<<<<<<<< + * if self._chain_map is NULL: * raise MemoryError("Could not allocate hasmap") - * */ - __pyx_t_2 = (__pyx_v_self->_chain == NULL); - if (unlikely(__pyx_t_2)) { + try { + __pyx_t_2 = new std::vector<::Block *> (); + } catch(...) { + __Pyx_CppExn2PyErr(); + __PYX_ERR(0, 338, __pyx_L1_error) + } + __pyx_v_self->_chain = __pyx_t_2; - /* "polluck_blockchain/placeholder_native.pyx":319 - * self._chain = new unordered_map[uint64_t, Block*]() + /* "polluck_blockchain/placeholder_native.pyx":339 + * self._chain_map = new unordered_map[uint64_t, Block*]() + * self._chain = new vector[Block*]() + * if self._chain_map is NULL: # <<<<<<<<<<<<<< + * raise MemoryError("Could not allocate hasmap") * if self._chain is NULL: - * raise MemoryError("Could not allocate hasmap") # <<<<<<<<<<<<<< - * - * def __init__(self, *args, **kwargs): */ - __pyx_t_4 = NULL; - __pyx_t_5 = 1; - { - PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_Could_not_allocate_hasmap}; - __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_MemoryError)), __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, 319, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - } - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 319, __pyx_L1_error) + __pyx_t_3 = (__pyx_v_self->_chain_map == NULL); + if (unlikely(__pyx_t_3)) { - /* "polluck_blockchain/placeholder_native.pyx":318 - * self._genesis_done = 0 - * self._chain = new unordered_map[uint64_t, Block*]() - * if self._chain is NULL: # <<<<<<<<<<<<<< + /* "polluck_blockchain/placeholder_native.pyx":340 + * self._chain = new vector[Block*]() + * if self._chain_map is NULL: + * raise MemoryError("Could not allocate hasmap") # <<<<<<<<<<<<<< + * if self._chain is NULL: + * raise MemoryError("Could not allocate vector") +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_Could_not_allocate_hasmap}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_MemoryError)), __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, 340, __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, 340, __pyx_L1_error) + + /* "polluck_blockchain/placeholder_native.pyx":339 + * self._chain_map = new unordered_map[uint64_t, Block*]() + * self._chain = new vector[Block*]() + * if self._chain_map is NULL: # <<<<<<<<<<<<<< * raise MemoryError("Could not allocate hasmap") + * if self._chain is NULL: +*/ + } + + /* "polluck_blockchain/placeholder_native.pyx":341 + * if self._chain_map is NULL: + * raise MemoryError("Could not allocate hasmap") + * if self._chain is NULL: # <<<<<<<<<<<<<< + * raise MemoryError("Could not allocate vector") + * +*/ + __pyx_t_3 = (__pyx_v_self->_chain == NULL); + if (unlikely(__pyx_t_3)) { + + /* "polluck_blockchain/placeholder_native.pyx":342 + * raise MemoryError("Could not allocate hasmap") + * if self._chain is NULL: + * raise MemoryError("Could not allocate vector") # <<<<<<<<<<<<<< + * + * def __init__(self, db_path): +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_Could_not_allocate_vector}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_MemoryError)), __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, 342, __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, 342, __pyx_L1_error) + + /* "polluck_blockchain/placeholder_native.pyx":341 + * if self._chain_map is NULL: + * raise MemoryError("Could not allocate hasmap") + * if self._chain is NULL: # <<<<<<<<<<<<<< + * raise MemoryError("Could not allocate vector") * */ } - /* "polluck_blockchain/placeholder_native.pyx":313 - * cdef bint _genesis_done + /* "polluck_blockchain/placeholder_native.pyx":333 + * readonly object _engine * - * def __cinit__(self): # <<<<<<<<<<<<<< + * def __cinit__(self, *args, **kwargs): # <<<<<<<<<<<<<< * self._difficulty = 26 * self._index = 0 */ @@ -6695,8 +7132,8 @@ static int __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain___cin __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("polluck_blockchain.placeholder_native.Blockchain.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; @@ -6704,21 +7141,24 @@ static int __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain___cin return __pyx_r; } -/* "polluck_blockchain/placeholder_native.pyx":321 - * raise MemoryError("Could not allocate hasmap") +/* "polluck_blockchain/placeholder_native.pyx":344 + * raise MemoryError("Could not allocate vector") * - * def __init__(self, *args, **kwargs): # <<<<<<<<<<<<<< - * # self.db_path = db_path - * pass + * def __init__(self, db_path): # <<<<<<<<<<<<<< + * self.db_path = Path(db_path).resolve() + * if not self.db_path.parent.exists(): */ /* Python wrapper */ static int __pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - CYTHON_UNUSED PyObject *__pyx_v_args = 0; - CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0; + PyObject *__pyx_v_db_path = 0; CYTHON_UNUSED Py_ssize_t __pyx_nargs; CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); @@ -6728,36 +7168,272 @@ static int __pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_3__in __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; #endif __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len < 0)) return -1; - if (__pyx_kwds_len > 0) { - if (unlikely(__Pyx_CheckKeywordStrings("__init__", __pyx_kwds) == -1)) return -1; + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_db_path,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 344, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 344, __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, 344, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, i); __PYX_ERR(0, 344, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 344, __pyx_L3_error) + } + __pyx_v_db_path = values[0]; } - __Pyx_INCREF(__pyx_args); - __pyx_v_args = __pyx_args; - __pyx_r = __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_2__init__(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self), __pyx_v_args, __pyx_v_kwargs); + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 344, __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("polluck_blockchain.placeholder_native.Blockchain.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_2__init__(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self), __pyx_v_db_path); /* function exit code */ - __Pyx_DECREF(__pyx_v_args); - __Pyx_XDECREF(__pyx_v_kwargs); + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } __Pyx_RefNannyFinishContext(); return __pyx_r; } -static int __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_2__init__(CYTHON_UNUSED struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs) { +static int __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_2__init__(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, PyObject *__pyx_v_db_path) { int __pyx_r; + __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; + size_t __pyx_t_6; + int __pyx_t_7; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "polluck_blockchain/placeholder_native.pyx":345 + * + * def __init__(self, db_path): + * self.db_path = Path(db_path).resolve() # <<<<<<<<<<<<<< + * if not self.db_path.parent.exists(): + * raise FileNotFoundError( +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_Path); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 345, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_db_path}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 345, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_t_2 = __pyx_t_3; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_resolve, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 345, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->db_path); + __Pyx_DECREF(__pyx_v_self->db_path); + __pyx_v_self->db_path = __pyx_t_1; + __pyx_t_1 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":346 + * def __init__(self, db_path): + * self.db_path = Path(db_path).resolve() + * if not self.db_path.parent.exists(): # <<<<<<<<<<<<<< + * raise FileNotFoundError( + * "The parent directory of the provided database path does not exist" +*/ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->db_path, __pyx_mstate_global->__pyx_n_u_parent); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 346, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_t_2; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_exists, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (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, 346, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 346, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_8 = (!__pyx_t_7); + if (unlikely(__pyx_t_8)) { + + /* "polluck_blockchain/placeholder_native.pyx":347 + * self.db_path = Path(db_path).resolve() + * if not self.db_path.parent.exists(): + * raise FileNotFoundError( # <<<<<<<<<<<<<< + * "The parent directory of the provided database path does not exist" + * ) +*/ + __pyx_t_2 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_mstate_global->__pyx_kp_u_The_parent_directory_of_the_prov}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_FileNotFoundError)), __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 347, __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, 347, __pyx_L1_error) + + /* "polluck_blockchain/placeholder_native.pyx":346 + * def __init__(self, db_path): + * self.db_path = Path(db_path).resolve() + * if not self.db_path.parent.exists(): # <<<<<<<<<<<<<< + * raise FileNotFoundError( + * "The parent directory of the provided database path does not exist" +*/ + } + + /* "polluck_blockchain/placeholder_native.pyx":351 + * ) + * + * self._engine = sql.create_engine(f"sqlite:///{str(self.db_path)}") # <<<<<<<<<<<<<< + * db.metadata_blockchain.create_all(self._engine) + * +*/ + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_sql); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_create_engine); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Unicode(__pyx_v_self->db_path); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_sqlite, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_engine); + __Pyx_DECREF(__pyx_v_self->_engine); + __pyx_v_self->_engine = __pyx_t_1; + __pyx_t_1 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":352 + * + * self._engine = sql.create_engine(f"sqlite:///{str(self.db_path)}") + * db.metadata_blockchain.create_all(self._engine) # <<<<<<<<<<<<<< + * + * def __dealloc__(self): +*/ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_db); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 352, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_metadata_blockchain); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 352, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __pyx_t_2; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_self->_engine}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_create_all, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 352, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":344 + * raise MemoryError("Could not allocate vector") + * + * def __init__(self, db_path): # <<<<<<<<<<<<<< + * self.db_path = Path(db_path).resolve() + * if not self.db_path.parent.exists(): +*/ /* function exit code */ __pyx_r = 0; + 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_AddTraceback("polluck_blockchain.placeholder_native.Blockchain.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "polluck_blockchain/placeholder_native.pyx":325 - * pass +/* "polluck_blockchain/placeholder_native.pyx":354 + * db.metadata_blockchain.create_all(self._engine) * * def __dealloc__(self): # <<<<<<<<<<<<<< * # ownership is typically not transferred from the Blockchain extension class - * cdef BcHashmap.iterator it = self._chain.begin() + * cdef BcHashmap.iterator it = self._chain_map.begin() */ /* Python wrapper */ @@ -6777,96 +7453,967 @@ static void __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_4__d std::unordered_map ::iterator __pyx_v_it; int __pyx_t_1; - /* "polluck_blockchain/placeholder_native.pyx":327 + /* "polluck_blockchain/placeholder_native.pyx":356 * def __dealloc__(self): * # ownership is typically not transferred from the Blockchain extension class - * cdef BcHashmap.iterator it = self._chain.begin() # <<<<<<<<<<<<<< - * if self._chain is not NULL: - * while it != self._chain.end(): + * cdef BcHashmap.iterator it = self._chain_map.begin() # <<<<<<<<<<<<<< + * if self._chain_map is not NULL: + * while it != self._chain_map.end(): */ - __pyx_v_it = __pyx_v_self->_chain->begin(); + __pyx_v_it = __pyx_v_self->_chain_map->begin(); - /* "polluck_blockchain/placeholder_native.pyx":328 + /* "polluck_blockchain/placeholder_native.pyx":357 * # ownership is typically not transferred from the Blockchain extension class - * cdef BcHashmap.iterator it = self._chain.begin() - * if self._chain is not NULL: # <<<<<<<<<<<<<< - * while it != self._chain.end(): + * cdef BcHashmap.iterator it = self._chain_map.begin() + * if self._chain_map is not NULL: # <<<<<<<<<<<<<< + * while it != self._chain_map.end(): * del dereference(it).second */ - __pyx_t_1 = (__pyx_v_self->_chain != NULL); + __pyx_t_1 = (__pyx_v_self->_chain_map != NULL); if (__pyx_t_1) { - /* "polluck_blockchain/placeholder_native.pyx":329 - * cdef BcHashmap.iterator it = self._chain.begin() - * if self._chain is not NULL: - * while it != self._chain.end(): # <<<<<<<<<<<<<< + /* "polluck_blockchain/placeholder_native.pyx":358 + * cdef BcHashmap.iterator it = self._chain_map.begin() + * if self._chain_map is not NULL: + * while it != self._chain_map.end(): # <<<<<<<<<<<<<< * del dereference(it).second * postincrement(it) */ while (1) { - __pyx_t_1 = (__pyx_v_it != __pyx_v_self->_chain->end()); + __pyx_t_1 = (__pyx_v_it != __pyx_v_self->_chain_map->end()); if (!__pyx_t_1) break; - /* "polluck_blockchain/placeholder_native.pyx":330 - * if self._chain is not NULL: - * while it != self._chain.end(): + /* "polluck_blockchain/placeholder_native.pyx":359 + * if self._chain_map is not NULL: + * while it != self._chain_map.end(): * del dereference(it).second # <<<<<<<<<<<<<< * postincrement(it) * */ delete (*__pyx_v_it).second; - /* "polluck_blockchain/placeholder_native.pyx":331 - * while it != self._chain.end(): + /* "polluck_blockchain/placeholder_native.pyx":360 + * while it != self._chain_map.end(): * del dereference(it).second * postincrement(it) # <<<<<<<<<<<<<< * - * del self._chain + * del self._chain_map */ (void)((__pyx_v_it++)); } - /* "polluck_blockchain/placeholder_native.pyx":333 + /* "polluck_blockchain/placeholder_native.pyx":362 * postincrement(it) * + * del self._chain_map # <<<<<<<<<<<<<< + * self._chain_map = NULL + * +*/ + delete __pyx_v_self->_chain_map; + + /* "polluck_blockchain/placeholder_native.pyx":363 + * + * del self._chain_map + * self._chain_map = NULL # <<<<<<<<<<<<<< + * + * if self._chain is not NULL: +*/ + __pyx_v_self->_chain_map = NULL; + + /* "polluck_blockchain/placeholder_native.pyx":357 + * # ownership is typically not transferred from the Blockchain extension class + * cdef BcHashmap.iterator it = self._chain_map.begin() + * if self._chain_map is not NULL: # <<<<<<<<<<<<<< + * while it != self._chain_map.end(): + * del dereference(it).second +*/ + } + + /* "polluck_blockchain/placeholder_native.pyx":365 + * self._chain_map = NULL + * + * if self._chain is not NULL: # <<<<<<<<<<<<<< + * del self._chain + * self._chain = NULL +*/ + __pyx_t_1 = (__pyx_v_self->_chain != NULL); + if (__pyx_t_1) { + + /* "polluck_blockchain/placeholder_native.pyx":366 + * + * if self._chain is not NULL: * del self._chain # <<<<<<<<<<<<<< * self._chain = NULL * */ delete __pyx_v_self->_chain; - /* "polluck_blockchain/placeholder_native.pyx":334 - * + /* "polluck_blockchain/placeholder_native.pyx":367 + * if self._chain is not NULL: * del self._chain * self._chain = NULL # <<<<<<<<<<<<<< * - * def __len__(self): + * cdef Block* get_block_c(self, uint64_t idx) nogil: */ __pyx_v_self->_chain = NULL; - /* "polluck_blockchain/placeholder_native.pyx":328 - * # ownership is typically not transferred from the Blockchain extension class - * cdef BcHashmap.iterator it = self._chain.begin() + /* "polluck_blockchain/placeholder_native.pyx":365 + * self._chain_map = NULL + * * if self._chain is not NULL: # <<<<<<<<<<<<<< - * while it != self._chain.end(): - * del dereference(it).second + * del self._chain + * self._chain = NULL */ } - /* "polluck_blockchain/placeholder_native.pyx":325 - * pass + /* "polluck_blockchain/placeholder_native.pyx":354 + * db.metadata_blockchain.create_all(self._engine) * * def __dealloc__(self): # <<<<<<<<<<<<<< * # ownership is typically not transferred from the Blockchain extension class - * cdef BcHashmap.iterator it = self._chain.begin() + * cdef BcHashmap.iterator it = self._chain_map.begin() */ /* function exit code */ } -/* "polluck_blockchain/placeholder_native.pyx":336 +/* "polluck_blockchain/placeholder_native.pyx":369 * self._chain = NULL * + * cdef Block* get_block_c(self, uint64_t idx) nogil: # <<<<<<<<<<<<<< + * if idx > self._index: + * return NULL +*/ + +static ::Block *__pyx_f_18polluck_blockchain_18placeholder_native_10Blockchain_get_block_c(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, uint64_t __pyx_v_idx) { + ::Block *__pyx_r; + int __pyx_t_1; + + /* "polluck_blockchain/placeholder_native.pyx":370 + * + * cdef Block* get_block_c(self, uint64_t idx) nogil: + * if idx > self._index: # <<<<<<<<<<<<<< + * return NULL + * return self._chain_map[0][idx] +*/ + __pyx_t_1 = (__pyx_v_idx > __pyx_v_self->_index); + if (__pyx_t_1) { + + /* "polluck_blockchain/placeholder_native.pyx":371 + * cdef Block* get_block_c(self, uint64_t idx) nogil: + * if idx > self._index: + * return NULL # <<<<<<<<<<<<<< + * return self._chain_map[0][idx] + * +*/ + __pyx_r = NULL; + goto __pyx_L0; + + /* "polluck_blockchain/placeholder_native.pyx":370 + * + * cdef Block* get_block_c(self, uint64_t idx) nogil: + * if idx > self._index: # <<<<<<<<<<<<<< + * return NULL + * return self._chain_map[0][idx] +*/ + } + + /* "polluck_blockchain/placeholder_native.pyx":372 + * if idx > self._index: + * return NULL + * return self._chain_map[0][idx] # <<<<<<<<<<<<<< + * + * cdef void add_block_from_loading(self, Block *block) nogil: +*/ + __pyx_r = ((__pyx_v_self->_chain_map[0])[__pyx_v_idx]); + goto __pyx_L0; + + /* "polluck_blockchain/placeholder_native.pyx":369 + * self._chain = NULL + * + * cdef Block* get_block_c(self, uint64_t idx) nogil: # <<<<<<<<<<<<<< + * if idx > self._index: + * return NULL +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "polluck_blockchain/placeholder_native.pyx":374 + * return self._chain_map[0][idx] + * + * cdef void add_block_from_loading(self, Block *block) nogil: # <<<<<<<<<<<<<< + * self._chain[0].push_back(block) + * self._chain_map[0][block.index] = block +*/ + +static void __pyx_f_18polluck_blockchain_18placeholder_native_10Blockchain_add_block_from_loading(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, ::Block *__pyx_v_block) { + uint64_t __pyx_t_1; + int __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyGILState_STATE __pyx_gilstate_save; + + /* "polluck_blockchain/placeholder_native.pyx":375 + * + * cdef void add_block_from_loading(self, Block *block) nogil: + * self._chain[0].push_back(block) # <<<<<<<<<<<<<< + * self._chain_map[0][block.index] = block + * self._index = block.index +*/ + try { + (__pyx_v_self->_chain[0]).push_back(__pyx_v_block); + } catch(...) { + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + __Pyx_CppExn2PyErr(); + __Pyx_PyGILState_Release(__pyx_gilstate_save); + __PYX_ERR(0, 375, __pyx_L1_error) + } + + /* "polluck_blockchain/placeholder_native.pyx":376 + * cdef void add_block_from_loading(self, Block *block) nogil: + * self._chain[0].push_back(block) + * self._chain_map[0][block.index] = block # <<<<<<<<<<<<<< + * self._index = block.index + * if not self._genesis_done: +*/ + ((__pyx_v_self->_chain_map[0])[__pyx_v_block->index]) = __pyx_v_block; + + /* "polluck_blockchain/placeholder_native.pyx":377 + * self._chain[0].push_back(block) + * self._chain_map[0][block.index] = block + * self._index = block.index # <<<<<<<<<<<<<< + * if not self._genesis_done: + * self._genesis_done = True +*/ + __pyx_t_1 = __pyx_v_block->index; + __pyx_v_self->_index = __pyx_t_1; + + /* "polluck_blockchain/placeholder_native.pyx":378 + * self._chain_map[0][block.index] = block + * self._index = block.index + * if not self._genesis_done: # <<<<<<<<<<<<<< + * self._genesis_done = True + * +*/ + __pyx_t_2 = (!__pyx_v_self->_genesis_done); + if (__pyx_t_2) { + + /* "polluck_blockchain/placeholder_native.pyx":379 + * self._index = block.index + * if not self._genesis_done: + * self._genesis_done = True # <<<<<<<<<<<<<< + * + * cdef int add_block(self, Block *block) nogil: +*/ + __pyx_v_self->_genesis_done = 1; + + /* "polluck_blockchain/placeholder_native.pyx":378 + * self._chain_map[0][block.index] = block + * self._index = block.index + * if not self._genesis_done: # <<<<<<<<<<<<<< + * self._genesis_done = True + * +*/ + } + + /* "polluck_blockchain/placeholder_native.pyx":374 + * return self._chain_map[0][idx] + * + * cdef void add_block_from_loading(self, Block *block) nogil: # <<<<<<<<<<<<<< + * self._chain[0].push_back(block) + * self._chain_map[0][block.index] = block +*/ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + __Pyx_AddTraceback("polluck_blockchain.placeholder_native.Blockchain.add_block_from_loading", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_PyGILState_Release(__pyx_gilstate_save); + __pyx_L0:; +} + +/* "polluck_blockchain/placeholder_native.pyx":381 + * self._genesis_done = True + * + * cdef int add_block(self, Block *block) nogil: # <<<<<<<<<<<<<< + * cdef: + * uint64_t mined_nonce +*/ + +static int __pyx_f_18polluck_blockchain_18placeholder_native_10Blockchain_add_block(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, ::Block *__pyx_v_block) { + uint64_t __pyx_v_mined_nonce; + size_t __pyx_v_digest_size; + unsigned char *__pyx_v_sha256_digest; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + unsigned char *__pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + size_t __pyx_t_9; + std::string __pyx_t_10; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyGILState_STATE __pyx_gilstate_save; + __Pyx_RefNannySetupContext("add_block", 1); + + /* "polluck_blockchain/placeholder_native.pyx":387 + * unsigned char *sha256_digest + * # mine block + * if mine_block(block, self._difficulty, &mined_nonce) != 0: # <<<<<<<<<<<<<< + * return 1 + * block.nonce = mined_nonce +*/ + __pyx_t_1 = __pyx_f_18polluck_blockchain_18placeholder_native_mine_block(__pyx_v_block, __pyx_v_self->_difficulty, (&__pyx_v_mined_nonce), NULL); if (unlikely(__pyx_t_1 == ((int)-1) && __Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 387, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "polluck_blockchain/placeholder_native.pyx":388 + * # mine block + * if mine_block(block, self._difficulty, &mined_nonce) != 0: + * return 1 # <<<<<<<<<<<<<< + * block.nonce = mined_nonce + * # hash block, add hash to block, add block to blockchain hashmap +*/ + __pyx_r = 1; + goto __pyx_L0; + + /* "polluck_blockchain/placeholder_native.pyx":387 + * unsigned char *sha256_digest + * # mine block + * if mine_block(block, self._difficulty, &mined_nonce) != 0: # <<<<<<<<<<<<<< + * return 1 + * block.nonce = mined_nonce +*/ + } + + /* "polluck_blockchain/placeholder_native.pyx":389 + * if mine_block(block, self._difficulty, &mined_nonce) != 0: + * return 1 + * block.nonce = mined_nonce # <<<<<<<<<<<<<< + * # hash block, add hash to block, add block to blockchain hashmap + * sha256_digest = perform_hash_c(block, &digest_size) +*/ + __pyx_v_block->nonce = __pyx_v_mined_nonce; + + /* "polluck_blockchain/placeholder_native.pyx":391 + * block.nonce = mined_nonce + * # hash block, add hash to block, add block to blockchain hashmap + * sha256_digest = perform_hash_c(block, &digest_size) # <<<<<<<<<<<<<< + * with gil: + * block.hash = bytes(sha256_digest[:digest_size]).hex().encode("UTF-8") +*/ + __pyx_t_3 = __pyx_f_18polluck_blockchain_18placeholder_native_perform_hash_c(__pyx_v_block, (&__pyx_v_digest_size)); if (unlikely(__pyx_t_3 == ((void *)NULL) && __Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 391, __pyx_L1_error) + __pyx_v_sha256_digest = __pyx_t_3; + + /* "polluck_blockchain/placeholder_native.pyx":392 + * # hash block, add hash to block, add block to blockchain hashmap + * sha256_digest = perform_hash_c(block, &digest_size) + * with gil: # <<<<<<<<<<<<<< + * block.hash = bytes(sha256_digest[:digest_size]).hex().encode("UTF-8") + * free(sha256_digest) +*/ + { + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + /*try:*/ { + + /* "polluck_blockchain/placeholder_native.pyx":393 + * sha256_digest = perform_hash_c(block, &digest_size) + * with gil: + * block.hash = bytes(sha256_digest[:digest_size]).hex().encode("UTF-8") # <<<<<<<<<<<<<< + * free(sha256_digest) + * self._chain[0].push_back(block) +*/ + __pyx_t_7 = NULL; + __pyx_t_8 = __Pyx_PyBytes_FromStringAndSize(((char const *)__pyx_v_sha256_digest) + 0, __pyx_v_digest_size - 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 393, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_8}; + __pyx_t_6 = __Pyx_PyObject_FastCall((PyObject*)(&PyBytes_Type), __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 393, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_6); + } + __pyx_t_5 = __pyx_t_6; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_hex, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 393, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_6 = PyUnicode_AsUTF8String(((PyObject*)__pyx_t_4)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 393, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_10 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_t_6); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 393, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_v_block->hash = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_10); + } + + /* "polluck_blockchain/placeholder_native.pyx":392 + * # hash block, add hash to block, add block to blockchain hashmap + * sha256_digest = perform_hash_c(block, &digest_size) + * with gil: # <<<<<<<<<<<<<< + * block.hash = bytes(sha256_digest[:digest_size]).hex().encode("UTF-8") + * free(sha256_digest) +*/ + /*finally:*/ { + /*normal exit:*/{ + __Pyx_PyGILState_Release(__pyx_gilstate_save); + goto __pyx_L6; + } + __pyx_L5_error: { + __Pyx_PyGILState_Release(__pyx_gilstate_save); + goto __pyx_L1_error; + } + __pyx_L6:; + } + } + + /* "polluck_blockchain/placeholder_native.pyx":394 + * with gil: + * block.hash = bytes(sha256_digest[:digest_size]).hex().encode("UTF-8") + * free(sha256_digest) # <<<<<<<<<<<<<< + * self._chain[0].push_back(block) + * self._chain_map[0][block.index] = block +*/ + free(__pyx_v_sha256_digest); + + /* "polluck_blockchain/placeholder_native.pyx":395 + * block.hash = bytes(sha256_digest[:digest_size]).hex().encode("UTF-8") + * free(sha256_digest) + * self._chain[0].push_back(block) # <<<<<<<<<<<<<< + * self._chain_map[0][block.index] = block + * +*/ + try { + (__pyx_v_self->_chain[0]).push_back(__pyx_v_block); + } catch(...) { + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + __Pyx_CppExn2PyErr(); + __Pyx_PyGILState_Release(__pyx_gilstate_save); + __PYX_ERR(0, 395, __pyx_L1_error) + } + + /* "polluck_blockchain/placeholder_native.pyx":396 + * free(sha256_digest) + * self._chain[0].push_back(block) + * self._chain_map[0][block.index] = block # <<<<<<<<<<<<<< + * + * if self._genesis_done: +*/ + ((__pyx_v_self->_chain_map[0])[__pyx_v_block->index]) = __pyx_v_block; + + /* "polluck_blockchain/placeholder_native.pyx":398 + * self._chain_map[0][block.index] = block + * + * if self._genesis_done: # <<<<<<<<<<<<<< + * self._index += 1 + * +*/ + if (__pyx_v_self->_genesis_done) { + + /* "polluck_blockchain/placeholder_native.pyx":399 + * + * if self._genesis_done: + * self._index += 1 # <<<<<<<<<<<<<< + * + * return 0 +*/ + __pyx_v_self->_index = (__pyx_v_self->_index + 1); + + /* "polluck_blockchain/placeholder_native.pyx":398 + * self._chain_map[0][block.index] = block + * + * if self._genesis_done: # <<<<<<<<<<<<<< + * self._index += 1 + * +*/ + } + + /* "polluck_blockchain/placeholder_native.pyx":401 + * self._index += 1 + * + * return 0 # <<<<<<<<<<<<<< + * + * cdef string hash_data(self, data): +*/ + __pyx_r = 0; + goto __pyx_L0; + + /* "polluck_blockchain/placeholder_native.pyx":381 + * self._genesis_done = True + * + * cdef int add_block(self, Block *block) nogil: # <<<<<<<<<<<<<< + * cdef: + * uint64_t mined_nonce +*/ + + /* function exit code */ + __pyx_L1_error:; + __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("polluck_blockchain.placeholder_native.Blockchain.add_block", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __Pyx_PyGILState_Release(__pyx_gilstate_save); + __pyx_L0:; + __Pyx_RefNannyFinishContextNogil() + return __pyx_r; +} + +/* "polluck_blockchain/placeholder_native.pyx":403 + * return 0 + * + * cdef string hash_data(self, data): # <<<<<<<<<<<<<< + * cdef: + * string data_str +*/ + +static std::string __pyx_f_18polluck_blockchain_18placeholder_native_10Blockchain_hash_data(CYTHON_UNUSED struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, PyObject *__pyx_v_data) { + std::string __pyx_v_data_str; + unsigned char *__pyx_v_data_digest; + size_t __pyx_v_digest_size; + std::string __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + size_t __pyx_t_3; + std::string __pyx_t_4; + unsigned char *__pyx_t_5; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("hash_data", 0); + + /* "polluck_blockchain/placeholder_native.pyx":408 + * unsigned char *data_digest + * size_t digest_size + * data_str = data.encode("UTF-8") # <<<<<<<<<<<<<< + * data_digest = SHA256_digest(data_str.c_str(), data_str.size(), &digest_size) + * if data_digest is NULL: +*/ + __pyx_t_2 = __pyx_v_data; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __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_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, 408, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_4 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 408, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_data_str = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_4); + + /* "polluck_blockchain/placeholder_native.pyx":409 + * size_t digest_size + * data_str = data.encode("UTF-8") + * data_digest = SHA256_digest(data_str.c_str(), data_str.size(), &digest_size) # <<<<<<<<<<<<<< + * if data_digest is NULL: + * raise RuntimeError("Failed to hash data") +*/ + __pyx_t_5 = __pyx_f_18polluck_blockchain_18placeholder_native_SHA256_digest(__pyx_v_data_str.c_str(), __pyx_v_data_str.size(), (&__pyx_v_digest_size)); if (unlikely(__pyx_t_5 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 409, __pyx_L1_error) + __pyx_v_data_digest = __pyx_t_5; + + /* "polluck_blockchain/placeholder_native.pyx":410 + * data_str = data.encode("UTF-8") + * data_digest = SHA256_digest(data_str.c_str(), data_str.size(), &digest_size) + * if data_digest is NULL: # <<<<<<<<<<<<<< + * raise RuntimeError("Failed to hash data") + * data_str = bytes(data_digest[:digest_size]).hex().encode("UTF-8") +*/ + __pyx_t_6 = (__pyx_v_data_digest == NULL); + if (unlikely(__pyx_t_6)) { + + /* "polluck_blockchain/placeholder_native.pyx":411 + * data_digest = SHA256_digest(data_str.c_str(), data_str.size(), &digest_size) + * if data_digest is NULL: + * raise RuntimeError("Failed to hash data") # <<<<<<<<<<<<<< + * data_str = bytes(data_digest[:digest_size]).hex().encode("UTF-8") + * free(data_digest) +*/ + __pyx_t_2 = NULL; + __pyx_t_3 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_mstate_global->__pyx_kp_u_Failed_to_hash_data}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_RuntimeError)), __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 411, __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, 411, __pyx_L1_error) + + /* "polluck_blockchain/placeholder_native.pyx":410 + * data_str = data.encode("UTF-8") + * data_digest = SHA256_digest(data_str.c_str(), data_str.size(), &digest_size) + * if data_digest is NULL: # <<<<<<<<<<<<<< + * raise RuntimeError("Failed to hash data") + * data_str = bytes(data_digest[:digest_size]).hex().encode("UTF-8") +*/ + } + + /* "polluck_blockchain/placeholder_native.pyx":412 + * if data_digest is NULL: + * raise RuntimeError("Failed to hash data") + * data_str = bytes(data_digest[:digest_size]).hex().encode("UTF-8") # <<<<<<<<<<<<<< + * free(data_digest) + * +*/ + __pyx_t_8 = NULL; + __pyx_t_9 = __Pyx_PyBytes_FromStringAndSize(((char const *)__pyx_v_data_digest) + 0, __pyx_v_digest_size - 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 412, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_3 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_9}; + __pyx_t_7 = __Pyx_PyObject_FastCall((PyObject*)(&PyBytes_Type), __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 412, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + } + __pyx_t_2 = __pyx_t_7; + __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_hex, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 412, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_7 = PyUnicode_AsUTF8String(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 412, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_4 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 412, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_v_data_str = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_4); + + /* "polluck_blockchain/placeholder_native.pyx":413 + * raise RuntimeError("Failed to hash data") + * data_str = bytes(data_digest[:digest_size]).hex().encode("UTF-8") + * free(data_digest) # <<<<<<<<<<<<<< + * + * return data_str +*/ + free(__pyx_v_data_digest); + + /* "polluck_blockchain/placeholder_native.pyx":415 + * free(data_digest) + * + * return data_str # <<<<<<<<<<<<<< + * + * cdef load_from_batch(self, batch): +*/ + __pyx_r = __pyx_v_data_str; + goto __pyx_L0; + + /* "polluck_blockchain/placeholder_native.pyx":403 + * return 0 + * + * cdef string hash_data(self, data): # <<<<<<<<<<<<<< + * cdef: + * string data_str +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("polluck_blockchain.placeholder_native.Blockchain.hash_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "polluck_blockchain/placeholder_native.pyx":417 + * return data_str + * + * cdef load_from_batch(self, batch): # <<<<<<<<<<<<<< + * cdef Block *block + * +*/ + +static PyObject *__pyx_f_18polluck_blockchain_18placeholder_native_10Blockchain_load_from_batch(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, PyObject *__pyx_v_batch) { + ::Block *__pyx_v_block; + PyObject *__pyx_v_entry = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *(*__pyx_t_3)(PyObject *); + PyObject *__pyx_t_4 = NULL; + uint64_t __pyx_t_5; + double __pyx_t_6; + uint64_t __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + size_t __pyx_t_10; + std::string __pyx_t_11; + std::string __pyx_t_12; + std::string __pyx_t_13; + ::Block *__pyx_t_14; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("load_from_batch", 0); + + /* "polluck_blockchain/placeholder_native.pyx":420 + * cdef Block *block + * + * for entry in batch: # <<<<<<<<<<<<<< + * block = new Block( + * entry[0], +*/ + if (likely(PyList_CheckExact(__pyx_v_batch)) || PyTuple_CheckExact(__pyx_v_batch)) { + __pyx_t_1 = __pyx_v_batch; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + __pyx_t_3 = NULL; + } else { + __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_batch); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 420, __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, 420, __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, 420, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + __pyx_t_4 = __Pyx_PyList_GetItemRefFast(__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, 420, __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, 420, __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, 420, __pyx_L1_error) + PyErr_Clear(); + } + break; + } + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_entry, __pyx_t_4); + __pyx_t_4 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":422 + * for entry in batch: + * block = new Block( + * entry[0], # <<<<<<<<<<<<<< + * entry[1], + * entry[2], +*/ + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_entry, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 422, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyLong_As_uint64_t(__pyx_t_4); if (unlikely((__pyx_t_5 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 422, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":423 + * block = new Block( + * entry[0], + * entry[1], # <<<<<<<<<<<<<< + * entry[2], + * entry[5].encode("UTF-8"), +*/ + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_entry, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 423, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 423, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":424 + * entry[0], + * entry[1], + * entry[2], # <<<<<<<<<<<<<< + * entry[5].encode("UTF-8"), + * entry[3].encode("UTF-8"), +*/ + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_entry, 2, long, 1, __Pyx_PyLong_From_long, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 424, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_PyLong_As_uint64_t(__pyx_t_4); if (unlikely((__pyx_t_7 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 424, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":425 + * entry[1], + * entry[2], + * entry[5].encode("UTF-8"), # <<<<<<<<<<<<<< + * entry[3].encode("UTF-8"), + * entry[4].encode("UTF-8"), +*/ + __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_entry, 5, long, 1, __Pyx_PyLong_From_long, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 425, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_8 = __pyx_t_9; + __Pyx_INCREF(__pyx_t_8); + __pyx_t_10 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_mstate_global->__pyx_kp_u_UTF_8}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_encode, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 425, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_11 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_t_4); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 425, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":426 + * entry[2], + * entry[5].encode("UTF-8"), + * entry[3].encode("UTF-8"), # <<<<<<<<<<<<<< + * entry[4].encode("UTF-8"), + * ) +*/ + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_entry, 3, long, 1, __Pyx_PyLong_From_long, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 426, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __pyx_t_8; + __Pyx_INCREF(__pyx_t_9); + __pyx_t_10 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_mstate_global->__pyx_kp_u_UTF_8}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_encode, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (1*__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, 426, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_12 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_t_4); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 426, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":427 + * entry[5].encode("UTF-8"), + * entry[3].encode("UTF-8"), + * entry[4].encode("UTF-8"), # <<<<<<<<<<<<<< + * ) + * self.add_block_from_loading(block) +*/ + __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_entry, 4, long, 1, __Pyx_PyLong_From_long, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_8 = __pyx_t_9; + __Pyx_INCREF(__pyx_t_8); + __pyx_t_10 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_mstate_global->__pyx_kp_u_UTF_8}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_encode, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_13 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_t_4); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 427, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":421 + * + * for entry in batch: + * block = new Block( # <<<<<<<<<<<<<< + * entry[0], + * entry[1], +*/ + try { + __pyx_t_14 = new ::Block(__pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_t_11, __pyx_t_12, __pyx_t_13); + } catch(...) { + __Pyx_CppExn2PyErr(); + __PYX_ERR(0, 421, __pyx_L1_error) + } + __pyx_v_block = __pyx_t_14; + + /* "polluck_blockchain/placeholder_native.pyx":429 + * entry[4].encode("UTF-8"), + * ) + * self.add_block_from_loading(block) # <<<<<<<<<<<<<< + * + * # // Python public API +*/ + ((struct __pyx_vtabstruct_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self->__pyx_vtab)->add_block_from_loading(__pyx_v_self, __pyx_v_block); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 429, __pyx_L1_error) + + /* "polluck_blockchain/placeholder_native.pyx":420 + * cdef Block *block + * + * for entry in batch: # <<<<<<<<<<<<<< + * block = new Block( + * entry[0], +*/ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":417 + * return data_str + * + * cdef load_from_batch(self, batch): # <<<<<<<<<<<<<< + * cdef Block *block + * +*/ + + /* 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_4); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("polluck_blockchain.placeholder_native.Blockchain.load_from_batch", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_entry); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "polluck_blockchain/placeholder_native.pyx":432 + * + * # // Python public API * def __len__(self): # <<<<<<<<<<<<<< * return self._index + 1 * @@ -6890,8 +8437,8 @@ static Py_ssize_t __pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchai static Py_ssize_t __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_6__len__(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self) { Py_ssize_t __pyx_r; - /* "polluck_blockchain/placeholder_native.pyx":337 - * + /* "polluck_blockchain/placeholder_native.pyx":433 + * # // Python public API * def __len__(self): * return self._index + 1 # <<<<<<<<<<<<<< * @@ -6900,9 +8447,9 @@ static Py_ssize_t __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchai __pyx_r = (__pyx_v_self->_index + 1); goto __pyx_L0; - /* "polluck_blockchain/placeholder_native.pyx":336 - * self._chain = NULL + /* "polluck_blockchain/placeholder_native.pyx":432 * + * # // Python public API * def __len__(self): # <<<<<<<<<<<<<< * return self._index + 1 * @@ -6913,7 +8460,7 @@ static Py_ssize_t __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchai return __pyx_r; } -/* "polluck_blockchain/placeholder_native.pyx":339 +/* "polluck_blockchain/placeholder_native.pyx":435 * return self._index + 1 * * @property # <<<<<<<<<<<<<< @@ -6945,7 +8492,7 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); - /* "polluck_blockchain/placeholder_native.pyx":341 + /* "polluck_blockchain/placeholder_native.pyx":437 * @property * def difficulty(self): * return self._difficulty # <<<<<<<<<<<<<< @@ -6953,13 +8500,13 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain * @difficulty.setter */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyLong_From_unsigned_int(__pyx_v_self->_difficulty); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 341, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_unsigned_int(__pyx_v_self->_difficulty); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 437, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "polluck_blockchain/placeholder_native.pyx":339 + /* "polluck_blockchain/placeholder_native.pyx":435 * return self._index + 1 * * @property # <<<<<<<<<<<<<< @@ -6978,7 +8525,7 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain return __pyx_r; } -/* "polluck_blockchain/placeholder_native.pyx":343 +/* "polluck_blockchain/placeholder_native.pyx":439 * return self._difficulty * * @difficulty.setter # <<<<<<<<<<<<<< @@ -7015,7 +8562,7 @@ static int __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_10dif int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); - /* "polluck_blockchain/placeholder_native.pyx":345 + /* "polluck_blockchain/placeholder_native.pyx":441 * @difficulty.setter * def difficulty(self, value): * if not isinstance(value, int): # <<<<<<<<<<<<<< @@ -7026,7 +8573,7 @@ static int __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_10dif __pyx_t_2 = (!__pyx_t_1); if (unlikely(__pyx_t_2)) { - /* "polluck_blockchain/placeholder_native.pyx":346 + /* "polluck_blockchain/placeholder_native.pyx":442 * def difficulty(self, value): * if not isinstance(value, int): * raise TypeError("Difficulty must be integer value") # <<<<<<<<<<<<<< @@ -7039,14 +8586,14 @@ static int __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_10dif PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_Difficulty_must_be_integer_value}; __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_TypeError)), __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, 346, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 442, __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, 346, __pyx_L1_error) + __PYX_ERR(0, 442, __pyx_L1_error) - /* "polluck_blockchain/placeholder_native.pyx":345 + /* "polluck_blockchain/placeholder_native.pyx":441 * @difficulty.setter * def difficulty(self, value): * if not isinstance(value, int): # <<<<<<<<<<<<<< @@ -7055,19 +8602,19 @@ static int __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_10dif */ } - /* "polluck_blockchain/placeholder_native.pyx":347 + /* "polluck_blockchain/placeholder_native.pyx":443 * if not isinstance(value, int): * raise TypeError("Difficulty must be integer value") * if value <= 0: # <<<<<<<<<<<<<< * raise ValueError("Difficulty must be greater than 0") * self._difficulty = value */ - __pyx_t_3 = PyObject_RichCompare(__pyx_v_value, __pyx_mstate_global->__pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 347, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 347, __pyx_L1_error) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_value, __pyx_mstate_global->__pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 443, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 443, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(__pyx_t_2)) { - /* "polluck_blockchain/placeholder_native.pyx":348 + /* "polluck_blockchain/placeholder_native.pyx":444 * raise TypeError("Difficulty must be integer value") * if value <= 0: * raise ValueError("Difficulty must be greater than 0") # <<<<<<<<<<<<<< @@ -7080,14 +8627,14 @@ static int __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_10dif PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_Difficulty_must_be_greater_than}; __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, 348, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 444, __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, 348, __pyx_L1_error) + __PYX_ERR(0, 444, __pyx_L1_error) - /* "polluck_blockchain/placeholder_native.pyx":347 + /* "polluck_blockchain/placeholder_native.pyx":443 * if not isinstance(value, int): * raise TypeError("Difficulty must be integer value") * if value <= 0: # <<<<<<<<<<<<<< @@ -7096,17 +8643,17 @@ static int __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_10dif */ } - /* "polluck_blockchain/placeholder_native.pyx":349 + /* "polluck_blockchain/placeholder_native.pyx":445 * if value <= 0: * raise ValueError("Difficulty must be greater than 0") * self._difficulty = value # <<<<<<<<<<<<<< * * @property */ - __pyx_t_6 = __Pyx_PyLong_As_unsigned_int(__pyx_v_value); if (unlikely((__pyx_t_6 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 349, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyLong_As_unsigned_int(__pyx_v_value); if (unlikely((__pyx_t_6 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 445, __pyx_L1_error) __pyx_v_self->_difficulty = __pyx_t_6; - /* "polluck_blockchain/placeholder_native.pyx":343 + /* "polluck_blockchain/placeholder_native.pyx":439 * return self._difficulty * * @difficulty.setter # <<<<<<<<<<<<<< @@ -7127,7 +8674,7 @@ static int __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_10dif return __pyx_r; } -/* "polluck_blockchain/placeholder_native.pyx":351 +/* "polluck_blockchain/placeholder_native.pyx":447 * self._difficulty = value * * @property # <<<<<<<<<<<<<< @@ -7159,7 +8706,7 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); - /* "polluck_blockchain/placeholder_native.pyx":353 + /* "polluck_blockchain/placeholder_native.pyx":449 * @property * def genesis_done(self): * return self._genesis_done # <<<<<<<<<<<<<< @@ -7167,13 +8714,13 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain * @property */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_genesis_done); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 353, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_genesis_done); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 449, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "polluck_blockchain/placeholder_native.pyx":351 + /* "polluck_blockchain/placeholder_native.pyx":447 * self._difficulty = value * * @property # <<<<<<<<<<<<<< @@ -7192,7 +8739,7 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain return __pyx_r; } -/* "polluck_blockchain/placeholder_native.pyx":355 +/* "polluck_blockchain/placeholder_native.pyx":451 * return self._genesis_done * * @property # <<<<<<<<<<<<<< @@ -7224,21 +8771,21 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); - /* "polluck_blockchain/placeholder_native.pyx":357 + /* "polluck_blockchain/placeholder_native.pyx":453 * @property * def index(self): * return self._index # <<<<<<<<<<<<<< * - * def print_key_value_pair(self): + * def _print_key_value_pair(self): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyLong_From_uint64_t(__pyx_v_self->_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 357, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_uint64_t(__pyx_v_self->_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 453, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "polluck_blockchain/placeholder_native.pyx":355 + /* "polluck_blockchain/placeholder_native.pyx":451 * return self._genesis_done * * @property # <<<<<<<<<<<<<< @@ -7257,24 +8804,24 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain return __pyx_r; } -/* "polluck_blockchain/placeholder_native.pyx":359 +/* "polluck_blockchain/placeholder_native.pyx":455 * return self._index * - * def print_key_value_pair(self): # <<<<<<<<<<<<<< - * cdef BcHashmap.iterator it = self._chain.begin() + * def _print_key_value_pair(self): # <<<<<<<<<<<<<< + * cdef BcHashmap.iterator it = self._chain_map.begin() * cdef Block *block */ /* Python wrapper */ -static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_9print_key_value_pair(PyObject *__pyx_v_self, +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_9_print_key_value_pair(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyMethodDef __pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_9print_key_value_pair = {"print_key_value_pair", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_9print_key_value_pair, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_9print_key_value_pair(PyObject *__pyx_v_self, +static PyMethodDef __pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_9_print_key_value_pair = {"_print_key_value_pair", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_9_print_key_value_pair, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_9_print_key_value_pair(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -7287,7 +8834,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("print_key_value_pair (wrapper)", 0); + __Pyx_RefNannySetupContext("_print_key_value_pair (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); @@ -7296,18 +8843,18 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("print_key_value_pair", 1, 0, 0, __pyx_nargs); return NULL; } + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("_print_key_value_pair", 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("print_key_value_pair", __pyx_kwds); return NULL;} - __pyx_r = __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_8print_key_value_pair(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self)); + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("_print_key_value_pair", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_8_print_key_value_pair(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_8print_key_value_pair(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self) { +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_8_print_key_value_pair(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self) { std::unordered_map ::iterator __pyx_v_it; ::Block *__pyx_v_block; struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_v_py_block = NULL; @@ -7322,37 +8869,37 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("print_key_value_pair", 0); + __Pyx_RefNannySetupContext("_print_key_value_pair", 0); - /* "polluck_blockchain/placeholder_native.pyx":360 + /* "polluck_blockchain/placeholder_native.pyx":456 * - * def print_key_value_pair(self): - * cdef BcHashmap.iterator it = self._chain.begin() # <<<<<<<<<<<<<< + * def _print_key_value_pair(self): + * cdef BcHashmap.iterator it = self._chain_map.begin() # <<<<<<<<<<<<<< * cdef Block *block - * while it != self._chain.end(): + * while it != self._chain_map.end(): */ - __pyx_v_it = __pyx_v_self->_chain->begin(); + __pyx_v_it = __pyx_v_self->_chain_map->begin(); - /* "polluck_blockchain/placeholder_native.pyx":362 - * cdef BcHashmap.iterator it = self._chain.begin() + /* "polluck_blockchain/placeholder_native.pyx":458 + * cdef BcHashmap.iterator it = self._chain_map.begin() * cdef Block *block - * while it != self._chain.end(): # <<<<<<<<<<<<<< + * while it != self._chain_map.end(): # <<<<<<<<<<<<<< * print(dereference(it).first) * block = dereference(it).second */ while (1) { - __pyx_t_1 = (__pyx_v_it != __pyx_v_self->_chain->end()); + __pyx_t_1 = (__pyx_v_it != __pyx_v_self->_chain_map->end()); if (!__pyx_t_1) break; - /* "polluck_blockchain/placeholder_native.pyx":363 + /* "polluck_blockchain/placeholder_native.pyx":459 * cdef Block *block - * while it != self._chain.end(): + * while it != self._chain_map.end(): * print(dereference(it).first) # <<<<<<<<<<<<<< * block = dereference(it).second * py_block = PyBlock.from_ptr(block) */ __pyx_t_3 = NULL; - __pyx_t_4 = __Pyx_PyLong_From_uint64_t((*__pyx_v_it).first); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 363, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyLong_From_uint64_t((*__pyx_v_it).first); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 459, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = 1; { @@ -7360,13 +8907,13 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_print, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 363, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 459, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "polluck_blockchain/placeholder_native.pyx":364 - * while it != self._chain.end(): + /* "polluck_blockchain/placeholder_native.pyx":460 + * while it != self._chain_map.end(): * print(dereference(it).first) * block = dereference(it).second # <<<<<<<<<<<<<< * py_block = PyBlock.from_ptr(block) @@ -7375,19 +8922,19 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain __pyx_t_6 = (*__pyx_v_it).second; __pyx_v_block = __pyx_t_6; - /* "polluck_blockchain/placeholder_native.pyx":365 + /* "polluck_blockchain/placeholder_native.pyx":461 * print(dereference(it).first) * block = dereference(it).second * py_block = PyBlock.from_ptr(block) # <<<<<<<<<<<<<< * print(py_block) * postincrement(it) */ - __pyx_t_2 = ((PyObject *)__pyx_vtabptr_18polluck_blockchain_18placeholder_native_PyBlock->from_ptr(__pyx_v_block, NULL)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 365, __pyx_L1_error) + __pyx_t_2 = ((PyObject *)__pyx_vtabptr_18polluck_blockchain_18placeholder_native_PyBlock->from_ptr(__pyx_v_block, NULL)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 461, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_XDECREF_SET(__pyx_v_py_block, ((struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *)__pyx_t_2)); __pyx_t_2 = 0; - /* "polluck_blockchain/placeholder_native.pyx":366 + /* "polluck_blockchain/placeholder_native.pyx":462 * block = dereference(it).second * py_block = PyBlock.from_ptr(block) * print(py_block) # <<<<<<<<<<<<<< @@ -7400,26 +8947,26 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain PyObject *__pyx_callargs[2] = {__pyx_t_4, ((PyObject *)__pyx_v_py_block)}; __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_print, __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_2)) __PYX_ERR(0, 366, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 462, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "polluck_blockchain/placeholder_native.pyx":367 + /* "polluck_blockchain/placeholder_native.pyx":463 * py_block = PyBlock.from_ptr(block) * print(py_block) * postincrement(it) # <<<<<<<<<<<<<< * - * cdef Block* get_block_c(self, uint64_t idx) nogil: + * def print_blocks(self, max_num): */ (void)((__pyx_v_it++)); } - /* "polluck_blockchain/placeholder_native.pyx":359 + /* "polluck_blockchain/placeholder_native.pyx":455 * return self._index * - * def print_key_value_pair(self): # <<<<<<<<<<<<<< - * cdef BcHashmap.iterator it = self._chain.begin() + * def _print_key_value_pair(self): # <<<<<<<<<<<<<< + * cdef BcHashmap.iterator it = self._chain_map.begin() * cdef Block *block */ @@ -7430,7 +8977,7 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("polluck_blockchain.placeholder_native.Blockchain.print_key_value_pair", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("polluck_blockchain.placeholder_native.Blockchain._print_key_value_pair", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_py_block); @@ -7439,315 +8986,310 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain return __pyx_r; } -/* "polluck_blockchain/placeholder_native.pyx":369 +/* "polluck_blockchain/placeholder_native.pyx":465 * postincrement(it) * - * cdef Block* get_block_c(self, uint64_t idx) nogil: # <<<<<<<<<<<<<< - * if idx > self._index: - * return NULL -*/ - -static ::Block *__pyx_f_18polluck_blockchain_18placeholder_native_10Blockchain_get_block_c(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, uint64_t __pyx_v_idx) { - ::Block *__pyx_r; - int __pyx_t_1; - - /* "polluck_blockchain/placeholder_native.pyx":370 - * - * cdef Block* get_block_c(self, uint64_t idx) nogil: - * if idx > self._index: # <<<<<<<<<<<<<< - * return NULL - * return self._chain[0][idx] -*/ - __pyx_t_1 = (__pyx_v_idx > __pyx_v_self->_index); - if (__pyx_t_1) { - - /* "polluck_blockchain/placeholder_native.pyx":371 - * cdef Block* get_block_c(self, uint64_t idx) nogil: - * if idx > self._index: - * return NULL # <<<<<<<<<<<<<< - * return self._chain[0][idx] - * -*/ - __pyx_r = NULL; - goto __pyx_L0; - - /* "polluck_blockchain/placeholder_native.pyx":370 - * - * cdef Block* get_block_c(self, uint64_t idx) nogil: - * if idx > self._index: # <<<<<<<<<<<<<< - * return NULL - * return self._chain[0][idx] -*/ - } - - /* "polluck_blockchain/placeholder_native.pyx":372 - * if idx > self._index: - * return NULL - * return self._chain[0][idx] # <<<<<<<<<<<<<< - * - * cdef int add_block(self, Block *block) nogil: -*/ - __pyx_r = ((__pyx_v_self->_chain[0])[__pyx_v_idx]); - goto __pyx_L0; - - /* "polluck_blockchain/placeholder_native.pyx":369 - * postincrement(it) - * - * cdef Block* get_block_c(self, uint64_t idx) nogil: # <<<<<<<<<<<<<< - * if idx > self._index: - * return NULL -*/ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "polluck_blockchain/placeholder_native.pyx":374 - * return self._chain[0][idx] - * - * cdef int add_block(self, Block *block) nogil: # <<<<<<<<<<<<<< + * def print_blocks(self, max_num): # <<<<<<<<<<<<<< * cdef: - * uint64_t mined_nonce -*/ - -static int __pyx_f_18polluck_blockchain_18placeholder_native_10Blockchain_add_block(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, ::Block *__pyx_v_block) { - uint64_t __pyx_v_mined_nonce; - size_t __pyx_v_digest_size; - unsigned char *__pyx_v_sha256_digest; - int __pyx_r; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - unsigned char *__pyx_t_3; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - size_t __pyx_t_9; - std::string __pyx_t_10; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyGILState_STATE __pyx_gilstate_save; - __Pyx_RefNannySetupContext("add_block", 1); - - /* "polluck_blockchain/placeholder_native.pyx":380 - * unsigned char *sha256_digest - * # mine block - * if mine_block(block, self._difficulty, &mined_nonce) != 0: # <<<<<<<<<<<<<< - * return 1 - * block.nonce = mined_nonce -*/ - __pyx_t_1 = __pyx_f_18polluck_blockchain_18placeholder_native_mine_block(__pyx_v_block, __pyx_v_self->_difficulty, (&__pyx_v_mined_nonce), NULL); if (unlikely(__pyx_t_1 == ((int)-1) && __Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 380, __pyx_L1_error) - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { - - /* "polluck_blockchain/placeholder_native.pyx":381 - * # mine block - * if mine_block(block, self._difficulty, &mined_nonce) != 0: - * return 1 # <<<<<<<<<<<<<< - * block.nonce = mined_nonce - * # hash block, add hash to block, add block to blockchain hashmap -*/ - __pyx_r = 1; - goto __pyx_L0; - - /* "polluck_blockchain/placeholder_native.pyx":380 - * unsigned char *sha256_digest - * # mine block - * if mine_block(block, self._difficulty, &mined_nonce) != 0: # <<<<<<<<<<<<<< - * return 1 - * block.nonce = mined_nonce -*/ - } - - /* "polluck_blockchain/placeholder_native.pyx":382 - * if mine_block(block, self._difficulty, &mined_nonce) != 0: - * return 1 - * block.nonce = mined_nonce # <<<<<<<<<<<<<< - * # hash block, add hash to block, add block to blockchain hashmap - * sha256_digest = perform_hash_c(block, &digest_size) -*/ - __pyx_v_block->nonce = __pyx_v_mined_nonce; - - /* "polluck_blockchain/placeholder_native.pyx":384 - * block.nonce = mined_nonce - * # hash block, add hash to block, add block to blockchain hashmap - * sha256_digest = perform_hash_c(block, &digest_size) # <<<<<<<<<<<<<< - * with gil: - * block.hash = bytes(sha256_digest[:digest_size]).hex().encode("UTF-8") -*/ - __pyx_t_3 = __pyx_f_18polluck_blockchain_18placeholder_native_perform_hash_c(__pyx_v_block, (&__pyx_v_digest_size)); if (unlikely(__pyx_t_3 == ((void *)NULL) && __Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 384, __pyx_L1_error) - __pyx_v_sha256_digest = __pyx_t_3; - - /* "polluck_blockchain/placeholder_native.pyx":385 - * # hash block, add hash to block, add block to blockchain hashmap - * sha256_digest = perform_hash_c(block, &digest_size) - * with gil: # <<<<<<<<<<<<<< - * block.hash = bytes(sha256_digest[:digest_size]).hex().encode("UTF-8") - * free(sha256_digest) -*/ - { - PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - /*try:*/ { - - /* "polluck_blockchain/placeholder_native.pyx":386 - * sha256_digest = perform_hash_c(block, &digest_size) - * with gil: - * block.hash = bytes(sha256_digest[:digest_size]).hex().encode("UTF-8") # <<<<<<<<<<<<<< - * free(sha256_digest) - * self._chain[0][block.index] = block -*/ - __pyx_t_7 = NULL; - __pyx_t_8 = __Pyx_PyBytes_FromStringAndSize(((char const *)__pyx_v_sha256_digest) + 0, __pyx_v_digest_size - 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 386, __pyx_L5_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_9 = 1; - { - PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_8}; - __pyx_t_6 = __Pyx_PyObject_FastCall((PyObject*)(&PyBytes_Type), __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 386, __pyx_L5_error) - __Pyx_GOTREF(__pyx_t_6); - } - __pyx_t_5 = __pyx_t_6; - __Pyx_INCREF(__pyx_t_5); - __pyx_t_9 = 0; - { - PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; - __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_hex, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 386, __pyx_L5_error) - __Pyx_GOTREF(__pyx_t_4); - } - __pyx_t_6 = PyUnicode_AsUTF8String(((PyObject*)__pyx_t_4)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 386, __pyx_L5_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_10 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_t_6); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 386, __pyx_L5_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_v_block->hash = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_10); - } - - /* "polluck_blockchain/placeholder_native.pyx":385 - * # hash block, add hash to block, add block to blockchain hashmap - * sha256_digest = perform_hash_c(block, &digest_size) - * with gil: # <<<<<<<<<<<<<< - * block.hash = bytes(sha256_digest[:digest_size]).hex().encode("UTF-8") - * free(sha256_digest) -*/ - /*finally:*/ { - /*normal exit:*/{ - __Pyx_PyGILState_Release(__pyx_gilstate_save); - goto __pyx_L6; - } - __pyx_L5_error: { - __Pyx_PyGILState_Release(__pyx_gilstate_save); - goto __pyx_L1_error; - } - __pyx_L6:; - } - } - - /* "polluck_blockchain/placeholder_native.pyx":387 - * with gil: - * block.hash = bytes(sha256_digest[:digest_size]).hex().encode("UTF-8") - * free(sha256_digest) # <<<<<<<<<<<<<< - * self._chain[0][block.index] = block - * -*/ - free(__pyx_v_sha256_digest); - - /* "polluck_blockchain/placeholder_native.pyx":388 - * block.hash = bytes(sha256_digest[:digest_size]).hex().encode("UTF-8") - * free(sha256_digest) - * self._chain[0][block.index] = block # <<<<<<<<<<<<<< - * - * if self._genesis_done: -*/ - ((__pyx_v_self->_chain[0])[__pyx_v_block->index]) = __pyx_v_block; - - /* "polluck_blockchain/placeholder_native.pyx":390 - * self._chain[0][block.index] = block - * - * if self._genesis_done: # <<<<<<<<<<<<<< - * self._index += 1 - * -*/ - if (__pyx_v_self->_genesis_done) { - - /* "polluck_blockchain/placeholder_native.pyx":391 - * - * if self._genesis_done: - * self._index += 1 # <<<<<<<<<<<<<< - * - * return 0 -*/ - __pyx_v_self->_index = (__pyx_v_self->_index + 1); - - /* "polluck_blockchain/placeholder_native.pyx":390 - * self._chain[0][block.index] = block - * - * if self._genesis_done: # <<<<<<<<<<<<<< - * self._index += 1 - * -*/ - } - - /* "polluck_blockchain/placeholder_native.pyx":393 - * self._index += 1 - * - * return 0 # <<<<<<<<<<<<<< - * - * # // Python public API -*/ - __pyx_r = 0; - goto __pyx_L0; - - /* "polluck_blockchain/placeholder_native.pyx":374 - * return self._chain[0][idx] - * - * cdef int add_block(self, Block *block) nogil: # <<<<<<<<<<<<<< - * cdef: - * uint64_t mined_nonce -*/ - - /* function exit code */ - __pyx_L1_error:; - __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("polluck_blockchain.placeholder_native.Blockchain.add_block", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __Pyx_PyGILState_Release(__pyx_gilstate_save); - __pyx_L0:; - __Pyx_RefNannyFinishContextNogil() - return __pyx_r; -} - -/* "polluck_blockchain/placeholder_native.pyx":396 - * - * # // Python public API - * def get_block(self, idx): # <<<<<<<<<<<<<< - * if idx < 0 or idx > self._index: - * raise IndexError("Index value is out of bounds") + * Block *block */ /* Python wrapper */ -static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_11get_block(PyObject *__pyx_v_self, +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_11print_blocks(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyMethodDef __pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_11get_block = {"get_block", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_11get_block, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_11get_block(PyObject *__pyx_v_self, +static PyMethodDef __pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_11print_blocks = {"print_blocks", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_11print_blocks, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_11print_blocks(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_max_num = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("print_blocks (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_max_num,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, 465, __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, 465, __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, "print_blocks", 0) < (0)) __PYX_ERR(0, 465, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("print_blocks", 1, 1, 1, i); __PYX_ERR(0, 465, __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, 465, __pyx_L3_error) + } + __pyx_v_max_num = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("print_blocks", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 465, __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("polluck_blockchain.placeholder_native.Blockchain.print_blocks", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_10print_blocks(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self), __pyx_v_max_num); + + /* 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_18polluck_blockchain_18placeholder_native_10Blockchain_10print_blocks(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, PyObject *__pyx_v_max_num) { + ::Block *__pyx_v_block; + int __pyx_v_max_nummber; + int __pyx_v_idx; + int __pyx_v_num; + struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *__pyx_v_py_block = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + size_t __pyx_t_5; + std::vector<::Block *> ::size_type __pyx_t_6; + std::vector<::Block *> ::size_type __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("print_blocks", 0); + + /* "polluck_blockchain/placeholder_native.pyx":468 + * cdef: + * Block *block + * int max_nummber = max_num # <<<<<<<<<<<<<< + * int idx, num = 0 + * +*/ + __pyx_t_1 = __Pyx_PyLong_As_int(__pyx_v_max_num); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 468, __pyx_L1_error) + __pyx_v_max_nummber = __pyx_t_1; + + /* "polluck_blockchain/placeholder_native.pyx":469 + * Block *block + * int max_nummber = max_num + * int idx, num = 0 # <<<<<<<<<<<<<< + * + * if max_num <= 0: +*/ + __pyx_v_num = 0; + + /* "polluck_blockchain/placeholder_native.pyx":471 + * int idx, num = 0 + * + * if max_num <= 0: # <<<<<<<<<<<<<< + * raise ValueError("Maximum number must be greater than 0") + * +*/ + __pyx_t_2 = PyObject_RichCompare(__pyx_v_max_num, __pyx_mstate_global->__pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 471, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 471, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(__pyx_t_3)) { + + /* "polluck_blockchain/placeholder_native.pyx":472 + * + * if max_num <= 0: + * raise ValueError("Maximum number must be greater than 0") # <<<<<<<<<<<<<< + * + * for idx in range(self._chain[0].size()): +*/ + __pyx_t_4 = NULL; + __pyx_t_5 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_Maximum_number_must_be_greater_t}; + __pyx_t_2 = __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_2)) __PYX_ERR(0, 472, __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, 472, __pyx_L1_error) + + /* "polluck_blockchain/placeholder_native.pyx":471 + * int idx, num = 0 + * + * if max_num <= 0: # <<<<<<<<<<<<<< + * raise ValueError("Maximum number must be greater than 0") + * +*/ + } + + /* "polluck_blockchain/placeholder_native.pyx":474 + * raise ValueError("Maximum number must be greater than 0") + * + * for idx in range(self._chain[0].size()): # <<<<<<<<<<<<<< + * block = self._chain[0][idx] + * py_block = PyBlock.from_ptr(block) +*/ + __pyx_t_6 = (__pyx_v_self->_chain[0]).size(); + __pyx_t_7 = __pyx_t_6; + for (__pyx_t_1 = 0; __pyx_t_1 < __pyx_t_7; __pyx_t_1+=1) { + __pyx_v_idx = __pyx_t_1; + + /* "polluck_blockchain/placeholder_native.pyx":475 + * + * for idx in range(self._chain[0].size()): + * block = self._chain[0][idx] # <<<<<<<<<<<<<< + * py_block = PyBlock.from_ptr(block) + * print(py_block) +*/ + __pyx_v_block = ((__pyx_v_self->_chain[0])[__pyx_v_idx]); + + /* "polluck_blockchain/placeholder_native.pyx":476 + * for idx in range(self._chain[0].size()): + * block = self._chain[0][idx] + * py_block = PyBlock.from_ptr(block) # <<<<<<<<<<<<<< + * print(py_block) + * num += 1 +*/ + __pyx_t_2 = ((PyObject *)__pyx_vtabptr_18polluck_blockchain_18placeholder_native_PyBlock->from_ptr(__pyx_v_block, NULL)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 476, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_py_block, ((struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *)__pyx_t_2)); + __pyx_t_2 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":477 + * block = self._chain[0][idx] + * py_block = PyBlock.from_ptr(block) + * print(py_block) # <<<<<<<<<<<<<< + * num += 1 + * if num == max_nummber: +*/ + __pyx_t_4 = NULL; + __pyx_t_5 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, ((PyObject *)__pyx_v_py_block)}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_print, __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_2)) __PYX_ERR(0, 477, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":478 + * py_block = PyBlock.from_ptr(block) + * print(py_block) + * num += 1 # <<<<<<<<<<<<<< + * if num == max_nummber: + * break +*/ + __pyx_v_num = (__pyx_v_num + 1); + + /* "polluck_blockchain/placeholder_native.pyx":479 + * print(py_block) + * num += 1 + * if num == max_nummber: # <<<<<<<<<<<<<< + * break + * +*/ + __pyx_t_3 = (__pyx_v_num == __pyx_v_max_nummber); + if (__pyx_t_3) { + + /* "polluck_blockchain/placeholder_native.pyx":480 + * num += 1 + * if num == max_nummber: + * break # <<<<<<<<<<<<<< + * + * def get_block(self, idx): +*/ + goto __pyx_L5_break; + + /* "polluck_blockchain/placeholder_native.pyx":479 + * print(py_block) + * num += 1 + * if num == max_nummber: # <<<<<<<<<<<<<< + * break + * +*/ + } + } + __pyx_L5_break:; + + /* "polluck_blockchain/placeholder_native.pyx":465 + * postincrement(it) + * + * def print_blocks(self, max_num): # <<<<<<<<<<<<<< + * cdef: + * Block *block +*/ + + /* 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_4); + __Pyx_AddTraceback("polluck_blockchain.placeholder_native.Blockchain.print_blocks", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_py_block); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "polluck_blockchain/placeholder_native.pyx":482 + * break + * + * def get_block(self, idx): # <<<<<<<<<<<<<< + * if idx < 0 or idx > self._index: + * raise IndexError("Index value is out of bounds") +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_13get_block(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_13get_block = {"get_block", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_13get_block, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_13get_block(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -7777,32 +9319,32 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { 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, 396, __pyx_L3_error) + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 482, __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, 396, __pyx_L3_error) + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 482, __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_block", 0) < (0)) __PYX_ERR(0, 396, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_block", 0) < (0)) __PYX_ERR(0, 482, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { - if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_block", 1, 1, 1, i); __PYX_ERR(0, 396, __pyx_L3_error) } + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_block", 1, 1, 1, i); __PYX_ERR(0, 482, __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, 396, __pyx_L3_error) + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 482, __pyx_L3_error) } __pyx_v_idx = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("get_block", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 396, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("get_block", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 482, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -7813,7 +9355,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_10get_block(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self), __pyx_v_idx); + __pyx_r = __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_12get_block(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self), __pyx_v_idx); /* function exit code */ for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { @@ -7823,7 +9365,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds return __pyx_r; } -static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_10get_block(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, PyObject *__pyx_v_idx) { +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_12get_block(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, PyObject *__pyx_v_idx) { ::Block *__pyx_v_block; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations @@ -7840,32 +9382,32 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_block", 0); - /* "polluck_blockchain/placeholder_native.pyx":397 - * # // Python public API + /* "polluck_blockchain/placeholder_native.pyx":483 + * * def get_block(self, idx): * if idx < 0 or idx > self._index: # <<<<<<<<<<<<<< * raise IndexError("Index value is out of bounds") * */ - __pyx_t_2 = PyObject_RichCompare(__pyx_v_idx, __pyx_mstate_global->__pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 397, __pyx_L1_error) - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 397, __pyx_L1_error) + __pyx_t_2 = PyObject_RichCompare(__pyx_v_idx, __pyx_mstate_global->__pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 483, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 483, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (!__pyx_t_3) { } else { __pyx_t_1 = __pyx_t_3; goto __pyx_L4_bool_binop_done; } - __pyx_t_2 = __Pyx_PyLong_From_uint64_t(__pyx_v_self->_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 397, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyLong_From_uint64_t(__pyx_v_self->_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 483, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_idx, __pyx_t_2, Py_GT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 397, __pyx_L1_error) + __pyx_t_4 = PyObject_RichCompare(__pyx_v_idx, __pyx_t_2, Py_GT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 483, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 397, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 483, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_1 = __pyx_t_3; __pyx_L4_bool_binop_done:; if (unlikely(__pyx_t_1)) { - /* "polluck_blockchain/placeholder_native.pyx":398 + /* "polluck_blockchain/placeholder_native.pyx":484 * def get_block(self, idx): * if idx < 0 or idx > self._index: * raise IndexError("Index value is out of bounds") # <<<<<<<<<<<<<< @@ -7878,15 +9420,15 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_mstate_global->__pyx_kp_u_Index_value_is_out_of_bounds}; __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_IndexError)), __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_4)) __PYX_ERR(0, 398, __pyx_L1_error) + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 484, __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, 398, __pyx_L1_error) + __PYX_ERR(0, 484, __pyx_L1_error) - /* "polluck_blockchain/placeholder_native.pyx":397 - * # // Python public API + /* "polluck_blockchain/placeholder_native.pyx":483 + * * def get_block(self, idx): * if idx < 0 or idx > self._index: # <<<<<<<<<<<<<< * raise IndexError("Index value is out of bounds") @@ -7894,30 +9436,30 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain */ } - /* "polluck_blockchain/placeholder_native.pyx":400 + /* "polluck_blockchain/placeholder_native.pyx":486 * raise IndexError("Index value is out of bounds") * * cdef Block *block = self.get_block_c(idx) # <<<<<<<<<<<<<< - * if block == NULL: + * if block is NULL: * raise IndexError("Provided index not found") */ - __pyx_t_6 = __Pyx_PyLong_As_uint64_t(__pyx_v_idx); if (unlikely((__pyx_t_6 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 400, __pyx_L1_error) - __pyx_t_7 = ((struct __pyx_vtabstruct_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self->__pyx_vtab)->get_block_c(__pyx_v_self, __pyx_t_6); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 400, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyLong_As_uint64_t(__pyx_v_idx); if (unlikely((__pyx_t_6 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 486, __pyx_L1_error) + __pyx_t_7 = ((struct __pyx_vtabstruct_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self->__pyx_vtab)->get_block_c(__pyx_v_self, __pyx_t_6); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 486, __pyx_L1_error) __pyx_v_block = __pyx_t_7; - /* "polluck_blockchain/placeholder_native.pyx":401 + /* "polluck_blockchain/placeholder_native.pyx":487 * * cdef Block *block = self.get_block_c(idx) - * if block == NULL: # <<<<<<<<<<<<<< + * if block is NULL: # <<<<<<<<<<<<<< * raise IndexError("Provided index not found") * return PyBlock.from_ptr(block, owner=False) */ __pyx_t_1 = (__pyx_v_block == NULL); if (unlikely(__pyx_t_1)) { - /* "polluck_blockchain/placeholder_native.pyx":402 + /* "polluck_blockchain/placeholder_native.pyx":488 * cdef Block *block = self.get_block_c(idx) - * if block == NULL: + * if block is NULL: * raise IndexError("Provided index not found") # <<<<<<<<<<<<<< * return PyBlock.from_ptr(block, owner=False) * @@ -7928,41 +9470,41 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_mstate_global->__pyx_kp_u_Provided_index_not_found}; __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_IndexError)), __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_4)) __PYX_ERR(0, 402, __pyx_L1_error) + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 488, __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, 402, __pyx_L1_error) + __PYX_ERR(0, 488, __pyx_L1_error) - /* "polluck_blockchain/placeholder_native.pyx":401 + /* "polluck_blockchain/placeholder_native.pyx":487 * * cdef Block *block = self.get_block_c(idx) - * if block == NULL: # <<<<<<<<<<<<<< + * if block is NULL: # <<<<<<<<<<<<<< * raise IndexError("Provided index not found") * return PyBlock.from_ptr(block, owner=False) */ } - /* "polluck_blockchain/placeholder_native.pyx":403 - * if block == NULL: + /* "polluck_blockchain/placeholder_native.pyx":489 + * if block is NULL: * raise IndexError("Provided index not found") * return PyBlock.from_ptr(block, owner=False) # <<<<<<<<<<<<<< * - * cdef string hash_data(self, data): + * def create_genesis_block(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_8.__pyx_n = 1; __pyx_t_8.owner = 0; - __pyx_t_4 = ((PyObject *)__pyx_vtabptr_18polluck_blockchain_18placeholder_native_PyBlock->from_ptr(__pyx_v_block, &__pyx_t_8)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 403, __pyx_L1_error) + __pyx_t_4 = ((PyObject *)__pyx_vtabptr_18polluck_blockchain_18placeholder_native_PyBlock->from_ptr(__pyx_v_block, &__pyx_t_8)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 489, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; - /* "polluck_blockchain/placeholder_native.pyx":396 + /* "polluck_blockchain/placeholder_native.pyx":482 + * break * - * # // Python public API * def get_block(self, idx): # <<<<<<<<<<<<<< * if idx < 0 or idx > self._index: * raise IndexError("Index value is out of bounds") @@ -7980,200 +9522,24 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain return __pyx_r; } -/* "polluck_blockchain/placeholder_native.pyx":405 +/* "polluck_blockchain/placeholder_native.pyx":491 * return PyBlock.from_ptr(block, owner=False) * - * cdef string hash_data(self, data): # <<<<<<<<<<<<<< - * cdef: - * string data_str -*/ - -static std::string __pyx_f_18polluck_blockchain_18placeholder_native_10Blockchain_hash_data(CYTHON_UNUSED struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, PyObject *__pyx_v_data) { - std::string __pyx_v_data_str; - unsigned char *__pyx_v_data_digest; - size_t __pyx_v_digest_size; - std::string __pyx_r; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - size_t __pyx_t_3; - std::string __pyx_t_4; - unsigned char *__pyx_t_5; - int __pyx_t_6; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - PyObject *__pyx_t_9 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("hash_data", 0); - - /* "polluck_blockchain/placeholder_native.pyx":410 - * unsigned char *data_digest - * size_t digest_size - * data_str = data.encode("UTF-8") # <<<<<<<<<<<<<< - * data_digest = SHA256_digest(data_str.c_str(), data_str.size(), &digest_size) - * if data_digest == NULL: -*/ - __pyx_t_2 = __pyx_v_data; - __Pyx_INCREF(__pyx_t_2); - __pyx_t_3 = 0; - { - PyObject *__pyx_callargs[2] = {__pyx_t_2, __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_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, 410, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - } - __pyx_t_4 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 410, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_data_str = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_4); - - /* "polluck_blockchain/placeholder_native.pyx":411 - * size_t digest_size - * data_str = data.encode("UTF-8") - * data_digest = SHA256_digest(data_str.c_str(), data_str.size(), &digest_size) # <<<<<<<<<<<<<< - * if data_digest == NULL: - * raise RuntimeError("Failed to hash data") -*/ - __pyx_t_5 = __pyx_f_18polluck_blockchain_18placeholder_native_SHA256_digest(__pyx_v_data_str.c_str(), __pyx_v_data_str.size(), (&__pyx_v_digest_size)); if (unlikely(__pyx_t_5 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 411, __pyx_L1_error) - __pyx_v_data_digest = __pyx_t_5; - - /* "polluck_blockchain/placeholder_native.pyx":412 - * data_str = data.encode("UTF-8") - * data_digest = SHA256_digest(data_str.c_str(), data_str.size(), &digest_size) - * if data_digest == NULL: # <<<<<<<<<<<<<< - * raise RuntimeError("Failed to hash data") - * data_str = bytes(data_digest[:digest_size]).hex().encode("UTF-8") -*/ - __pyx_t_6 = (__pyx_v_data_digest == NULL); - if (unlikely(__pyx_t_6)) { - - /* "polluck_blockchain/placeholder_native.pyx":413 - * data_digest = SHA256_digest(data_str.c_str(), data_str.size(), &digest_size) - * if data_digest == NULL: - * raise RuntimeError("Failed to hash data") # <<<<<<<<<<<<<< - * data_str = bytes(data_digest[:digest_size]).hex().encode("UTF-8") - * free(data_digest) -*/ - __pyx_t_2 = NULL; - __pyx_t_3 = 1; - { - PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_mstate_global->__pyx_kp_u_Failed_to_hash_data}; - __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_RuntimeError)), __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 413, __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, 413, __pyx_L1_error) - - /* "polluck_blockchain/placeholder_native.pyx":412 - * data_str = data.encode("UTF-8") - * data_digest = SHA256_digest(data_str.c_str(), data_str.size(), &digest_size) - * if data_digest == NULL: # <<<<<<<<<<<<<< - * raise RuntimeError("Failed to hash data") - * data_str = bytes(data_digest[:digest_size]).hex().encode("UTF-8") -*/ - } - - /* "polluck_blockchain/placeholder_native.pyx":414 - * if data_digest == NULL: - * raise RuntimeError("Failed to hash data") - * data_str = bytes(data_digest[:digest_size]).hex().encode("UTF-8") # <<<<<<<<<<<<<< - * free(data_digest) - * -*/ - __pyx_t_8 = NULL; - __pyx_t_9 = __Pyx_PyBytes_FromStringAndSize(((char const *)__pyx_v_data_digest) + 0, __pyx_v_digest_size - 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 414, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_3 = 1; - { - PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_9}; - __pyx_t_7 = __Pyx_PyObject_FastCall((PyObject*)(&PyBytes_Type), __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 414, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - } - __pyx_t_2 = __pyx_t_7; - __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_hex, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 414, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - } - __pyx_t_7 = PyUnicode_AsUTF8String(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 414, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_4 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 414, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_v_data_str = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_4); - - /* "polluck_blockchain/placeholder_native.pyx":415 - * raise RuntimeError("Failed to hash data") - * data_str = bytes(data_digest[:digest_size]).hex().encode("UTF-8") - * free(data_digest) # <<<<<<<<<<<<<< - * - * return data_str -*/ - free(__pyx_v_data_digest); - - /* "polluck_blockchain/placeholder_native.pyx":417 - * free(data_digest) - * - * return data_str # <<<<<<<<<<<<<< - * - * def create_genesis_block(self): -*/ - __pyx_r = __pyx_v_data_str; - goto __pyx_L0; - - /* "polluck_blockchain/placeholder_native.pyx":405 - * return PyBlock.from_ptr(block, owner=False) - * - * cdef string hash_data(self, data): # <<<<<<<<<<<<<< - * cdef: - * string data_str -*/ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_XDECREF(__pyx_t_9); - __Pyx_AddTraceback("polluck_blockchain.placeholder_native.Blockchain.hash_data", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_pretend_to_initialize(&__pyx_r); - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "polluck_blockchain/placeholder_native.pyx":419 - * return data_str - * * def create_genesis_block(self): # <<<<<<<<<<<<<< - * genesis_prev_hash = ("0" * 64).encode("UTF-8") - * cdef string data_str = self.hash_data("Genesis Block") + * if self._genesis_done: + * return */ /* Python wrapper */ -static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_13create_genesis_block(PyObject *__pyx_v_self, +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_15create_genesis_block(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyMethodDef __pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_13create_genesis_block = {"create_genesis_block", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_13create_genesis_block, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_13create_genesis_block(PyObject *__pyx_v_self, +static PyMethodDef __pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_15create_genesis_block = {"create_genesis_block", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_15create_genesis_block, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_15create_genesis_block(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -8199,14 +9565,14 @@ PyObject *__pyx_args, PyObject *__pyx_kwds 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("create_genesis_block", __pyx_kwds); return NULL;} - __pyx_r = __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_12create_genesis_block(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self)); + __pyx_r = __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_14create_genesis_block(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_12create_genesis_block(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self) { +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_14create_genesis_block(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self) { PyObject *__pyx_v_genesis_prev_hash = NULL; std::string __pyx_v_data_str; ::Block *__pyx_v_block; @@ -8214,24 +9580,51 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations std::string __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - size_t __pyx_t_6; - double __pyx_t_7; - std::string __pyx_t_8; - ::Block *__pyx_t_9; - int __pyx_t_10; - int __pyx_t_11; + uint64_t __pyx_t_2; + std::string __pyx_t_3; + ::Block *__pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + size_t __pyx_t_9; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("create_genesis_block", 0); - /* "polluck_blockchain/placeholder_native.pyx":420 + /* "polluck_blockchain/placeholder_native.pyx":492 * * def create_genesis_block(self): + * if self._genesis_done: # <<<<<<<<<<<<<< + * return + * +*/ + if (__pyx_v_self->_genesis_done) { + + /* "polluck_blockchain/placeholder_native.pyx":493 + * def create_genesis_block(self): + * if self._genesis_done: + * return # <<<<<<<<<<<<<< + * + * genesis_prev_hash = ("0" * 64).encode("UTF-8") +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "polluck_blockchain/placeholder_native.pyx":492 + * + * def create_genesis_block(self): + * if self._genesis_done: # <<<<<<<<<<<<<< + * return + * +*/ + } + + /* "polluck_blockchain/placeholder_native.pyx":495 + * return + * * genesis_prev_hash = ("0" * 64).encode("UTF-8") # <<<<<<<<<<<<<< * cdef string data_str = self.hash_data("Genesis Block") * @@ -8239,122 +9632,99 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_b_00000000000000000000000000000000); __pyx_v_genesis_prev_hash = __pyx_mstate_global->__pyx_kp_b_00000000000000000000000000000000; - /* "polluck_blockchain/placeholder_native.pyx":421 - * def create_genesis_block(self): + /* "polluck_blockchain/placeholder_native.pyx":496 + * * genesis_prev_hash = ("0" * 64).encode("UTF-8") * cdef string data_str = self.hash_data("Genesis Block") # <<<<<<<<<<<<<< * * cdef Block *block = new Block( */ - __pyx_t_1 = ((struct __pyx_vtabstruct_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self->__pyx_vtab)->hash_data(__pyx_v_self, __pyx_mstate_global->__pyx_kp_u_Genesis_Block); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 421, __pyx_L1_error) + __pyx_t_1 = ((struct __pyx_vtabstruct_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self->__pyx_vtab)->hash_data(__pyx_v_self, __pyx_mstate_global->__pyx_kp_u_Genesis_Block); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 496, __pyx_L1_error) __pyx_v_data_str = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_1); - /* "polluck_blockchain/placeholder_native.pyx":425 + /* "polluck_blockchain/placeholder_native.pyx":500 * cdef Block *block = new Block( * self._index, - * int(datetime.datetime(2025, 12, 1, 12, 0, 0).timestamp()), # <<<<<<<<<<<<<< + * current_timestamp_integer(), # <<<<<<<<<<<<<< * 0, * data_str, */ - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 425, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 425, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_mstate_global->__pyx_tuple[0], NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 425, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_3 = __pyx_t_4; - __Pyx_INCREF(__pyx_t_3); - __pyx_t_6 = 0; - { - PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; - __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_timestamp, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 425, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - } - __pyx_t_4 = __Pyx_PyNumber_Int(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 425, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_7 = __Pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_7 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 425, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_2 = __pyx_f_18polluck_blockchain_18placeholder_native_current_timestamp_integer(); if (unlikely(__pyx_t_2 == ((uint64_t)-1LL) && PyErr_Occurred())) __PYX_ERR(0, 500, __pyx_L1_error) - /* "polluck_blockchain/placeholder_native.pyx":428 + /* "polluck_blockchain/placeholder_native.pyx":503 * 0, * data_str, * genesis_prev_hash, # <<<<<<<<<<<<<< * "".encode("UTF-8"), * ) */ - __pyx_t_1 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_v_genesis_prev_hash); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 428, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_v_genesis_prev_hash); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 503, __pyx_L1_error) - /* "polluck_blockchain/placeholder_native.pyx":429 + /* "polluck_blockchain/placeholder_native.pyx":504 * data_str, * genesis_prev_hash, * "".encode("UTF-8"), # <<<<<<<<<<<<<< * ) * cdef int res = self.add_block(block) */ - __pyx_t_8 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_mstate_global->__pyx_kp_b_); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 429, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_mstate_global->__pyx_kp_b_); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 504, __pyx_L1_error) - /* "polluck_blockchain/placeholder_native.pyx":423 + /* "polluck_blockchain/placeholder_native.pyx":498 * cdef string data_str = self.hash_data("Genesis Block") * * cdef Block *block = new Block( # <<<<<<<<<<<<<< * self._index, - * int(datetime.datetime(2025, 12, 1, 12, 0, 0).timestamp()), + * current_timestamp_integer(), */ try { - __pyx_t_9 = new ::Block(__pyx_v_self->_index, __pyx_t_7, 0, __pyx_v_data_str, __pyx_t_1, __pyx_t_8); + __pyx_t_4 = new ::Block(__pyx_v_self->_index, __pyx_t_2, 0, __pyx_v_data_str, __pyx_t_1, __pyx_t_3); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(0, 423, __pyx_L1_error) + __PYX_ERR(0, 498, __pyx_L1_error) } - __pyx_v_block = __pyx_t_9; + __pyx_v_block = __pyx_t_4; - /* "polluck_blockchain/placeholder_native.pyx":431 + /* "polluck_blockchain/placeholder_native.pyx":506 * "".encode("UTF-8"), * ) * cdef int res = self.add_block(block) # <<<<<<<<<<<<<< * if res != 0: * raise RuntimeError("Could not mine block. No nonce found") */ - __pyx_t_10 = ((struct __pyx_vtabstruct_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self->__pyx_vtab)->add_block(__pyx_v_self, __pyx_v_block); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 431, __pyx_L1_error) - __pyx_v_res = __pyx_t_10; + __pyx_t_5 = ((struct __pyx_vtabstruct_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self->__pyx_vtab)->add_block(__pyx_v_self, __pyx_v_block); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 506, __pyx_L1_error) + __pyx_v_res = __pyx_t_5; - /* "polluck_blockchain/placeholder_native.pyx":432 + /* "polluck_blockchain/placeholder_native.pyx":507 * ) * cdef int res = self.add_block(block) * if res != 0: # <<<<<<<<<<<<<< * raise RuntimeError("Could not mine block. No nonce found") * self._genesis_done = True */ - __pyx_t_11 = (__pyx_v_res != 0); - if (unlikely(__pyx_t_11)) { + __pyx_t_6 = (__pyx_v_res != 0); + if (unlikely(__pyx_t_6)) { - /* "polluck_blockchain/placeholder_native.pyx":433 + /* "polluck_blockchain/placeholder_native.pyx":508 * cdef int res = self.add_block(block) * if res != 0: * raise RuntimeError("Could not mine block. No nonce found") # <<<<<<<<<<<<<< * self._genesis_done = True * */ - __pyx_t_2 = NULL; - __pyx_t_6 = 1; + __pyx_t_8 = NULL; + __pyx_t_9 = 1; { - PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_mstate_global->__pyx_kp_u_Could_not_mine_block_No_nonce_fo}; - __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_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 433, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_mstate_global->__pyx_kp_u_Could_not_mine_block_No_nonce_fo}; + __pyx_t_7 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_RuntimeError)), __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 508, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); } - __Pyx_Raise(__pyx_t_4, 0, 0, 0); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(0, 433, __pyx_L1_error) + __Pyx_Raise(__pyx_t_7, 0, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(0, 508, __pyx_L1_error) - /* "polluck_blockchain/placeholder_native.pyx":432 + /* "polluck_blockchain/placeholder_native.pyx":507 * ) * cdef int res = self.add_block(block) * if res != 0: # <<<<<<<<<<<<<< @@ -8363,7 +9733,7 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain */ } - /* "polluck_blockchain/placeholder_native.pyx":434 + /* "polluck_blockchain/placeholder_native.pyx":509 * if res != 0: * raise RuntimeError("Could not mine block. No nonce found") * self._genesis_done = True # <<<<<<<<<<<<<< @@ -8372,22 +9742,20 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain */ __pyx_v_self->_genesis_done = 1; - /* "polluck_blockchain/placeholder_native.pyx":419 - * return data_str + /* "polluck_blockchain/placeholder_native.pyx":491 + * return PyBlock.from_ptr(block, owner=False) * * def create_genesis_block(self): # <<<<<<<<<<<<<< - * genesis_prev_hash = ("0" * 64).encode("UTF-8") - * cdef string data_str = self.hash_data("Genesis Block") + * if self._genesis_done: + * return */ /* 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_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("polluck_blockchain.placeholder_native.Blockchain.create_genesis_block", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -8397,7 +9765,7 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain return __pyx_r; } -/* "polluck_blockchain/placeholder_native.pyx":436 +/* "polluck_blockchain/placeholder_native.pyx":511 * self._genesis_done = True * * def new_block(self, data): # <<<<<<<<<<<<<< @@ -8406,15 +9774,15 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain */ /* Python wrapper */ -static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_15new_block(PyObject *__pyx_v_self, +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_17new_block(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyMethodDef __pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_15new_block = {"new_block", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_15new_block, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_15new_block(PyObject *__pyx_v_self, +static PyMethodDef __pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_17new_block = {"new_block", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_17new_block, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_17new_block(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -8444,32 +9812,32 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_data,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, 436, __pyx_L3_error) + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 511, __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, 436, __pyx_L3_error) + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 511, __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, "new_block", 0) < (0)) __PYX_ERR(0, 436, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "new_block", 0) < (0)) __PYX_ERR(0, 511, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { - if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("new_block", 1, 1, 1, i); __PYX_ERR(0, 436, __pyx_L3_error) } + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("new_block", 1, 1, 1, i); __PYX_ERR(0, 511, __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, 436, __pyx_L3_error) + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 511, __pyx_L3_error) } __pyx_v_data = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("new_block", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 436, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("new_block", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 511, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -8480,7 +9848,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_14new_block(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self), __pyx_v_data); + __pyx_r = __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_16new_block(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self), __pyx_v_data); /* function exit code */ for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { @@ -8490,7 +9858,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds return __pyx_r; } -static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_14new_block(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, PyObject *__pyx_v_data) { +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_16new_block(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, PyObject *__pyx_v_data) { ::Block *__pyx_v_prev_block; std::string __pyx_v_prev_hash; uint64_t __pyx_v_new_idx; @@ -8506,16 +9874,14 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain int __pyx_t_5; std::string __pyx_t_6; ::Block *__pyx_t_7; - PyObject *__pyx_t_8 = NULL; - PyObject *__pyx_t_9 = NULL; - double __pyx_t_10; - int __pyx_t_11; + uint64_t __pyx_t_8; + int __pyx_t_9; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("new_block", 0); - /* "polluck_blockchain/placeholder_native.pyx":445 + /* "polluck_blockchain/placeholder_native.pyx":520 * size_t digest_size * * if not self._genesis_done: # <<<<<<<<<<<<<< @@ -8525,7 +9891,7 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain __pyx_t_1 = (!__pyx_v_self->_genesis_done); if (unlikely(__pyx_t_1)) { - /* "polluck_blockchain/placeholder_native.pyx":446 + /* "polluck_blockchain/placeholder_native.pyx":521 * * if not self._genesis_done: * raise RuntimeError("Create a genesis block first.") # <<<<<<<<<<<<<< @@ -8538,14 +9904,14 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Create_a_genesis_block_first}; __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_RuntimeError)), __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, 446, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 521, __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, 446, __pyx_L1_error) + __PYX_ERR(0, 521, __pyx_L1_error) - /* "polluck_blockchain/placeholder_native.pyx":445 + /* "polluck_blockchain/placeholder_native.pyx":520 * size_t digest_size * * if not self._genesis_done: # <<<<<<<<<<<<<< @@ -8554,7 +9920,7 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain */ } - /* "polluck_blockchain/placeholder_native.pyx":447 + /* "polluck_blockchain/placeholder_native.pyx":522 * if not self._genesis_done: * raise RuntimeError("Create a genesis block first.") * if not isinstance(data, str): # <<<<<<<<<<<<<< @@ -8565,7 +9931,7 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain __pyx_t_5 = (!__pyx_t_1); if (unlikely(__pyx_t_5)) { - /* "polluck_blockchain/placeholder_native.pyx":448 + /* "polluck_blockchain/placeholder_native.pyx":523 * raise RuntimeError("Create a genesis block first.") * if not isinstance(data, str): * raise TypeError("Data must be a string") # <<<<<<<<<<<<<< @@ -8578,14 +9944,14 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Data_must_be_a_string}; __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_TypeError)), __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, 448, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 523, __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, 448, __pyx_L1_error) + __PYX_ERR(0, 523, __pyx_L1_error) - /* "polluck_blockchain/placeholder_native.pyx":447 + /* "polluck_blockchain/placeholder_native.pyx":522 * if not self._genesis_done: * raise RuntimeError("Create a genesis block first.") * if not isinstance(data, str): # <<<<<<<<<<<<<< @@ -8594,112 +9960,89 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain */ } - /* "polluck_blockchain/placeholder_native.pyx":450 + /* "polluck_blockchain/placeholder_native.pyx":525 * raise TypeError("Data must be a string") * * data_str = self.hash_data(data) # <<<<<<<<<<<<<< * prev_block = self.get_block_c(self._index) - * prev_hash = prev_block.prev_hash + * prev_hash = prev_block.hash */ - __pyx_t_6 = ((struct __pyx_vtabstruct_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self->__pyx_vtab)->hash_data(__pyx_v_self, __pyx_v_data); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 450, __pyx_L1_error) + __pyx_t_6 = ((struct __pyx_vtabstruct_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self->__pyx_vtab)->hash_data(__pyx_v_self, __pyx_v_data); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 525, __pyx_L1_error) __pyx_v_data_str = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_6); - /* "polluck_blockchain/placeholder_native.pyx":451 + /* "polluck_blockchain/placeholder_native.pyx":526 * * data_str = self.hash_data(data) * prev_block = self.get_block_c(self._index) # <<<<<<<<<<<<<< - * prev_hash = prev_block.prev_hash + * prev_hash = prev_block.hash * new_idx = self._index + 1 */ - __pyx_t_7 = ((struct __pyx_vtabstruct_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self->__pyx_vtab)->get_block_c(__pyx_v_self, __pyx_v_self->_index); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 451, __pyx_L1_error) + __pyx_t_7 = ((struct __pyx_vtabstruct_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self->__pyx_vtab)->get_block_c(__pyx_v_self, __pyx_v_self->_index); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 526, __pyx_L1_error) __pyx_v_prev_block = __pyx_t_7; - /* "polluck_blockchain/placeholder_native.pyx":452 + /* "polluck_blockchain/placeholder_native.pyx":527 * data_str = self.hash_data(data) * prev_block = self.get_block_c(self._index) - * prev_hash = prev_block.prev_hash # <<<<<<<<<<<<<< + * prev_hash = prev_block.hash # <<<<<<<<<<<<<< * new_idx = self._index + 1 * */ - __pyx_t_6 = __pyx_v_prev_block->prev_hash; + __pyx_t_6 = __pyx_v_prev_block->hash; __pyx_v_prev_hash = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_6); - /* "polluck_blockchain/placeholder_native.pyx":453 + /* "polluck_blockchain/placeholder_native.pyx":528 * prev_block = self.get_block_c(self._index) - * prev_hash = prev_block.prev_hash + * prev_hash = prev_block.hash * new_idx = self._index + 1 # <<<<<<<<<<<<<< * * cdef Block *block = new Block( */ __pyx_v_new_idx = (__pyx_v_self->_index + 1); - /* "polluck_blockchain/placeholder_native.pyx":457 + /* "polluck_blockchain/placeholder_native.pyx":532 * cdef Block *block = new Block( * new_idx, - * int(datetime.datetime(2025, 12, 1, 12, 0, 0).timestamp()), # <<<<<<<<<<<<<< + * current_timestamp_integer(), # <<<<<<<<<<<<<< * 0, * data_str, */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 457, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 457, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_mstate_global->__pyx_tuple[0], NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 457, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_3 = __pyx_t_8; - __Pyx_INCREF(__pyx_t_3); - __pyx_t_4 = 0; - { - PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; - __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_timestamp, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 457, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - } - __pyx_t_8 = __Pyx_PyNumber_Int(__pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 457, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_10 = __Pyx_PyFloat_AsDouble(__pyx_t_8); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 457, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __pyx_f_18polluck_blockchain_18placeholder_native_current_timestamp_integer(); if (unlikely(__pyx_t_8 == ((uint64_t)-1LL) && PyErr_Occurred())) __PYX_ERR(0, 532, __pyx_L1_error) - /* "polluck_blockchain/placeholder_native.pyx":461 + /* "polluck_blockchain/placeholder_native.pyx":536 * data_str, * prev_hash, * "".encode("UTF-8"), # <<<<<<<<<<<<<< * ) * cdef int res = self.add_block(block) */ - __pyx_t_6 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_mstate_global->__pyx_kp_b_); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 461, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_mstate_global->__pyx_kp_b_); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 536, __pyx_L1_error) - /* "polluck_blockchain/placeholder_native.pyx":455 + /* "polluck_blockchain/placeholder_native.pyx":530 * new_idx = self._index + 1 * * cdef Block *block = new Block( # <<<<<<<<<<<<<< * new_idx, - * int(datetime.datetime(2025, 12, 1, 12, 0, 0).timestamp()), + * current_timestamp_integer(), */ try { - __pyx_t_7 = new ::Block(__pyx_v_new_idx, __pyx_t_10, 0, __pyx_v_data_str, __pyx_v_prev_hash, __pyx_t_6); + __pyx_t_7 = new ::Block(__pyx_v_new_idx, __pyx_t_8, 0, __pyx_v_data_str, __pyx_v_prev_hash, __pyx_t_6); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(0, 455, __pyx_L1_error) + __PYX_ERR(0, 530, __pyx_L1_error) } __pyx_v_block = __pyx_t_7; - /* "polluck_blockchain/placeholder_native.pyx":463 + /* "polluck_blockchain/placeholder_native.pyx":538 * "".encode("UTF-8"), * ) * cdef int res = self.add_block(block) # <<<<<<<<<<<<<< * if res != 0: * raise RuntimeError("Could not mine block. No nonce found") */ - __pyx_t_11 = ((struct __pyx_vtabstruct_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self->__pyx_vtab)->add_block(__pyx_v_self, __pyx_v_block); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 463, __pyx_L1_error) - __pyx_v_res = __pyx_t_11; + __pyx_t_9 = ((struct __pyx_vtabstruct_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self->__pyx_vtab)->add_block(__pyx_v_self, __pyx_v_block); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 538, __pyx_L1_error) + __pyx_v_res = __pyx_t_9; - /* "polluck_blockchain/placeholder_native.pyx":464 + /* "polluck_blockchain/placeholder_native.pyx":539 * ) * cdef int res = self.add_block(block) * if res != 0: # <<<<<<<<<<<<<< @@ -8709,26 +10052,27 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain __pyx_t_5 = (__pyx_v_res != 0); if (unlikely(__pyx_t_5)) { - /* "polluck_blockchain/placeholder_native.pyx":465 + /* "polluck_blockchain/placeholder_native.pyx":540 * cdef int res = self.add_block(block) * if res != 0: * raise RuntimeError("Could not mine block. No nonce found") # <<<<<<<<<<<<<< * + * def validate(self): */ - __pyx_t_2 = NULL; + __pyx_t_3 = NULL; __pyx_t_4 = 1; { - PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_mstate_global->__pyx_kp_u_Could_not_mine_block_No_nonce_fo}; - __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_RuntimeError)), __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 465, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Could_not_mine_block_No_nonce_fo}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_RuntimeError)), __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, 540, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); } - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 465, __pyx_L1_error) + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 540, __pyx_L1_error) - /* "polluck_blockchain/placeholder_native.pyx":464 + /* "polluck_blockchain/placeholder_native.pyx":539 * ) * cdef int res = self.add_block(block) * if res != 0: # <<<<<<<<<<<<<< @@ -8737,7 +10081,7 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain */ } - /* "polluck_blockchain/placeholder_native.pyx":436 + /* "polluck_blockchain/placeholder_native.pyx":511 * self._genesis_done = True * * def new_block(self, data): # <<<<<<<<<<<<<< @@ -8751,8 +10095,6 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("polluck_blockchain.placeholder_native.Blockchain.new_block", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -8761,6 +10103,1991 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain return __pyx_r; } +/* "polluck_blockchain/placeholder_native.pyx":542 + * raise RuntimeError("Could not mine block. No nonce found") + * + * def validate(self): # <<<<<<<<<<<<<< + * cdef: + * Block *block +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_19validate(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_19validate = {"validate", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_19validate, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_19validate(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("validate (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("validate", 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("validate", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_18validate(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_18validate(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self) { + ::Block *__pyx_v_block; + ::Block *__pyx_v_prev_block; + int __pyx_v_idx; + unsigned char *__pyx_v_digest; + size_t __pyx_v_digest_size; + PyObject *__pyx_v_py_bytes = NULL; + PyObject *__pyx_v_py_bytes_rehashed = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + std::vector<::Block *> ::size_type __pyx_t_1; + std::vector<::Block *> ::size_type __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + size_t __pyx_t_7; + unsigned char *__pyx_t_8; + int __pyx_t_9; + PyObject *__pyx_t_10[3]; + PyObject *__pyx_t_11 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("validate", 0); + + /* "polluck_blockchain/placeholder_native.pyx":545 + * cdef: + * Block *block + * Block *prev_block = NULL # <<<<<<<<<<<<<< + * int idx = 0 + * unsigned char *digest +*/ + __pyx_v_prev_block = NULL; + + /* "polluck_blockchain/placeholder_native.pyx":546 + * Block *block + * Block *prev_block = NULL + * int idx = 0 # <<<<<<<<<<<<<< + * unsigned char *digest + * size_t digest_size +*/ + __pyx_v_idx = 0; + + /* "polluck_blockchain/placeholder_native.pyx":550 + * size_t digest_size + * + * for idx in range(self._chain[0].size()): # <<<<<<<<<<<<<< + * block = self._chain[0][idx] + * py_bytes = bytes.fromhex(block.hash.decode("UTF-8")) +*/ + __pyx_t_1 = (__pyx_v_self->_chain[0]).size(); + __pyx_t_2 = __pyx_t_1; + for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { + __pyx_v_idx = __pyx_t_3; + + /* "polluck_blockchain/placeholder_native.pyx":551 + * + * for idx in range(self._chain[0].size()): + * block = self._chain[0][idx] # <<<<<<<<<<<<<< + * py_bytes = bytes.fromhex(block.hash.decode("UTF-8")) + * digest = perform_hash_c(block, &digest_size) +*/ + __pyx_v_block = ((__pyx_v_self->_chain[0])[__pyx_v_idx]); + + /* "polluck_blockchain/placeholder_native.pyx":552 + * for idx in range(self._chain[0].size()): + * block = self._chain[0][idx] + * py_bytes = bytes.fromhex(block.hash.decode("UTF-8")) # <<<<<<<<<<<<<< + * digest = perform_hash_c(block, &digest_size) + * py_bytes_rehashed = bytes(digest[:digest_size]) +*/ + __pyx_t_5 = ((PyObject *)(&PyBytes_Type)); + __Pyx_INCREF(__pyx_t_5); + __pyx_t_6 = __Pyx_decode_cpp_string(__pyx_v_block->hash, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 552, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_fromhex, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 552, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XDECREF_SET(__pyx_v_py_bytes, __pyx_t_4); + __pyx_t_4 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":553 + * block = self._chain[0][idx] + * py_bytes = bytes.fromhex(block.hash.decode("UTF-8")) + * digest = perform_hash_c(block, &digest_size) # <<<<<<<<<<<<<< + * py_bytes_rehashed = bytes(digest[:digest_size]) + * free(digest) +*/ + __pyx_t_8 = __pyx_f_18polluck_blockchain_18placeholder_native_perform_hash_c(__pyx_v_block, (&__pyx_v_digest_size)); if (unlikely(__pyx_t_8 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 553, __pyx_L1_error) + __pyx_v_digest = __pyx_t_8; + + /* "polluck_blockchain/placeholder_native.pyx":554 + * py_bytes = bytes.fromhex(block.hash.decode("UTF-8")) + * digest = perform_hash_c(block, &digest_size) + * py_bytes_rehashed = bytes(digest[:digest_size]) # <<<<<<<<<<<<<< + * free(digest) + * if py_bytes != py_bytes_rehashed: +*/ + __pyx_t_6 = NULL; + __pyx_t_5 = __Pyx_PyBytes_FromStringAndSize(((char const *)__pyx_v_digest) + 0, __pyx_v_digest_size - 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 554, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)(&PyBytes_Type), __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_4)) __PYX_ERR(0, 554, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XDECREF_SET(__pyx_v_py_bytes_rehashed, ((PyObject*)__pyx_t_4)); + __pyx_t_4 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":555 + * digest = perform_hash_c(block, &digest_size) + * py_bytes_rehashed = bytes(digest[:digest_size]) + * free(digest) # <<<<<<<<<<<<<< + * if py_bytes != py_bytes_rehashed: + * print(f"Index {idx}: Hashes to not match. Abort.") +*/ + free(__pyx_v_digest); + + /* "polluck_blockchain/placeholder_native.pyx":556 + * py_bytes_rehashed = bytes(digest[:digest_size]) + * free(digest) + * if py_bytes != py_bytes_rehashed: # <<<<<<<<<<<<<< + * print(f"Index {idx}: Hashes to not match. Abort.") + * return False +*/ + __pyx_t_9 = (__Pyx_PyBytes_Equals(__pyx_v_py_bytes, __pyx_v_py_bytes_rehashed, Py_NE)); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(0, 556, __pyx_L1_error) + if (__pyx_t_9) { + + /* "polluck_blockchain/placeholder_native.pyx":557 + * free(digest) + * if py_bytes != py_bytes_rehashed: + * print(f"Index {idx}: Hashes to not match. Abort.") # <<<<<<<<<<<<<< + * return False + * if prev_block is not NULL: +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = __Pyx_PyUnicode_From_int(__pyx_v_idx, 0, ' ', 'd'); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 557, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_10[0] = __pyx_mstate_global->__pyx_kp_u_Index; + __pyx_t_10[1] = __pyx_t_6; + __pyx_t_10[2] = __pyx_mstate_global->__pyx_kp_u_Hashes_to_not_match_Abort; + __pyx_t_11 = __Pyx_PyUnicode_Join(__pyx_t_10, 3, 6 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6) + 29, 127); + if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 557, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_7 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_11}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_print, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 557, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":558 + * if py_bytes != py_bytes_rehashed: + * print(f"Index {idx}: Hashes to not match. Abort.") + * return False # <<<<<<<<<<<<<< + * if prev_block is not NULL: + * if prev_block.hash != block.prev_hash: +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + goto __pyx_L0; + + /* "polluck_blockchain/placeholder_native.pyx":556 + * py_bytes_rehashed = bytes(digest[:digest_size]) + * free(digest) + * if py_bytes != py_bytes_rehashed: # <<<<<<<<<<<<<< + * print(f"Index {idx}: Hashes to not match. Abort.") + * return False +*/ + } + + /* "polluck_blockchain/placeholder_native.pyx":559 + * print(f"Index {idx}: Hashes to not match. Abort.") + * return False + * if prev_block is not NULL: # <<<<<<<<<<<<<< + * if prev_block.hash != block.prev_hash: + * print( +*/ + __pyx_t_9 = (__pyx_v_prev_block != NULL); + if (__pyx_t_9) { + + /* "polluck_blockchain/placeholder_native.pyx":560 + * return False + * if prev_block is not NULL: + * if prev_block.hash != block.prev_hash: # <<<<<<<<<<<<<< + * print( + * (f"Index {idx}: Hash mismatch. Hash of previous block does not " +*/ + __pyx_t_9 = (__pyx_v_prev_block->hash != __pyx_v_block->prev_hash); + if (__pyx_t_9) { + + /* "polluck_blockchain/placeholder_native.pyx":561 + * if prev_block is not NULL: + * if prev_block.hash != block.prev_hash: + * print( # <<<<<<<<<<<<<< + * (f"Index {idx}: Hash mismatch. Hash of previous block does not " + * "match the saved one in the current block. Abort.") +*/ + __pyx_t_11 = NULL; + + /* "polluck_blockchain/placeholder_native.pyx":562 + * if prev_block.hash != block.prev_hash: + * print( + * (f"Index {idx}: Hash mismatch. Hash of previous block does not " # <<<<<<<<<<<<<< + * "match the saved one in the current block. Abort.") + * ) +*/ + __pyx_t_5 = __Pyx_PyUnicode_From_int(__pyx_v_idx, 0, ' ', 'd'); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 562, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_10[0] = __pyx_mstate_global->__pyx_kp_u_Index; + __pyx_t_10[1] = __pyx_t_5; + __pyx_t_10[2] = __pyx_mstate_global->__pyx_kp_u_Hash_mismatch_Hash_of_previous; + __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_10, 3, 6 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + 97, 127); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 562, __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_11, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_print, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 561, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":565 + * "match the saved one in the current block. Abort.") + * ) + * return False # <<<<<<<<<<<<<< + * prev_block = block + * +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + goto __pyx_L0; + + /* "polluck_blockchain/placeholder_native.pyx":560 + * return False + * if prev_block is not NULL: + * if prev_block.hash != block.prev_hash: # <<<<<<<<<<<<<< + * print( + * (f"Index {idx}: Hash mismatch. Hash of previous block does not " +*/ + } + + /* "polluck_blockchain/placeholder_native.pyx":559 + * print(f"Index {idx}: Hashes to not match. Abort.") + * return False + * if prev_block is not NULL: # <<<<<<<<<<<<<< + * if prev_block.hash != block.prev_hash: + * print( +*/ + } + + /* "polluck_blockchain/placeholder_native.pyx":566 + * ) + * return False + * prev_block = block # <<<<<<<<<<<<<< + * + * return True +*/ + __pyx_v_prev_block = __pyx_v_block; + } + + /* "polluck_blockchain/placeholder_native.pyx":568 + * prev_block = block + * + * return True # <<<<<<<<<<<<<< + * + * def get_saving_entries(self, max_idx): +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_True); + __pyx_r = Py_True; + goto __pyx_L0; + + /* "polluck_blockchain/placeholder_native.pyx":542 + * raise RuntimeError("Could not mine block. No nonce found") + * + * def validate(self): # <<<<<<<<<<<<<< + * cdef: + * Block *block +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_AddTraceback("polluck_blockchain.placeholder_native.Blockchain.validate", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_py_bytes); + __Pyx_XDECREF(__pyx_v_py_bytes_rehashed); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "polluck_blockchain/placeholder_native.pyx":570 + * return True + * + * def get_saving_entries(self, max_idx): # <<<<<<<<<<<<<< + * entries = [] + * cdef: +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_21get_saving_entries(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_21get_saving_entries = {"get_saving_entries", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_21get_saving_entries, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_21get_saving_entries(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_max_idx = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_saving_entries (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_max_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, 570, __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, 570, __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_saving_entries", 0) < (0)) __PYX_ERR(0, 570, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_saving_entries", 1, 1, 1, i); __PYX_ERR(0, 570, __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, 570, __pyx_L3_error) + } + __pyx_v_max_idx = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get_saving_entries", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 570, __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("polluck_blockchain.placeholder_native.Blockchain.get_saving_entries", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_20get_saving_entries(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self), __pyx_v_max_idx); + + /* 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_18polluck_blockchain_18placeholder_native_10Blockchain_20get_saving_entries(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, PyObject *__pyx_v_max_idx) { + PyObject *__pyx_v_entries = NULL; + ::Block *__pyx_v_block; + int __pyx_v_idx; + int __pyx_v__max_idx; + PyObject *__pyx_v_contents = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + std::vector<::Block *> ::size_type __pyx_t_4; + std::vector<::Block *> ::size_type __pyx_t_5; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_saving_entries", 0); + + /* "polluck_blockchain/placeholder_native.pyx":571 + * + * def get_saving_entries(self, max_idx): + * entries = [] # <<<<<<<<<<<<<< + * cdef: + * Block *block +*/ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 571, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_entries = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":574 + * cdef: + * Block *block + * int idx = 0 # <<<<<<<<<<<<<< + * int _max_idx + * +*/ + __pyx_v_idx = 0; + + /* "polluck_blockchain/placeholder_native.pyx":577 + * int _max_idx + * + * if max_idx is None: # <<<<<<<<<<<<<< + * _max_idx = -1 + * else: +*/ + __pyx_t_2 = (__pyx_v_max_idx == Py_None); + if (__pyx_t_2) { + + /* "polluck_blockchain/placeholder_native.pyx":578 + * + * if max_idx is None: + * _max_idx = -1 # <<<<<<<<<<<<<< + * else: + * _max_idx = max_idx +*/ + __pyx_v__max_idx = -1; + + /* "polluck_blockchain/placeholder_native.pyx":577 + * int _max_idx + * + * if max_idx is None: # <<<<<<<<<<<<<< + * _max_idx = -1 + * else: +*/ + goto __pyx_L3; + } + + /* "polluck_blockchain/placeholder_native.pyx":580 + * _max_idx = -1 + * else: + * _max_idx = max_idx # <<<<<<<<<<<<<< + * + * for idx in range(self._chain[0].size()): +*/ + /*else*/ { + __pyx_t_3 = __Pyx_PyLong_As_int(__pyx_v_max_idx); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 580, __pyx_L1_error) + __pyx_v__max_idx = __pyx_t_3; + } + __pyx_L3:; + + /* "polluck_blockchain/placeholder_native.pyx":582 + * _max_idx = max_idx + * + * for idx in range(self._chain[0].size()): # <<<<<<<<<<<<<< + * if idx <= _max_idx: + * continue +*/ + __pyx_t_4 = (__pyx_v_self->_chain[0]).size(); + __pyx_t_5 = __pyx_t_4; + for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_5; __pyx_t_3+=1) { + __pyx_v_idx = __pyx_t_3; + + /* "polluck_blockchain/placeholder_native.pyx":583 + * + * for idx in range(self._chain[0].size()): + * if idx <= _max_idx: # <<<<<<<<<<<<<< + * continue + * block = self._chain[0][idx] +*/ + __pyx_t_2 = (__pyx_v_idx <= __pyx_v__max_idx); + if (__pyx_t_2) { + + /* "polluck_blockchain/placeholder_native.pyx":584 + * for idx in range(self._chain[0].size()): + * if idx <= _max_idx: + * continue # <<<<<<<<<<<<<< + * block = self._chain[0][idx] + * contents = {} +*/ + goto __pyx_L4_continue; + + /* "polluck_blockchain/placeholder_native.pyx":583 + * + * for idx in range(self._chain[0].size()): + * if idx <= _max_idx: # <<<<<<<<<<<<<< + * continue + * block = self._chain[0][idx] +*/ + } + + /* "polluck_blockchain/placeholder_native.pyx":585 + * if idx <= _max_idx: + * continue + * block = self._chain[0][idx] # <<<<<<<<<<<<<< + * contents = {} + * contents["index"] = block.index +*/ + __pyx_v_block = ((__pyx_v_self->_chain[0])[__pyx_v_idx]); + + /* "polluck_blockchain/placeholder_native.pyx":586 + * continue + * block = self._chain[0][idx] + * contents = {} # <<<<<<<<<<<<<< + * contents["index"] = block.index + * contents["timestamp"] = block.timestamp +*/ + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 586, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_contents, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":587 + * block = self._chain[0][idx] + * contents = {} + * contents["index"] = block.index # <<<<<<<<<<<<<< + * contents["timestamp"] = block.timestamp + * contents["nonce"] = block.nonce +*/ + __pyx_t_1 = __Pyx_PyLong_From_uint64_t(__pyx_v_block->index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 587, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_contents, __pyx_mstate_global->__pyx_n_u_index, __pyx_t_1) < 0))) __PYX_ERR(0, 587, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":588 + * contents = {} + * contents["index"] = block.index + * contents["timestamp"] = block.timestamp # <<<<<<<<<<<<<< + * contents["nonce"] = block.nonce + * contents["previous_hash"] = block.prev_hash.decode("UTF-8") +*/ + __pyx_t_1 = __Pyx_PyLong_From_uint64_t(__pyx_v_block->timestamp); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 588, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_contents, __pyx_mstate_global->__pyx_n_u_timestamp, __pyx_t_1) < 0))) __PYX_ERR(0, 588, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":589 + * contents["index"] = block.index + * contents["timestamp"] = block.timestamp + * contents["nonce"] = block.nonce # <<<<<<<<<<<<<< + * contents["previous_hash"] = block.prev_hash.decode("UTF-8") + * contents["hash"] = block.hash.decode("UTF-8") +*/ + __pyx_t_1 = __Pyx_PyLong_From_uint64_t(__pyx_v_block->nonce); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 589, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_contents, __pyx_mstate_global->__pyx_n_u_nonce, __pyx_t_1) < 0))) __PYX_ERR(0, 589, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":590 + * contents["timestamp"] = block.timestamp + * contents["nonce"] = block.nonce + * contents["previous_hash"] = block.prev_hash.decode("UTF-8") # <<<<<<<<<<<<<< + * contents["hash"] = block.hash.decode("UTF-8") + * contents["data"] = block.data.decode("UTF-8") +*/ + __pyx_t_1 = __Pyx_decode_cpp_string(__pyx_v_block->prev_hash, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 590, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_contents, __pyx_mstate_global->__pyx_n_u_previous_hash, __pyx_t_1) < 0))) __PYX_ERR(0, 590, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":591 + * contents["nonce"] = block.nonce + * contents["previous_hash"] = block.prev_hash.decode("UTF-8") + * contents["hash"] = block.hash.decode("UTF-8") # <<<<<<<<<<<<<< + * contents["data"] = block.data.decode("UTF-8") + * entries.append(contents) +*/ + __pyx_t_1 = __Pyx_decode_cpp_string(__pyx_v_block->hash, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 591, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_contents, __pyx_mstate_global->__pyx_n_u_hash, __pyx_t_1) < 0))) __PYX_ERR(0, 591, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":592 + * contents["previous_hash"] = block.prev_hash.decode("UTF-8") + * contents["hash"] = block.hash.decode("UTF-8") + * contents["data"] = block.data.decode("UTF-8") # <<<<<<<<<<<<<< + * entries.append(contents) + * +*/ + __pyx_t_1 = __Pyx_decode_cpp_string(__pyx_v_block->data, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 592, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_contents, __pyx_mstate_global->__pyx_n_u_data, __pyx_t_1) < 0))) __PYX_ERR(0, 592, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":593 + * contents["hash"] = block.hash.decode("UTF-8") + * contents["data"] = block.data.decode("UTF-8") + * entries.append(contents) # <<<<<<<<<<<<<< + * + * return entries +*/ + __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_entries, __pyx_v_contents); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 593, __pyx_L1_error) + __pyx_L4_continue:; + } + + /* "polluck_blockchain/placeholder_native.pyx":595 + * entries.append(contents) + * + * return entries # <<<<<<<<<<<<<< + * + * def save(self): +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_entries); + __pyx_r = __pyx_v_entries; + goto __pyx_L0; + + /* "polluck_blockchain/placeholder_native.pyx":570 + * return True + * + * def get_saving_entries(self, max_idx): # <<<<<<<<<<<<<< + * entries = [] + * cdef: +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("polluck_blockchain.placeholder_native.Blockchain.get_saving_entries", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_entries); + __Pyx_XDECREF(__pyx_v_contents); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "polluck_blockchain/placeholder_native.pyx":597 + * return entries + * + * def save(self): # <<<<<<<<<<<<<< + * # get max index from db + * # only retrieve indices greater than max value +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_23save(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_23save = {"save", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_23save, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_23save(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("save (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("save", 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("save", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_22save(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_22save(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self) { + PyObject *__pyx_v_stmt = NULL; + PyObject *__pyx_v_conn = NULL; + PyObject *__pyx_v_result = NULL; + PyObject *__pyx_v_max_value = NULL; + PyObject *__pyx_v_entries = NULL; + PyObject *__pyx_v_con = 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; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + size_t __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + int __pyx_t_15; + int __pyx_t_16; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("save", 0); + + /* "polluck_blockchain/placeholder_native.pyx":600 + * # get max index from db + * # only retrieve indices greater than max value + * stmt = sql.select(sql.func.max(db.blocks.c.index)) # <<<<<<<<<<<<<< + * with self._engine.connect() as conn: + * result = conn.execute(stmt) +*/ + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_sql); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_select); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_sql); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_func); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_5 = __pyx_t_7; + __Pyx_INCREF(__pyx_t_5); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_db); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_blocks); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_c); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_index); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_8}; + __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_max, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_t_9 = 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_9 = 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_9, (2-__pyx_t_9) | (__pyx_t_9*__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, 600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_stmt = __pyx_t_1; + __pyx_t_1 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":601 + * # only retrieve indices greater than max value + * stmt = sql.select(sql.func.max(db.blocks.c.index)) + * with self._engine.connect() as conn: # <<<<<<<<<<<<<< + * result = conn.execute(stmt) + * max_value = result.scalar() +*/ + /*with:*/ { + __pyx_t_4 = __pyx_v_self->_engine; + __Pyx_INCREF(__pyx_t_4); + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_connect, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 601, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_10 = __Pyx_PyObject_LookupSpecial(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_exit); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 601, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_3 = NULL; + __pyx_t_2 = __Pyx_PyObject_LookupSpecial(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_enter); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 601, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_2, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_2, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (__pyx_t_9*__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_4)) __PYX_ERR(0, 601, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_2 = __pyx_t_4; + __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /*try:*/ { + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13); + __Pyx_XGOTREF(__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_12); + __Pyx_XGOTREF(__pyx_t_13); + /*try:*/ { + __pyx_v_conn = __pyx_t_2; + __pyx_t_2 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":602 + * stmt = sql.select(sql.func.max(db.blocks.c.index)) + * with self._engine.connect() as conn: + * result = conn.execute(stmt) # <<<<<<<<<<<<<< + * max_value = result.scalar() + * +*/ + __pyx_t_1 = __pyx_v_conn; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_v_stmt}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_execute, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 602, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_v_result = __pyx_t_2; + __pyx_t_2 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":603 + * with self._engine.connect() as conn: + * result = conn.execute(stmt) + * max_value = result.scalar() # <<<<<<<<<<<<<< + * + * entries = self.get_saving_entries(max_value) +*/ + __pyx_t_1 = __pyx_v_result; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_scalar, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 603, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_v_max_value = __pyx_t_2; + __pyx_t_2 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":601 + * # only retrieve indices greater than max value + * stmt = sql.select(sql.func.max(db.blocks.c.index)) + * with self._engine.connect() as conn: # <<<<<<<<<<<<<< + * result = conn.execute(stmt) + * max_value = result.scalar() +*/ + } + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + goto __pyx_L12_try_end; + __pyx_L7_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + /*except:*/ { + __Pyx_AddTraceback("polluck_blockchain.placeholder_native.Blockchain.save", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_1, &__pyx_t_4) < 0) __PYX_ERR(0, 601, __pyx_L9_except_error) + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_4); + __pyx_t_3 = PyTuple_Pack(3, __pyx_t_2, __pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 601, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_3, NULL); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 601, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_14); + __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_t_14); + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + if (__pyx_t_15 < (0)) __PYX_ERR(0, 601, __pyx_L9_except_error) + __pyx_t_16 = (!__pyx_t_15); + if (unlikely(__pyx_t_16)) { + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ErrRestoreWithState(__pyx_t_2, __pyx_t_1, __pyx_t_4); + __pyx_t_2 = 0; __pyx_t_1 = 0; __pyx_t_4 = 0; + __PYX_ERR(0, 601, __pyx_L9_except_error) + } + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L8_exception_handled; + } + __pyx_L9_except_error:; + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13); + goto __pyx_L1_error; + __pyx_L8_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13); + __pyx_L12_try_end:; + } + } + /*finally:*/ { + /*normal exit:*/{ + if (__pyx_t_10) { + __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_mstate_global->__pyx_tuple[0], NULL); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 601, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } + goto __pyx_L6; + } + __pyx_L6:; + } + goto __pyx_L16; + __pyx_L3_error:; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + goto __pyx_L1_error; + __pyx_L16:; + } + + /* "polluck_blockchain/placeholder_native.pyx":605 + * max_value = result.scalar() + * + * entries = self.get_saving_entries(max_value) # <<<<<<<<<<<<<< + * if not entries: + * return +*/ + __pyx_t_1 = ((PyObject *)__pyx_v_self); + __Pyx_INCREF(__pyx_t_1); + if (unlikely(!__pyx_v_max_value)) { __Pyx_RaiseUnboundLocalError("max_value"); __PYX_ERR(0, 605, __pyx_L1_error) } + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_v_max_value}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_get_saving_entries, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 605, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_v_entries = __pyx_t_4; + __pyx_t_4 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":606 + * + * entries = self.get_saving_entries(max_value) + * if not entries: # <<<<<<<<<<<<<< + * return + * +*/ + __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_v_entries); if (unlikely((__pyx_t_16 < 0))) __PYX_ERR(0, 606, __pyx_L1_error) + __pyx_t_15 = (!__pyx_t_16); + if (__pyx_t_15) { + + /* "polluck_blockchain/placeholder_native.pyx":607 + * entries = self.get_saving_entries(max_value) + * if not entries: + * return # <<<<<<<<<<<<<< + * + * with self._engine.begin() as con: +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "polluck_blockchain/placeholder_native.pyx":606 + * + * entries = self.get_saving_entries(max_value) + * if not entries: # <<<<<<<<<<<<<< + * return + * +*/ + } + + /* "polluck_blockchain/placeholder_native.pyx":609 + * return + * + * with self._engine.begin() as con: # <<<<<<<<<<<<<< + * con.execute(sql.insert(db.blocks), entries) + * +*/ + /*with:*/ { + __pyx_t_1 = __pyx_v_self->_engine; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_begin, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 609, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_10 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_exit); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 609, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_2 = NULL; + __pyx_t_3 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_enter); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 609, __pyx_L18_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 609, __pyx_L18_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_3 = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + /*try:*/ { + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_13, &__pyx_t_12, &__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_13); + __Pyx_XGOTREF(__pyx_t_12); + __Pyx_XGOTREF(__pyx_t_11); + /*try:*/ { + __pyx_v_con = __pyx_t_3; + __pyx_t_3 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":610 + * + * with self._engine.begin() as con: + * con.execute(sql.insert(db.blocks), entries) # <<<<<<<<<<<<<< + * + * def close_db_connections(self): +*/ + __pyx_t_4 = __pyx_v_con; + __Pyx_INCREF(__pyx_t_4); + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_sql); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 610, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_insert); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 610, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_db); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 610, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_blocks); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 610, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_8); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_8, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_8, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 610, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_1, __pyx_v_entries}; + __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_execute, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 610, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":609 + * return + * + * with self._engine.begin() as con: # <<<<<<<<<<<<<< + * con.execute(sql.insert(db.blocks), entries) + * +*/ + } + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + goto __pyx_L27_try_end; + __pyx_L22_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + /*except:*/ { + __Pyx_AddTraceback("polluck_blockchain.placeholder_native.Blockchain.save", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_1, &__pyx_t_4) < 0) __PYX_ERR(0, 609, __pyx_L24_except_error) + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_4); + __pyx_t_8 = PyTuple_Pack(3, __pyx_t_3, __pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 609, __pyx_L24_except_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_8, NULL); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 609, __pyx_L24_except_error) + __Pyx_GOTREF(__pyx_t_14); + __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_t_14); + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + if (__pyx_t_15 < (0)) __PYX_ERR(0, 609, __pyx_L24_except_error) + __pyx_t_16 = (!__pyx_t_15); + if (unlikely(__pyx_t_16)) { + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ErrRestoreWithState(__pyx_t_3, __pyx_t_1, __pyx_t_4); + __pyx_t_3 = 0; __pyx_t_1 = 0; __pyx_t_4 = 0; + __PYX_ERR(0, 609, __pyx_L24_except_error) + } + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L23_exception_handled; + } + __pyx_L24_except_error:; + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_ExceptionReset(__pyx_t_13, __pyx_t_12, __pyx_t_11); + goto __pyx_L1_error; + __pyx_L23_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_ExceptionReset(__pyx_t_13, __pyx_t_12, __pyx_t_11); + __pyx_L27_try_end:; + } + } + /*finally:*/ { + /*normal exit:*/{ + if (__pyx_t_10) { + __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_mstate_global->__pyx_tuple[0], NULL); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 609, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } + goto __pyx_L21; + } + __pyx_L21:; + } + goto __pyx_L31; + __pyx_L18_error:; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + goto __pyx_L1_error; + __pyx_L31:; + } + + /* "polluck_blockchain/placeholder_native.pyx":597 + * return entries + * + * def save(self): # <<<<<<<<<<<<<< + * # get max index from db + * # only retrieve indices greater than max value +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("polluck_blockchain.placeholder_native.Blockchain.save", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_stmt); + __Pyx_XDECREF(__pyx_v_conn); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_max_value); + __Pyx_XDECREF(__pyx_v_entries); + __Pyx_XDECREF(__pyx_v_con); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "polluck_blockchain/placeholder_native.pyx":612 + * con.execute(sql.insert(db.blocks), entries) + * + * def close_db_connections(self): # <<<<<<<<<<<<<< + * self._engine.dispose() + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_25close_db_connections(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_25close_db_connections = {"close_db_connections", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_25close_db_connections, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_25close_db_connections(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("close_db_connections (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("close_db_connections", 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("close_db_connections", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_24close_db_connections(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_24close_db_connections(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__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("close_db_connections", 0); + + /* "polluck_blockchain/placeholder_native.pyx":613 + * + * def close_db_connections(self): + * self._engine.dispose() # <<<<<<<<<<<<<< + * + * def load(self, batch_size): +*/ + __pyx_t_2 = __pyx_v_self->_engine; + __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_dispose, __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, 613, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":612 + * con.execute(sql.insert(db.blocks), entries) + * + * def close_db_connections(self): # <<<<<<<<<<<<<< + * self._engine.dispose() + * +*/ + + /* 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("polluck_blockchain.placeholder_native.Blockchain.close_db_connections", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "polluck_blockchain/placeholder_native.pyx":615 + * self._engine.dispose() + * + * def load(self, batch_size): # <<<<<<<<<<<<<< + * with self._engine.connect() as con: + * res = con.execute(sql.select(db.blocks).order_by(db.blocks.c.index.asc())) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_27load(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_27load = {"load", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_27load, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_27load(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_batch_size = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("load (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_batch_size,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, 615, __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, 615, __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, "load", 0) < (0)) __PYX_ERR(0, 615, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("load", 1, 1, 1, i); __PYX_ERR(0, 615, __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, 615, __pyx_L3_error) + } + __pyx_v_batch_size = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("load", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 615, __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("polluck_blockchain.placeholder_native.Blockchain.load", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_26load(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self), __pyx_v_batch_size); + + /* 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_18polluck_blockchain_18placeholder_native_10Blockchain_26load(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, PyObject *__pyx_v_batch_size) { + PyObject *__pyx_v_con = NULL; + PyObject *__pyx_v_res = NULL; + PyObject *__pyx_v_batch = 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; + 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; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + PyObject *__pyx_t_15 = NULL; + int __pyx_t_16; + int __pyx_t_17; + Py_ssize_t __pyx_t_18; + PyObject *(*__pyx_t_19)(PyObject *); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("load", 0); + + /* "polluck_blockchain/placeholder_native.pyx":616 + * + * def load(self, batch_size): + * with self._engine.connect() as con: # <<<<<<<<<<<<<< + * res = con.execute(sql.select(db.blocks).order_by(db.blocks.c.index.asc())) + * +*/ + /*with:*/ { + __pyx_t_2 = __pyx_v_self->_engine; + __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_connect, __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, 616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_4 = __Pyx_PyObject_LookupSpecial(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_exit); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = __Pyx_PyObject_LookupSpecial(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_enter); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 616, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = 1; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_3 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 616, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_t_6 = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /*try:*/ { + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_9); + /*try:*/ { + __pyx_v_con = __pyx_t_6; + __pyx_t_6 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":617 + * def load(self, batch_size): + * with self._engine.connect() as con: + * res = con.execute(sql.select(db.blocks).order_by(db.blocks.c.index.asc())) # <<<<<<<<<<<<<< + * + * for batch in res.partitions(batch_size): +*/ + __pyx_t_1 = __pyx_v_con; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_11 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_sql); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 617, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_select); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 617, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_db); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 617, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_blocks); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 617, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_14); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_3 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_13))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_13); + assert(__pyx_t_11); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_13); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_13, __pyx__function); + __pyx_t_3 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_11, __pyx_t_14}; + __pyx_t_10 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_13, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 617, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_10); + } + __pyx_t_5 = __pyx_t_10; + __Pyx_INCREF(__pyx_t_5); + __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_db); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 617, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_blocks); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 617, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_c); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 617, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_index); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 617, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_14 = __pyx_t_12; + __Pyx_INCREF(__pyx_t_14); + __pyx_t_3 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_14, NULL}; + __pyx_t_13 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_asc, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 617, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_13); + } + __pyx_t_3 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_13}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_order_by, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 617, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_t_3 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_2}; + __pyx_t_6 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_execute, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 617, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_6); + } + __pyx_v_res = __pyx_t_6; + __pyx_t_6 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":616 + * + * def load(self, batch_size): + * with self._engine.connect() as con: # <<<<<<<<<<<<<< + * res = con.execute(sql.select(db.blocks).order_by(db.blocks.c.index.asc())) + * +*/ + } + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L12_try_end; + __pyx_L7_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + /*except:*/ { + __Pyx_AddTraceback("polluck_blockchain.placeholder_native.Blockchain.load", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_2, &__pyx_t_1) < 0) __PYX_ERR(0, 616, __pyx_L9_except_error) + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_1); + __pyx_t_10 = PyTuple_Pack(3, __pyx_t_6, __pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 616, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_10, NULL); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 616, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_15); + __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_15); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (__pyx_t_16 < (0)) __PYX_ERR(0, 616, __pyx_L9_except_error) + __pyx_t_17 = (!__pyx_t_16); + if (unlikely(__pyx_t_17)) { + __Pyx_GIVEREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_ErrRestoreWithState(__pyx_t_6, __pyx_t_2, __pyx_t_1); + __pyx_t_6 = 0; __pyx_t_2 = 0; __pyx_t_1 = 0; + __PYX_ERR(0, 616, __pyx_L9_except_error) + } + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L8_exception_handled; + } + __pyx_L9_except_error:; + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); + goto __pyx_L1_error; + __pyx_L8_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); + __pyx_L12_try_end:; + } + } + /*finally:*/ { + /*normal exit:*/{ + if (__pyx_t_4) { + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_mstate_global->__pyx_tuple[0], NULL); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + goto __pyx_L6; + } + __pyx_L6:; + } + goto __pyx_L16; + __pyx_L3_error:; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L1_error; + __pyx_L16:; + } + + /* "polluck_blockchain/placeholder_native.pyx":619 + * res = con.execute(sql.select(db.blocks).order_by(db.blocks.c.index.asc())) + * + * for batch in res.partitions(batch_size): # <<<<<<<<<<<<<< + * self.load_from_batch(batch) +*/ + if (unlikely(!__pyx_v_res)) { __Pyx_RaiseUnboundLocalError("res"); __PYX_ERR(0, 619, __pyx_L1_error) } + __pyx_t_2 = __pyx_v_res; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_batch_size}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_partitions, __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, 619, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { + __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); + __pyx_t_18 = 0; + __pyx_t_19 = NULL; + } else { + __pyx_t_18 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 619, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_19 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 619, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + for (;;) { + if (likely(!__pyx_t_19)) { + 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, 619, __pyx_L1_error) + #endif + if (__pyx_t_18 >= __pyx_temp) break; + } + __pyx_t_1 = __Pyx_PyList_GetItemRefFast(__pyx_t_2, __pyx_t_18, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_18; + } 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, 619, __pyx_L1_error) + #endif + if (__pyx_t_18 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_18)); + #else + __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_18); + #endif + ++__pyx_t_18; + } + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 619, __pyx_L1_error) + } else { + __pyx_t_1 = __pyx_t_19(__pyx_t_2); + 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, 619, __pyx_L1_error) + PyErr_Clear(); + } + break; + } + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_batch, __pyx_t_1); + __pyx_t_1 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":620 + * + * for batch in res.partitions(batch_size): + * self.load_from_batch(batch) # <<<<<<<<<<<<<< +*/ + __pyx_t_1 = ((struct __pyx_vtabstruct_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self->__pyx_vtab)->load_from_batch(__pyx_v_self, __pyx_v_batch); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 620, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":619 + * res = con.execute(sql.select(db.blocks).order_by(db.blocks.c.index.asc())) + * + * for batch in res.partitions(batch_size): # <<<<<<<<<<<<<< + * self.load_from_batch(batch) +*/ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":615 + * self._engine.dispose() + * + * def load(self, batch_size): # <<<<<<<<<<<<<< + * with self._engine.connect() as con: + * res = con.execute(sql.select(db.blocks).order_by(db.blocks.c.index.asc())) +*/ + + /* 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_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_XDECREF(__pyx_t_14); + __Pyx_AddTraceback("polluck_blockchain.placeholder_native.Blockchain.load", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_con); + __Pyx_XDECREF(__pyx_v_res); + __Pyx_XDECREF(__pyx_v_batch); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "polluck_blockchain/placeholder_native.pyx":330 + * vector[Block*] *_chain + * bint _genesis_done + * readonly object db_path # <<<<<<<<<<<<<< + * readonly object _engine + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_7db_path_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_7db_path_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_18polluck_blockchain_18placeholder_native_10Blockchain_7db_path___get__(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_7db_path___get__(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->db_path); + __pyx_r = __pyx_v_self->db_path; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "polluck_blockchain/placeholder_native.pyx":331 + * bint _genesis_done + * readonly object db_path + * readonly object _engine # <<<<<<<<<<<<<< + * + * def __cinit__(self, *args, **kwargs): +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_7_engine_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_7_engine_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_18polluck_blockchain_18placeholder_native_10Blockchain_7_engine___get__(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_7_engine___get__(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_engine); + __pyx_r = __pyx_v_self->_engine; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" @@ -8768,15 +12095,15 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain */ /* Python wrapper */ -static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_17__reduce_cython__(PyObject *__pyx_v_self, +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_29__reduce_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyMethodDef __pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_17__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_17__reduce_cython__(PyObject *__pyx_v_self, +static PyMethodDef __pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_29__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_29__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_29__reduce_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -8802,14 +12129,14 @@ PyObject *__pyx_args, PyObject *__pyx_kwds 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_18polluck_blockchain_18placeholder_native_10Blockchain_16__reduce_cython__(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self)); + __pyx_r = __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_28__reduce_cython__(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_16__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self) { +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_28__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; @@ -8849,15 +12176,15 @@ static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain */ /* Python wrapper */ -static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_19__setstate_cython__(PyObject *__pyx_v_self, +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_31__setstate_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyMethodDef __pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_19__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_19__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_19__setstate_cython__(PyObject *__pyx_v_self, +static PyMethodDef __pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_31__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_31__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_31__setstate_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -8923,7 +12250,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_18__setstate_cython__(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *)__pyx_v_self), __pyx_v___pyx_state); + __pyx_r = __pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_30__setstate_cython__(((struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *)__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) { @@ -8933,7 +12260,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds return __pyx_r; } -static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_18__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pf_18polluck_blockchain_18placeholder_native_10Blockchain_30__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; @@ -9036,10 +12363,11 @@ static PyObject *__pyx_getprop_18polluck_blockchain_18placeholder_native_7PyBloc } static PyMethodDef __pyx_methods_18polluck_blockchain_18placeholder_native_PyBlock[] = { - {"bytes_serialize", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_11bytes_serialize, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"perform_hash", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_13perform_hash, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_15__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_17__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"serialize_dict", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_11serialize_dict, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"bytes_serialize", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_13bytes_serialize, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"perform_hash", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_15perform_hash, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_7PyBlock_19__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {0, 0, 0, 0} }; @@ -9146,14 +12474,16 @@ static PyTypeObject __pyx_type_18polluck_blockchain_18placeholder_native_PyBlock #endif static struct __pyx_vtabstruct_18polluck_blockchain_18placeholder_native_Blockchain __pyx_vtable_18polluck_blockchain_18placeholder_native_Blockchain; -static PyObject *__pyx_tp_new_18polluck_blockchain_18placeholder_native_Blockchain(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { +static PyObject *__pyx_tp_new_18polluck_blockchain_18placeholder_native_Blockchain(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *p; PyObject *o; o = __Pyx_AllocateExtensionType(t, 0); if (unlikely(!o)) return 0; p = ((struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *)o); p->__pyx_vtab = __pyx_vtabptr_18polluck_blockchain_18placeholder_native_Blockchain; - if (unlikely(__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_1__cinit__(o, __pyx_mstate_global->__pyx_empty_tuple, NULL) < 0)) goto bad; + p->db_path = Py_None; Py_INCREF(Py_None); + p->_engine = Py_None; Py_INCREF(Py_None); + if (unlikely(__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_1__cinit__(o, a, k) < 0)) goto bad; return o; bad: Py_DECREF(o); o = 0; @@ -9161,13 +12491,15 @@ static PyObject *__pyx_tp_new_18polluck_blockchain_18placeholder_native_Blockcha } static void __pyx_tp_dealloc_18polluck_blockchain_18placeholder_native_Blockchain(PyObject *o) { + struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *p = (struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *)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 (unlikely(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_18polluck_blockchain_18placeholder_native_Blockchain) { if (PyObject_CallFinalizerFromDealloc(o)) return; } } #endif + PyObject_GC_UnTrack(o); { PyObject *etype, *eval, *etb; PyErr_Fetch(&etype, &eval, &etb); @@ -9176,6 +12508,8 @@ static void __pyx_tp_dealloc_18polluck_blockchain_18placeholder_native_Blockchai __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); PyErr_Restore(etype, eval, etb); } + Py_CLEAR(p->db_path); + Py_CLEAR(p->_engine); PyTypeObject *tp = Py_TYPE(o); #if CYTHON_USE_TYPE_SLOTS (*tp->tp_free)(o); @@ -9190,6 +12524,34 @@ static void __pyx_tp_dealloc_18polluck_blockchain_18placeholder_native_Blockchai #endif } +static int __pyx_tp_traverse_18polluck_blockchain_18placeholder_native_Blockchain(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *p = (struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->db_path) { + e = (*v)(p->db_path, a); if (e) return e; + } + if (p->_engine) { + e = (*v)(p->_engine, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_18polluck_blockchain_18placeholder_native_Blockchain(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *p = (struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *)o; + tmp = ((PyObject*)p->db_path); + p->db_path = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_engine); + p->_engine = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + static PyObject *__pyx_getprop_18polluck_blockchain_18placeholder_native_10Blockchain_difficulty(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_10difficulty_1__get__(o); } @@ -9212,13 +12574,27 @@ static PyObject *__pyx_getprop_18polluck_blockchain_18placeholder_native_10Block return __pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_5index_1__get__(o); } +static PyObject *__pyx_getprop_18polluck_blockchain_18placeholder_native_10Blockchain_db_path(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_7db_path_1__get__(o); +} + +static PyObject *__pyx_getprop_18polluck_blockchain_18placeholder_native_10Blockchain__engine(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_7_engine_1__get__(o); +} + static PyMethodDef __pyx_methods_18polluck_blockchain_18placeholder_native_Blockchain[] = { - {"print_key_value_pair", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_9print_key_value_pair, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"get_block", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_11get_block, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"create_genesis_block", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_13create_genesis_block, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"new_block", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_15new_block, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_19__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"_print_key_value_pair", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_9_print_key_value_pair, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"print_blocks", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_11print_blocks, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"get_block", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_13get_block, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"create_genesis_block", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_15create_genesis_block, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"new_block", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_17new_block, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"validate", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_19validate, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"get_saving_entries", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_21get_saving_entries, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"save", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_23save, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"close_db_connections", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_25close_db_connections, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"load", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_27load, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_29__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_31__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {0, 0, 0, 0} }; @@ -9226,6 +12602,8 @@ static struct PyGetSetDef __pyx_getsets_18polluck_blockchain_18placeholder_nativ {"difficulty", __pyx_getprop_18polluck_blockchain_18placeholder_native_10Blockchain_difficulty, __pyx_setprop_18polluck_blockchain_18placeholder_native_10Blockchain_difficulty, 0, 0}, {"genesis_done", __pyx_getprop_18polluck_blockchain_18placeholder_native_10Blockchain_genesis_done, 0, 0, 0}, {"index", __pyx_getprop_18polluck_blockchain_18placeholder_native_10Blockchain_index, 0, 0, 0}, + {"db_path", __pyx_getprop_18polluck_blockchain_18placeholder_native_10Blockchain_db_path, 0, 0, 0}, + {"_engine", __pyx_getprop_18polluck_blockchain_18placeholder_native_10Blockchain__engine, 0, 0, 0}, {0, 0, 0, 0, 0} }; #if CYTHON_USE_TYPE_SPECS @@ -9233,6 +12611,8 @@ static PyType_Slot __pyx_type_18polluck_blockchain_18placeholder_native_Blockcha {Py_tp_dealloc, (void *)__pyx_tp_dealloc_18polluck_blockchain_18placeholder_native_Blockchain}, {Py_sq_length, (void *)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_7__len__}, {Py_mp_length, (void *)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_7__len__}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_18polluck_blockchain_18placeholder_native_Blockchain}, + {Py_tp_clear, (void *)__pyx_tp_clear_18polluck_blockchain_18placeholder_native_Blockchain}, {Py_tp_methods, (void *)__pyx_methods_18polluck_blockchain_18placeholder_native_Blockchain}, {Py_tp_getset, (void *)__pyx_getsets_18polluck_blockchain_18placeholder_native_Blockchain}, {Py_tp_init, (void *)__pyx_pw_18polluck_blockchain_18placeholder_native_10Blockchain_3__init__}, @@ -9243,7 +12623,7 @@ static PyType_Spec __pyx_type_18polluck_blockchain_18placeholder_native_Blockcha "polluck_blockchain.placeholder_native.Blockchain", sizeof(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain), 0, - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, __pyx_type_18polluck_blockchain_18placeholder_native_Blockchain_slots, }; #else @@ -9287,10 +12667,10 @@ static PyTypeObject __pyx_type_18polluck_blockchain_18placeholder_native_Blockch 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ - 0, /*tp_traverse*/ - 0, /*tp_clear*/ + __pyx_tp_traverse_18polluck_blockchain_18placeholder_native_Blockchain, /*tp_traverse*/ + __pyx_tp_clear_18polluck_blockchain_18placeholder_native_Blockchain, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ @@ -9396,15 +12776,15 @@ static int __Pyx_modinit_type_init_code(__pyx_mstatetype *__pyx_mstate) { __pyx_vtabptr_18polluck_blockchain_18placeholder_native_PyBlock = &__pyx_vtable_18polluck_blockchain_18placeholder_native_PyBlock; __pyx_vtable_18polluck_blockchain_18placeholder_native_PyBlock.from_ptr = (struct __pyx_obj_18polluck_blockchain_18placeholder_native_PyBlock *(*)(::Block *, struct __pyx_opt_args_18polluck_blockchain_18placeholder_native_7PyBlock_from_ptr *__pyx_optional_args))__pyx_f_18polluck_blockchain_18placeholder_native_7PyBlock_from_ptr; #if CYTHON_USE_TYPE_SPECS - __pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_PyBlock = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_18polluck_blockchain_18placeholder_native_PyBlock_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_PyBlock)) __PYX_ERR(0, 85, __pyx_L1_error) - if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_18polluck_blockchain_18placeholder_native_PyBlock_spec, __pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_PyBlock) < (0)) __PYX_ERR(0, 85, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_PyBlock = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_18polluck_blockchain_18placeholder_native_PyBlock_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_PyBlock)) __PYX_ERR(0, 86, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_18polluck_blockchain_18placeholder_native_PyBlock_spec, __pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_PyBlock) < (0)) __PYX_ERR(0, 86, __pyx_L1_error) #else __pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_PyBlock = &__pyx_type_18polluck_blockchain_18placeholder_native_PyBlock; #endif #if !CYTHON_COMPILING_IN_LIMITED_API #endif #if !CYTHON_USE_TYPE_SPECS - if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_PyBlock) < (0)) __PYX_ERR(0, 85, __pyx_L1_error) + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_PyBlock) < (0)) __PYX_ERR(0, 86, __pyx_L1_error) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_PyBlock); @@ -9414,24 +12794,26 @@ static int __Pyx_modinit_type_init_code(__pyx_mstatetype *__pyx_mstate) { __pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_PyBlock->tp_getattro = PyObject_GenericGetAttr; } #endif - if (__Pyx_SetVtable(__pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_PyBlock, __pyx_vtabptr_18polluck_blockchain_18placeholder_native_PyBlock) < (0)) __PYX_ERR(0, 85, __pyx_L1_error) - if (__Pyx_MergeVtables(__pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_PyBlock) < (0)) __PYX_ERR(0, 85, __pyx_L1_error) - if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_PyBlock_2, (PyObject *) __pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_PyBlock) < (0)) __PYX_ERR(0, 85, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_PyBlock) < (0)) __PYX_ERR(0, 85, __pyx_L1_error) + if (__Pyx_SetVtable(__pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_PyBlock, __pyx_vtabptr_18polluck_blockchain_18placeholder_native_PyBlock) < (0)) __PYX_ERR(0, 86, __pyx_L1_error) + if (__Pyx_MergeVtables(__pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_PyBlock) < (0)) __PYX_ERR(0, 86, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_PyBlock, (PyObject *) __pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_PyBlock) < (0)) __PYX_ERR(0, 86, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_PyBlock) < (0)) __PYX_ERR(0, 86, __pyx_L1_error) __pyx_vtabptr_18polluck_blockchain_18placeholder_native_Blockchain = &__pyx_vtable_18polluck_blockchain_18placeholder_native_Blockchain; __pyx_vtable_18polluck_blockchain_18placeholder_native_Blockchain.get_block_c = (::Block *(*)(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *, uint64_t))__pyx_f_18polluck_blockchain_18placeholder_native_10Blockchain_get_block_c; + __pyx_vtable_18polluck_blockchain_18placeholder_native_Blockchain.add_block_from_loading = (void (*)(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *, ::Block *))__pyx_f_18polluck_blockchain_18placeholder_native_10Blockchain_add_block_from_loading; __pyx_vtable_18polluck_blockchain_18placeholder_native_Blockchain.add_block = (int (*)(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *, ::Block *))__pyx_f_18polluck_blockchain_18placeholder_native_10Blockchain_add_block; __pyx_vtable_18polluck_blockchain_18placeholder_native_Blockchain.hash_data = (std::string (*)(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *, PyObject *))__pyx_f_18polluck_blockchain_18placeholder_native_10Blockchain_hash_data; + __pyx_vtable_18polluck_blockchain_18placeholder_native_Blockchain.load_from_batch = (PyObject *(*)(struct __pyx_obj_18polluck_blockchain_18placeholder_native_Blockchain *, PyObject *))__pyx_f_18polluck_blockchain_18placeholder_native_10Blockchain_load_from_batch; #if CYTHON_USE_TYPE_SPECS - __pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_18polluck_blockchain_18placeholder_native_Blockchain_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain)) __PYX_ERR(0, 307, __pyx_L1_error) - if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_18polluck_blockchain_18placeholder_native_Blockchain_spec, __pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain) < (0)) __PYX_ERR(0, 307, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_18polluck_blockchain_18placeholder_native_Blockchain_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain)) __PYX_ERR(0, 323, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_18polluck_blockchain_18placeholder_native_Blockchain_spec, __pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain) < (0)) __PYX_ERR(0, 323, __pyx_L1_error) #else __pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain = &__pyx_type_18polluck_blockchain_18placeholder_native_Blockchain; #endif #if !CYTHON_COMPILING_IN_LIMITED_API #endif #if !CYTHON_USE_TYPE_SPECS - if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain) < (0)) __PYX_ERR(0, 307, __pyx_L1_error) + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain) < (0)) __PYX_ERR(0, 323, __pyx_L1_error) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain); @@ -9441,10 +12823,10 @@ static int __Pyx_modinit_type_init_code(__pyx_mstatetype *__pyx_mstate) { __pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain->tp_getattro = PyObject_GenericGetAttr; } #endif - if (__Pyx_SetVtable(__pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain, __pyx_vtabptr_18polluck_blockchain_18placeholder_native_Blockchain) < (0)) __PYX_ERR(0, 307, __pyx_L1_error) - if (__Pyx_MergeVtables(__pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain) < (0)) __PYX_ERR(0, 307, __pyx_L1_error) - if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_Blockchain, (PyObject *) __pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain) < (0)) __PYX_ERR(0, 307, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain) < (0)) __PYX_ERR(0, 307, __pyx_L1_error) + if (__Pyx_SetVtable(__pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain, __pyx_vtabptr_18polluck_blockchain_18placeholder_native_Blockchain) < (0)) __PYX_ERR(0, 323, __pyx_L1_error) + if (__Pyx_MergeVtables(__pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain) < (0)) __PYX_ERR(0, 323, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_Blockchain, (PyObject *) __pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain) < (0)) __PYX_ERR(0, 323, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain) < (0)) __PYX_ERR(0, 323, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; @@ -9659,6 +13041,8 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_placeholder_native(PyObject *__pyx __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_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -9749,8 +13133,8 @@ __Pyx_RefNannySetupContext("PyInit_placeholder_native", 0); * from __future__ import annotations * * import datetime # <<<<<<<<<<<<<< - * import hashlib - * import struct + * from pathlib import Path + * */ __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_datetime, 0, 0, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) __pyx_t_2 = __pyx_t_1; @@ -9761,83 +13145,120 @@ __Pyx_RefNannySetupContext("PyInit_placeholder_native", 0); /* "polluck_blockchain/placeholder_native.pyx":8 * * import datetime - * import hashlib # <<<<<<<<<<<<<< - * import struct - * import time -*/ - __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_hashlib, 0, 0, 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); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_hashlib, __pyx_t_2) < (0)) __PYX_ERR(0, 8, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "polluck_blockchain/placeholder_native.pyx":9 - * import datetime - * import hashlib - * import struct # <<<<<<<<<<<<<< - * import time + * from pathlib import Path # <<<<<<<<<<<<<< * + * import dopt_basics.datetime */ - __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_struct, 0, 0, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error) + { + PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_Path}; + __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_pathlib, __pyx_imported_names, 1, 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); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_struct, __pyx_t_2) < (0)) __PYX_ERR(0, 9, __pyx_L1_error) + { + PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_Path}; + __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, 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; /* "polluck_blockchain/placeholder_native.pyx":10 - * import hashlib - * import struct - * import time # <<<<<<<<<<<<<< + * from pathlib import Path * - * import cython -*/ - __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_time, 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_time, __pyx_t_2) < (0)) __PYX_ERR(0, 10, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "polluck_blockchain/placeholder_native.pyx":13 - * - * import cython * import dopt_basics.datetime # <<<<<<<<<<<<<< - * - * # from cython.cimports.cpython.ref import Py_INCREF, PyObject + * import sqlalchemy as sql + * from polluck_blockchain import db */ - __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_dopt_basics_datetime, 0, 0, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error) + __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_dopt_basics_datetime, 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_dopt_basics, __pyx_t_2) < (0)) __PYX_ERR(0, 13, __pyx_L1_error) + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_dopt_basics, __pyx_t_2) < (0)) __PYX_ERR(0, 10, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "polluck_blockchain/placeholder_native.pyx":166 + /* "polluck_blockchain/placeholder_native.pyx":11 + * + * import dopt_basics.datetime + * import sqlalchemy as sql # <<<<<<<<<<<<<< + * from polluck_blockchain import db + * +*/ + __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_sqlalchemy, 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_sql, __pyx_t_2) < (0)) __PYX_ERR(0, 11, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":12 + * import dopt_basics.datetime + * import sqlalchemy as sql + * from polluck_blockchain import db # <<<<<<<<<<<<<< + * + * +*/ + { + PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_db}; + __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_polluck_blockchain, __pyx_imported_names, 1, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __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_db}; + __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, 12, __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, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":145 + * return self.__repr__() + * + * def serialize_dict(self): # <<<<<<<<<<<<<< + * contents = {} + * +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_18polluck_blockchain_18placeholder_native_7PyBlock_11serialize_dict, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PyBlock_serialize_dict, NULL, __pyx_mstate_global->__pyx_n_u_polluck_blockchain_placeholder_n, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 145, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_18polluck_blockchain_18placeholder_native_PyBlock, __pyx_mstate_global->__pyx_n_u_serialize_dict, __pyx_t_2) < (0)) __PYX_ERR(0, 145, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":182 * return self.BlockC.hash.decode("UTF-8") * * def bytes_serialize(self): # <<<<<<<<<<<<<< * cdef: * unsigned char *serialize_res */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_18polluck_blockchain_18placeholder_native_7PyBlock_11bytes_serialize, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PyBlock_bytes_serialize, NULL, __pyx_mstate_global->__pyx_n_u_polluck_blockchain_placeholder_n, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 166, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_18polluck_blockchain_18placeholder_native_7PyBlock_13bytes_serialize, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PyBlock_bytes_serialize, NULL, __pyx_mstate_global->__pyx_n_u_polluck_blockchain_placeholder_n, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[1])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 182, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); #endif - if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_18polluck_blockchain_18placeholder_native_PyBlock, __pyx_mstate_global->__pyx_n_u_bytes_serialize, __pyx_t_2) < (0)) __PYX_ERR(0, 166, __pyx_L1_error) + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_18polluck_blockchain_18placeholder_native_PyBlock, __pyx_mstate_global->__pyx_n_u_bytes_serialize, __pyx_t_2) < (0)) __PYX_ERR(0, 182, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "polluck_blockchain/placeholder_native.pyx":177 + /* "polluck_blockchain/placeholder_native.pyx":193 * * * def perform_hash(self): # <<<<<<<<<<<<<< * cdef: * unsigned char *digest */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_18polluck_blockchain_18placeholder_native_7PyBlock_13perform_hash, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PyBlock_perform_hash, NULL, __pyx_mstate_global->__pyx_n_u_polluck_blockchain_placeholder_n, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[1])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 177, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_18polluck_blockchain_18placeholder_native_7PyBlock_15perform_hash, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PyBlock_perform_hash, NULL, __pyx_mstate_global->__pyx_n_u_polluck_blockchain_placeholder_n, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[2])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 193, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); #endif - if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_18polluck_blockchain_18placeholder_native_PyBlock, __pyx_mstate_global->__pyx_n_u_perform_hash, __pyx_t_2) < (0)) __PYX_ERR(0, 177, __pyx_L1_error) + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_18polluck_blockchain_18placeholder_native_PyBlock, __pyx_mstate_global->__pyx_n_u_perform_hash, __pyx_t_2) < (0)) __PYX_ERR(0, 193, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "(tree fragment)":1 @@ -9845,7 +13266,7 @@ __Pyx_RefNannySetupContext("PyInit_placeholder_native", 0); * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_18polluck_blockchain_18placeholder_native_7PyBlock_15__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PyBlock___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_polluck_blockchain_placeholder_n, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[2])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_18polluck_blockchain_18placeholder_native_7PyBlock_17__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PyBlock___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_polluck_blockchain_placeholder_n, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[3])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); @@ -9859,7 +13280,7 @@ __Pyx_RefNannySetupContext("PyInit_placeholder_native", 0); * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_18polluck_blockchain_18placeholder_native_7PyBlock_17__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PyBlock___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_polluck_blockchain_placeholder_n, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[3])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_18polluck_blockchain_18placeholder_native_7PyBlock_19__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PyBlock___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_polluck_blockchain_placeholder_n, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[4])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); @@ -9867,64 +13288,154 @@ __Pyx_RefNannySetupContext("PyInit_placeholder_native", 0); if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_2) < (0)) __PYX_ERR(1, 3, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "polluck_blockchain/placeholder_native.pyx":359 + /* "polluck_blockchain/placeholder_native.pyx":455 * return self._index * - * def print_key_value_pair(self): # <<<<<<<<<<<<<< - * cdef BcHashmap.iterator it = self._chain.begin() + * def _print_key_value_pair(self): # <<<<<<<<<<<<<< + * cdef BcHashmap.iterator it = self._chain_map.begin() * cdef Block *block */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_9print_key_value_pair, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Blockchain_print_key_value_pair, NULL, __pyx_mstate_global->__pyx_n_u_polluck_blockchain_placeholder_n, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[4])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 359, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_9_print_key_value_pair, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Blockchain__print_key_value_pair, NULL, __pyx_mstate_global->__pyx_n_u_polluck_blockchain_placeholder_n, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[5])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 455, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); #endif - if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain, __pyx_mstate_global->__pyx_n_u_print_key_value_pair, __pyx_t_2) < (0)) __PYX_ERR(0, 359, __pyx_L1_error) + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain, __pyx_mstate_global->__pyx_n_u_print_key_value_pair, __pyx_t_2) < (0)) __PYX_ERR(0, 455, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "polluck_blockchain/placeholder_native.pyx":396 + /* "polluck_blockchain/placeholder_native.pyx":465 + * postincrement(it) + * + * def print_blocks(self, max_num): # <<<<<<<<<<<<<< + * cdef: + * Block *block +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_11print_blocks, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Blockchain_print_blocks, NULL, __pyx_mstate_global->__pyx_n_u_polluck_blockchain_placeholder_n, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[6])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 465, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain, __pyx_mstate_global->__pyx_n_u_print_blocks, __pyx_t_2) < (0)) __PYX_ERR(0, 465, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":482 + * break * - * # // Python public API * def get_block(self, idx): # <<<<<<<<<<<<<< * if idx < 0 or idx > self._index: * raise IndexError("Index value is out of bounds") */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_11get_block, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Blockchain_get_block, NULL, __pyx_mstate_global->__pyx_n_u_polluck_blockchain_placeholder_n, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[5])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 396, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_13get_block, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Blockchain_get_block, NULL, __pyx_mstate_global->__pyx_n_u_polluck_blockchain_placeholder_n, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[7])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 482, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); #endif - if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain, __pyx_mstate_global->__pyx_n_u_get_block, __pyx_t_2) < (0)) __PYX_ERR(0, 396, __pyx_L1_error) + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain, __pyx_mstate_global->__pyx_n_u_get_block, __pyx_t_2) < (0)) __PYX_ERR(0, 482, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "polluck_blockchain/placeholder_native.pyx":419 - * return data_str + /* "polluck_blockchain/placeholder_native.pyx":491 + * return PyBlock.from_ptr(block, owner=False) * * def create_genesis_block(self): # <<<<<<<<<<<<<< - * genesis_prev_hash = ("0" * 64).encode("UTF-8") - * cdef string data_str = self.hash_data("Genesis Block") + * if self._genesis_done: + * return */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_13create_genesis_block, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Blockchain_create_genesis_block, NULL, __pyx_mstate_global->__pyx_n_u_polluck_blockchain_placeholder_n, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[6])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 419, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_15create_genesis_block, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Blockchain_create_genesis_block, NULL, __pyx_mstate_global->__pyx_n_u_polluck_blockchain_placeholder_n, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[8])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 491, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); #endif - if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain, __pyx_mstate_global->__pyx_n_u_create_genesis_block, __pyx_t_2) < (0)) __PYX_ERR(0, 419, __pyx_L1_error) + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain, __pyx_mstate_global->__pyx_n_u_create_genesis_block, __pyx_t_2) < (0)) __PYX_ERR(0, 491, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "polluck_blockchain/placeholder_native.pyx":436 + /* "polluck_blockchain/placeholder_native.pyx":511 * self._genesis_done = True * * def new_block(self, data): # <<<<<<<<<<<<<< * cdef: * Block *prev_block */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_15new_block, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Blockchain_new_block, NULL, __pyx_mstate_global->__pyx_n_u_polluck_blockchain_placeholder_n, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[7])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 436, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_17new_block, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Blockchain_new_block, NULL, __pyx_mstate_global->__pyx_n_u_polluck_blockchain_placeholder_n, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[9])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 511, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); #endif - if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain, __pyx_mstate_global->__pyx_n_u_new_block, __pyx_t_2) < (0)) __PYX_ERR(0, 436, __pyx_L1_error) + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain, __pyx_mstate_global->__pyx_n_u_new_block, __pyx_t_2) < (0)) __PYX_ERR(0, 511, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":542 + * raise RuntimeError("Could not mine block. No nonce found") + * + * def validate(self): # <<<<<<<<<<<<<< + * cdef: + * Block *block +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_19validate, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Blockchain_validate, NULL, __pyx_mstate_global->__pyx_n_u_polluck_blockchain_placeholder_n, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[10])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 542, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain, __pyx_mstate_global->__pyx_n_u_validate, __pyx_t_2) < (0)) __PYX_ERR(0, 542, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":570 + * return True + * + * def get_saving_entries(self, max_idx): # <<<<<<<<<<<<<< + * entries = [] + * cdef: +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_21get_saving_entries, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Blockchain_get_saving_entries, NULL, __pyx_mstate_global->__pyx_n_u_polluck_blockchain_placeholder_n, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[11])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 570, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain, __pyx_mstate_global->__pyx_n_u_get_saving_entries, __pyx_t_2) < (0)) __PYX_ERR(0, 570, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":597 + * return entries + * + * def save(self): # <<<<<<<<<<<<<< + * # get max index from db + * # only retrieve indices greater than max value +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_23save, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Blockchain_save, NULL, __pyx_mstate_global->__pyx_n_u_polluck_blockchain_placeholder_n, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[12])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 597, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain, __pyx_mstate_global->__pyx_n_u_save, __pyx_t_2) < (0)) __PYX_ERR(0, 597, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":612 + * con.execute(sql.insert(db.blocks), entries) + * + * def close_db_connections(self): # <<<<<<<<<<<<<< + * self._engine.dispose() + * +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_25close_db_connections, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Blockchain_close_db_connections, NULL, __pyx_mstate_global->__pyx_n_u_polluck_blockchain_placeholder_n, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[13])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 612, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain, __pyx_mstate_global->__pyx_n_u_close_db_connections, __pyx_t_2) < (0)) __PYX_ERR(0, 612, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "polluck_blockchain/placeholder_native.pyx":615 + * self._engine.dispose() + * + * def load(self, batch_size): # <<<<<<<<<<<<<< + * with self._engine.connect() as con: + * res = con.execute(sql.select(db.blocks).order_by(db.blocks.c.index.asc())) +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_27load, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Blockchain_load, NULL, __pyx_mstate_global->__pyx_n_u_polluck_blockchain_placeholder_n, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[14])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 615, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_18polluck_blockchain_18placeholder_native_Blockchain, __pyx_mstate_global->__pyx_n_u_load, __pyx_t_2) < (0)) __PYX_ERR(0, 615, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "(tree fragment)":1 @@ -9932,7 +13443,7 @@ __Pyx_RefNannySetupContext("PyInit_placeholder_native", 0); * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_17__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Blockchain___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_polluck_blockchain_placeholder_n, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[8])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_29__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Blockchain___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_polluck_blockchain_placeholder_n, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[15])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); @@ -9946,7 +13457,7 @@ __Pyx_RefNannySetupContext("PyInit_placeholder_native", 0); * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_19__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Blockchain___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_polluck_blockchain_placeholder_n, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[9])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_18polluck_blockchain_18placeholder_native_10Blockchain_31__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Blockchain___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_polluck_blockchain_placeholder_n, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[16])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); @@ -9969,6 +13480,7 @@ __Pyx_RefNannySetupContext("PyInit_placeholder_native", 0); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); if (__pyx_m) { if (__pyx_mstate->__pyx_d && stringtab_initialized) { __Pyx_AddTraceback("init polluck_blockchain.placeholder_native", __pyx_clineno, __pyx_lineno, __pyx_filename); @@ -10000,7 +13512,7 @@ __Pyx_RefNannySetupContext("PyInit_placeholder_native", 0); static int __Pyx_InitCachedBuiltins(__pyx_mstatetype *__pyx_mstate) { CYTHON_UNUSED_VAR(__pyx_mstate); - __pyx_builtin_print = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_print); if (!__pyx_builtin_print) __PYX_ERR(0, 363, __pyx_L1_error) + __pyx_builtin_print = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_print); if (!__pyx_builtin_print) __PYX_ERR(0, 459, __pyx_L1_error) /* Cached unbound methods */ __pyx_mstate->__pyx_umethod_PyDict_Type_items.type = (PyObject*)&PyDict_Type; @@ -10020,14 +13532,14 @@ static int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate) { CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - /* "polluck_blockchain/placeholder_native.pyx":101 - * self.BlockC = new Block( - * index, - * int(datetime.datetime(2025, 12, 1, 12, 0, 0).timestamp()), # <<<<<<<<<<<<<< - * nonce, - * data.encode("UTF-8"), + /* "polluck_blockchain/placeholder_native.pyx":601 + * # only retrieve indices greater than max value + * stmt = sql.select(sql.func.max(db.blocks.c.index)) + * with self._engine.connect() as conn: # <<<<<<<<<<<<<< + * result = conn.execute(stmt) + * max_value = result.scalar() */ - __pyx_mstate_global->__pyx_tuple[0] = PyTuple_Pack(6, __pyx_mstate_global->__pyx_int_2025, __pyx_mstate_global->__pyx_int_12, __pyx_mstate_global->__pyx_int_1, __pyx_mstate_global->__pyx_int_12, __pyx_mstate_global->__pyx_int_0, __pyx_mstate_global->__pyx_int_0); if (unlikely(!__pyx_mstate_global->__pyx_tuple[0])) __PYX_ERR(0, 101, __pyx_L1_error) + __pyx_mstate_global->__pyx_tuple[0] = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_mstate_global->__pyx_tuple[0])) __PYX_ERR(0, 601, __pyx_L1_error) __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[0]); __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[0]); #if CYTHON_IMMORTAL_CONSTANTS @@ -10053,34 +13565,34 @@ static int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate) { static int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate) { CYTHON_UNUSED_VAR(__pyx_mstate); { - const struct { const unsigned int length: 8; } index[] = {{25},{36},{29},{21},{33},{32},{19},{13},{28},{24},{8},{5},{1},{1},{7},{6},{2},{9},{50},{45},{14},{10},{28},{30},{31},{20},{20},{31},{7},{25},{27},{23},{20},{20},{12},{18},{5},{15},{18},{20},{15},{16},{4},{11},{8},{8},{6},{11},{11},{20},{6},{8},{13},{8},{17},{9},{12},{4},{7},{3},{3},{5},{13},{2},{5},{8},{10},{8},{9},{7},{5},{12},{37},{3},{10},{9},{13},{5},{20},{8},{11},{14},{12},{10},{17},{13},{8},{3},{4},{13},{14},{12},{10},{12},{19},{6},{8},{4},{9},{6},{0},{64},{75},{70},{170},{39},{71},{118},{9}}; - #if (CYTHON_COMPRESS_STRINGS) == 2 /* compression: bz2 (1195 bytes) */ -const char* const cstring = "BZh91AY&SY\235r\326;\000\000\242\177\377\375\377\377\247\367\177\375W\277\267\3673\277\357\377\360@@@@@@@@@@@@@\000@\000P\004,(\231\211\017J\341\004\242\212yS\362\r'\243M)\343F\224\037\252\006\217Q\352\006\203 \r\000\006OH\003\320L\301M\350\236\224\032%\033M\031L\324\021\351\036\246\206\200\000\000\000\000\000\000\000\000\000\000Jh\202\232i\241\240\230M\rS\322\006\232h\000\320\000\000\000\000\001\351\036\241\265\0321\016\000\001\240\001\240\r\000\000\0321\000\003@\000\000\000\003@\006\251\351)\247\350P\375S\323Bz\236\246\322\006\201\204\000d\302h2d\030\203L@\032h\032a\006\035q\377p\030\214+\227*fS\215\222V\245\317\241\2614\n\252\212\202\243E$lq\272\223\032\213\330\260\033\010\222a\273\212X\346\266\263:\004\244\202\344#\0216\310\2368\356\301Q\244\356\343\272I\261\275\260\325\201\322\347\350\353s\377|\302\t?_\367\376\267\1773\257]\346\271\321)v\211\223\355)\333N\314\260R3h\327\274\333\255\242o\307\252$_\357\322\250\356 \372\366\365\253\242\035#K\351D#:\354K\335oF\334\271s(Z\036\362\366\035{\225)\253\r1\3734)\207Q\033\240\323)\022\017+\366\212\211\263\277\275-\307\211'\177\240\177L\247\273\275F\031\030\177\2208no\301\0168\340\262f.\375\3146\351r\366p\207\027K\370:\224\235~G\2575\224\2431b9T\320\030\271\003\253\000<\002\233\347\343\357\263KBu>CD\027@\260\240\252\355\255\366\022\227o\034X7\022\204#\376\233\273\316\223\313\204\252.\036E0@\321\003\260\363zX\344,S\2406\363j\240\323\213:\361\231\256\254\010\017@gB|\325\020\240\216\2168\240N\027\016.PT\256\340\214##\245\302\332F,w\256\0149d\250\220D\014\014\241aPb8\347\317.\332m\341\2420L)\n \026\213gA\022A\202\t2\205\303K\002\241\001F\021\374\340+\331\255z\2105\211\220O\2351\260\245\311o\207\212D\013\3625\233\200\301)O\010\"\211u/F\211\007J*\344\374\017y\275\352:\223\304$\222F\n\023'\240)\027\361YE*\014\361\331\233F\034\006\033!g:7\005\265\306\365\226\023\244X\031&Z5G\2561\005\010!\3414\202m\200\326\272^\037!\262\366\330r\2346\210\223\351\267\024\247\014\365n,R\2357\233\262\232\230'%\322Q\222#I0$\022\n\2053@lN\n\331\2416""\022\244\211\345E\200\214\020\223\n_ZC\004\263\t4-\340\311A&\026lvs\3550\266:dm\254P\004O\203\022\250\n\003h\264\355M\217V\014\014TWS\241 L\204\311\204\222M`A&2\024\305\222M\210h\317\353\310\307Y4=\030\020$)\026R\255\206\207N\220W\304O7\t1\307^I6\273\215\311\240\2526l7\306Pf\340\342\301\254\330j0\300\310\244\2567\020Rm\323$m\333u\265m\267h4\347\346{\3365,\324\325J\360=I\331m \341\342\345\027/\240\341\001\214S\004:|fZ\031\310A\002\013\221\202\300,\024 \010\031\"`4\0250\374F!S3\265,\335\246MU!)N\313\347v(q\261\354\030\261\210\036\367\202\326\275\303!$\316>\336\303\340\274\343\311s\"\327\337|\357yi.9\014\017(\264;\305\014\022N0\300P\317\302\014\027L$\231\303$e\201\316\016\024p\256\021\t\004\252A\001\303\221\240\033\020\205\346\306\251\261:\rC\3458\r\322\007ZY:0\343l\346C6\206\244\344\232\364p\010Qh\213N\301i\022v\221VB\220\232M(\335\021'\273\336\341\301\267^\343^\375\244\330R\372m\230\321UW\332\016\2333\305\345\344\207\2225\264\210\260\214}\303\360a\272~\212\247\227'\006\r\303\004>;\346\356\305_\215]E\372V1\034\356\037\252\177x\205\310\222\372X\305\257\327R\266?>Z\375\311s3v\317\001\025\214jh\263\225}\221g\"\276f\267\323I\254\323\254A$\223k\312q\366\037\371R\233M/\227\255\304\365\202n\321\3154^\267\333\227\260u7k\356\275M=RzS\373DJ\024\034!$\324\210{\224\324\241F\214P\245\030\024\334\255^\2579\267\376.\344\212p\241!:\345\254v"; - PyObject *data = __Pyx_DecompressString(cstring, 1195, 2); + const struct { const unsigned int length: 8; } index[] = {{25},{25},{36},{29},{9},{21},{33},{32},{19},{13},{9},{97},{29},{6},{28},{37},{13},{24},{18},{65},{5},{2},{1},{1},{7},{6},{2},{9},{50},{10},{10},{45},{14},{13},{10},{28},{30},{32},{31},{31},{20},{29},{15},{20},{23},{15},{19},{4},{7},{25},{27},{23},{20},{22},{20},{12},{3},{18},{5},{10},{5},{5},{6},{15},{1},{18},{20},{3},{4},{7},{8},{10},{13},{20},{15},{16},{4},{11},{8},{8},{2},{7},{6},{11},{7},{11},{20},{6},{9},{7},{7},{6},{8},{8},{7},{13},{4},{8},{17},{9},{18},{12},{4},{3},{3},{5},{6},{13},{2},{5},{4},{8},{3},{7},{8},{7},{11},{9},{19},{10},{8},{9},{7},{5},{3},{8},{6},{10},{7},{12},{18},{37},{3},{10},{9},{13},{5},{12},{21},{8},{8},{17},{11},{14},{12},{10},{17},{13},{8},{3},{7},{6},{4},{6},{6},{4},{14},{13},{14},{12},{10},{12},{19},{3},{10},{4},{8},{9},{8},{6},{0},{64},{75},{85},{106},{70},{148},{11},{39},{71},{101},{187},{180},{72},{112},{9}}; + #if (CYTHON_COMPRESS_STRINGS) == 2 /* compression: bz2 (1947 bytes) */ +const char* const cstring = "BZh91AY&SY\250\024\364z\000\001i\377\377\377\377\377\377\377\377\377\367\277\367\377\373\277\357\377\370@@@@@@@@@@@@@\000@\000`\007;\276\264\027\230R)T\255\262\251Us\301\336\r\"\"d\320\000\000\036\24356\246jy#@\006\200\365\006F\232\003F\203@4i\221\247\250\310\310d\320J!4\323\023B\031F \247\204\321\251\352\036\243\324\000h\000\000\000\000\000\000\323F\232\000\000\323I\205\022\237\245\036\240\310\000\006\206\232d\320\r4\320\000\006@h\030\232\000\r\000h4\000\022\232 \223&\210\n~L\247\222zS\310\0204\031\014\200\000\000\000\000\000\000m\023&M\032h\203\000\004\300\000L\023\000\000\000\000\004\300&\002\030\000\0020\000\000\030\245O(\000\032\017Q\220\000\000\310\321\240\000\036\240\000\000h\0004\r\000\000\005\252\364U\251A\335D\372\000>\251\366\316\373\206\316\2422P\376\241@\205\013\374 G\370#D\253L\354L\2537e\222I\204$\302I2\031\036`k\215\225\326\300;\272Rq\327Qa^\274\310u\364\220p\000\360K\220\004\302I IH\237\344Ca\260&\223m\033-9\352`\242\020!\2465g\r!\223G\006J\311\273V\206\271\244\333y\244\207\226rC\322\356\325d\024F\225\240.XX\250\003\031KvK9\024*\366\205\2212b\225\254\345\255V\2669\nBD\355\344\340k(:.z\360\233\207S\210\375g\353\307K\255\320\020\325\023\360\256\227G\2518\337\336\207\243\360\271DU\022j\317\255\376\025*]\211Dup`\254\251iz.\270\330\225\225\245p\3264\344\312e\360\267C@\267\263\263\247\354\304*\272^\014J0\032l\254\226\346\357o.~\027n\312\017\247s\310\321na?\250\247\t$\270\253:\010F\342u\277\354\277U\374\372\367\254\370\366\3636L\312D\022B\204DC\260\373L\317\"\035\241G\265\003\335\3516[\r\037\345\260v\355e\202\335W\031\342\340\226@RP[\270\330A(\324j#9\t\033dL\271\016\206Z\205\343c.\315>\237K+,y?\343\034\341\2304\037o\334\304\266\355z\366\222\243`\242\215\224\254\325S\337P\363\354\313\245\246\037\245\3211\324\361\333\243\tO[\021\230\003A\214DU^o\032\033\213N\207D\346c\221K\254\266\022M%\372\271\030\\H\2431Dp*&h\307\276\017\014\320\0217\332[\331+\310\036]\245\203\272\256r\310,\202\216B*\273\031M*R\227;\202\013\\\307\327+h\305\252\\a:d#\235k\273\323`\303L-Y'K""\010\360H\272\270\325\264a\324\354 \206#L\242\313\336\026\2651\2246\366*\2235-X\271\345\334\243\316k\221\022\3659\017\353M\231\r\023=\307\370\341.I\244IH\212\364\356\253\250\n$\303\213\027\t\240l\r3,\311\\\320\2310\355oM\027\233\346F-c\226\267\303\177\272\344\271\034cH\350\035\027\266-Y\315\273\347\234)yP\200\253k&c\203\204\226\227\0342e\330y|\022\036p\0274v\370\227#u\205\350\002\357Z\356|Q\022\010\242\004\024\r\313\343]\266\260\2115}Sc\360ADT\315g\372\350\t\331i\304q\024R\372\n\310\260\243)n{\231i\275fg\020\262\023&\205\203\227S\372\221\030Z\312\305\021\262\220_\243G\253~\265\267\344\202R|\263\304\207\237\036\256\236#,\266M/-\325\nn\362I%\200\220\306\251(\016\037\222#\332V\360\215Q\343\220\346\31666\310\010\307O\226\301\315\243\355-\260\243\346\334\216\256\350j\212*\252W\034\0357\017Z%\\D\204z\351-\246\222\304\276\306\261\2142B\303\262\310\204Z\210y\n\023H!\023k\303\034\356#6\304\371\272\214\372\351R\\s\310Z)c5l\344\350\336\221\203\221\221M\333\326\225U]b\357\233\361\317\241MH\250\3560\"\2700&\036R9\250\244,\270\234\225\202\031\333Q\233lm\253&r\263\031J\212\313\266T\261++N\031\210\374\032\200W\264\327['VFB\341\0304,W=\036>Km\010)j\325\013Y#%\244\314\024\243lPU\\1$\"\004\305D\307\230\377\234\263Kh\026\356-.\317\271R\334\016\301c-8\356:v\211\t\204\311&\005TUQ\010\020\232\025$\004\261\270\014\272;\002\350j\354=\265\266\t\200\230E\361+\na\036\352&@g\024b\210\205\001\004\320Y\321\255\032\261\t\203+\246a\205\004\027\223\244I\22166\354\336\223I\024\014\370\216f\313\263NbT\034\022w\035\003`28\034*\374\020D64ZE5\032\323ge&\341\025 =B(\265\300\224w\n\215c\255'\t\"s$\n\3512\330\004\365\346\035\252\214l6c\016\365\264f|k\311\231\243\271\206\266\3372%a\030u\256\301\202d7\023\266\343\352F\363\207\034\356\035\234\221';\227~\\\341h\rX3\025Li\300\312\266\367C\240Y\237:\212.[\212\255\223\211\363Q\006\026\250\212\203\260\257#\212\327\301:a\306ay\226C\355\355N\212\202X\026\225\233{\024Q\252\247\014\371\366\337\201S\326\221\2522u\003ES\214\363;;\244\250h\266H\210\25056\333\027e[[\277""\316\206\363\214B\372\332\205\007\2520\340n]W\325M)n&p\274b\024m\016&lIV\033R\342\027\227\030\021l4\342\366nT\236L\t\213\236\0245\311\230\255a@\266\0033P\314*\242\264F\300\306\215\260\221\022\333\t\311*&A\324j0\357\226\366\274\242\020Wd5\032\271ZF\240$\306F|f\033\215\233\303AP\220\211\002q\022\222u\211pn\346\316fGcs\225\2301\222\030T>,L\374\\<\347\006\261`d\243UC<8;\217]}\3236\370\033\rCs\221\225\006Q\247D[\203i\201\356Y\317\021cEL\\\214\205S\032\35422QC-\035\263\270{\210\317c\021\t0\221\265*P{\340\343E\242\036\206\010`1\022\3077\322\331\014\rF_\224uAH\247X;.\006\246\002\035\017\20083 ]\016\350\273\210\243)\030\rAw\335\373\224\214T\317\004\247\233\247\332\"H\004\212\243t\300\311M\3128\247\037\252L\267\362\302\n\004\376\013%\226\301\2743\t\237\251\223\271\n\223I\305\032\204\323\240\361\231\242\016\0310p\360\306n\257\220[\203\345\355\374%\212\207\333\206\324\203bj\252\370\216\027|\200?\321.\2609\245\301\246\033\222\306\242\212\364\211\362\253\347\0322\000\363\325\017\277?F\257\201\220\014c\223C\n5k\226\261\277\226\013\205\225\013\314-u\024\024\217\2459\351\206\373\016\330R\030\216\356$WD\353\307\225$\344\3409\301I\223\010\t\336\024\253\221l\376\336,.\027.'S\340\377\265c\016[8\374Wu\374\215\362w\375\354\245.\327\027;\274Z\022\332k*[\324mJ\361\355k\016\000W\n!\241\365\0214z\203\002\254\261$K\230\006A\2404\360\031\221UAU\324Mp\261\002\241\025\025+_n(\356K\314\205\251k\252\222h\320\344\022\244\177\305\334\221N\024$*\005=\036\200"; + PyObject *data = __Pyx_DecompressString(cstring, 1947, 2); 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 /* compression: zlib (1048 bytes) */ -const char* const cstring = "x\332\255S\315o\033E\024\257\241\"Np?\234\264TH)\254Q\251\010\020\267\241\025B\025\037r\343\026\005\225P\243\024\t$\030\215g\307\366(\353\235\365\314\254k\347\224\243\217s\234\343\036\367\350c\2169r\354q\217\376\023\370\023x3\273\331\004\234\033X\336\3357\357\363\367~\357\315.\217\003\337\013\271\362p\020p\202\025\365\006X\016q\264[\032\206,\244^\027\214\207Mo\237\203*$\324\353\3618\364w\005\265\001\330\353\323\220J&s/\257\307\204T\3156V\330\033\306Ry]\353\"\225`a\277\315z=F\342@MKS\337%\021\236\032\340\320{x\211\003\013\025\355\203\303\030\0071}\216Y@}Oq\013s\340\371P\344\373\242\370S[|/\364\351$w\365@\307c\345\361\236\327\265h\345K\301\307\314\207h\346\234lo\256\215\227S\027\372\311\253\203\347\333_m}\3473\211\273\001\245\241}\367\t\223\271\344\207\334\363i\017\0036\017!A\375\230P\204<\037\n)\307\3126t8f8\000+a!S\010IA\036D<\010br\210\0345d\200Y\370 \n0\241\003\036\370T\240\020+6\246\315h:\371:gH\362X\020\372\355\323\322\375\\j\226e\311T\rx\210\320?l\222*\251\200\312\313\254\304\221\214\2129\345`.\230\373T-\351B\372zI\027\001B\205\016\351\0249\206Q\204\231(\330+>\313\030\317\rK\000\317L\335\251\242\022\314\002\330cG\364L\035Q\321\343b\210\354\244\255\363\004\2366#\n\355\323\211\372\231\366\016\366~|\366\333O\373\317\320\253\203],\247!a\274I\270\200\231\303\306J\207\375_\231I\000\026\304B\244\004\214\240\213\241\257K\210!\261\020\024\372TlH\221:\"\261BCF\004\227\224pX#\273s\366A>\353S\251\234\010\263\203/\265\021\205\326\275\221\204\242>\217\200],\031\221\027\304\346\231?\r\t\207\275\022|\210\"%\354\327j\201\250a\204P/\016\t*\321E\202\216\035\033\345\274\254\255 \325\031\354\023\260\356\200N\230?qk\216 \256$\205)\246\350P\"4\204i\"\370\r\271\037\007\324J!\206fQ9t+@\nw\331/\316ay\235\233\313\353\034\361\310AuN%h+0\036\313\342\000\233t\331:E\323\263\316\340N\240\2425+\216\225\275\205\026\352(\306A\016\367\374\036.\255]\251\000\n\334!\022\366-%\rz\345>\344\212\263\203\035\226\333\322\202\014\220\212\013\177aw\321%{\014\323\217a-\221\262#wkS\216\3205&\037\376\307\337q""\353\257\265+\253kY\355\266\376#\331I\332\351\352\274>od\265\033\263\327\232\230zv\263\276\250\335\324+zb\342\244\225\374\222~\221\376~r\357\244{\272r:\372\263bM\025]_To\314\224\3369ne\325wg\217gB\257\353G\3327\037\231vR\311j\353\372S\3232\235Eu\023\316\265\264\225v\254\333\227zC\267JcV}O33J\256\245\035\000\264~e\265\006y \245u\370\334`3\3123\037\231\272\271\237\347\3342;\246\265\250n\350\307\372(\251'\215\254z[\037\230\315\244\223\370)\034n\351\037\014\316\252\353\372\236\036\230nR\261\325\367\222NV\273f[\033\351\252Y\205\250\373\351\325t7U\363G\363\356\311\332i\303Y\363\377\365Y_w4^T\357he\236@V\234#\220\272Qb\002\244UG\335\346\233\315\355\264\223\372\363\255\223\235\023hjC\177\223\274\2254\nv,-\037'\007\351\235\371;sHx}F\240\365\266Y1*\201\376\352\272\016\331HR\317j\267\364\213\344m\253\373\300\260d\224Vr#\324{\037\332n\3304w\315\257I\037*\001\230\017!\374\211\025\313\316\240\330\377\327[V\255\275\251\3355\235\343Jvum\366\231\356\374\r:+\003\346"; - PyObject *data = __Pyx_DecompressString(cstring, 1048, 1); + #elif (CYTHON_COMPRESS_STRINGS) != 0 /* compression: zlib (1825 bytes) */ +const char* const cstring = "x\332\245UIs\033\307\025\026\274H\000\004Z\004)\222rDG\303X\212\255$\002M[\211\025V\226\202Dm\256X\021e\312I\224J\246\0063\r\240K\203\031`\246\007\004\224\213\2168\366\261\217}\234#\216<\352\250#\2178\362'\370'\370{\215\301b\003\251J9\254ao\257\373-\337\373\336\303\2750\361=+\010\205\345\370~\350:\202YM'n9\355{\213\202.sE\030\315\004-\0360\253\006\341\313\212\365$\304Q\3402\253\036&\201w/b\364\300\261\032,`1\217\307\267\254:\217bQ)\026\016\034\341\354\027\314d\265\222XX5\272\033\213\210\007\215\003^\257s7\361E\177*j\030m\221%\232N`}\266\344\002\017\004k\340B\327\361\023\366\300\341>\363,\021R M\313\203\221\207\231\027w\311\213b\341\021\316a~\337\242\005\242@\270\302mV\306\333\260n\265#\326\345a2\361\332\013Y<\216\227\256\301\013f\305N\027&\302\200L\233\0037\211\"\026\210\t\032\325Z\030\211\312\330\000\036\213p\366~\"|\034x\254g\215G\343\267\005\007\303D\220\0035\3020\376\332\351\361V\322\262\202\244UCp\313\321(\026\236\302[k\034\322\323(\354r\017\236q\243\226l\232t<\355\233\310?-\026\214=\304~\004\237\333\216q\331\343\221\311k\237,S,\355\211\026\202\256\346\304tS4g0\260\036\217\305\363\243\007\267\356\024oV\376\354\361\330\251\371\214\00546\\\036\217W^\020Z\036\253;\310\223e\333\021\363\022\227\331\266\345!N\203Fp\013\331\356r\307\207\324\345\001\027\266],\030\006\301\273\270\343s\301\366www\343\310\335m\207\276\237\270/m\203\255\333tx\260\333\366\035\2275C\337c\221\0358\202wY\245\335\357\375a\314\2408L\"\227\375\251X\020\274\305b\341\264\332\373\205\273\323\267\263Ue\352\227\333\027\3150\260\355\037\310b&\360X,\227\266aH\330/Y\3376\271\263\333\016\217\346\344\256\037\306\314\366j\266\033\006\001\320\345a\020\317\213M\n\355\2548\306\201\315\211\033L,=\003\353\020\236\215\244E\234\315\353\363C\307\233\333\006\354x\341\375\330as:\377\222\210<\267E0\034YgO\221\360\2144\331\264\010\326L\260\200\324DT\353\013\026C\034!\317\374\025\233\034\267YT\017\243\226M\36599\233^\262=\356\nR\321\303\377\001\255\237\260\236x\306\352G\217\277\276\377\342\257O\356\333\317\217\3569\261""\353\304\375\300\345a\305\r#T\r:Q\\\243\3622\203\035CQ\2155x`\002\036G\375#g\\\327\307#\233\007\266\210@\246\232\003\014\226d\rK\332e'\230\004\340\217\263\004\2423f+\026\300\030[\226\327\2543\330DF[\274r\023a\267\270\033\301\022\224y1\325\030\375#\354\006\310j\226\2401%\201^x5\270C\345\227\211\315h\302C\335\265\241\304\013\333H\253\023s7\236[V&\357\031<\367Px\360\000\2452\241\016\3531\370\301L!\3078\355Q\371\325\243\260e\267EDs\223\365h\232\026P=\t\\\3340\343$:\352\222&\205S\272.r\224ng\3340W\241\227{=\323\235x\200T\010\033\212\246\031\344\002U\337\212\211\315\266\335\002\037i\354\341\263\361\310\316f\232\320\021'\023:#-M\025\266X\206\345\254S@C\350%>\314\333h\024\310\200=-\016Z@\237\3519\320\024F\324Lj\375qW\304\010g\210\000\004\276\317k\363\234]lH\213'\225\305\026\325\016\333\0063si\212\336\344\307&\333\240J\347Kui\243i\3673\035\230\211\324\223\031\025JJ\030\320C7\2643\334i\331\025\324\223\t\204N\342\370c f]y\241\264\247\007\2547\336\264#\032c|\241\337e\230\320\326\251u\240\014}'\212\231\217\332\300X\377a\025\317vx1\333\020{M\323\3102\202U\366K1\327J\354%m\005?\013\370\034\337m\262V?\026-\334\027T\016\366\224\247\223\376e\260\212?\373?\377^W\277+\236+\024G\245\r\371o\275\247\017\322\302\260<\334\031\225.\r\216\245\253\312\243\325\362YiU^\220=\225\350\252\3766\375<\375\327\311\365\223\332\233\013o:os$\312\311\362Y\376\322@\310\275\327\325Q~]\356\235\345\351\360\252:\320\027tgd6\327\364{\372a\2727Z\220\234\226\257\303dn,\370\231\272\255:sKR\333!\245\027\007\267\007\235Qi\345,\377\221\372\207n\244\207\2513\312_SB\357\323\362,\277\255\036\353\303\021\3712*\335\240\325\312\344\373`\320\220\207\022W\266\244P\373\372P;cm\261D\210k\3627\312!\213\245\323\322G\352pb)\222k\362\013\351\251_\300\317\034\335\372\225\252\252C\262r\240Ki5=\244k\277\223\353\262:\025\216\362\233\222\253\216^I\241\345\273\265s\205\022\364\000\2219\033\244\371\225*\253_\216u\336T{\252z\006\270n\313W\272\254wF\371\ry\244\266\341\241\227bsY~\245\340\352\232\274.\233\252\246s\323\030W~J\204\024Yi\360H>R""U\270\2277\351\336>\335\276\005\364\274\341\315\223\275\023D\262.\377\250\337\321;YF\351\305\r}\224^\035>8\3319\313\1770p\021\357\201\272\250o#q\245\262,C\261\253\313\243\322e\371\027\375\256F\240?W\\w\220I#\204\351\017\021\353\016\254\235?\267r\r\241\224\256*\020\343\342\340\016\240u\346@-\r\036\312\337\252\234\272\254\376\006z=\323IZ%\245\007\352\002\340\204?\313T\257\023\260\3048R\265j|]\223;diK:\230\200~f\346\212\002E\267d\347\277\330\231\351X\260\211GtV\225\377\324\357\023\336\264\264\365\375\264\374\343\323\323\215O\323\367\323\027\303\343\023\347${\362\002\245r?\335\032\346\206\345%\007\353\362K\265C`\030r\223\327;D\211M\270\216\314\254\374\017xl\311D=\202\364yz#=\036:\303\316\244xQbt\335\"\347t=\275\2132\031\247\223B\355\253w\325\336hu\003li\032J\256\232\030/\r\376\243>A&W\327\345\276\372V\177\241\031\352\3642\2627\372p\207\210\t\0077\266\361\220\022:)\310\225\262\274\242\256\350M\342\302\232\374X\376]\035\202\r[i.]K\357\014\177\177R=yvr\374\246\366\366\374[\357\364\3317\004\376c\371\r\310\263\247\341\335\352\351\252\245s\272lb/\254\202\250\237\200*\037\253\347\372\272vt\004\230\336A\377\2317A\225q\305\024\t\022z^54x\203\3128\335\274\231\226\251X\246\355\301<\332T]J\315\245AOv\020\362\227\300\354s\375\"\355\274\316\215\336+\016~-\017\277\007\247?f\336"; + PyObject *data = __Pyx_DecompressString(cstring, 1825, 1); 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 (1998 bytes) */ -const char* const bytes = "Could not allocate hasmapCould not mine block. No nonce foundCreate a genesis block first.Data must be a stringDifficulty must be greater than 0Difficulty must be integer valueFailed to hash dataGenesis BlockIndex value is out of boundsProvided index not foundPyBlock(UTF-8)?disableenablegcisenabledno default __reduce__ due to non-trivial __cinit__src/polluck_blockchain/placeholder_native.pyxBlockchainBlockchain.__reduce_cython__Blockchain.__setstate_cython__Blockchain.create_genesis_blockBlockchain.get_blockBlockchain.new_blockBlockchain.print_key_value_pairPyBlockPyBlock.__reduce_cython__PyBlock.__setstate_cython__PyBlock.bytes_serializePyBlock.perform_hash__Pyx_PyDict_NextRefTIMEZONE_UTCasyncio.coroutinesblockbytes_serializecline_in_tracebackcreate_genesis_blockcurrent_time_tzcut_microsecondsdatadata_digestdata_strdatetimedigestdigest_sizedopt_basicsdopt_basics.datetimeencodefrom_ptrfromtimestamp__func__genesis_prev_hashget_block__getstate__hashhashlibhexidxindex_is_coroutineititems__main____module____name__new_blocknew_idxnonceperform_hashpolluck_blockchain.placeholder_nativepopprev_blockprev_hashprevious_hashprintprint_key_value_pairpy_block__pyx_state__pyx_vtable____qualname____reduce____reduce_cython____reduce_ex____repr__resselfserialize_resserialize_size__set_name__setdefault__setstate____setstate_cython__struct__test__timetimestampvalues0000000000000000000000000000000000000000000000000000000000000000\200A\360\n\000\t\n\330\014\025\220^\2401\240D\250\t\260\021\260!\330\014\017\210w\220c\230\021\330\020\021\340\014\020\220\007\220x\230u\240A\240V\2502\250]\270$\270b\300\007\300q\310\001\340\014\020\220\001\220\021\340\010\017\210t\2201\200A\330\010\013\2104\210r\220\022\2203\220d\230\"\230D\240\001\330\014\022\220*\230A\230Q\340\010\034\230D\240\014\250A\250Q\330\010\013\2106\220\023\220A\330\014\022\220*\230A\230Q\330\010\026\220i\230q\240\r\250Q\200A\360\022\000\t\014\2104\210t\2201\330\014\022\220,\230a\230q\330\010\013\2104\210z\230\021\230&""\240\001\330\014\022\220)\2301\230A\340\010\023\2204\220z\240\021\240!\330\010\025\220T\230\034\240Q\240d\250!\330\010\024\220J\230a\330\010\022\220$\220h\230b\240\001\340\010\034\230I\240Q\330\014\r\330\014\017\210q\220\010\230\t\240\021\240&\250\004\250C\250t\2603\260b\270\n\300!\330\014\r\330\014\r\330\014\r\330\014\016\210g\220Q\220a\340\010\027\220t\230:\240Q\240a\330\010\013\2104\210s\220!\330\014\022\220,\230a\230q\200A\360\010\000\t\n\330\014\034\320\034-\250Q\250d\260)\2701\270A\330\014\023\220=\240\002\240!\340\014\020\220\001\220\021\200A\330\010%\240T\250\027\260\006\260a\340\010\016\210c\220\023\220D\230\007\230t\2401\330\014\021\220\021\220,\230c\240\021\330\014\024\220L\240\003\2401\330\014\036\230i\240q\250\001\330\014\021\220\021\220!\330\014\031\230\021\230!\200A\330\010\035\230Y\240g\250Q\250a\330\010\037\230t\240:\250Q\250a\340\010\034\230I\240Q\330\014\020\220\001\330\014\017\210q\220\010\230\t\240\021\240&\250\004\250C\250t\2603\260b\270\n\300!\330\014\r\330\014\r\330\014\r\330\014\016\210g\220Q\220a\340\010\027\220t\230:\240Q\240a\330\010\013\2104\210s\220!\330\014\022\220,\230a\230q\330\010\014\320\014\035\230Q\200\001\330\004\n\210+\220Q"; + #else /* compression: none (3598 bytes) */ +const char* const bytes = "Could not allocate hasmapCould not allocate vectorCould not mine block. No nonce foundCreate a genesis block first.\n\tData:\t\tData must be a stringDifficulty must be greater than 0Difficulty must be integer valueFailed to hash dataGenesis Block\n\tHash:\t\t: Hash mismatch. Hash of previous block does not match the saved one in the current block. Abort.: Hashes to not match. Abort.Index Index value is out of boundsMaximum number must be greater than 0\n\tPrev Hash:\tProvided index not foundPyBlock(\n\tIndex:\t\tThe parent directory of the provided database path does not existUTF-8\n).?disableenablegcisenabledno default __reduce__ due to non-trivial __cinit__\n\tnonce:\t\tsqlite:///src/polluck_blockchain/placeholder_native.pyx\n\ttimestamp:\tBlockchainBlockchain.__reduce_cython__Blockchain.__setstate_cython__Blockchain._print_key_value_pairBlockchain.close_db_connectionsBlockchain.create_genesis_blockBlockchain.get_blockBlockchain.get_saving_entriesBlockchain.loadBlockchain.new_blockBlockchain.print_blocksBlockchain.saveBlockchain.validatePathPyBlockPyBlock.__reduce_cython__PyBlock.__setstate_cython__PyBlock.bytes_serializePyBlock.perform_hashPyBlock.serialize_dict__Pyx_PyDict_NextRefTIMEZONE_UTCascasyncio.coroutinesbatchbatch_sizebeginblockblocksbytes_serializeccline_in_tracebackclose_db_connectionsconconnconnectcontentscreate_allcreate_enginecreate_genesis_blockcurrent_time_tzcut_microsecondsdatadata_digestdata_strdatetimedbdb_pathdigestdigest_sizedisposedopt_basicsdopt_basics.datetimeencode__enter__entriesexecuteexists__exit__from_ptrfromhexfromtimestampfunc__func__genesis_prev_hashget_blockget_saving_entries__getstate__hashhexidxindexinsert_is_coroutineititemsload__main__maxmax_idx_max_idxmax_nummax_nummbermax_valuemetadata_blockchain__module____name__new_blocknew_idxnoncenumorder_byparentpartitionspathlibperform_hashpolluck_blockchainpolluck_blockchain.placeholder_nativepopprev_blockprev_hashprevious_hashprintprint_blocks_print_key_value_pairpy_bl""ockpy_bytespy_bytes_rehashed__pyx_state__pyx_vtable____qualname____reduce____reduce_cython____reduce_ex____repr__resresolveresultsavescalarselectselfserialize_dictserialize_resserialize_size__set_name__setdefault__setstate____setstate_cython__sqlsqlalchemystmt__test__timestampvalidatevalues0000000000000000000000000000000000000000000000000000000000000000\200A\360\n\000\t\n\330\014\025\220^\2401\240D\250\t\260\021\260!\330\014\017\210w\220c\230\021\330\020\021\340\014\020\220\007\220x\230u\240A\240V\2502\250]\270$\270b\300\007\300q\310\001\340\014\020\220\001\220\021\340\010\017\210t\2201\200A\330\010\023\2201\340\010\020\220\001\220\033\230D\240\007\240q\330\010\020\220\001\220\037\240\004\240G\2501\330\010\020\220\001\220\033\230D\240\007\240q\330\010\020\220\001\320\021$\240D\250\001\330\010\020\220\001\220\032\2304\230q\330\010\020\220\001\220\032\2304\230q\340\010\017\210q\200A\330\010\013\2104\210q\330\014\r\340\010\035\230Y\240g\250Q\250a\330\010\037\230t\240:\250Q\250a\340\010\034\230I\240Q\330\014\020\220\001\330\014%\240Q\330\014\r\330\014\r\330\014\r\330\014\016\210g\220Q\220a\340\010\027\220t\230:\240Q\240a\330\010\013\2104\210s\220!\330\014\022\220,\230a\230q\330\010\014\320\014\035\230Q\200A\330\010\013\2104\210r\220\022\2203\220d\230\"\230D\240\001\330\014\022\220*\230A\230Q\340\010\034\230D\240\014\250A\250Q\330\010\013\2106\220\023\220A\330\014\022\220*\230A\230Q\330\010\026\220i\230q\240\r\250Q\200A\360\022\000\t\014\2104\210t\2201\330\014\022\220,\230a\230q\330\010\013\2104\210z\230\021\230&\240\001\330\014\022\220)\2301\230A\340\010\023\2204\220z\240\021\240!\330\010\025\220T\230\034\240Q\240d\250!\330\010\024\220J\230a\330\010\022\220$\220h\230b\240\001\340\010\034\230I\240Q\330\014\r\330\014%\240Q\330\014\r\330\014\r\330\014\r\330\014\016\210g\220Q\220a\340\010\027\220t\230:\240Q\240a\330\010\013\2104\210s\220!\330\014\022\220,\230a\230q\200A\330\010\014\210H\220H\230A\200A\360\010\000\t\n\330\014\034\320\034-\250Q\250d\260)\2701\270A\330\014""\023\220=\240\002\240!\340\014\020\220\001\220\021\200A\330\010%\240T\250\033\260F\270!\340\010\016\210c\220\023\220D\230\013\2404\240q\330\014\021\220\021\220,\230c\240\021\330\014\024\220L\240\003\2401\330\014\036\230i\240q\250\001\330\014\021\220\021\220!\330\014\031\230\021\230!\200A\360\006\000\r\037\230a\330\014\033\2301\340\010\013\2108\2203\220a\330\014\022\220*\230A\230Q\340\010\014\210G\2205\230\001\230\024\230W\240A\240R\240u\250A\330\014\024\220D\230\007\230q\240\002\240!\2401\330\014\036\230i\240q\250\001\330\014\021\220\021\220!\330\014\023\2201\330\014\017\210t\2203\220a\330\020\021\200A\330\010\022\220!\360\006\000\r\027\220a\360\006\000\t\014\2108\2203\220a\330\014\030\230\001\340\014\027\220q\340\010\014\210G\2205\230\001\230\024\230W\240A\240R\240u\250A\330\014\017\210t\2203\220a\330\020\021\330\014\024\220D\230\007\230q\240\002\240!\2401\330\014\027\220q\330\014\024\220A\220[\240\005\240Q\330\014\024\220A\220_\240E\250\021\330\014\024\220A\220[\240\005\240Q\330\014\024\220A\320\025(\250\005\250Z\260w\270a\270q\330\014\024\220A\220Z\230u\240E\250\027\260\001\260\021\330\014\024\220A\220Z\230u\240E\250\027\260\001\260\021\330\014\023\2207\230!\2301\340\010\017\210q\200A\360\006\000\r!\240\001\330\014\026\220a\360\010\000\t\r\210G\2205\230\001\230\024\230W\240A\240R\240u\250A\330\014\024\220D\230\007\230q\240\002\240!\2401\330\014\027\220u\230H\240A\240U\250%\250w\260a\260q\330\014\025\220^\2401\240G\2501\250A\330\014 \240\005\240Q\240f\250B\250a\330\014\020\220\001\220\021\330\014\017\210y\230\003\2301\330\020\025\220Q\220h\230a\230q\330\020\027\220q\330\014\017\210{\230'\240\021\330\020\023\220:\230V\2403\240e\2501\330\024\031\230\021\330\031!\240\021\240!\360\006\000\025\034\2301\330\014\031\230\021\340\010\017\210q\200A\330\r\021\220\030\230\030\240\026\240q\330\014\022\220#\220X\230Q\230c\240\027\250\001\250\022\2508\2609\270A\270R\270w\300b\310\006\310d\320RS\340\010\014\210I\220S\230\013\2401\240A\330\014\020\320\020 \240\001\240\021\200A""\360\006\000\t\020\210s\220'\230\021\230#\230U\240$\240a\240r\250\027\260\002\260!\330\r\021\220\030\230\030\240\026\240q\330\014\025\220T\230\030\240\021\240!\330\014\030\230\006\230g\240Q\340\010\022\220$\320\026)\250\021\250!\330\010\013\2104\210q\330\014\r\340\r\021\220\030\230\026\230v\240Q\330\014\017\210x\220q\230\003\2307\240!\2402\240Z\250q\200\001\330\004\n\210+\220Q"; PyObject *data = NULL; CYTHON_UNUSED_VAR(__Pyx_DecompressString); #endif PyObject **stringtab = __pyx_mstate->__pyx_string_tab; Py_ssize_t pos = 0; - for (int i = 0; i < 100; i++) { + for (int i = 0; i < 170; i++) { Py_ssize_t bytes_length = index[i].length; PyObject *string = PyUnicode_DecodeUTF8(bytes + pos, bytes_length, NULL); - if (likely(string) && i >= 21) PyUnicode_InternInPlace(&string); + if (likely(string) && i >= 34) PyUnicode_InternInPlace(&string); if (unlikely(!string)) { Py_XDECREF(data); __PYX_ERR(0, 1, __pyx_L1_error) @@ -10088,7 +13600,7 @@ const char* const bytes = "Could not allocate hasmapCould not mine block. No non stringtab[i] = string; pos += bytes_length; } - for (int i = 100; i < 109; i++) { + for (int i = 170; i < 186; i++) { Py_ssize_t bytes_length = index[i].length; PyObject *string = PyBytes_FromStringAndSize(bytes + pos, bytes_length); stringtab[i] = string; @@ -10099,15 +13611,15 @@ const char* const bytes = "Could not allocate hasmapCould not mine block. No non } } Py_XDECREF(data); - for (Py_ssize_t i = 0; i < 109; i++) { + for (Py_ssize_t i = 0; i < 186; i++) { if (unlikely(PyObject_Hash(stringtab[i]) == -1)) { __PYX_ERR(0, 1, __pyx_L1_error) } } #if CYTHON_IMMORTAL_CONSTANTS { - PyObject **table = stringtab + 100; - for (Py_ssize_t i=0; i<9; ++i) { + PyObject **table = stringtab + 170; + for (Py_ssize_t i=0; i<16; ++i) { #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING Py_SET_REFCNT(table[i], _Py_IMMORTAL_REFCNT_LOCAL); #else @@ -10119,17 +13631,16 @@ const char* const bytes = "Could not allocate hasmapCould not mine block. No non } { PyObject **numbertab = __pyx_mstate->__pyx_number_tab + 0; - int8_t const cint_constants_1[] = {0,1,12}; - int16_t const cint_constants_2[] = {2025}; - for (int i = 0; i < 4; i++) { - numbertab[i] = PyLong_FromLong((i < 3 ? cint_constants_1[i - 0] : cint_constants_2[i - 3])); + int8_t const cint_constants_1[] = {0}; + for (int i = 0; i < 1; i++) { + numbertab[i] = PyLong_FromLong(cint_constants_1[i - 0]); 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<4; ++i) { + for (Py_ssize_t i=0; i<1; ++i) { #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING Py_SET_REFCNT(table[i], _Py_IMMORTAL_REFCNT_LOCAL); #else @@ -10149,7 +13660,7 @@ typedef struct { unsigned int num_kwonly_args : 1; unsigned int nlocals : 4; unsigned int flags : 10; - unsigned int first_line : 9; + unsigned int first_line : 10; } __Pyx_PyCode_New_function_description; /* NewCodeObj.proto */ static PyObject* __Pyx_PyCode_New( @@ -10166,54 +13677,89 @@ static int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate) { PyObject* tuple_dedup_map = PyDict_New(); if (unlikely(!tuple_dedup_map)) return -1; { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 166}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 145}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_contents}; + __pyx_mstate_global->__pyx_codeobj_tab[0] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_polluck_blockchain_placehold, __pyx_mstate->__pyx_n_u_serialize_dict, __pyx_mstate->__pyx_kp_b_iso88591_A_1_D_q_G1_D_q_D_4q_4q_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[0])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 182}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_serialize_res, __pyx_mstate->__pyx_n_u_serialize_size}; - __pyx_mstate_global->__pyx_codeobj_tab[0] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_polluck_blockchain_placehold, __pyx_mstate->__pyx_n_u_bytes_serialize, __pyx_mstate->__pyx_kp_b_iso88591_A_Qd_1A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[0])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[1] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_polluck_blockchain_placehold, __pyx_mstate->__pyx_n_u_bytes_serialize, __pyx_mstate->__pyx_kp_b_iso88591_A_Qd_1A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[1])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 177}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 193}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_digest, __pyx_mstate->__pyx_n_u_digest_size}; - __pyx_mstate_global->__pyx_codeobj_tab[1] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_polluck_blockchain_placehold, __pyx_mstate->__pyx_n_u_perform_hash, __pyx_mstate->__pyx_kp_b_iso88591_A_1D_wc_xuAV2_b_q_t1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[1])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[2] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_polluck_blockchain_placehold, __pyx_mstate->__pyx_n_u_perform_hash, __pyx_mstate->__pyx_kp_b_iso88591_A_1D_wc_xuAV2_b_q_t1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[2])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1}; 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_stringsource, __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[2])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[3] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __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[3])) 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[3] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __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[3])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[4] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __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[4])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 359}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 455}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_it, __pyx_mstate->__pyx_n_u_block, __pyx_mstate->__pyx_n_u_py_block}; - __pyx_mstate_global->__pyx_codeobj_tab[4] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_polluck_blockchain_placehold, __pyx_mstate->__pyx_n_u_print_key_value_pair, __pyx_mstate->__pyx_kp_b_iso88591_A_T_a_c_D_t1_c_L_1_iq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[4])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[5] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_polluck_blockchain_placehold, __pyx_mstate->__pyx_n_u_print_key_value_pair, __pyx_mstate->__pyx_kp_b_iso88591_A_T_F_c_D_4q_c_L_1_iq, 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), 396}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 465}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_max_num, __pyx_mstate->__pyx_n_u_block, __pyx_mstate->__pyx_n_u_max_nummber, __pyx_mstate->__pyx_n_u_idx, __pyx_mstate->__pyx_n_u_num, __pyx_mstate->__pyx_n_u_py_block}; + __pyx_mstate_global->__pyx_codeobj_tab[6] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_polluck_blockchain_placehold, __pyx_mstate->__pyx_n_u_print_blocks, __pyx_mstate->__pyx_kp_b_iso88591_A_a_1_83a_AQ_G5_WARuA_D_q_1_iq_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), 482}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_idx, __pyx_mstate->__pyx_n_u_block}; - __pyx_mstate_global->__pyx_codeobj_tab[5] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_polluck_blockchain_placehold, __pyx_mstate->__pyx_n_u_get_block, __pyx_mstate->__pyx_kp_b_iso88591_A_4r_3d_D_AQ_D_AQ_6_A_AQ_iq_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[5])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[7] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_polluck_blockchain_placehold, __pyx_mstate->__pyx_n_u_get_block, __pyx_mstate->__pyx_kp_b_iso88591_A_4r_3d_D_AQ_D_AQ_6_A_AQ_iq_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[7])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 419}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 491}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_genesis_prev_hash, __pyx_mstate->__pyx_n_u_data_str, __pyx_mstate->__pyx_n_u_block, __pyx_mstate->__pyx_n_u_res}; - __pyx_mstate_global->__pyx_codeobj_tab[6] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_polluck_blockchain_placehold, __pyx_mstate->__pyx_n_u_create_genesis_block, __pyx_mstate->__pyx_kp_b_iso88591_A_YgQa_t_Qa_IQ_q_Ct3b_gQa_t_Qa_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[6])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[8] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_polluck_blockchain_placehold, __pyx_mstate->__pyx_n_u_create_genesis_block, __pyx_mstate->__pyx_kp_b_iso88591_A_4q_YgQa_t_Qa_IQ_Q_gQa_t_Qa_4s, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[8])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 436}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 511}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_data, __pyx_mstate->__pyx_n_u_prev_block, __pyx_mstate->__pyx_n_u_prev_hash, __pyx_mstate->__pyx_n_u_new_idx, __pyx_mstate->__pyx_n_u_data_str, __pyx_mstate->__pyx_n_u_data_digest, __pyx_mstate->__pyx_n_u_digest_size, __pyx_mstate->__pyx_n_u_block, __pyx_mstate->__pyx_n_u_res}; - __pyx_mstate_global->__pyx_codeobj_tab[7] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_polluck_blockchain_placehold, __pyx_mstate->__pyx_n_u_new_block, __pyx_mstate->__pyx_kp_b_iso88591_A_4t1_aq_4z_1A_4z_T_Qd_Ja_hb_IQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[7])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[9] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_polluck_blockchain_placehold, __pyx_mstate->__pyx_n_u_new_block, __pyx_mstate->__pyx_kp_b_iso88591_A_4t1_aq_4z_1A_4z_T_Qd_Ja_hb_IQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[9])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 542}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_block, __pyx_mstate->__pyx_n_u_prev_block, __pyx_mstate->__pyx_n_u_idx, __pyx_mstate->__pyx_n_u_digest, __pyx_mstate->__pyx_n_u_digest_size, __pyx_mstate->__pyx_n_u_py_bytes, __pyx_mstate->__pyx_n_u_py_bytes_rehashed}; + __pyx_mstate_global->__pyx_codeobj_tab[10] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_polluck_blockchain_placehold, __pyx_mstate->__pyx_n_u_validate, __pyx_mstate->__pyx_kp_b_iso88591_A_a_G5_WARuA_D_q_1_uHAU_waq_1G1A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[10])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 570}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_max_idx, __pyx_mstate->__pyx_n_u_entries, __pyx_mstate->__pyx_n_u_block, __pyx_mstate->__pyx_n_u_idx, __pyx_mstate->__pyx_n_u_max_idx_2, __pyx_mstate->__pyx_n_u_contents}; + __pyx_mstate_global->__pyx_codeobj_tab[11] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_polluck_blockchain_placehold, __pyx_mstate->__pyx_n_u_get_saving_entries, __pyx_mstate->__pyx_kp_b_iso88591_A_a_83a_q_G5_WARuA_t3a_D_q_1_q_A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[11])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 597}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_stmt, __pyx_mstate->__pyx_n_u_conn, __pyx_mstate->__pyx_n_u_result, __pyx_mstate->__pyx_n_u_max_value, __pyx_mstate->__pyx_n_u_entries, __pyx_mstate->__pyx_n_u_con}; + __pyx_mstate_global->__pyx_codeobj_tab[12] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_polluck_blockchain_placehold, __pyx_mstate->__pyx_n_u_save, __pyx_mstate->__pyx_kp_b_iso88591_A_s_U_ar_q_T_gQ_4q_vQ_xq_7_2Zq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[12])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 612}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[13] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_polluck_blockchain_placehold, __pyx_mstate->__pyx_n_u_close_db_connections, __pyx_mstate->__pyx_kp_b_iso88591_A_HHA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[13])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 615}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_batch_size, __pyx_mstate->__pyx_n_u_con, __pyx_mstate->__pyx_n_u_res, __pyx_mstate->__pyx_n_u_batch}; + __pyx_mstate_global->__pyx_codeobj_tab[14] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_polluck_blockchain_placehold, __pyx_mstate->__pyx_n_u_load, __pyx_mstate->__pyx_kp_b_iso88591_A_q_XQc_89ARwb_dRS_IS_1A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[14])) goto bad; } { const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; - __pyx_mstate_global->__pyx_codeobj_tab[8] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __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[8])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[15] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __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[15])) 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[9] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __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[9])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[16] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __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[16])) goto bad; } Py_DECREF(tuple_dedup_map); return 0; @@ -11732,33 +15278,6 @@ bad: #endif } -/* decode_c_bytes (used by decode_cpp_string) */ -static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes( - const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop, - const char* encoding, const char* errors, - PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { - if (unlikely((start < 0) | (stop < 0))) { - if (start < 0) { - start += length; - if (start < 0) - start = 0; - } - if (stop < 0) - stop += length; - } - if (stop > length) - stop = length; - if (unlikely(stop <= start)) - return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_unicode); - length = stop - start; - cstring += start; - if (decode_func) { - return decode_func(cstring, length, errors); - } else { - return PyUnicode_Decode(cstring, length, encoding, errors); - } -} - /* RejectKeywords */ static void __Pyx_RejectKeywords(const char* function_name, PyObject *kwds) { PyObject *key = NULL; @@ -11786,6 +15305,33 @@ static void __Pyx_RejectKeywords(const char* function_name, PyObject *kwds) { } } +/* decode_c_bytes (used by decode_cpp_string) */ +static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes( + const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { + if (unlikely((start < 0) | (stop < 0))) { + if (start < 0) { + start += length; + if (start < 0) + start = 0; + } + if (stop < 0) + stop += length; + } + if (stop > length) + stop = length; + if (unlikely(stop <= start)) + return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_unicode); + length = stop - start; + cstring += start; + if (decode_func) { + return decode_func(cstring, length, errors); + } else { + return PyUnicode_Decode(cstring, length, encoding, errors); + } +} + /* GetException */ #if CYTHON_FAST_THREAD_STATE static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) @@ -12197,6 +15743,378 @@ static CYTHON_INLINE int __Pyx_UnknownThreadStateMayHaveHadGil(__Pyx_UnknownThre #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 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_ASSUME_SAFE_SIZE + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyList_GET_SIZE(o); + } + if ((CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS)) { + return __Pyx_PyList_GetItemRefFast(o, wrapped_i, unsafe_shared); + } else + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { + return __Pyx_NewRef(PyList_GET_ITEM(o, wrapped_i)); + } + return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(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_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyTuple_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { + return __Pyx_NewRef(PyTuple_GET_ITEM(o, wrapped_i)); + } + return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i)); +#else + (void)wraparound; + (void)boundscheck; + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, + int wraparound, int boundscheck, int unsafe_shared) { + CYTHON_MAYBE_UNUSED_VAR(unsafe_shared); +#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); + if ((CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS)) { + return __Pyx_PyList_GetItemRefFast(o, n, unsafe_shared); + } else if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { + return __Pyx_NewRef(PyList_GET_ITEM(o, n)); + } + } else + #if !CYTHON_AVOID_BORROWED_REFS + if (PyTuple_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { + return __Pyx_NewRef(PyTuple_GET_ITEM(o, n)); + } + } else + #endif +#endif +#if CYTHON_USE_TYPE_SLOTS && !CYTHON_COMPILING_IN_PYPY + { + PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping; + PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence; + if (!is_list && mm && mm->mp_subscript) { + PyObject *r, *key = PyLong_FromSsize_t(i); + if (unlikely(!key)) return NULL; + r = mm->mp_subscript(o, key); + Py_DECREF(key); + return r; + } + if (is_list || likely(sm && sm->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) { + Py_ssize_t l = sm->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return NULL; + PyErr_Clear(); + } + } + return sm->sq_item(o, i); + } + } +#else + if (is_list || !PyMapping_Check(o)) { + return PySequence_GetItem(o, i); + } +#endif + (void)wraparound; + (void)boundscheck; + return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i)); +} + +/* CIntToDigits (used by CIntToPyUnicode) */ +static const char DIGIT_PAIRS_10[2*10*10+1] = { + "00010203040506070809" + "10111213141516171819" + "20212223242526272829" + "30313233343536373839" + "40414243444546474849" + "50515253545556575859" + "60616263646566676869" + "70717273747576777879" + "80818283848586878889" + "90919293949596979899" +}; +static const char DIGIT_PAIRS_8[2*8*8+1] = { + "0001020304050607" + "1011121314151617" + "2021222324252627" + "3031323334353637" + "4041424344454647" + "5051525354555657" + "6061626364656667" + "7071727374757677" +}; +static const char DIGITS_HEX[2*16+1] = { + "0123456789abcdef" + "0123456789ABCDEF" +}; + +/* BuildPyUnicode (used by COrdinalToPyUnicode) */ +static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, const char* chars, int clength, + int prepend_sign, char padding_char) { + PyObject *uval; + Py_ssize_t uoffset = ulength - clength; +#if CYTHON_USE_UNICODE_INTERNALS + Py_ssize_t i; + void *udata; + uval = PyUnicode_New(ulength, 127); + if (unlikely(!uval)) return NULL; + udata = PyUnicode_DATA(uval); + if (uoffset > 0) { + i = 0; + if (prepend_sign) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, 0, '-'); + i++; + } + for (; i < uoffset; i++) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, i, padding_char); + } + } + for (i=0; i < clength; i++) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, uoffset+i, chars[i]); + } +#else + { + 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); +} + +/* 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 + +/* RaiseUnboundLocalError */ +static void __Pyx_RaiseUnboundLocalError(const char *varname) { + PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); +} + /* AllocateExtensionType */ static PyObject *__Pyx_AllocateExtensionType(PyTypeObject *t, int is_final) { if (is_final || likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { @@ -12219,6 +16137,25 @@ static PyObject *__Pyx_AllocateExtensionType(PyTypeObject *t, int is_final) { } } +/* CallTypeTraverse */ +#if !CYTHON_USE_TYPE_SPECS || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x03090000) +#else +static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg) { + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x03090000 + if (__Pyx_get_runtime_version() < 0x03090000) return 0; + #endif + if (!always_call) { + PyTypeObject *base = __Pyx_PyObject_GetSlot(o, tp_base, PyTypeObject*); + unsigned long flags = PyType_GetFlags(base); + if (flags & Py_TPFLAGS_HEAPTYPE) { + return 0; + } + } + Py_VISIT((PyObject*)Py_TYPE(o)); + return 0; +} +#endif + /* LimitedApiGetTypeDict (used by SetItemOnTypeDict) */ #if CYTHON_COMPILING_IN_LIMITED_API static Py_ssize_t __Pyx_GetTypeDictOffset(void) { @@ -13063,6 +17000,45 @@ static PyObject *__Pyx_Import(PyObject *name, PyObject *const *imported_names, P 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__3); + 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; @@ -13286,25 +17262,6 @@ static int __pyx_CommonTypesMetaclass_init(PyObject *module) { return 0; } -/* CallTypeTraverse (used by CythonFunctionShared) */ -#if !CYTHON_USE_TYPE_SPECS || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x03090000) -#else -static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg) { - #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x03090000 - if (__Pyx_get_runtime_version() < 0x03090000) return 0; - #endif - if (!always_call) { - PyTypeObject *base = __Pyx_PyObject_GetSlot(o, tp_base, PyTypeObject*); - unsigned long flags = PyType_GetFlags(base); - if (flags & Py_TPFLAGS_HEAPTYPE) { - return 0; - } - } - Py_VISIT((PyObject*)Py_TYPE(o)); - return 0; -} -#endif - /* PyMethodNew (used by CythonFunctionShared) */ #if CYTHON_COMPILING_IN_LIMITED_API static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { @@ -13434,7 +17391,7 @@ static CYTHON_INLINE int __Pyx__IsSameCyOrCFunctionNoMethod(PyObject *func, void 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); + PyObject *newFunc = PyObject_GetAttr(func, __pyx_mstate_global->__pyx_n_u_func_2); if (unlikely(!newFunc)) { PyErr_Clear(); // It's only an optimization, so don't throw an error return 0; @@ -15466,6 +19423,75 @@ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_unsigned_int(unsigned int value } } +/* 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 *from_bytes, *result = NULL, *kwds = NULL; + PyObject *py_bytes = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + { + PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str }; + if (!is_unsigned) { + kwds = __Pyx_MakeVectorcallBuilderKwds(1); + if (!kwds) goto limited_bad; + if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad; + } + result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); + } + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif + } +} + /* CIntFromPy */ static CYTHON_INLINE unsigned int __Pyx_PyLong_As_unsigned_int(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC @@ -15749,81 +19775,12 @@ __Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp) result = name; name = NULL; } else { - result = __Pyx_NewRef(__pyx_mstate_global->__pyx_kp_u__3); + result = __Pyx_NewRef(__pyx_mstate_global->__pyx_kp_u__4); } goto done; } #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 *from_bytes, *result = NULL, *kwds = NULL; - PyObject *py_bytes = NULL, *order_str = NULL; - from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); - if (!from_bytes) return NULL; - py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); - if (!py_bytes) goto limited_bad; - order_str = PyUnicode_FromString(little ? "little" : "big"); - if (!order_str) goto limited_bad; - { - PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str }; - if (!is_unsigned) { - kwds = __Pyx_MakeVectorcallBuilderKwds(1); - if (!kwds) goto limited_bad; - if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad; - } - result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); - } - limited_bad: - Py_XDECREF(kwds); - Py_XDECREF(order_str); - Py_XDECREF(py_bytes); - Py_XDECREF(from_bytes); - return result; -#endif - } -} - /* CIntFromPy */ static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC diff --git a/src/polluck_blockchain/python.py b/src/dopt_pollublock_blockchain/python.py similarity index 100% rename from src/polluck_blockchain/python.py rename to src/dopt_pollublock_blockchain/python.py diff --git a/src/polluck_blockchain/python_translate.c b/src/dopt_pollublock_blockchain/python_translate.c similarity index 100% rename from src/polluck_blockchain/python_translate.c rename to src/dopt_pollublock_blockchain/python_translate.c diff --git a/src/polluck_blockchain/python_translate.py b/src/dopt_pollublock_blockchain/python_translate.py similarity index 100% rename from src/polluck_blockchain/python_translate.py rename to src/dopt_pollublock_blockchain/python_translate.py